Eliminate_gold_nuggets/assets/script/game/eliminate/view/EliminateViewComp.ts

/*
 * @Author: mojunshou 1637302775@qq.com
 * @Date: 2025-03-20 15:01:09
 * @LastEditors: mojunshou 1637302775@qq.com
 * @LastEditTime: 2025-04-02 17:55:03
 * @Description: 消除游戏主场景
 */
import { _decorator, Color, EventTouch, instantiate, JsonAsset, Label, Node, Prefab, randomRangeInt, Sprite, Toggle, tween, UITransform, Vec2, Vec3, Widget } from "cc";
import { RandomManager } from "db://oops-framework/core/common/random/RandomManager";
import { oops } from "db://oops-framework/core/Oops";
import { ecs } from "db://oops-framework/libs/ecs/ECS";
import { LabelChange } from "db://oops-framework/libs/gui/label/LabelChange";
import { CCComp } from "db://oops-framework/module/common/CCComp";
import { GameEvent } from "../../common/config/GameEvent";
import { UIID } from "../../common/config/GameUIConfig";
import { Button } from "cc";

const { ccclass, property } = _decorator;

// 游戏状态枚举
enum GameState {
    READY,      // 准备中
    PLAYING,    // 游戏中
    PAUSED,     // 暂停
    GAME_OVER   // 游戏结束
}

// 游戏模式枚举
enum GameMode {
    MANUAL,     // 手动模式
    AUTO        // 自动模式
}


// 格子状态
enum CellState {
    EMPTY,     // 空格子
    FILLED,    // 有方块
    HIGHLIGHTED // 高亮（可放置）
}

// 新手引导步骤
enum TutorialStep {
    NONE,               // 无引导
    ROW_ELIMINATION,    // 行消除引导
    COLUMN_ELIMINATION, // 列消除引导
    ROTATION,           // 旋转引导
    FINAL_ELIMINATION   // 最终消除引导
}


//网格数据接口
interface GridData {
    name: string,       // 名称
    status: CellState,  // 状态
    gridNode: Node | null      // 网格节点
    row: number,        // 行
    col: number,        // 列
    type: number,       // 类型--gridColorKey
}


interface Grids {
    row: number,
    column: number,
}


interface EditingData {
    brickData: BrickData | null,
    gridList: GridData[],
}

//底部方块数据定义
interface BrickData {
    index: number,
    brickKey: string | null,
    rotateTag: boolean,
    rotateFlag: boolean,
    gridConfig: Grids[],
    deg: number,
    brickNode: Node | null,
    brickInitPos: Vec3, // 方块初始位置
    type: number,   // 方块类型--gridColorKey
}

interface GridConfigData {
    row: number,
    column: number,
}


/** 视图层对象 */
@ccclass('EliminateViewComp')
@ecs.register('EliminateView', false)
export class EliminateViewComp extends CCComp {
    @property({ type: LabelChange, displayName: "自动提现金额" })
    private amountLb: LabelChange = null!;
    @property({ type: LabelChange, displayName: "额外奖励" })
    private awardLb: LabelChange = null!;
    @property({ type: Node, displayName: "tween微信钱Node" })
    private tweenWechatNode: Node = null!;
    @property({ type: Node, displayName: "tween红包Node" })
    private tweenRedNode: Node = null!;

    @property({ type: Prefab, displayName: "金币预制体" })
    private coinPrefab: Prefab = null!;
    @property({ type: Prefab, displayName: "红包预制体" })
    private redPacketPrefab: Prefab = null!;
    @property({ type: Label, displayName: "本局分数" })
    private lab_score: Label = null!;
    @property({ type: Label, displayName: "目标分数" })
    private lab_taget: Label = null!;
    @property({ type: Label, displayName: "第几块金砖" })
    private lab_brick: Label = null!;

    @property({ type: Label, displayName: "第几关" })
    private lab_levle: Label = null!;



    @property({ type: Prefab, displayName: "item预制体列表" })
    private itemPrefabs: Prefab[] = [];
    @property({ type: Node, displayName: "网格Node" })
    private gridNode: Node = null!;
    @property({ type: Node, displayName: "移动Node" })
    private moveNode: Node = null!;
    @property({ type: Node, displayName: "旋转Node" })
    private rotateNode: Node = null!;
    @property({ type: Node, displayName: "方块Node" })
    private brickNode: Node = null!;

    @property({ type: Prefab, displayName: "旋转预制体" })
    private rotatePrefab: Node = null!;
    @property({ type: Label, displayName: "累计消除次数" })
    private lab_total: Label = null!;
    @property({ type: Label, displayName: "每次放置添加的分数" })
    private lab_addScore: Label = null!;

    @property({ type: Button, displayName: "自动按钮" })
    private autoBtn: Button = null!;
    @property({ type: Button, displayName: "二倍速按钮" })
    private addSpeedBtn: Button = null!;



    //游戏配置行列
    private rows: number = 8;       // 行数
    private cols: number = 8;       // 列数
    private itemSize: number = 76.25;  // 格子大小
    private brickNum: number = 3;   // 砖块数量

    private gameState: GameState = GameState.READY;
    private score: number = 0;      //本局分数
    private money: number = 0;      //左边金钱
    private cash: number = 0;       //右边红包钱数

    private totalNum: number = 0;   //累计消除次数，断了就是又从0开始

    private _isDoubleSpeed: boolean = false;  //是否开启二倍速

    //网格列表
    // gridsNode: Node | null = null;          //中间网格区域
    // brickNode: Node | null = null;           //底部三个item块区域
    // moveNode: Node | null = null;           //移动层Node
    // rotateNode: Node | null = null;         //旋转Node吧     

    //没使用颜色
    notUseColor = new Color(255, 255, 255, 255)
    //可用的颜色
    usableColor = new Color(0, 255, 0, 100)
    //不可用的颜色
    unavailableColor = new Color(255, 0, 0, 100)
    //旋转容错
    rotateFaultTolerant = 10;
    private _isAutoFunc: (() => void) | null = null;

    isAutoMode: boolean = false;
    autoModeInterval: number = 1  // 自动模式的间隔时间（秒）
    autoModeTimer: number = 0  // 自动模式计时器


    //网格列表管理列表  
    gridList: GridData[][] = [];
    //砖块列表
    bricksList: BrickData[] = [];
    //网格颜色列表
    gridColorList: GridData[] = [];

    brickConfig: { bricks?: any } = {}  //方块配置
    editingFlag = false                 //编辑状态
    editingData: EditingData = {
        brickData: null,
        gridList: [],
    }

    //旋转标记
    rotateFlag = false
    rotateBrickData: BrickData | null = null

    // 添加新的属性来跟踪是否需要重置消除计数
    private shouldResetEliminateCount: boolean = true;
    private consecutiveEliminations: boolean = false;

    // 添加配置属性 - 消除基础分
    @property({ displayName: "消除一行/列基础分" })
    private eliminateBaseScore: number = 10;

