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

/*
 * @Author: mojunshou 1637302775@qq.com
 * @Date: 2025-04-20 10:00:00
 * @LastEditors: mojunshou 1637302775@qq.com
 * @LastEditTime: 2025-04-20 10:00:00
 * @Description: 消除游戏引导管理器
 */
import { Label, Node } from "cc";
import { BrickData, CellState, GridConfigData } from "./EliminateTypes";
import { EliminateGridManager } from "./EliminateGridManager";
import { EliminateBrickManager } from "./EliminateBrickManager";

export class EliminateGuideManager {
    private isGuideMode: boolean = false;
    private guideStep: number = 0;
    private guideNode: Node | null = null;

    private gridManager: EliminateGridManager;
    private brickManager: EliminateBrickManager;

    // 引导提示文本
    private guideTips: string[] = [
        "拖动方块，填满整行可以进行消除",
        "当行与列被砖块同时填满，砖块会被消除",
        "点击方块可以旋转90°，不限旋转次数哦",
        "放置&消除方块得分达成目标获得金砖"
    ];

    constructor(guideNode: Node, gridManager: EliminateGridManager, brickManager: EliminateBrickManager) {
        this.guideNode = guideNode;
        this.gridManager = gridManager;
        this.brickManager = brickManager;
    }

    /**
     * 开始引导模式
     */
    public startGuideMode(): void {
        this.isGuideMode = true;
        this.guideStep = 1;

        if (this.guideNode) {
            this.guideNode.active = true;
        }

        this.setupGuideStep(this.guideStep);
    }

    /**
     * 设置引导步骤
     */
    public setupGuideStep(step: number): void {
        this.gridManager.clearAllGuideGrids();
        this.guideStep = step;

        // 更新引导提示文本
        const tips_node = this.guideNode?.getChildByPath("tips/lab_tips");
        if (tips_node) {
            const tips = tips_node.getComponent(Label);
            if (tips) {
                tips.string = this.guideTips[step - 1];
            }
        }

        // 根据不同步骤创建不同的引导场景
        switch (step) {
            case 1:
                this.setupStep1();
                break;

            case 2:
                this.setupStep2();
                break;

            case 3:
                this.setupStep3();
                break;

            case 4:
                this.setupStep4();
                break;
        }
    }

    /**
     * 第1步：引导玩家消除一行
     */
    private setupStep1(): void {
        const cols = this.gridManager.getCols();
        const emptyIndex = Math.floor(cols / 2);

        // 创建一行只缺一个格子的状态
        for (let c = 0; c < cols; c++) {
            if (c !== emptyIndex) {
                const gridList = this.gridManager.getGridList();
                const g = gridList[0][c];
                g.status = CellState.FILLED;
                g.type = 1;
                this.gridManager.generateGrid(g);
            }
        }

        // 创建一个简单的单格子方块供玩家放置
        this.brickManager.createGuideBrick(
            [{ row: 0, column: 0 }],
            "Brick1",
            1,
            1
        );
    }

    /**
     * 第2步：引导玩家消除一列
     */
    private setupStep2(): void {
        const rows = this.gridManager.getRows();
        const emptyRow = rows - 1;

        // 创建一列只缺一个格子的状态
        for (let r = 0; r < rows; r++) {
            if (r !== emptyRow) {
                const gridList = this.gridManager.getGridList();
                const g = gridList[r][0];
                g.status = CellState.FILLED;
                g.type = 1;
                this.gridManager.generateGrid(g);
            }
        }

        // 创建一个简单的单格子方块供玩家放置
        this.brickManager.createGuideBrick(
            [{ row: 0, column: 0 }],
            "Brick1",
            1,
            1
        );
    }

    /**
     * 第3步：引导玩家旋转方块
     */
    private setupStep3(): void {
        // 填满前两列，除去特定位置，制造一个L型缺口
        for (let r = 0; r < this.gridManager.getRows(); r++) {
            for (let c = 0; c < 2; c++) {
                if (r === 2 && c === 0) continue; // 留一个空位用于放置旋转后的L型砖块
                if (r === 1 && c === 0) continue; // 留一个空位用于放置旋转后的L型砖块
                if (r === 3 && c === 0) continue; // 留一个空位用于放置旋转后的L型砖块
                if (r === 2 && c === 1) continue; // 留一个空位用于放置旋转后的L型砖块
                if (r === 1 && c === 1) continue; // 留一个空位用于放置旋转后的L型砖块
                if (r === 3 && c === 1) continue; // 留一个空位用于放置旋转后的L型砖块
                const gridList = this.gridManager.getGridList();
                const g = gridList[r][c];
                g.status = CellState.FILLED;
                g.type = 1;
                this.gridManager.generateGrid(g);
            }
        }

        // 创建一个L型方块，引导玩家旋转后放置
        this.brickManager.createGuideBrick(
            [
                { row: 0, column: 0 },
                { row: 0, column: 1 },
                { row: 0, column: 2 },
                { row: 1, column: 0 },
                { row: 1, column: 1 },
                { row: 1, column: 2 }
            ],
            "BrickII",
            1,
            1,
            true
        );
    }

    /**
     * 第4步：引导玩家同时消除行和列
     */
    private setupStep4(): void {
        const rows = this.gridManager.getRows();
        const cols = this.gridManager.getCols();
        const centerRow = Math.floor(rows / 2);
        const centerCol = Math.floor(cols / 2);

        // 遍历整个网格
        for (let r = 0; r < rows; r++) {
            for (let c = 0; c < cols; c++) {
                const inCenter =
                    r >= centerRow && r <= centerRow + 1 &&
                    c >= centerCol && c <= centerCol + 1;

                const isCross =
                    r === centerRow || r === centerRow + 1 || // 中间两行
                    c === centerCol || c === centerCol + 1;   // 中间两列

                if (isCross && !inCenter) {
                    const gridList = this.gridManager.getGridList();
                    const g = gridList[r][c];
                    g.status = CellState.FILLED;
                    g.type = 1;
                    this.gridManager.generateGrid(g);
                }
            }
        }

        // 创建一个正方形方块，引导玩家放在中间空位
        this.brickManager.createGuideBrick(
            [
                { row: 0, column: 0 },
                { row: 0, column: 1 },
                { row: 1, column: 0 },
                { row: 1, column: 1 }
            ],
            "BrickO",
            1,
            1
        );
    }

    /**
     * 结束引导模式
     */
    public endGuideMode(): void {
        this.isGuideMode = false;
        if (this.guideNode) {
            this.guideNode.active = false;
        }
    }

    /**
     * 检查是否需要进入下一步引导
     */
    public checkNextStep(): void {
        if (this.isGuideMode && this.guideStep < 4) {
            this.setupGuideStep(this.guideStep + 1);
        } else if (this.isGuideMode && this.guideStep >= 4) {
            this.endGuideMode();
        }
    }

    /**
     * 获取当前是否为引导模式
     */
    public getIsGuideMode(): boolean {
        return this.isGuideMode;
    }

    /**
     * 获取当前引导步骤
     */
    public getGuideStep(): number {
        return this.guideStep;
    }
}