    //当前局数
    private curGameNum: number = 0;
    //第一通关开始新人模式
    //第二局开始马上播放新的弹窗
    //往后根据每局需要弹窗就弹窗
    //通关一局算一块金砖
    //通关比例算金砖比例

    private autoState: boolean = false;  //自动状态

    /** 视图层逻辑代码分离演示 */
    async start() {
        // const entity = this.ent as ecs.Entity;         // ecs.Entity 可转为当前模块的具体实体对象
        this.setButton();
        this.initButtonState(false);
        await this.loadConfig();
        this.initGrid();
        this.initData();
        this.addEventList();
    }


    addEventList() {
        oops.message.on(GameEvent.RestartGame, this.restartGame, this);
        oops.message.on(GameEvent.DoubleSpeedOpenSuccess, this.doubleSpeedOpenSuccess, this);
    }



    //初始化网格
    private initGrid() {
        // 清理现有网格
        this.clearExistingGrids();
        // 生成网格矩阵
        this.createGridMatrix();
    }

    //初始化按钮状态
    private initButtonState(state: boolean) {
        //自动按钮默认关闭
        if (this.autoBtn) {
            //关闭
            const on = this.autoBtn.node.getChildByName("on");
            on ? on.active = state : null;
            const off = this.autoBtn.node.getChildByName("off");
            off ? off.active = !state : null;
            // this.autoState = state;
        }
    }


    //初始化数据
    private initData() {
        // this.gameMode = GameMode.MANUAL;
        this.score = 0;
        this.money = 0;
        this.cash = 0;
        this.totalNum = 0;
        this.autoState = false;
        this.shouldResetEliminateCount = true;
        this.consecutiveEliminations = false;
        this.lab_score.string = this.score.toString();
        this.amountLb.string = this.money.toString();
        this.awardLb.string = this.cash.toString();
    }

    //初始化关卡信息
    private initLevelInfo() {
        //关卡通关服务器或者本地读出来
        // const level = 


    }




    //初始化网格
    private async loadConfig() {
        let json_name: string = "gui/eliminate/config/GridConfig";
        return new Promise<void>((resolve, reject) => {
            oops.res.load(json_name, JsonAsset, (err: Error | null, res: any) => {
                if (res) {
                    this.brickConfig = res.json;
                    resolve();
                } else {
                    console.log("JSON数据加载失,请检查文件");
                    reject(err);
                }
            });
        });
    }

    /**
     * @description: 清理现有的网格数据
     * @return {*}
     */
    private clearExistingGrids(): void {
        this.gridList = [];
        if (this.gridNode) {
            this.gridNode.children.forEach(node => node.destroy());
        }
    }

    /**
     * @description: 设置网格容器大小
     * @return {*}
     */
    private createGridMatrix(): void {
        for (let rowIndex = 0; rowIndex < this.rows; rowIndex++) {
            const currentRow: GridData[] = [];
            this.gridList.push(currentRow);
            for (let columnIndex = 0; columnIndex < this.cols; columnIndex++) {
                const gridData = this.createGridData(rowIndex, columnIndex);
                currentRow.push(gridData);
                this.createGridNode(gridData);
            }
        }

        // 初始化格子状态
        for (let rowIndex = 0; rowIndex < this.rows; rowIndex++) {
            for (let columnIndex = 0; columnIndex < this.cols; columnIndex++) {
                this.gridList[rowIndex][columnIndex].status = CellState.EMPTY
                this.generateGrid(this.gridList[rowIndex][columnIndex])
            }
        }
        // 初始化方块
        if (this.brickNode) {
            if (this.brickNode) {
                this.brickNode.children.forEach(node => { node.destroy() });
            }
        }
        this.bricksList.length = 0
        for (let i = 1; i <= this.brickNum; i++) {
            this.addBrick(i)
        }
        // 清除旋转数据
        if (this.rotateNode) {
            this.rotateNode.children.forEach(node => { node.destroy() })
        }
    }

    /**
     * @description: 创建格子数据
     * @param {number} row
     * @param {number} column
     * @return {*}
     */
    private createGridData(row: number, column: number): GridData {
        return {
            name: `Grid-${row}-${column}`,
            status: CellState.EMPTY,
            gridNode: null,
            row: row,
            col: column,
            type: 0
        };
    }


    /**
     * @description: 创建网格Node
     * @param {GridData} gridData
     * @return {*}
     */
    private createGridNode(gridData: GridData): void {
        const gridNode = new Node(gridData.name);
        if (this.gridNode) {
            this.gridNode.addChild(gridNode);
        }
        gridData.gridNode = gridNode;
        // 设置网格大小
        gridNode.addComponent(UITransform).setContentSize(this.itemSize, this.itemSize);
    }

    /**
     * 生成或更新网格
     * @param gridData 网格数据
     */
    private generateGrid(gridData: GridData) {
        if (!gridData || !gridData.gridNode) {
            console.warn('无效的网格数据');
            return;
        }

        // 清理现有子节点
        this.clearGridChildren(gridData.gridNode);

        // 获取对应的预制体
        const prefab = this.getGridPrefab(gridData);
        if (!prefab) {
            console.warn('无法获取网格预制体');
            return;
        }
        // 创建并配置新节点
        const node = this.createNewGridNode(prefab, gridData);
        // 设置节点属性
        this.setupGridNode(node, gridData);
    }


    /**
     * 获取对应状态的预制体
     */
    private getGridPrefab(gridData: GridData): Prefab {
        if (gridData.status === CellState.EMPTY) {
            if (this.itemPrefabs[0]) {
                return this.itemPrefabs[0];
            } else {
                throw new Error('Grid prefab is not loaded');
            }
        }

        if (gridData.status === CellState.FILLED && gridData.type) {
            const type = gridData.type;
            return this.itemPrefabs[type];
        }
        throw new Error('Invalid grid status or missing gridColorKey');
    }


    /**
     * 创建网格节点
     */
    private createNewGridNode(prefab: Prefab, gridData: GridData): Node {
        const node = instantiate(prefab);
        if (gridData && gridData.gridNode) {
            gridData.gridNode.addChild(node);
            return node;
        }
        return node
    }

    /**
     * 设置网格节点的属性
     */
    private setupGridNode(node: Node, gridData: GridData): void {
        // 设置未使用状态的颜色
        if (gridData.status === CellState.EMPTY) {
            const sprite = node.getComponent(Sprite);
            if (sprite) {
                sprite.color = this.notUseColor;
            }
        }
        // 设置节点大小
        const transform = node.getComponent(UITransform);
        if (transform) {
            transform.setContentSize(
                this.itemSize,
                this.itemSize
            );
        }
        // 设置位置
        node.setPosition(Vec3.ZERO);
    }



    addBrick(index: number) {
        //随机名字
        const brickKey = Object.keys(this.brickConfig['bricks'])[randomRangeInt(0, Object.keys(this.brickConfig['bricks']).length)]
        const brickConfig = this.brickConfig['bricks'][brickKey];
        const randomIndex = oops.random.getRandomInt(1, 5);
        // 生成方块
        const brickData: BrickData = {
            index,
            brickKey: brickKey,
            rotateFlag: brickConfig['rotateFlag'],
            gridConfig: brickConfig['gridConfig'],
            deg: 0,
            brickNode: null,
            brickInitPos: new Vec3(),
            rotateTag: false,
            type: randomIndex,
        }
        this.bricksList.push(brickData)
        // 生成方块
        const brickNode = this.generateBrick(brickKey, randomIndex);
        if (this.brickNode) {
            this.brickNode.addChild(brickNode)
        }
        brickData.brickNode = brickNode;
        let offset = 220
        if (this.brickNum % 2 === 1) {
            const middleNum = Math.floor(this.brickNum / 2) + 1
            if (index < middleNum) {
                offset = - offset
            }
            else if (index === middleNum) {
                offset = 0
            }
        }
        if (brickData && brickData.brickNode) {
            brickData.brickNode.setPosition(offset, 0)
            brickData.brickNode.scale_x = 0.6;
            brickData.brickNode.scale_y = 0.6;
            brickData.brickInitPos = brickData.brickNode.getWorldPosition()
        }
        this.brickAddEvent(brickData);
        //2508801946299286
    }



    // 每个item生成独立的方块节点
    generateBrick(brickKey: string, randomIndex: number) {
        const brickConfig = this.brickConfig['bricks'][brickKey]
        let rowMin = 0
        let rowMax = 0
        let columnMin = 0
        let columnMax = 0
        brickConfig['gridConfig'].forEach((gridConfigData: GridConfigData) => {
            if (gridConfigData.row < rowMin) {
                rowMin = gridConfigData.row
            }
            else if (gridConfigData.row > rowMax) {
                rowMax = gridConfigData.row
            }
            if (gridConfigData.column < columnMin) {
                columnMin = gridConfigData.column
            }
            else if (gridConfigData.column > columnMax) {
                columnMax = gridConfigData.column
            }
        })
        const rowNum = (rowMax - rowMin + 1)
        const columnNum = (columnMax - columnMin + 1)
        // 生成独立的方块节点
        const brickNode = new Node()
        brickNode.name = brickKey
        // 设置方块大小
        const transformCom: UITransform = brickNode.addComponent(UITransform)
        transformCom.setContentSize(
            this.itemSize * columnNum,
            this.itemSize * rowNum
        )
        transformCom.setAnchorPoint(0.5, 0.5)

        // 设置方块位置
        const gridPrefab = this.itemPrefabs[randomIndex]
        //生成对应的配置方块设置地址
        brickConfig['gridConfig'].forEach((gridConfigData: GridConfigData) => {
            const gridNode = new Node()
            gridNode.name = 'grid'
            brickNode.addChild(gridNode)
            gridNode.addComponent(UITransform).setContentSize(this.itemSize, this.itemSize)
            const gridWidget: Widget = gridNode.addComponent(Widget)
            gridWidget.isAlignLeft = true
            gridWidget.left = this.itemSize * gridConfigData.column - this.itemSize * columnMin
            gridWidget.isAlignBottom = true
            gridWidget.bottom = this.itemSize * gridConfigData.row - this.itemSize * rowMin
            const node = instantiate(gridPrefab)
            gridNode.addChild(node)
            const uiTransform = node.getComponent(UITransform);
            if (uiTransform) {
                uiTransform.setContentSize(
                    this.itemSize,
                    this.itemSize,
                )
            }
            node.setPosition(Vec3.ZERO)
            node.on(Node.EventType.TOUCH_START, (event: EventTouch) => {
                event.preventSwallow = true;
            }, this);
            node.on(Node.EventType.TOUCH_MOVE, (event: EventTouch) => {
                event.preventSwallow = true;
            }, this);
            node.on(Node.EventType.TOUCH_END, (event: EventTouch) => {
                event.preventSwallow = true;
            }, this);
        })
        return brickNode
    }

    touchStartLocation = new Vec2()
    touchStartFlag = false
    brickAddEvent(brickData: BrickData) {
        const brickNode = brickData.brickNode
        if (!brickNode) {
            console.error("brickNode为空，无法添加事件");
            return
        }

        // 确保节点可交互
        brickNode.active = true;

        // 移除可能存在的旧事件监听器
        brickNode.off(Node.EventType.TOUCH_START);
        brickNode.off(Node.EventType.TOUCH_MOVE);
        brickNode.off(Node.EventType.TOUCH_END);
        brickNode.off(Node.EventType.TOUCH_CANCEL);

        // 记录初始位置和状态
        let startPos = new Vec3();
        let originalParent: Node | null = null;
        let isDragging = false;

        // 触摸开始事件
        brickNode.on(Node.EventType.TOUCH_START, (event: EventTouch) => {
            // 如果正在编辑其他方块，则忽略
            if (this.editingFlag) return;

            // 设置编辑状态
            this.editingFlag = true;
            isDragging = true;
            this.touchStartFlag = true;

            // 清空编辑中的数据
            this.editingData.brickData = null;
            this.editingData.gridList.length = 0;

            // 记录触摸开始位置和方块原始信息
            this.touchStartLocation.set(event.getUILocation());
            originalParent = brickNode.parent;
            startPos = brickNode.getWorldPosition().clone();

            // 将方块移到移动层并放大
            brickNode.setParent(this.moveNode);
            brickNode.setWorldPosition(startPos);
            tween(brickNode)
                .to(0.2, { scale: new Vec3(1, 1, 1) })
                .start();

            // 从方块列表中移除该方块
            const index = this.bricksList.findIndex(item => item === brickData);
            if (index > -1) {
                this.editingData.brickData = this.bricksList.splice(index, 1)[0];
            } else {
                console.error("未找到方块数据:", brickData);
                this.editingData.brickData = brickData;
            }

            // 清除旋转数据
            if (this.rotateFlag && this.rotateBrickData !== this.editingData.brickData) {
                this.rotateFlag = false;
                this.rotateBrickData = null;
                if (this.rotateNode) {
                    this.rotateNode.children.forEach(node => { node.destroy() });
                }
            }
        }, this);

        // 触摸移动事件
        brickNode.on(Node.EventType.TOUCH_MOVE, (event: EventTouch) => {
            if (!isDragging || !this.editingData.brickData) return;

            // 清除旋转数据
            if (event.getUILocation().subtract(this.touchStartLocation).length() >= this.rotateFaultTolerant) {
                this.rotateFlag = false;
                this.rotateBrickData = null;
                if (this.rotateNode) {
                    this.rotateNode.children.forEach(node => { node.destroy() });
                }
            }

            // 恢复所有网格颜色
            this.gridColorRecovery();

            // 移动方块
            brickNode.setWorldPosition(brickNode.getWorldPosition().add(event.getUIDelta().toVec3()));

            // 重置编辑中的网格数据
            this.editingData.gridList.length = 0;

            // 检查方块每个子网格是否与游戏网格重叠
            const tempGridList: GridData[] = [];
            let allEmptyGrids: boolean = true; // 标记是否所有网格都为空

            brickNode.children.forEach((childNode) => {
                const childWorldPos = childNode.getWorldPosition();

                // 查找与子网格重叠的游戏网格
                let matchedGrid: GridData | null = null;
                for (let row = 0; row < this.rows && !matchedGrid; row++) {
                    for (let col = 0; col < this.cols && !matchedGrid; col++) {
                        const grid = this.gridList[row][col];
                        if (!grid || !grid.gridNode) continue;

                        const gridPos = grid.gridNode.getWorldPosition();
                        if (Vec3.distance(gridPos, childWorldPos) <= (this.itemSize / 2)) {
                            matchedGrid = grid;
                        }
                    }
                }

                if (matchedGrid) {
                    tempGridList.push(matchedGrid);
                    // 检查是否有非空网格
                    if (matchedGrid.status !== CellState.EMPTY) {
                        allEmptyGrids = false;
                    }
                }
            });

            // 检查是否所有子网格都有对应的游戏网格，且都是空的
            let canPlace = tempGridList.length === brickData.gridConfig.length && allEmptyGrids;

            // 更新编辑中的网格列表
            if (canPlace) {
                this.editingData.gridList = [...tempGridList];
            }

            // 更新网格颜色提示 - 只改变空网格的颜色
            tempGridList.forEach(grid => {
                // 只处理空网格
                if (grid.status === CellState.EMPTY) {
                    if (grid.gridNode && grid.gridNode.children[0]) {
                        const sprite = grid.gridNode.children[0].getComponent(Sprite);
                        if (sprite) {
                            sprite.color = canPlace ? this.usableColor : this.unavailableColor;
                        }
                    }
                    // 用于后续恢复颜色
                    this.gridColorList.push(grid);
                }
            });
        }, this);

        // 触摸结束或取消事件
        const touchEndHandler = (event: EventTouch) => {
            if (!isDragging) return;
            isDragging = false;
            this.touchStartFlag = false;

            // 恢复网格颜色
            this.gridColorRecovery();

            // 防止如放回方块回弹动画时，已经触摸在另一个方块上面
            if (this.editingData.brickData !== brickData) return;

            // 检查是否可以放置
            if (this.editingData.brickData && this.editingData.gridList.length > 0) {
                // 计算放置的格子数量
                const placedGridCount = this.editingData.gridList.length;

                // 获取中心位置用于显示分数
                let centerPos = new Vec3(0, 0, 0);
                if (this.editingData.gridList.length > 0 && this.editingData.gridList[0].gridNode) {
                    centerPos = this.editingData.gridList[0].gridNode.getWorldPosition().clone();
                    if (this.editingData.gridList.length > 1) {
                        // 计算所有格子的平均位置作为中心点
                        for (let i = 1; i < this.editingData.gridList.length; i++) {
                            const gridNode = this.editingData.gridList[i].gridNode;
                            if (gridNode) {
                                centerPos.add(gridNode.getWorldPosition());
                            }
                        }
                        const validGridCount = this.editingData.gridList.filter(grid => grid.gridNode).length;
                        centerPos.x /= validGridCount;
                        centerPos.y /= validGridCount;
                    }
                }

                // 放置方块到网格
                this.editingData.gridList.forEach(grid => {
                    grid.status = CellState.FILLED;
                    grid.type = this.editingData.brickData!.type;
                    this.generateGrid(grid);
                });

                // 显示放置得分动画（显示一次，包含总格子数）
                this.showScoreAnimation(centerPos, placedGridCount);

                // 标记需要重置消除计数器
                this.shouldResetEliminateCount = true;
                this.consecutiveEliminations = true;

                // 销毁方块节点
                brickNode.destroy();

                // 添加新方块到待选区
                this.addBrick(this.editingData.brickData.index);

                // 检查消除
                this.scheduleOnce(() => {
                    this.gridEliminate().then((hasElimination) => {
                        // 如果没有消除，确保下次消除会重置计数
                        if (!hasElimination) {
                            this.shouldResetEliminateCount = true;
                        }

                        // 检查游戏是否结束
                        this.prompt(false).then(canContinue => {
                            if (!canContinue) {
                                this.gameOver();
                            }
                            this.editingFlag = false;
                        });
                    });
                }, 0.1);
            } else if (this.rotateFlag) {
                // 旋转方块
                const brickData = this.editingData.brickData;
                this.brickGridRotate(brickData);
                // 方块放回待选区
                this.bricksList.push(brickData);
                if (this.brickNode && brickData.brickNode) {
                    this.brickNode.addChild(brickData.brickNode);
                    tween(brickData.brickNode)
                        .to(0.2, {
                            worldPosition: brickData.brickInitPos,
                            scale: new Vec3(0.6, 0.6, 0.6)
                        })
                        .start();
                }
                this.editingFlag = false;
            } else {
                // 无法放置，将方块返回原位置
                const brickData = this.editingData.brickData;
                if (brickData) {
                    this.bricksList.push(brickData);

                    // 添加回弹动画
                    tween(brickNode)
                        .to(0.2, {
                            worldPosition: brickData.brickInitPos,
                            scale: new Vec3(0.6, 0.6, 0.6)
                        })
                        .call(() => {
                            if (originalParent) {
                                brickNode.setParent(originalParent);
                                brickNode.setWorldPosition(brickData.brickInitPos);
                            }
                            this.editingFlag = false;
                        })
                        .start();
                } else {
                    this.editingFlag = false;
                }
            }

            // 检查是否需要处理旋转（短距离移动视为点击）
            if (!this.rotateFlag &&
                this.editingData.brickData &&
                this.editingData.brickData.rotateFlag &&
                event.getUILocation().subtract(this.touchStartLocation).length() < this.rotateFaultTolerant) {
                this.rotateFlag = true;
                this.rotateBrickData = this.editingData.brickData;

                // 显示旋转提示
                if (this.rotatePrefab && this.rotateNode && brickNode) {
                    const rotateIndicator = instantiate(this.rotatePrefab);
                    this.rotateNode.addChild(rotateIndicator);
                    rotateIndicator.setWorldPosition(brickNode.getWorldPosition());
                }
            }
        };

        brickNode.on(Node.EventType.TOUCH_END, touchEndHandler, this);
        brickNode.on(Node.EventType.TOUCH_CANCEL, touchEndHandler, this);
    }

    //格子颜色恢复
    gridColorRecovery() {
        while (this.gridColorList.length > 0) {
            const gridData = this.gridColorList.pop();
            if (gridData) {
                if (gridData.status === CellState.EMPTY) {
                    if (gridData.gridNode) {
                        gridData.gridNode.children[0].getComponent(Sprite)!.color = this.notUseColor;
                    }
                }
            }
        }
    }

    brickGridRotate(brickData: BrickData) {
        const next = this.nextGridRotate(brickData.gridConfig, brickData.deg)
        brickData.deg = next.deg
        brickData.gridConfig = next.gridConfig;
        if (brickData.brickNode) {
            tween(brickData.brickNode).to(0.1, { angle: next.deg }).start();
        }
        // this.audioManager.playRotate()
    }

    //下一个旋转
    nextGridRotate(gridConfig: GridConfigData[], deg: number) {
        const newGridConfig: GridConfigData[] = []
        // 顺时针旋转
        let newDeg = deg - 90
        gridConfig.forEach((gridConfigData) => {
            // 例如（1，2） => （-2，1），可以画图分析
            newGridConfig.push({
                row: -gridConfigData.column,
                column: gridConfigData.row
            })
        })
        return { gridConfig: newGridConfig, deg: newDeg }
    }

    // 显示分数增加动画
    showScoreAnimation(position: Vec3, score: number) {
        if (!this.lab_addScore) return;

        // 复制得分Label
        const scoreLabel = instantiate(this.lab_addScore.node);
        scoreLabel.active = true;

        // 设置文本和位置
        const label = scoreLabel.getComponent(Label);
        if (label) {
            label.string = `+${score}`;
        }

        // 添加到场景中
        this.node.addChild(scoreLabel);
        scoreLabel.setWorldPosition(position);

        // 创建动画效果
        tween(scoreLabel)
            .to(0.5, {
                position: new Vec3(scoreLabel.position.x, scoreLabel.position.y + 50, 0),
                scale: new Vec3(1.2, 1.2, 1.2)
            })
            .to(0.3, { opacity: 0 })
            .call(() => {
                scoreLabel.destroy();
            })
            .start();

        // 更新总分
        this.score += score;
        this.lab_score.string = this.score.toString();
        //计算总分够一局没有，够就马上停止，展示界面

    }

    // 显示消除次数动画
    showEliminateCountAnimation(yPosition: number) {
        if (!this.lab_total) return;

        // 如果需要重置计数器，先将计数归零
        if (this.shouldResetEliminateCount) {
            this.totalNum = 0;
            this.shouldResetEliminateCount = false;
        }

        // 增加累计消除次数
        this.totalNum++;

        // 复制总次数Label
        const totalLabel = instantiate(this.lab_total.node);
        totalLabel.active = true;

        // 设置文本
        const label = totalLabel.getComponent(Label);
        if (label) {
            label.string = `Combo${this.totalNum}`;
        }

        // 添加到场景中
        this.node.addChild(totalLabel);

        // 计算网格区域的X轴中心位置，Y轴使用传入的消除行位置
        const centerPos = new Vec3();
        if (this.gridNode) {
            // 获取网格区域的X轴中心
            const worldPos = this.gridNode.getWorldPosition();
            centerPos.set(worldPos.x, yPosition, worldPos.z);
        }

        totalLabel.setWorldPosition(centerPos);

        // 创建动画效果
        tween(totalLabel)
            .to(0.3, {
                scale: new Vec3(1.5, 1.5, 1.5),
                opacity: 255
            })
            .delay(0.5) // 停留更长时间
            .to(0.4, {
                scale: new Vec3(1.2, 1.2, 1.2),
                position: new Vec3(totalLabel.position.x, totalLabel.position.y + 50, 0),
                opacity: 0
            })
            .call(() => {
                totalLabel.destroy();
            })
            .start();
    }

    // 修改 gridEliminate 方法来显示消除次数
    gridEliminate() {
        return new Promise<boolean>((resolve, reject) => {
            const d = this.gridEliminateCheck(this.gridList)
            const gridEliminateList = d.gridEliminateList
            const eliminateRowNum = d.eliminateRowNum
            const eliminateColumnNum = d.eliminateColumnNum

            if (gridEliminateList.length < 1) {
                // 没有发生消除
                this.shouldResetEliminateCount = true;  // 下一次消除需要重置计数
                this.consecutiveEliminations = false;   // 不是连续消除
                resolve(false);
                return;
            }

            // 如果有消除，计算消除行的平均Y轴位置
            if (gridEliminateList.length > 0) {
                // 计算所有被消除格子的平均Y轴位置
                let totalY = 0;
                let validGrids = 0;
                for (const grid of gridEliminateList) {
                    if (grid.gridNode) {
                        totalY += grid.gridNode.getWorldPosition().y;
                        validGrids++;
                    }
                }
                // 计算平均Y位置
                const avgY = validGrids > 0 ? totalY / validGrids : 0;

                // 标记为连续消除
                this.consecutiveEliminations = true;

                // 显示消除次数动画，传入Y轴位置
                this.showEliminateCountAnimation(avgY);
            }

            gridEliminateList.forEach((gridData) => {
                if (gridData.gridNode?.children[0]) {
                    const startPos = gridData.gridNode.getWorldPosition();
                    tween(gridData.gridNode.children[0])
                        .to(0.2, { scale: new Vec3(0.5, 0.5) })
                        .call(() => {
                            gridData.status = CellState.EMPTY
                            this.generateGrid(gridData)
                        })
                        .start()

                    if (this.coinPrefab && this.amountLb?.node) {
                        this.createCoinFlyAnimation(
                            this.coinPrefab,
                            startPos,
                            this.amountLb.node.getWorldPosition(),
                            5
                        );
                    }
                    //增加红包
                    this.createCoinFlyAnimation(
                        this.redPacketPrefab,
                        startPos,
                        this.awardLb.node.getWorldPosition(),
                        5
                    );
                }
            })

            this.scheduleOnce(() => {
                let score = 0
                for (let i = 1; i <= eliminateRowNum; i++) {
                    score += this.cols * i
                }
                for (let i = 1; i <= eliminateColumnNum; i++) {
                    score += this.rows * i
                }
                this.score += score
                this.lab_score.string = this.score.toString();

                const lastGrid = gridEliminateList[gridEliminateList.length - 1];
                if (lastGrid?.gridNode && this.coinPrefab && this.amountLb?.node) {
                    const lastPos = lastGrid.gridNode.getWorldPosition();

                    // 添加回调函数，在金币动画完成后显示微信分数增加
                    this.createCoinFlyAnimation(
                        this.coinPrefab,
                        lastPos,
                        this.amountLb.node.getWorldPosition(),
                        score,
                        () => {
                            // 显示微信分数增加动画
                            this.showWechatScoreAnimation();
                        }
                    );

                    // 添加回调函数，在红包动画完成后显示红包分数增加
                    this.createCoinFlyAnimation(
                        this.redPacketPrefab,
                        lastPos,
                        this.awardLb.node.getWorldPosition(),
                        5,
                        () => {
                            // 显示红包分数增加动画
                            this.showRedPacketScoreAnimation();
                        }
                    );
                }

                // 告诉调用者有消除发生
                resolve(true)

                // 检查是否需要继续消除
                this.scheduleOnce(() => {
                    // 递归调用，检查并处理连锁消除
                    this.gridEliminate().then(() => {
                        // 连锁消除结束，不做额外处理
                    });
                }, 0.2);
            }, 0.2)
        })
    }


    gridEliminateCheck(gridList: GridData[][]) {
        const gridEliminateList: GridData[] = []
        let eliminateRowNum = 0
        let eliminateColumnNum = 0
        // 行检查
        for (let rowIndex = 0; rowIndex < this.rows; rowIndex++) {
            const rowData = gridList[rowIndex]
            if (rowData.every(gridData => gridData.status === CellState.FILLED)) {
                rowData.forEach(gridData => {
                    if (gridEliminateList.findIndex(data => data === gridData) < 0) {
                        gridEliminateList.push(gridData)
                    }
                })
                eliminateRowNum += 1
            }
        }
        // 列检查
        for (let columnIndex = 0; columnIndex < this.cols; columnIndex++) {
            if (gridList.every(rowData => rowData[columnIndex].status === CellState.FILLED)) {
                gridList.forEach(rowData => {
                    const gridData = rowData[columnIndex]
                    if (gridEliminateList.findIndex(data => data === gridData) < 0) {
                        gridEliminateList.push(gridData)
                    }
                })
                eliminateColumnNum += 1
            }
        }
        return {
            gridEliminateList,
            eliminateRowNum,
            eliminateColumnNum,
        }
    }

    // 修改 createCoinFlyAnimation 方法，添加回调
    private createCoinFlyAnimation(prefab: Prefab, startPos: Vec3, endPos: Vec3, count: number, callback?: Function) {
        if (!prefab) return;

        let completedCount = 0;
        const totalCoins = Math.min(count, 10); // 限制最大数量

        for (let i = 0; i < totalCoins; i++) {
            const coin = instantiate(prefab);
            this.node.addChild(coin);
            coin.setWorldPosition(startPos);

            // 随机偏移起始位置
            const randomOffset = new Vec3(
                (Math.random() - 0.5) * 50,
                (Math.random() - 0.5) * 50,
                0
            );

            // 创建曲线动画
            tween(coin)
                .to(0.2, {
                    position: new Vec3(
                        coin.position.x + randomOffset.x,
                        coin.position.y + randomOffset.y,
                        0
                    )
                })
                .to(0.5, { worldPosition: endPos })
                .call(() => {
                    coin.destroy();
                    completedCount++;

                    // 所有金币动画完成后执行回调
                    if (completedCount === totalCoins && callback) {
                        callback();
                    }
                })
                .start();
        }
    }

    // 显示微信分数增加动画
    private showWechatScoreAnimation() {
        if (!this.tweenWechatNode) return;

        // 生成随机小数（小于1，保留2位小数）
        const randomValue = Math.random() * 0.99;
        const formattedValue = randomValue.toFixed(2);

        // 获取并设置分数标签
        const scoreLabel = this.tweenWechatNode.getChildByName("lab_num")?.getComponent(Label);
        if (scoreLabel) {
            scoreLabel.string = "+" + formattedValue;
        }

        // 保存原始位置
        const originalPosition = this.tweenWechatNode.position.clone();

        // 显示节点
        this.tweenWechatNode.active = true;

        // 创建向上移动的动画
        tween(this.tweenWechatNode)
            .to(0.8, {
                position: new Vec3(
                    originalPosition.x,
                    originalPosition.y + 80,
                    originalPosition.z
                ),
                opacity: 255
            })
            .to(0.2, { opacity: 0 })
            .call(() => {
                // 重置位置
                this.tweenWechatNode.setPosition(originalPosition);
                this.tweenWechatNode.active = false;

                // 更新总金额
                if (this.amountLb) {
                    const currentAmount = parseFloat(this.amountLb.string);
                    const newAmount = currentAmount + parseFloat(formattedValue);
                    this.money = newAmount;
                    this.amountLb.string = newAmount.toFixed(2);
                }
            })
            .start();
    }

    // 显示红包分数增加动画
    private showRedPacketScoreAnimation() {
        if (!this.tweenRedNode) return;

        // 生成随机小数（小于1，保留2位小数）
        const randomValue = Math.random() * 0.99;
        const formattedValue = randomValue.toFixed(2);

        // 获取并设置分数标签
        const scoreLabel = this.tweenRedNode.getChildByName("lab_num")?.getComponent(Label);
        if (scoreLabel) {
            scoreLabel.string = "+" + formattedValue;
        }

        // 保存原始位置
        const originalPosition = this.tweenRedNode.position.clone();

        // 显示节点
        this.tweenRedNode.active = true;

        // 创建向上移动的动画
        tween(this.tweenRedNode)
            .to(0.8, {
                position: new Vec3(
                    originalPosition.x,
                    originalPosition.y + 80,
                    originalPosition.z
                ),
                opacity: 255
            })
            .to(0.2, { opacity: 0 })
            .call(() => {
                // 重置位置
                this.tweenRedNode.setPosition(originalPosition);
                this.tweenRedNode.active = false;

                // 更新总红包金额
                if (this.awardLb) {
                    const currentAmount = parseFloat(this.awardLb.string);
                    const newAmount = currentAmount + parseFloat(formattedValue);
                    this.cash = newAmount;
                    this.awardLb.string = newAmount.toFixed(2);
                }
            })
            .start();
    }

    // 提示
    prompt(tipFlag = true) {
        return new Promise((resolve, reject) => {
            const gridPromptList: GridData[] = []
            let moveFlag = false
            // 找方块可消除位置
            for (let rowIndex = 0; rowIndex < this.rows && !moveFlag; rowIndex++) {
                for (let columnIndex = 0; columnIndex < this.cols && !moveFlag; columnIndex++) {
                    const gridData = this.gridList[rowIndex][columnIndex]
                    if (gridData.status !== CellState.EMPTY) continue
                    // 方块不旋转检测是否能放
                    for (let brickI = 0; brickI < this.bricksList.length && !moveFlag; brickI++) {
                        const brickData = this.bricksList[brickI]
                        if (this.moveIf(rowIndex, columnIndex, brickData.gridConfig)) {
                            // 复制整体网格，以方块设置网格状态
                            const gridList = this.copyGridList()
                            brickData.gridConfig.forEach((gridConfigData) => {
                                gridList[gridConfigData.row + rowIndex][gridConfigData.column + columnIndex].status = CellState.FILLED
                            })
                            // 检查复制的整体网格是否有可消除
                            if (this.gridEliminateCheck(gridList).gridEliminateList.length > 0) {
                                moveFlag = true
                                brickData.gridConfig.forEach((gridConfigData) => {
                                    gridPromptList.push(this.gridList[gridConfigData.row + rowIndex][gridConfigData.column + columnIndex])
                                })
                            }
                        }
                    }
                    // 方块旋转检测是否能放
                    for (let brickI = 0; brickI < this.bricksList.length && !moveFlag; brickI++) {
                        const brickData = this.bricksList[brickI]
                        if (!brickData.rotateFlag) continue
                        let gridConfig = brickData.gridConfig
                        let deg = brickData.deg
                        // 获得旋转的方块网格配置
                        for (let count = 1; count <= 3 && !moveFlag; count++) {
                            const next = this.nextGridRotate(gridConfig, deg)
                            if (this.moveIf(rowIndex, columnIndex, next.gridConfig)) {
                                // 复制整体网格，以方块设置网格状态
                                const gridList = this.copyGridList()
                                next.gridConfig.forEach((gridConfigData) => {
                                    gridList[gridConfigData.row + rowIndex][gridConfigData.column + columnIndex].status = CellState.FILLED
                                })
                                // 检查复制的整体网格是否有可消除
                                if (this.gridEliminateCheck(gridList).gridEliminateList.length > 0) {
                                    moveFlag = true
                                    next.gridConfig.forEach((gridConfigData) => {
                                        gridPromptList.push(this.gridList[gridConfigData.row + rowIndex][gridConfigData.column + columnIndex])
                                    })
                                }
                            }
                            gridConfig = next.gridConfig
                            deg = next.deg
                        }
                    }
                }
            }
            // 找方块可放置位置
            for (let rowIndex = 0; rowIndex < this.rows && !moveFlag; rowIndex++) {
                for (let columnIndex = 0; columnIndex < this.cols && !moveFlag; columnIndex++) {
                    const gridData = this.gridList[rowIndex][columnIndex]
                    if (gridData.status !== CellState.EMPTY) continue
                    // 方块不旋转检测是否能放
                    for (let brickI = 0; brickI < this.bricksList.length && !moveFlag; brickI++) {
                        const brickData = this.bricksList[brickI]
                        if (this.moveIf(rowIndex, columnIndex, brickData.gridConfig)) {
                            moveFlag = true
                            brickData.gridConfig.forEach((gridConfigData) => {
                                gridPromptList.push(this.gridList[gridConfigData.row + rowIndex][gridConfigData.column + columnIndex])
                            })
                        }
                    }
                    // 方块旋转检测是否能放
                    for (let brickI = 0; brickI < this.bricksList.length && !moveFlag; brickI++) {
                        const brickData = this.bricksList[brickI]
                        if (!brickData.rotateFlag) continue
                        let gridConfig = brickData.gridConfig
                        let deg = brickData.deg
                        for (let count = 1; count <= 3 && !moveFlag; count++) {
                            const next = this.nextGridRotate(gridConfig, deg)
                            if (this.moveIf(rowIndex, columnIndex, next.gridConfig)) {
                                moveFlag = true
                                next.gridConfig.forEach((gridConfigData) => {
                                    gridPromptList.push(this.gridList[gridConfigData.row + rowIndex][gridConfigData.column + columnIndex])
                                })
                            }
                            gridConfig = next.gridConfig
                            deg = next.deg
                        }
                    }
                }
            }

            if (gridPromptList.length < 1) {
                resolve(false)
                return
            }
            if (!tipFlag) {
                resolve(true)
                return
            }
            // 提示用户（网格变绿）
            gridPromptList.forEach((gridData) => {
                if (gridData.gridNode && gridData.gridNode.children[0]) {
                    const sprite = gridData.gridNode.children[0].getComponent(Sprite);
                    if (sprite) {
                        sprite.color = this.usableColor;
                    }
                }
                // 用于恢复格子
                this.gridColorList.push(gridData)
            })
            resolve(true)
        })
    }

    moveIf(row: number, column: number, gridConfig: GridConfigData[]) {
        let moveFlag = true
        for (let i = 0; i < gridConfig.length; i++) {
            const gridConfigData = gridConfig[i]
            const gridI = row + gridConfigData.row
            const gridJ = column + gridConfigData.column
            // 边界判断
            if (
                gridI < 0 ||
                gridI > this.rows - 1 ||
                gridJ < 0 ||
                gridJ > this.cols - 1
            ) {
                moveFlag = false
                break
            }
            // 已用
            else if (this.gridList[gridI][gridJ].status === CellState.FILLED) {
                moveFlag = false
                break
            }
        }
        return moveFlag
    }

    // 复制整体网格
    copyGridList() {
        const gridList: GridData[][] = []
        for (let rowIndex = 0; rowIndex < this.rows; rowIndex++) {
            gridList.push([])
            for (let columnIndex = 0; columnIndex < this.cols; columnIndex++) {
                const gridData = this.gridList[rowIndex][columnIndex]
                gridList[rowIndex].push({
                    name: gridData.name,
                    status: gridData.status,
                    gridNode: null,
                    row: gridData.row,
                    col: gridData.col,
                    type: gridData.type,
                })
            }
        }
        return gridList
    }

    gameOver() {
        this.gameState = GameState.GAME_OVER
        this.setGameState(GameState.GAME_OVER)
        console.log("游戏结束")
        oops.gui.open(UIID.GameOver);
    }


    /**
     * 清理网格的子节点
     */
    private clearGridChildren(gridNode: Node): void {
        const children = gridNode.children.slice(); // 创建副本避免遍历时修改问题
        children.forEach(node => node.destroy());
    }

    private setGameState(state: GameState) {
        this.gameState = state;
        switch (state) {
            case GameState.READY:
                break;
            case GameState.PLAYING:
                break;
            case GameState.PAUSED:
                break;
            case GameState.GAME_OVER:
                //打开游戏结束界面
                break;
        }
    }



    //========================打开其他界面和按钮逻辑=======================

    /** 视图对象通过 ecs.Entity.remove(eliminateViewComp) 删除组件是触发组件处理自定义释放逻辑 */
    reset() {
        this.node.destroy();
    }

    //设置按钮
    private btn_setting() {
        oops.gui.open(UIID.Setting);
    }

    //左边微信按钮
    private btn_withdraw() {
        oops.gui.open(UIID.WechatWithdraw);
    }

    //顶部红包按钮
    private btn_award() {
        oops.gui.open(UIID.RedPacketWithdraw);
    }

    //二倍速按钮
    private btn_double() {
        oops.gui.open(UIID.DoubleSpeed);
    }


    //自动按钮
    private btn_auto() {
        //自动放置
        this.autoState = !this.autoState;
        this.initButtonState(this.autoState);
        if (this.autoState) {
            this.gameState = GameState.PLAYING;
            this.executeAutoPlace()
        }
    }


    executeAutoPlace() {
        if (!this.autoState || this.gameState !== GameState.PLAYING || this.editingFlag) {
            return
        }
        console.log("开始自动放置")
        const bestPlacement = this.findBestPlacement()
        if (!bestPlacement) {
            // 所有方块都无法放置，游戏结束
            this.autoState = false
            this.gameOver()
            return
        }

        // 执行放置
        this.placeBrickAtPosition(bestPlacement)
    }

    findBestPlacement() {
        const placements = []

        // 对每个方块计算所有可能的放置位置和分数
        for (let brickIndex = 0; brickIndex < this.bricksList.length; brickIndex++) {
            const brickData = this.bricksList[brickIndex]

            // 检查不同旋转状态
            let gridConfigs = [brickData.gridConfig]
            let degrees = [brickData.deg]

            // 如果可旋转，计算所有旋转状态
            if (brickData.rotateFlag) {
                for (let i = 1; i <= 3; i++) {
                    const next = this.nextGridRotate(
                        i === 1 ? brickData.gridConfig : gridConfigs[i - 1],
                        i === 1 ? brickData.deg : degrees[i - 1]
                    )
                    gridConfigs.push(next.gridConfig)
                    degrees.push(next.deg)
                }
            }

            // 遍历所有网格位置
            for (let rowIndex = 0; rowIndex < this.rows; rowIndex++) {
                for (let columnIndex = 0; columnIndex < this.cols; columnIndex++) {
                    // 对每个旋转状态检查
                    for (let rotateIndex = 0; rotateIndex < gridConfigs.length; rotateIndex++) {
                        const currentGridConfig = gridConfigs[rotateIndex]
                        const currentDeg = degrees[rotateIndex]

                        // 检查是否可以放置
                        if (this.moveIf(rowIndex, columnIndex, currentGridConfig)) {
                            // 复制网格并模拟放置
                            const gridList = this.copyGridList()
                            currentGridConfig.forEach((gridConfigData) => {
                                const r = gridConfigData.row + rowIndex
                                const c = gridConfigData.column + columnIndex
                                gridList[r][c].status = CellState.FILLED
                                // gridList[r][c].gridColorKey = brickData.gridColorKey
                                gridList[r][c].type = brickData.type;
                            })

                            // 检查是否可以消除，计算分数
                            const elimination = this.gridEliminateCheck(gridList)
                            let score = 0

                            if (elimination.gridEliminateList.length > 0) {
                                // 计算消除得分
                                for (let i = 1; i <= elimination.eliminateRowNum; i++) {
                                    score += this.cols * i
                                }
                                for (let i = 1; i <= elimination.eliminateColumnNum; i++) {
                                    score += this.rows * i
                                }
                            }

                            // 记录此放置选项
                            placements.push({
                                brickIndex,
                                brickData,
                                rowIndex,
                                columnIndex,
                                gridConfig: currentGridConfig,
                                deg: currentDeg,
                                score,
                                canEliminate: elimination.gridEliminateList.length > 0
                            })
                        }
                    }
                }
            }
        }

        // 按优先级排序：最高分 > 有分数 > 没有分数但可放置
        placements.sort((a, b) => {
            // 首先按分数排序
            if (a.score !== b.score) {
                return b.score - a.score
            }
            // 其次按是否可消除排序
            if (a.canEliminate !== b.canEliminate) {
                return a.canEliminate ? -1 : 1
            }
            // 最后按照方块优先级排序（底部的方块优先）
            return a.brickIndex - b.brickIndex
        })

        return placements.length > 0 ? placements[0] : null
    }

    // ... existing code ...

    placeBrickAtPosition(placement) {
        // 获取方块数据
        const brickData = placement.brickData
        const index = this.bricksList.findIndex(data => data === brickData)
        if (index === -1) {
            console.error("无法找到要放置的方块:", brickData)
            return
        }

        // 从待选区移除方块
        this.editingData.brickData = this.bricksList.splice(index, 1)[0]

        // 如果需要旋转，执行旋转
        if (brickData.deg !== placement.deg) {
            // 更新方块配置和角度
            brickData.gridConfig = placement.gridConfig
            brickData.deg = placement.deg
            // 添加旋转动画
            tween(brickData.brickNode).to(0.1, { angle: placement.deg }).start()
        }

        // 准备网格列表
        this.editingData.gridList = []
        placement.gridConfig.forEach((gridConfigData: GridConfigData) => {
            const r = gridConfigData.row + placement.rowIndex
            const c = gridConfigData.column + placement.columnIndex
            this.editingData.gridList.push(this.gridList[r][c])
        })

        // 计算目标位置 - 使用中间位置作为基准
        let centerPos = new Vec3(0, 0, 0);
        let validGridCount = 0;

        // 计算所有网格的平均位置
        this.editingData.gridList.forEach(grid => {
            if (grid.gridNode) {
                const worldPos = grid.gridNode.getWorldPosition();
                centerPos.add(worldPos);
                validGridCount++;
            }
        });

        // 计算平均位置
        if (validGridCount > 0) {
            centerPos.x /= validGridCount;
            centerPos.y /= validGridCount;
            centerPos.z /= validGridCount;
        } else {
            // 如果没有有效网格，使用第一个网格的位置作为后备
            const targetGridData = this.editingData.gridList[0];
            if (targetGridData && targetGridData.gridNode) {
                centerPos = targetGridData.gridNode.getWorldPosition();
            }
        }

        // 添加到移动节点里进行移动
        const originPos = brickData.brickNode.getWorldPosition()
        brickData.brickNode.setParent(this.moveNode)
        brickData.brickNode.setWorldPosition(originPos)

        // 使用动画移动到目标位置--这里的最终放置有问题
        tween(brickData.brickNode)
            .to(2, { worldPosition: centerPos })
            .call(() => {
                // 动画完成后修改格子状态
                this.editingData.gridList.forEach((gridData) => {
                    gridData.status = CellState.FILLED
                    gridData.type = this.editingData.brickData.type
                    this.generateGrid(gridData)
                })

                // 销毁方块
                this.editingData.brickData.brickNode.destroy()

                // 添加新方块
                this.addBrick(this.editingData.brickData.index)

                // 检查消除和游戏状态
                this.gridEliminate().then(() => {
                    this.prompt(false).then((value: unknown) => {
                        const promptFlag = value as boolean;
                        if (!promptFlag) {
                            this.autoState = false
                            this.gameOver()
                        } else if (this.autoState) {
                            // 继续自动放置
                            this.scheduleOnce(() => {
                                this.executeAutoPlace()
                            }, 0.3)
                        }
                        this.editingFlag = false
                    })
                })
            })
            .start()
    }


    doubleSpeedOpenSuccess() {
        this._isDoubleSpeed = true;
        //3分钟后关闭
        this.scheduleOnce(() => {
            this._isDoubleSpeed = false;
            //关闭会自动触发二倍速弹窗，这要带参数
            // oops.gui.open(UIID.DoubleSpeed, { isAutoOpen: true });
        }, 180);
    }


    //重新开始
    private restartGame() {
        if (this.gameState === GameState.READY) return;
        this.initData();
        this.reopenGrid();
        this.initButtonState(this.autoState);
    }

    //重新清除网格
    private reopenGrid() {
        for (let rowIndex = 0; rowIndex < this.rows; rowIndex++) {
            for (let columnIndex = 0; columnIndex < this.cols; columnIndex++) {
                this.gridList[rowIndex][columnIndex].status = CellState.EMPTY
                this.generateGrid(this.gridList[rowIndex][columnIndex])
            }
        }
        // 初始化方块
        if (this.brickNode) {
            if (this.brickNode) {
                this.brickNode.children.forEach(node => { node.destroy() });
            }
        }
        this.bricksList.length = 0
        for (let i = 1; i <= this.brickNum; i++) {
            this.addBrick(i)
        }
        // 清除旋转数据
        if (this.rotateNode) {
            this.rotateNode.children.forEach(node => { node.destroy() })
        }
    }

}