tanqiu/assets/scripts/CombatSystem/BlockManager.ts

import { _decorator, Component, Node, Prefab, instantiate, Vec3, EventTouch, Color, Vec2, UITransform, find, Rect, Label, Size, Sprite, SpriteFrame, resources, Button, Collider2D, Material, tween, JsonAsset } from 'cc';
import * as cc from 'cc';
import { ConfigManager, WeaponConfig } from '../Core/ConfigManager';
import { SaveDataManager } from '../LevelSystem/SaveDataManager';
import { LevelSessionManager } from '../Core/LevelSessionManager';
import { LevelConfigManager } from '../LevelSystem/LevelConfigManager';
import { BlockTag } from './BlockSelection/BlockTag';
import { BlockInfo } from './BlockSelection/BlockInfo';
import { SkillManager } from './SkillSelection/SkillManager';
import EventBus, { GameEvents } from '../Core/EventBus';
import { sp } from 'cc';
import { BundleLoader } from '../Core/BundleLoader';
import { Audio } from '../AudioManager/AudioManager';
import { GuideUIController } from '../../NewbieGuidePlugin-v1.0.0/NewbieGuidePlugin-v1.0.0/scripts/GuideUIController';
const { ccclass, property } = _decorator;

@ccclass('BlockManager')
export class BlockManager extends Component {
    // 预制体数组，存储10个预制体
    @property([Prefab])
    public blockPrefabs: Prefab[] = [];
    
    // 网格容器节点
    @property({
        type: Node,
        tooltip: '拖拽GridContainer节点到这里'
    })
    public gridContainer: Node = null;
    
    // 方块容器节点（kuang）
    @property({
        type: Node,
        tooltip: '拖拽kuang节点到这里'
    })
    public kuangContainer: Node = null;
    
    // Block1节点
    @property({
        type: Node,
        tooltip: '拖拽Block1节点到这里（Canvas/GameLevelUI/BlockSelectionUI/diban/kuang/Block1）'
    })
    public block1Container: Node = null;
    
    // Block2节点
    @property({
        type: Node,
        tooltip: '拖拽Block2节点到这里（Canvas/GameLevelUI/BlockSelectionUI/diban/kuang/Block2）'
    })
    public block2Container: Node = null;
    
    // Block3节点
    @property({
        type: Node,
        tooltip: '拖拽Block3节点到这里（Canvas/GameLevelUI/BlockSelectionUI/diban/kuang/Block3）'
    })
    public block3Container: Node = null;
    
    // 价格节点装饰器
    @property({
        type: Node,
        tooltip: '拖拽Block1价格节点到这里（Canvas/GameLevelUI/BlockSelectionUI/diban/kuang/Block1/db01/Price）'
    })
    public block1PriceNode: Node = null;
    
    @property({
        type: Node,
        tooltip: '拖拽Block2价格节点到这里（Canvas/GameLevelUI/BlockSelectionUI/diban/kuang/Block2/db01/Price）'
    })
    public block2PriceNode: Node = null;
    
    @property({
        type: Node,
        tooltip: '拖拽Block3价格节点到这里（Canvas/GameLevelUI/BlockSelectionUI/diban/kuang/Block3/db01/Price）'
    })
    public block3PriceNode: Node = null;
    
    // db标签节点装饰器
    @property({
        type: Node,
        tooltip: '拖拽Block1的db标签节点到这里（Canvas/GameLevelUI/BlockSelectionUI/diban/kuang/Block1/db01）'
    })
    public block1DbNode: Node = null;
    
    @property({
        type: Node,
        tooltip: '拖拽Block2的db标签节点到这里（Canvas/GameLevelUI/BlockSelectionUI/diban/kuang/Block2/db01）'
    })
    public block2DbNode: Node = null;
    
    @property({
        type: Node,
        tooltip: '拖拽Block3的db标签节点到这里（Canvas/GameLevelUI/BlockSelectionUI/diban/kuang/Block3/db01）'
    })
    public block3DbNode: Node = null;
    
    // 金币标签节点
    @property({
        type: Node,
        tooltip: '拖拽CoinLabel节点到这里'
    })
    public coinLabelNode: Node = null;
    
    // 已放置方块容器节点
    @property({
        type: Node,
        tooltip: '拖拽PlacedBlocks节点到这里（Canvas/GameLevelUI/GameArea/PlacedBlocks）'
    })
    public placedBlocksContainer: Node = null;
    private guideUIController: GuideUIController = null;
    
    
    // 游戏是否已开始
    public gameStarted: boolean = false;
    
    // 移除移动冷却：相关属性/逻辑已废弃
    
    // SaveDataManager 单例
    private saveDataManager: SaveDataManager = null; // 仅用于局外数据

    private session: LevelSessionManager = null;
    
    // 方块价格标签映射
    private blockPriceMap: Map<Node, Node> = new Map();
    
    // 已经生成的块
    private blocks: Node[] = [];
    // 网格占用情况，用于控制台输出
    private gridOccupationMap: number[][] = [];
    // 网格行数和列数
    private readonly GRID_ROWS = 6;
    private readonly GRID_COLS = 11;
    // 是否已初始化网格信息
    private gridInitialized = false;
    // 存储网格节点信息
    private gridNodes: Node[][] = [];
    // 网格间距
    private gridSpacing = 54; // 默认值，将在initGridInfo中动态计算
    // 不参与占用的节点名称列表
    private readonly NON_BLOCK_NODES: string[] = ['Weapon', 'Price'];
    // 临时保存方块的原始占用格子
    private tempRemovedOccupiedGrids: { block: Node, occupiedGrids: { row: number, col: number }[] }[] = [];
    // 方块原始位置（在kuang中的位置）
    public originalPositions: Map<Node, Vec3> = new Map();
    // 方块当前所在的区域
    public blockLocations: Map<Node, string> = new Map();
    
    // 配置管理器
    private configManager: ConfigManager = null;
    
    // 关卡配置管理器
    private levelConfigManager: LevelConfigManager = null;
    
    // 方块武器配置映射
    private blockWeaponConfigs: Map<Node, WeaponConfig> = new Map();
    
    // 预加载的武器配置数据
    private preloadedWeaponsConfig: any = null;
    
    // 配置是否已预加载的标志
    private isWeaponsConfigPreloaded: boolean = false;
    
    private bundleLoader: BundleLoader = null;
    
    // 新手教程相关属性
    private _tutorialStep: number = 0;
    private _tutorialTargetGrids: string[] = ['Grid_3_1', 'Grid_4_1'];
    private _tutorialTargetGridsStep2: string[] = ['Grid_3_5', 'Grid_3_6'];
    private _tutorialTargetGridsStep4: string[] = ['Grid_3_9', 'Grid_4_9'];
    private _tutorialBlockContainers: Node[] = [];
    // 第二波固定形状应用标志，防止重复应用
    private _secondWaveFixedApplied: boolean = false;

    
    // 设置预加载的武器配置数据调试绘制相关
    // 调试绘制功能已迁移到GameBlockSelection
    
    /** 冷却机制已废弃，方块随时可移动 */

    // 清除所有冷却（游戏重置时调用）
    public clearAllCooldowns() { /* no-op */ }
    
    /**
     * 设置预加载的武器配置数据
     * @param weaponsConfigData 从JsonAsset获取的武器配置数据
     */
    public setPreloadedWeaponsConfig(weaponsConfigData: any): void {
        console.log('[BlockManager] 接收到预加载的武器配置数据');
        this.preloadedWeaponsConfig = weaponsConfigData;
        this.isWeaponsConfigPreloaded = true;
        
        // 验证配置数据结构
        if (weaponsConfigData && weaponsConfigData.weapons && Array.isArray(weaponsConfigData.weapons)) {
            console.log(`[BlockManager] 武器配置验证成功，包含 ${weaponsConfigData.weapons.length} 个武器`);
        } else {
            console.warn('[BlockManager] 武器配置数据结构异常');
            this.isWeaponsConfigPreloaded = false;
        }
    }


    
    /**
     * 获取预加载的武器配置，如果没有预加载则返回null
     */
    private getPreloadedWeaponsConfig(): any {
        return this.isWeaponsConfigPreloaded ? this.preloadedWeaponsConfig : null;
    }

    // 获取当前关卡的武器列表
    private async getCurrentLevelWeapons(): Promise<string[]> {
        if (!this.levelConfigManager || !this.saveDataManager) {
            console.warn('关卡配置管理器或存档管理器未初始化，使用默认武器列表');
            return [];
        }
        
        try {
            const currentLevel = this.saveDataManager.getCurrentLevel();
            const levelConfig = await this.levelConfigManager.getLevelConfig(currentLevel);
            
            if (levelConfig && levelConfig.weapons && Array.isArray(levelConfig.weapons)) {
                console.log(`关卡 ${currentLevel} 配置的武器:`, levelConfig.weapons);
                return levelConfig.weapons;
            } else {
                console.warn(`关卡 ${currentLevel} 没有配置武器列表`);
                return [];
            }
        } catch (error) {
            console.error('获取当前关卡武器配置失败:', error);
            return [];
        }
    }
    
    // 根据武器名称获取武器配置
    private getWeaponConfigByName(weaponName: string): WeaponConfig | null {
        // 优先使用预加载的配置数据
        const preloadedConfig = this.getPreloadedWeaponsConfig();
        if (preloadedConfig && preloadedConfig.weapons && Array.isArray(preloadedConfig.weapons)) {
            const weapon = preloadedConfig.weapons.find((w: any) => w.name === weaponName);
            if (weapon) {
                console.log(`[BlockManager] 从预加载配置中找到武器: ${weaponName}`);
                return weapon as WeaponConfig;
            }
        }
        
        // 如果预加载配置中没有找到，回退到ConfigManager
        if (!this.configManager) {
            console.warn(`[BlockManager] 武器配置未预加载且ConfigManager不可用，无法获取武器: ${weaponName}`);
            return null;
        }
        
        console.log(`[BlockManager] 从ConfigManager中查找武器: ${weaponName}`);
        const allWeapons = this.configManager.getAllWeapons();
        return allWeapons.find(weapon => weapon.name === weaponName) || null;
    }

    // 设置事件监听器
    private setupEventListeners() {
        const eventBus = EventBus.getInstance();
        
        // 监听重置方块管理器事件
        eventBus.on(GameEvents.RESET_BLOCK_MANAGER, this.onResetBlockManagerEvent, this);
        
        // 监听方块生成事件
        eventBus.on(GameEvents.GENERATE_BLOCKS, this.onGenerateBlocksEvent, this);
        
        // 移除GAME_START事件监听，避免与GameBlockSelection重复生成方块
        // eventBus.on(GameEvents.GAME_START, this.onGameStartEvent, this);
        
        // 监听波次完成事件（每波结束后生成新方块）
        eventBus.on(GameEvents.WAVE_COMPLETED, this.onWaveCompletedEvent, this);

        // 监听敌人开始生成事件（开启第4步教程）
        eventBus.on(GameEvents.ENEMY_SPAWNING_STARTED, this.onEnemySpawningStartedEvent, this);
        
        // 移除敌人对玩家方块造成伤害事件监听，因为抛掷物不攻击玩家方块
        // eventBus.on(GameEvents.ENEMY_DAMAGE_PLAYER_BLOCK, this.onEnemyDamagePlayerBlockEvent, this);
    }
    
    // 处理重置方块管理器事件
    private onResetBlockManagerEvent() {
        console.log('[BlockManager] 接收到重置方块管理器事件');
        this.onGameReset();
    }
    
    // 处理方块生成事件
    private onGenerateBlocksEvent() {
        console.log('[BlockManager] 接收到方块生成事件');
        this.generateRandomBlocksInKuang();

        // 引导：指向可拖拽的方块 - 使用步骤索引让GuideUIController使用配置的节点
        this.scheduleOnce(() => {
            if (this.guideUIController && this.block1Container) {
                // 传入步骤索引0，让GuideUIController使用配置的fingerStartNodes和fingerTargetNodes
                this.guideUIController.createPointingAnimation('guild_1', undefined, 0);
                void 0;
            }
        }, 0);
    }

    // 敌人开始生成事件：进入教程第4步，并显示Block3指引
    private onEnemySpawningStartedEvent() {
        console.log('[BlockManager] 接收到敌人生成开始事件');
        try {
            const levelOk = !!this.saveDataManager && typeof this.saveDataManager.getCurrentLevel === 'function' && this.saveDataManager.getCurrentLevel() === 1;
            const sessionOk = !!this.session && typeof this.session.getRefreshUsageCount === 'function' && typeof this.session.getAddBallUsageCount === 'function'
                && this.session.getRefreshUsageCount() === 0 && this.session.getAddBallUsageCount() === 0;
            if (!levelOk || !sessionOk) return;
            // 仅当处于第3步（等待游戏开始）时推进到第4步
            if (this._tutorialStep >= 3 && this._tutorialStep < 4) {
                    this._tutorialStep = 4;
                    if (this.guideUIController) {
                        // 运行时注入：将已放置在 _tutorialTargetGrids 指定位置的“I”型方块设为第4步拖拽起点
                        try {
                            const targetGridNames = Array.isArray(this._tutorialTargetGrids) ? this._tutorialTargetGrids : [];
                            const gridA = targetGridNames[0] ? this.findGridNodeByName(targetGridNames[0]) : null;
                            const gridB = targetGridNames[1] ? this.findGridNodeByName(targetGridNames[1]) : null;
                            const rowColA = gridA ? this.getGridRowCol(gridA) : null;
                            const rowColB = gridB ? this.getGridRowCol(gridB) : null;
                            
                            if (rowColA && rowColB && this.placedBlocksContainer && this.placedBlocksContainer.isValid) {
                                let iBlock: Node = null;
                                for (let i = 0; i < this.placedBlocksContainer.children.length; i++) {
                                    const block = this.placedBlocksContainer.children[i];
                                    const shapeId = this.getBlockShape(block);
                                    const occ = block['occupiedGrids'] || [];
                                    const hasA = occ.some(g => g.row === rowColA.row && g.col === rowColA.col);
                                    const hasB = occ.some(g => g.row === rowColB.row && g.col === rowColB.col);
                                    if (shapeId === 'I' && hasA && hasB) {
                                        iBlock = block;
                                        break;
                                    }
                                }
                                if (iBlock) {
                                    this.guideUIController.fingerStartNodes[3] = iBlock;
                                    console.log(`[BlockManager] 教程第4步拖拽起点已注入为已放置的“I”型方块: ${iBlock.name}`);
                                } else {
                                    console.warn('[BlockManager] 未找到占用 Grid_3_1/Grid_4_1 的“I”型方块，指引将使用默认兜底位置');
                                }
                            }
                        } catch (e) {
                            console.warn(`[BlockManager] 注入教程第4步拖拽起点失败: ${e}`);
                        }
                        // 使用步骤索引3创建拖拽动画（起点为注入的方块，终点为编辑器配置的目标节点）
                        this.guideUIController.showDragAnimationForStep(3);
                    }
                    console.log('[BlockManager] 教程进入第4步并显示Block3指引');
                }
        } catch (e) {
            console.warn(`[BlockManager] 处理 ENEMY_SPAWNING_STARTED 失败: ${e}`);
        }
    }
    
    // 处理游戏开始事件 - 已废弃，避免与GameBlockSelection重复生成方块
    // private onGameStartEvent() {
    //     console.log('[BlockManager] 接收到游戏开始事件，生成初始方块');
    //     this.generateRandomBlocksInKuang();
    // }
    
    // 处理波次完成事件
    private onWaveCompletedEvent() {
        console.log('[BlockManager] 接收到波次完成事件，生成新方块');
        this.generateRandomBlocksInKuang();

        // 引导：波次结束后新生成方块也展示指引 - 使用步骤索引让GuideUIController使用配置的节点
        this.scheduleOnce(() => {
            if (this.guideUIController && this.block1Container) {
                // 传入步骤索引0，让GuideUIController使用配置的fingerStartNodes和fingerTargetNodes
                this.guideUIController.createPointingAnimation('guild_1', undefined, 0);
                void 0;
            }
        }, 0);
    }
    
    
    /**
     * 摧毁玩家方块
     */
    private destroyPlayerBlock(blockNode: Node) {
        console.log(`[BlockManager] 摧毁玩家方块: ${blockNode.name}`);
        
        // 清理方块占用的网格位置
        this.clearOccupiedPositions(blockNode);
        
        // 播放摧毁效果
        this.playBlockDestroyEffect(blockNode);
        
        // 延迟销毁节点，让效果播放完成
        this.scheduleOnce(() => {
            if (blockNode && blockNode.isValid) {
                blockNode.destroy();
            }
        }, 0.5);
    }
    
    /**
     * 播放方块受伤效果
     */
    private playBlockDamageEffect(blockNode: Node) {
        // 简单的闪烁效果
        const originalOpacity = blockNode.getComponent(Sprite)?.color.a || 255;
        
        tween(blockNode)
            .to(0.1, { scale: new Vec3(0.9, 0.9, 1) })
            .to(0.1, { scale: new Vec3(1, 1, 1) })
            .start();
            
        // 颜色闪烁
        const sprite = blockNode.getComponent(Sprite);
        if (sprite) {
            const originalColor = new Color(sprite.color);
            sprite.color = new Color(255, 100, 100, originalOpacity); // 红色闪烁
            
            this.scheduleOnce(() => {
                if (sprite && sprite.node && sprite.node.isValid) {
                    sprite.color = originalColor;
                }
            }, 0.2);
        }
    }
    
    /**
     * 播放方块摧毁效果
     */
    private playBlockDestroyEffect(blockNode: Node) {
        // 缩放消失效果
        tween(blockNode)
            .to(0.3, { scale: new Vec3(0, 0, 1) })
            .start();
            
        // 透明度消失效果
        const sprite = blockNode.getComponent(Sprite);
        if (sprite) {
            tween(sprite)
                .to(0.3, { color: new Color(sprite.color.r, sprite.color.g, sprite.color.b, 0) })
                .start();
        }
    }
    
    start() {
        console.log('[BlockManager] 开始初始化BlockManager');
        
        // 获取配置管理器
        this.configManager = ConfigManager.getInstance();
        if (!this.configManager) {
            console.error('[BlockManager] 无法获取ConfigManager实例');
        } else {
            console.log('[BlockManager] ConfigManager实例获取成功，配置加载状态:', this.configManager.isConfigLoaded());
        }
        
        // 获取关卡配置管理器
        this.levelConfigManager = LevelConfigManager.getInstance();
        if (!this.levelConfigManager) {
            console.error('[BlockManager] 无法获取LevelConfigManager实例');
        } else {
            console.log('[BlockManager] LevelConfigManager实例获取成功');
        }
        
        // 获取BundleLoader实例
        this.bundleLoader = BundleLoader.getInstance();

        // 如果没有指定GridContainer，尝试找到它
        if (!this.gridContainer) {
            this.gridContainer = find('Canvas/GameLevelUI/GameArea/GridContainer');
            if (!this.gridContainer) {
                console.error('找不到GridContainer节点');
                return;
            }
        }
        
        // 如果没有指定kuangContainer，尝试找到它
        if (!this.kuangContainer) {
            this.kuangContainer = find('Canvas/GameLevelUI/BlockSelectionUI/diban/kuang');
            if (!this.kuangContainer) {
                console.error('找不到kuang节点');
                return;
            }
        }
        
        // 如果没有指定Block1Container，尝试找到它
        if (!this.block1Container) {
            this.block1Container = find('Canvas/GameLevelUI/BlockSelectionUI/diban/kuang/Block1');
            if (!this.block1Container) {
                console.error('找不到Block1节点');
                return;
            }
        }
        
        // 如果没有指定Block2Container，尝试找到它
        if (!this.block2Container) {
            this.block2Container = find('Canvas/GameLevelUI/BlockSelectionUI/diban/kuang/Block2');
            if (!this.block2Container) {
                console.error('找不到Block2节点');
                return;
            }
        }
        
        // 如果没有指定Block3Container，尝试找到它
        if (!this.block3Container) {
            this.block3Container = find('Canvas/GameLevelUI/BlockSelectionUI/diban/kuang/Block3');
            if (!this.block3Container) {
                console.error('找不到Block3节点');
                return;
            }
        }
        
        // 如果没有指定coinLabelNode，尝试找到它
        if (!this.coinLabelNode) {
            this.coinLabelNode = find('Canvas/GameLevelUI/CoinNode/CoinLabel');
            if (!this.coinLabelNode) {
                console.error('找不到CoinLabel节点');
                return;
            }
        }
        
        // 如果没有指定placedBlocksContainer，尝试找到它
        if (!this.placedBlocksContainer) {
            this.placedBlocksContainer = find('Canvas/GameLevelUI/GameArea/PlacedBlocks');   
        }
        
        // 如果没有指定价格节点，尝试找到它们
        if (!this.block1PriceNode) {
            this.block1PriceNode = find('Canvas/GameLevelUI/BlockSelectionUI/diban/kuang/Block1/db01/Price');
            if (!this.block1PriceNode) {
                console.warn('找不到Block1价格节点');
            }
        }
        
        if (!this.block2PriceNode) {
            this.block2PriceNode = find('Canvas/GameLevelUI/BlockSelectionUI/diban/kuang/Block2/db01/Price');
            if (!this.block2PriceNode) {
                console.warn('找不到Block2价格节点');
            }
        }
        
        if (!this.block3PriceNode) {
            this.block3PriceNode = find('Canvas/GameLevelUI/BlockSelectionUI/diban/kuang/Block3/db01/Price');
            if (!this.block3PriceNode) {
                console.warn('找不到Block3价格节点');
            }
        }
        
        // 确保有PlacedBlocks节点用于存放已放置的方块
        this.ensurePlacedBlocksNode();
        
        // 获取数据管理器
        this.saveDataManager = SaveDataManager.getInstance();
        this.session = LevelSessionManager.inst;
        
        // 初始化玩家金币显示
        this.updateCoinDisplay();
        
        // 初始化网格信息
        this.initGridInfo();
        
        // 初始化网格占用情况
        this.initGridOccupationMap();
        
        // 设置事件监听器
        this.setupEventListeners();

        // 新手引导控制器初始化（从 Canvas 获取已挂载的组件）
        const canvas = find('Canvas');
        this.guideUIController = canvas ? canvas.getComponent(GuideUIController) : null;
        if (!this.guideUIController) {
            console.warn('[BlockManager] Canvas未挂载GuideUIController组件，指引功能不可用');
        }
        
        // 调试绘制功能已迁移到GameBlockSelection
        
        // 移除自动生成方块逻辑，改为事件触发
        // 方块生成现在通过以下事件触发：
        // - GAME_START: 游戏开始时
        // - WAVE_COMPLETED: 每波敌人消灭后
        // - GENERATE_BLOCKS: 手动触发生成
    }
    
    // 确保有PlacedBlocks节点
    ensurePlacedBlocksNode() {
        // 如果已经通过拖拽设置了节点，直接使用
        if (this.placedBlocksContainer && this.placedBlocksContainer.isValid) {
            return;
        }
        
        // 尝试查找节点
        this.placedBlocksContainer = find('Canvas/GameLevelUI/GameArea/PlacedBlocks');
        if (this.placedBlocksContainer) {
            return;
        }
        
        // 如果找不到，创建新节点
        const gameLevelUI = find('Canvas/GameLevelUI');
        if (!gameLevelUI) {
            console.error('找不到GameLevelUI节点，无法创建PlacedBlocks');
            return;
        }
        
        this.placedBlocksContainer = new Node('PlacedBlocks');
        gameLevelUI.addChild(this.placedBlocksContainer);
        if (!this.placedBlocksContainer.getComponent(UITransform)) {
            this.placedBlocksContainer.addComponent(UITransform);
        }
        console.log('已在GameLevelUI下创建PlacedBlocks节点');
    }
    
    // 初始化网格信息
    initGridInfo() {
        if (!this.gridContainer || this.gridInitialized) return;
        
        this.gridNodes = [];
        for (let row = 0; row < this.GRID_ROWS; row++) {
            this.gridNodes[row] = [];
        }
        
        for (let i = 0; i < this.gridContainer.children.length; i++) {
            const grid = this.gridContainer.children[i];
            if (grid.name.startsWith('Grid_')) {
                const parts = grid.name.split('_');
                if (parts.length === 3) {
                    const row = parseInt(parts[1]);
                    const col = parseInt(parts[2]);
                    
                    if (row >= 0 && row < this.GRID_ROWS && col >= 0 && col < this.GRID_COLS) {
                        this.gridNodes[row][col] = grid;
                    }
                }
            }
        }
        // 动态计算网格间距，适应不同分辨率
        this.calculateGridSpacing();
        
        this.gridInitialized = true;
    }

    // 动态计算网格间距
    private calculateGridSpacing() {
        // 优先使用相邻行之间的距离计算间距
        if (this.GRID_ROWS > 1 && this.GRID_COLS > 0) {
            if (this.gridNodes[0][0] && this.gridNodes[1][0]) {
                const pos1 = this.gridNodes[0][0].position;
                const pos2 = this.gridNodes[1][0].position;
                this.gridSpacing = Math.abs(pos2.y - pos1.y);
                console.log(`动态计算网格间距(行间距): ${this.gridSpacing}`);
                return;
            }
        }
        
        // 如果行间距计算失败，尝试使用相邻列之间的距离
        if (this.GRID_COLS > 1 && this.GRID_ROWS > 0) {
            if (this.gridNodes[0][0] && this.gridNodes[0][1]) {
                const pos1 = this.gridNodes[0][0].position;
                const pos2 = this.gridNodes[0][1].position;
                this.gridSpacing = Math.abs(pos2.x - pos1.x);
                console.log(`动态计算网格间距(列间距): ${this.gridSpacing}`);
                return;
            }
        }
        
        // 如果都失败了，保持默认值
         console.warn(`无法动态计算网格间距，使用默认值: ${this.gridSpacing}`);
     }

     // 获取当前网格间距
     public getGridSpacing(): number {
         return this.gridSpacing;
     }
    
    // 初始化网格占用情况
    initGridOccupationMap() {
        this.gridOccupationMap = [];
        for (let row = 0; row < this.GRID_ROWS; row++) {
            const rowArray: number[] = [];
            for (let col = 0; col < this.GRID_COLS; col++) {
                rowArray.push(0);
            }
            this.gridOccupationMap.push(rowArray);
        }
    }
    
    // 在kuang下生成三个方块（基于关卡配置）
    private async generateRandomBlocksInKuang() {
        // 清除kuang区域中的旧方块，但不清除已放置在网格中的方块的标签
        this.clearBlocks();
        
        // 优先检查预加载的武器配置
        if (this.isWeaponsConfigPreloaded) {
            const preloadedConfig = this.getPreloadedWeaponsConfig();
            if (preloadedConfig && preloadedConfig.weapons && preloadedConfig.blockSizes) {
                console.log('[BlockManager] 使用预加载的武器配置生成方块');
                // 直接使用预加载配置继续生成方块
                // 跳过ConfigManager的等待逻辑
            } else {
                console.warn('[BlockManager] 预加载配置不完整，回退到ConfigManager模式');
                this.isWeaponsConfigPreloaded = false;
            }
        }
        
        // 如果没有预加载配置，检查ConfigManager
        if (!this.isWeaponsConfigPreloaded) {
            // 检查配置管理器是否可用
            if (!this.configManager) {
                console.error('[BlockManager] ConfigManager实例未找到，延迟2秒后重试');
                this.scheduleOnce(() => {
                    this.generateRandomBlocksInKuang();
                }, 2.0);
                return;
            }
            
            // 检查武器配置是否已加载（不需要等待所有配置完成）
            const weaponsConfigLoaded = !!this.configManager['weaponsConfig'];
            const blockSizesAvailable = weaponsConfigLoaded && !!this.configManager['weaponsConfig'].blockSizes;
            
            if (!weaponsConfigLoaded) {
                console.log('[BlockManager] 武器配置未加载完成，延迟2秒后重试生成方块');
                console.log('[BlockManager] 整体配置状态:', this.configManager.isConfigLoaded());
                this.scheduleOnce(() => {
                    this.generateRandomBlocksInKuang();
                }, 2.0);
                return;
            }
            
            if (!blockSizesAvailable) {
                console.warn('[BlockManager] 武器配置已加载但blockSizes缺失，延迟2秒后重试');
                console.log('[BlockManager] weaponsConfig keys:', Object.keys(this.configManager['weaponsConfig']));
                this.scheduleOnce(() => {
                    this.generateRandomBlocksInKuang();
                }, 2.0);
                return;
            }
        }
        
        console.log('[BlockManager] 配置已加载完成，开始生成方块');
        
        if (this.blockPrefabs.length === 0) {
            console.error('没有可用的预制体');
            return;
        }
        
        // 使用Block1、Block2、Block3节点作为方块容器
        const blockContainers = [
            this.block1Container,
            this.block2Container,
            this.block3Container
        ];
        
        // 检查所有Block容器是否存在
        for (let i = 0; i < blockContainers.length; i++) {
            if (!blockContainers[i]) {
                console.error(`找不到Block${i + 1}节点`);
                return;
            }
        }
        
        // 方块在各自容器中的位置偏移（相对于容器中心）
        const offsets = [
            new Vec3(0, 0, 0),  // Block1中心
            new Vec3(0, 0, 0),  // Block2中心
            new Vec3(0, 0, 0)   // Block3中心
        ];
        
        // 价格节点使用装饰器属性
        const priceNodes = [
            this.block1PriceNode,
            this.block2PriceNode,
            this.block3PriceNode
        ];
        
        // 获取当前关卡的武器配置列表
        const levelWeapons = await this.getCurrentLevelWeapons();

        // 是否处于新手引导的首次生成场景（第1关、未使用过刷新/加球、且尚未放置方块）
        const isNewbieTutorial = this.isNewbieTutorialContext();
        if (isNewbieTutorial) {
            console.log('[BlockManager] 检测到新手引导场景，优先生成固定形状的方块');
        }
        // 第二波固定形状场景（第4步完成后首次波次结束进入第二次选方块）
        const isSecondWaveFixed = this.shouldApplySecondWaveFixedShapes();
        if (isSecondWaveFixed) {
            console.log('[BlockManager] 检测到第二波固定形状场景，按要求生成固定形状');
        }
        
        for (let i = 0; i < 3; i++) {
            let weaponConfig: WeaponConfig | null = null;
            
            // 优先使用关卡配置的武器，确保符合关卡设计
            if (levelWeapons.length > 0) {
                const randomWeaponName = levelWeapons[Math.floor(Math.random() * levelWeapons.length)];
                weaponConfig = this.getWeaponConfigByName(randomWeaponName);
                
                if (!weaponConfig) {
                    console.warn(`关卡配置的武器 "${randomWeaponName}" 在武器配置文件中未找到`);
                }
            }
            
            // 如果关卡没有配置武器或获取失败，使用随机武器
            if (!weaponConfig) {
                weaponConfig = this.configManager.getRandomWeapon();
            }
            
            // 最后的兜底处理
            if (!weaponConfig) {
                console.warn('无法获取武器配置，使用默认武器');
                // 尝试获取一个基础武器作为兜底
                const allWeapons = this.configManager.getAllWeapons();
                if (allWeapons.length > 0) {
                    weaponConfig = allWeapons[0];
                }
            }
            
            if (!weaponConfig) {
                console.error(`无法获取第 ${i + 1} 个武器配置`);
                continue;
            }
            
            // 选择形状ID：新手引导优先使用固定形状，否则随机
            let targetShapeId: string | null = null;
            if (isNewbieTutorial) {
                targetShapeId = this.getTutorialShapeForIndex(i, weaponConfig);
                console.log(`[BlockManager] 新手引导为武器 ${weaponConfig.name} 指定形状: ${targetShapeId ?? '未找到合适形状，回退随机'}`);
            }
            // 第二波固定形状选择（优先于随机）
            if (!targetShapeId && isSecondWaveFixed) {
                targetShapeId = this.getSecondWaveShapeForIndex(i, weaponConfig);
                console.log(`[BlockManager] 第二波固定为武器 ${weaponConfig.name} 指定形状: ${targetShapeId ?? '未找到合适形状，回退随机'}`);
            }
            if (!targetShapeId) {
                try {
                    const shapeCosts = weaponConfig.inGameCostConfig?.shapeCosts;
                    if (shapeCosts && Object.keys(shapeCosts).length > 0) {
                        const availableShapes = Object.keys(shapeCosts);
                        targetShapeId = availableShapes[Math.floor(Math.random() * availableShapes.length)];
                        console.log(`[BlockManager] 为武器 ${weaponConfig.name} 随机选择形状: ${targetShapeId}`);
                        console.log(`[BlockManager] 可用形状列表: ${availableShapes.join(', ')}`);
                    } else {
                        console.warn(`[BlockManager] 武器 ${weaponConfig.name} 没有配置shapeCosts或为空`);
                    }
                } catch (error) {
                    console.warn(`[BlockManager] 无法从武器配置获取形状信息: ${error}`);
                }
            }
            
            // 基于武器配置和目标形状选择合适的预制体
            console.log(`[BlockManager] 开始为武器 ${weaponConfig.name} 选择预制体，目标形状: ${targetShapeId || '未指定'}`);
            const prefab = this.selectPrefabForWeapon(weaponConfig, targetShapeId);
            console.log(`[BlockManager] 预制体选择结果: ${prefab ? '成功' : '失败'}`);
            if (!prefab) {
                console.error(`无法为武器 ${weaponConfig.name} 选择合适的预制体`);
                continue;
            }
            
            const block = instantiate(prefab);
            blockContainers[i].addChild(block);
            
            block.position = offsets[i];
            
            // 设置方块名称
            block.name = `WeaponBlock_${weaponConfig.id}`;
            
            // 保存武器配置到方块
            this.blockWeaponConfigs.set(block, weaponConfig);
            block['weaponConfig'] = weaponConfig;
            block['weaponId'] = weaponConfig.id;
            
            this.originalPositions.set(block, offsets[i].clone());
            this.blockLocations.set(block, `block${i + 1}`);
            this.blocks.push(block);
            
            // 关联Block容器与方块（替代原来的dbNode关联）
            this.associateBlockContainerWithBlock(block, blockContainers[i]);
            
            // 设置方块位置信息到blockLocations映射中
            const blockLocation = `block${i + 1}`;
            this.blockLocations.set(block, blockLocation);
            
            // 设置方块的武器外观，传入目标形状ID以确保正确加载图片
            this.setupBlockWeaponVisual(block, weaponConfig, targetShapeId);
            
            // 设置BlockInfo组件信息，传入容器位置信息
            this.setupBlockInfo(block, weaponConfig, targetShapeId, blockLocation);
            
            // 处理价格显示 - 在BlockInfo设置完成后调用，确保能正确读取shapePrice
            if (priceNodes[i]) {
                this.blockPriceMap.set(block, priceNodes[i]);
                priceNodes[i].active = true;
                
                // 根据武器配置和方块形状设置价格
                this.setBlockPriceByWeaponConfig(block, priceNodes[i]);
            } else {
                console.warn(`Block${i + 1}容器下找不到Price节点`);
            }
            
            // 为新生成的方块添加标签
            BlockTag.addTag(block);
            console.log(`[BlockManager] 为方块 ${block.name} 添加标签，UUID: ${block.uuid}`);
        }
        
        // 通过事件机制通知GameBlockSelection为新生成的方块设置拖拽事件
        if (this.blocks.length > 0) {
            const eventBus = EventBus.getInstance();
            eventBus.emit(GameEvents.SETUP_BLOCK_DRAG_EVENTS, this.blocks.slice());
            console.log(`[BlockManager] 发送方块拖拽事件设置请求，方块数量: ${this.blocks.length}`);
        }
        
        this.updateCoinDisplay();
        // 第二波固定生成已应用后标记，避免后续波次重复
        if (isSecondWaveFixed) {
            this._secondWaveFixedApplied = true;
        }
    }

    /**
     * 新手引导环境判定：仅在第1关、未使用过刷新/加球、且未放置任何方块时生效
     */
    private isNewbieTutorialContext(): boolean {
        try {
            const levelOk = !!this.saveDataManager && typeof this.saveDataManager.getCurrentLevel === 'function' && this.saveDataManager.getCurrentLevel() === 1;
            const sessionOk = !!this.session && typeof this.session.getRefreshUsageCount === 'function' && typeof this.session.getAddBallUsageCount === 'function'
                && this.session.getRefreshUsageCount() === 0 && this.session.getAddBallUsageCount() === 0;
            // 教程在第1-4步期间保持限制，第4步为空目标表示不限制
            const tutorialActive = this._tutorialStep < 5;
            return levelOk && sessionOk && tutorialActive;
        } catch (e) {
            console.warn(`[BlockManager] 新手引导上下文检测失败: ${e}`);
            return false;
        }
    }

    /**
     * 扩展教程事件上下文：用于第5-6步仅触发事件，不施加位置限制
     */
    private isExtendedTutorialEventContext(): boolean {
        try {
            const levelOk = !!this.saveDataManager && typeof this.saveDataManager.getCurrentLevel === 'function' && this.saveDataManager.getCurrentLevel() === 1;
            const sessionOk = !!this.session && typeof this.session.getRefreshUsageCount === 'function' && typeof this.session.getAddBallUsageCount === 'function'
                && this.session.getRefreshUsageCount() === 0 && this.session.getAddBallUsageCount() === 0;
            return this._tutorialStep >= 5 && this._tutorialStep < 7 && levelOk && sessionOk;
        } catch (e) {
            console.warn(`[BlockManager] 扩展教程事件上下文检测失败: ${e}`);
            return false;
        }
    }

    // 新增：教程阶段对场上已放置方块的移动控制
    public canMovePlacedBlocks(): boolean {
        try {
            // 非新手引导环境允许自由移动
            if (!this.isNewbieTutorialContext() && !this.isExtendedTutorialEventContext()) {
                return true;
            }
            // 新手引导阶段：仅在第4步允许移动，或第6步完成（_tutorialStep >= 7）后恢复自由移动
            return this._tutorialStep === 4 || this._tutorialStep >= 7;
        } catch (e) {
            return true;
        }
    }

    /**
     * 新手引导下为第 i 个容器选择固定形状（I、S、L），并确保形状在该武器可用
     */
    private getTutorialShapeForIndex(index: number, weaponConfig: WeaponConfig): string | null {
        const preferredOrder = ['I', 'H-I', 'L'];
        const desired = preferredOrder[index % preferredOrder.length];
        const shapeCosts = weaponConfig?.inGameCostConfig?.shapeCosts || null;
        if (shapeCosts && typeof shapeCosts === 'object') {
            if (shapeCosts[desired] !== undefined) {
                return desired;
            }
            // 选择首个在该武器可用的优先形状
            const fallbackPreferred = preferredOrder.find(s => shapeCosts[s] !== undefined);
            if (fallbackPreferred) {
                return fallbackPreferred;
            }
            const anyShape = Object.keys(shapeCosts)[0];
            return anyShape || null;
        }
        return null;
    }
    
    /**
     * 第二波（教程第4步完成后的首次波次结束后）固定形状判定
     */
    private shouldApplySecondWaveFixedShapes(): boolean {
        try {
            const levelOk = !!this.saveDataManager && typeof this.saveDataManager.getCurrentLevel === 'function' && this.saveDataManager.getCurrentLevel() === 1;
            const sessionOk = !!this.session && typeof this.session.getRefreshUsageCount === 'function' && typeof this.session.getAddBallUsageCount === 'function'
                && this.session.getRefreshUsageCount() === 0 && this.session.getAddBallUsageCount() === 0;
            // 第4步完成后（_tutorialStep >= 5），且未应用过第二波固定形状
            return this._tutorialStep >= 5 && levelOk && sessionOk && !this._secondWaveFixedApplied;
        } catch (e) {
            console.warn(`[BlockManager] 第二波固定形状上下文检测失败: ${e}`);
            return false;
        }
    }
    
    /**
     * 第二波固定形状选择：Block2 -> “H-I”，Block3 -> “I”，Block1 -> “I”
     * 如果目标形状在该武器不可用，按固定列表内可用形状回退
     */
    private getSecondWaveShapeForIndex(index: number, weaponConfig: WeaponConfig): string | null {
        const preferredOrder = ['I', 'H-I', 'I'];
        const desired = preferredOrder[index % preferredOrder.length];
        const shapeCosts = weaponConfig?.inGameCostConfig?.shapeCosts || null;
        if (shapeCosts && typeof shapeCosts === 'object') {
            if (shapeCosts[desired] !== undefined) {
                return desired;
            }
            const fallbackPreferred = preferredOrder.find(s => shapeCosts[s] !== undefined);
            if (fallbackPreferred) {
                return fallbackPreferred;
            }
            const anyShape = Object.keys(shapeCosts)[0];
            return anyShape || null;
        }
        return null;
    }
    
    // 将db节点与方块关联
    // 将Block容器与方块关联
    associateBlockContainerWithBlock(block: Node, blockContainer: Node) {
        block['blockContainer'] = blockContainer;
        
        block.on(Node.EventType.TRANSFORM_CHANGED, () => {
            if (blockContainer && block.parent) {
                const location = this.blockLocations.get(block);
                
                if (location === 'grid') {
                    // 方块在网格区域时，隐藏整个db标签节点
                    this.hideDbLabel(block);
                    return;
                }
                
                // 检查方块是否正在被拖动，如果是则隐藏整个db标签节点
                if (block['isDragging']) {
                    this.hideDbLabel(block);
                    return;
                }
                
                // 方块在Block容器区域时，显示整个db标签节点
                if (location && location.startsWith('block')) {
                    this.showDbLabel(block);
                }
            }
        });
    }
    
    // 保留原方法以兼容可能的调用（现在委托给新方法）
    associateDbNodeWithBlock(block: Node, dbNode: Node) {
        this.associateBlockContainerWithBlock(block, dbNode);
    }
    
    // 更新金币显示
    updateCoinDisplay() {
        if (this.coinLabelNode) {
            const label = this.coinLabelNode.getComponent(Label);
            if (label) {
                const coins = this.session.getCoins();
                label.string = coins.toString();
            }
        }
    }
    
    // 获取方块价格
    getBlockPrice(block: Node): number {
        const priceNode = this.blockPriceMap.get(block);
        if (priceNode) {
            const label = priceNode.getComponent(Label);
            if (label) {
                const price = parseInt(label.string);
                if (!isNaN(price)) {
                    return price;
                }
            }
        }
        return 50;
    }
    
    // 隐藏价格标签
    hidePriceLabel(block: Node) {
        const priceNode = this.blockPriceMap.get(block);
        if (priceNode) {
            priceNode.active = false;
        }
    }
    
    // 显示价格标签
    showPriceLabel(block: Node) {
        const priceNode = this.blockPriceMap.get(block);
        if (priceNode) {
            priceNode.active = true;
        }
    }
    
    // 隐藏整个db标签节点（包括价格标签）
    hideDbLabel(originalBlock: Node) {
        // 检查方块是否已经放置成功（不在原始容器中），如果是则不需要隐藏价格标签
        const blockLocation = this.blockLocations.get(originalBlock);
        if (blockLocation === 'grid' || originalBlock['placedBefore']) {
            // 已放置成功的方块（包括合成后的方块）不需要隐藏价格标签
            console.log(`[BlockManager] 方块 ${originalBlock.name} 已放置成功，跳过隐藏价格标签操作`);
            return;
        }
        
        // 只有在kuang区域的方块才需要隐藏价格标签
        if (!originalBlock.parent || 
            (originalBlock.parent !== this.block1Container && 
             originalBlock.parent !== this.block2Container && 
             originalBlock.parent !== this.block3Container)) {
            console.log(`[BlockManager] 方块 ${originalBlock.name} 不在原始容器中，跳过隐藏价格标签操作`);
            return;
        }
        
        // 隐藏价格标签
        this.hidePriceLabel(originalBlock);
        console.log(`[BlockManager] 隐藏价格标签: ${originalBlock.name}`);
        
        // 根据原始方块找到对应的db节点
        let dbNode: Node = null;
        if (originalBlock.parent === this.block1Container) {
            dbNode = this.block1DbNode;
        } else if (originalBlock.parent === this.block2Container) {
            dbNode = this.block2DbNode;
        } else if (originalBlock.parent === this.block3Container) {
            dbNode = this.block3DbNode;
        }
        
        console.log(`[BlockManager] db标签节点: ${dbNode ? dbNode.name : 'null'}`);
        if (dbNode) {
            dbNode.active = false;
            console.log(`[BlockManager] 隐藏db标签节点: ${dbNode.name}`);
        } else {
            console.log(`[BlockManager] 未找到对应的db节点`);
        }
    }
    
    // 显示整个db标签节点（包括价格标签）
    showDbLabel(originalBlock: Node) {
        // 检查方块是否已经放置成功（不在原始容器中），如果是则不需要显示价格标签
        const blockLocation = this.blockLocations.get(originalBlock);
        if (blockLocation === 'grid' || originalBlock['placedBefore']) {
            // 已放置成功的方块（包括合成后的方块）不需要显示价格标签
            console.log(`[BlockManager] 方块 ${originalBlock.name} 已放置成功，跳过显示价格标签操作`);
            return;
        }
        
        // 只有在kuang区域的方块才需要显示价格标签
        if (!originalBlock.parent || 
            (originalBlock.parent !== this.block1Container && 
             originalBlock.parent !== this.block2Container && 
             originalBlock.parent !== this.block3Container)) {
            console.log(`[BlockManager] 方块 ${originalBlock.name} 不在原始容器中，跳过显示价格标签操作`);
            return;
        }
        
        // 根据原始方块找到对应的db节点
        let dbNode: Node = null;
        if (originalBlock.parent === this.block1Container) {
            dbNode = this.block1DbNode;
        } else if (originalBlock.parent === this.block2Container) {
            dbNode = this.block2DbNode;
        } else if (originalBlock.parent === this.block3Container) {
            dbNode = this.block3DbNode;
        }
        
        console.log(`[BlockManager] db标签节点: ${dbNode ? dbNode.name : 'null'}`);
        if (dbNode) {
            dbNode.active = true;
            console.log(`[BlockManager] 显示db标签节点: ${dbNode.name}`);
        } else {
            console.log(`[BlockManager] 未找到对应的db节点`);
        }
        // 显示价格标签
        this.showPriceLabel(originalBlock);
    }
    
    // 扣除玩家金币
    deductPlayerCoins(amount: number): boolean {
        const success = this.session.spendCoins(amount);
        if (success) {
            this.updateCoinDisplay();
        }
        return success;
    }
    
    // 显示金币不足时的价格标签闪烁效果
    showInsufficientCoinsEffect(block: Node) {
        const priceNode = this.blockPriceMap.get(block);
        if (!priceNode) {
            console.warn('[BlockManager] 找不到方块对应的价格标签');
            return;
        }
        
        const label = priceNode.getComponent(Label);
        if (!label) {
            console.warn('[BlockManager] 价格节点缺少Label组件');
            return;
        }
        
        // 保存原始颜色
        const originalColor = label.color.clone();
        
        // 设置红色
        const redColor = new Color(255, 0, 0, 255);
        
        // 创建闪烁动画：变红 -> 恢复原色，重复3次，总时长2秒
        tween(label)
            .to(0.2, { color: redColor })
            .to(0.2, { color: originalColor })
            .to(0.2, { color: redColor })
            .to(0.2, { color: originalColor })
            .to(0.2, { color: redColor })
            .to(1.0, { color: originalColor })
            .start();
        
        // 发送显示资源不足Toast事件
        EventBus.getInstance().emit(GameEvents.SHOW_RESOURCE_TOAST, {
            message: '金币不足',
            duration: 2.0
        });
        
        console.log('[BlockManager] 显示金币不足效果');
    }
    
    // 归还玩家金币
    refundPlayerCoins(amount: number) {
        this.session.addCoins(amount);
        this.updateCoinDisplay();
    }
    
    // 设置拖拽事件方法已迁移到GameBlockSelection
    

    
    // 清除临时保存的占用状态
    clearTempStoredOccupiedGrids(block: Node) {
        const index = this.tempRemovedOccupiedGrids.findIndex(item => item.block === block);
        if (index === -1) return;
        
        this.tempRemovedOccupiedGrids.splice(index, 1);
    }
    
    // 清除特定方块的占用状态
    public clearOccupiedPositions(block: Node) {
        if (!this.gridInitialized) return;
        
        const occupiedGrids = block['occupiedGrids'];
        if (!occupiedGrids || occupiedGrids.length === 0) return;
        
        // 清除网格占用状态
        for (const grid of occupiedGrids) {
            if (grid.row >= 0 && grid.row < this.GRID_ROWS && 
                grid.col >= 0 && grid.col < this.GRID_COLS) {
                this.gridOccupationMap[grid.row][grid.col] = 0;
            }
        }
        
        // 清除方块的占用记录
        block['occupiedGrids'] = [];
    }
    
    // 尝试将方块放置到网格中
    tryPlaceBlockToGrid(block: Node): boolean {
        console.log(`[BlockManager] 尝试放置方块 ${block.name} 到网格`);
        
        if (!this.gridContainer || !this.gridInitialized) {
            console.log(`[BlockManager] 网格容器或网格未初始化`);
            return false;
        }
        
        let b1Node = block;
        if (block.name !== 'B1') {
            b1Node = block.getChildByName('B1');
            if (!b1Node) {
                console.log(`[BlockManager] 方块 ${block.name} 没有B1子节点`);
                return false;
            }
        }
        
        const b1WorldPos = b1Node.parent.getComponent(UITransform).convertToWorldSpaceAR(b1Node.position);
        const gridPos = this.gridContainer.getComponent(UITransform).convertToNodeSpaceAR(b1WorldPos);
        
        console.log(`[BlockManager] B1世界坐标:`, b1WorldPos);
        console.log(`[BlockManager] 网格本地坐标:`, gridPos);
        
        const gridSize = this.gridContainer.getComponent(UITransform).contentSize;
        const halfWidth = gridSize.width / 2;
        const halfHeight = gridSize.height / 2;
        
        const tolerance = this.gridSpacing * 0.5;
        if (gridPos.x < -halfWidth - tolerance || gridPos.x > halfWidth + tolerance || 
            gridPos.y < -halfHeight - tolerance || gridPos.y > halfHeight + tolerance) {
            console.log(`[BlockManager] 方块超出网格边界`);
            return false;
        }
        
        const nearestGrid = this.findNearestGridNode(gridPos);
        if (!nearestGrid) {
            console.log(`[BlockManager] 找不到最近的网格节点`);
            return false;
        }

        // 新手教程限制：只允许放置到指定网格
        if (this.isNewbieTutorialContext()) {
            const isValidTutorialPlacement = this.validateTutorialPlacement(block, nearestGrid);
            if (!isValidTutorialPlacement) {
                console.log(`[BlockManager] 新手教程：方块不能放置到此网格`);
                return false;
            }
        }

        // 扩展教程（第5-6步）：只允许拖到指定格子
        if (this._tutorialStep >= 5 && this._tutorialStep < 7) {
            const basePair = this._tutorialStep >= 6 ? this._tutorialTargetGridsStep4 : this._tutorialTargetGridsStep2;
            if (basePair && basePair.length === 2) {
                const parse = (name: string) => {
                    const m = name.match(/^Grid_(\d+)_(\d+)$/);
                    return m ? { row: parseInt(m[1]), col: parseInt(m[2]) } : null;
                };
                const pairKey = (arr: string[]) => arr.slice().sort().join('|');
                const p0 = parse(basePair[0]);
                const p1 = parse(basePair[1]);
                if (p0 && p1) {
                    let anchor = p0;
                    if (p0.row !== p1.row) {
                        anchor = p0.row < p1.row ? p0 : p1;
                    } else if (p0.col !== p1.col) {
                        anchor = p0.col < p1.col ? p0 : p1;
                    }
                    const horizontalPair = [`Grid_${anchor.row}_${anchor.col}`, `Grid_${anchor.row}_${anchor.col + 1}`];
                    const verticalPair = [`Grid_${anchor.row}_${anchor.col}`, `Grid_${anchor.row + 1}_${anchor.col}`];
                    const allowedPairs = new Set<string>([
                        pairKey(horizontalPair),
                        pairKey(verticalPair),
                        pairKey(basePair),
                    ]);
                    const targetRowCol = this.getGridRowCol(nearestGrid);
                    if (!targetRowCol) return false;
                    const parts = this.getBlockParts(block);
                    const occupiedNames: string[] = [];
                    for (let i = 0; i < parts.length; i++) {
                        const part = parts[i];
                        const row = targetRowCol.row - part.y;
                        const col = targetRowCol.col + part.x;
                        occupiedNames.push(`Grid_${row}_${col}`);
                    }
                    const occupiedKey = pairKey(occupiedNames);
                    if (!allowedPairs.has(occupiedKey)) {
                        console.log(`[BlockManager] 扩展教程：方块不能放置到此网格`);
                        return false;
                    }
                }
            }
        }
        
        return this.tryPlaceBlockToSpecificGrid(block, nearestGrid);
    }

    /**
     * 验证新手教程中的方块放置是否有效
     */
    private validateTutorialPlacement(block: Node, targetGrid: Node): boolean {
        // 基础目标对（当前步骤）
        const basePair = this._tutorialStep >= 4 ? this._tutorialTargetGridsStep4
            : this._tutorialStep >= 2 ? this._tutorialTargetGridsStep2 : this._tutorialTargetGrids;
        if (!basePair || basePair.length !== 2) {
            return true; // 配置不完整不强制
        }

        // 辅助：解析与配对键
        const parse = (name: string) => {
            const m = name.match(/^Grid_(\d+)_(\d+)$/);
            return m ? { row: parseInt(m[1]), col: parseInt(m[2]) } : null;
        };
        const pairKey = (arr: string[]) => arr.slice().sort().join('|');

        const p0 = parse(basePair[0]);
        const p1 = parse(basePair[1]);
        if (!p0 || !p1) return true;

        // 选择锚点（行不同取较小行，否则取较小列）
        let anchor = p0;
        if (p0.row !== p1.row) {
            anchor = p0.row < p1.row ? p0 : p1;
        } else if (p0.col !== p1.col) {
            anchor = p0.col < p1.col ? p0 : p1;
        }

        // 从基础对推导允许的横/竖两种占位对
        const horizontalPair = [`Grid_${anchor.row}_${anchor.col}`, `Grid_${anchor.row}_${anchor.col + 1}`];
        const verticalPair = [`Grid_${anchor.row}_${anchor.col}`, `Grid_${anchor.row + 1}_${anchor.col}`];
        const allowedPairs = new Set<string>([
            pairKey(horizontalPair),
            pairKey(verticalPair),
            pairKey(basePair),
        ]);

        // 计算实际占用格子
        const targetRowCol = this.getGridRowCol(targetGrid);
        if (!targetRowCol) return false;
        const parts = this.getBlockParts(block);
        const occupiedNames: string[] = [];
        for (let i = 0; i < parts.length; i++) {
            const part = parts[i];
            const row = targetRowCol.row - part.y;
            const col = targetRowCol.col + part.x;
            occupiedNames.push(`Grid_${row}_${col}`);
        }
        const occupiedKey = pairKey(occupiedNames);

        const ok = allowedPairs.has(occupiedKey);
        if (!ok) {
            console.log(`[BlockManager] 新手教程：需要占用任一允许对，当前占用为 ${occupiedNames.join('、')}`);
        }
        return ok;
    }

    /**
     * 获取指定名称的网格节点
     */
    private findGridNodeByName(gridName: string): Node | null {
        if (!this.gridContainer || !this.gridInitialized) {
            return null;
        }

        for (let row = 0; row < this.GRID_ROWS; row++) {
            for (let col = 0; col < this.GRID_COLS; col++) {
                const gridNode = this.gridNodes[row][col];
                if (gridNode && gridNode.name === gridName) {
                    return gridNode;
                }
            }
        }
        return null;
    }
    
    // 找到最近的网格节点
    public findNearestGridNode(position: Vec3): Node {
        if (!this.gridContainer || !this.gridInitialized) return null;
        
        let nearestNode: Node = null;
        let minDistance = Number.MAX_VALUE;
        
        for (let row = 0; row < this.GRID_ROWS; row++) {
            for (let col = 0; col < this.GRID_COLS; col++) {
                const grid = this.gridNodes[row][col];
                if (grid) {
                    const distance = Vec3.distance(position, grid.position);
                    if (distance < minDistance) {
                        minDistance = distance;
                        nearestNode = grid;
                    }
                }
            }
        }
        
        if (minDistance > this.gridSpacing * 2) {
            return null;
        }
        
        return nearestNode;
    }
    
    // 尝试将方块放置到指定的网格节点
    tryPlaceBlockToSpecificGrid(block: Node, targetGrid: Node): boolean {
        let b1Node = block;
        if (block.name !== 'B1') {
            b1Node = block.getChildByName('B1');
            if (!b1Node) {
                return false;
            }
        }
        
        if (!this.canPlaceBlockAt(block, targetGrid)) {
            return false;
        }
        
        // 在放置前缓存一次教程上下文判定，避免放置后 hasPlacedBlocks 改变导致不触发
        const tutorialContextBeforePlacement = this.isNewbieTutorialContext();
        
        const gridCenterWorldPos = this.gridContainer.getComponent(UITransform).convertToWorldSpaceAR(targetGrid.position);
        const targetWorldPos = gridCenterWorldPos.clone();
        
        const b1LocalPos = b1Node.position.clone();
        
        let rootTargetWorldPos;
        if (b1Node === block) {
            rootTargetWorldPos = targetWorldPos.clone();
        } else {
            rootTargetWorldPos = new Vec3(
                targetWorldPos.x - b1LocalPos.x,
                targetWorldPos.y - b1LocalPos.y,
                targetWorldPos.z
            );
        }
        
        const rootTargetLocalPos = block.parent.getComponent(UITransform).convertToNodeSpaceAR(rootTargetWorldPos);
        
        block.position = rootTargetLocalPos;
        this.markOccupiedPositions(block, targetGrid);
        
        // 当方块从kuang区域拖到网格时，恢复植物图标的正常缩放
        // 根据新的预制体结构，武器节点直接位于方块根节点下
        let weaponNode = block.getChildByName('Weapon');
        
        // 兼容旧结构：如果直接查找失败，尝试B1/Weapon路径
        if (!weaponNode && b1Node) {
            weaponNode = b1Node.getChildByName('Weapon');
        }
        
        if (weaponNode) {
            weaponNode.setScale(0.4, 0.4, 1.0);
            console.log(`[BlockManager] 方块 ${block.name} 放置到网格，植物图标缩放设置为0.4倍`);
        }

        // 引导：放置成功后隐藏指引与高亮
        if (this.guideUIController) {
            this.guideUIController.hideAllGuideUI();
            void 0;
        }

        // 新手教程：触发方块放置事件（使用放置前的上下文判定）
        if (tutorialContextBeforePlacement) {
            this.handleTutorialBlockPlacement(block, targetGrid);
        } else if (this.isExtendedTutorialEventContext()) {
            // 扩展步骤（第5-6步）也触发事件判断，但不进行位置限制
            this.handleTutorialBlockPlacement(block, targetGrid);
        }
        
        return true;
    }
    
    /**
     * 统一判断：拖拽放置步骤完成（占用目标格子对 + 可选期望方块）
     */
    private isTutorialPlacementCompleted(block: Node, targetGrid: Node, gridPair: string[], expectedBlock?: Node): boolean {
        if (!gridPair || gridPair.length !== 2) return false;
        if (expectedBlock) {
            const originContainer = (block as any)['blockContainer'] as Node | undefined;
            let matches = false;
            // 1) 期望为实际方块：直接等值
            if (block === expectedBlock) {
                matches = true;
            }
            // 2) 期望为容器：使用生成来源容器匹配
            if (!matches && originContainer && originContainer === expectedBlock) {
                matches = true;
            }
            // 3) 兼容：尚在容器层级下（未移动出容器）
            if (!matches) {
                let p = block.parent;
                while (p) {
                    if (p === expectedBlock) { matches = true; break; }
                    p = p.parent;
                }
            }
            if (!matches) {
                console.log(`[BlockManager] 教程：放置的方块未匹配期望（容器或生成来源）`);
                return false;
            }
        }
        const parse = (name: string) => {
            const m = name.match(/^Grid_(\d+)_(\d+)$/);
            return m ? { row: parseInt(m[1]), col: parseInt(m[2]) } : null;
        };
        const pairKey = (arr: string[]) => arr.slice().sort().join('|');

        const p0 = parse(gridPair[0]);
        const p1 = parse(gridPair[1]);
        if (!p0 || !p1) return false;

        let anchor = p0;
        if (p0.row !== p1.row) {
            anchor = p0.row < p1.row ? p0 : p1;
        } else if (p0.col !== p1.col) {
            anchor = p0.col < p1.col ? p0 : p1;
        }

        const horizontalPair = [`Grid_${anchor.row}_${anchor.col}`, `Grid_${anchor.row}_${anchor.col + 1}`];
        const verticalPair = [`Grid_${anchor.row}_${anchor.col}`, `Grid_${anchor.row + 1}_${anchor.col}`];
        const allowedPairs = new Set<string>([
            pairKey(horizontalPair),
            pairKey(verticalPair),
            pairKey(gridPair),
        ]);

        const targetRowCol = this.getGridRowCol(targetGrid);
        if (!targetRowCol) return false;
        const parts = this.getBlockParts(block);
        const occupiedNames: string[] = [];
        for (let i = 0; i < parts.length; i++) {
            const part = parts[i];
            const row = targetRowCol.row - part.y;
            const col = targetRowCol.col + part.x;
            occupiedNames.push(`Grid_${row}_${col}`);
        }
        const occupiedKey = pairKey(occupiedNames);
        const ok = allowedPairs.has(occupiedKey);
        if (!ok) {
            console.log(`[BlockManager] 教程：占用 ${occupiedNames.join('、')} 未匹配允许对`);
        }
        return ok;
    }

    /**
     * 处理教程方块放置事件（统一结束判断）
     */
    private handleTutorialBlockPlacement(block: cc.Node, targetGrid: cc.Node): void {
        // 第6步：使用 _tutorialTargetGridsStep4 + 期望方块校验（fingerStartNodes[5]）
        if (this._tutorialStep >= 6) {
            const expectedStep6 = this.guideUIController ? this.guideUIController.fingerStartNodes[5] : null;
            const completedStep6 = this.isTutorialPlacementCompleted(block, targetGrid, this._tutorialTargetGridsStep4, expectedStep6 || undefined);
            if (completedStep6) {
                EventBus.getInstance().emit(GameEvents.TUTORIAL_BLOCK_5_PLACED);
                this._tutorialStep = 7;
                console.log(`[BlockManager] 教程第六步完成`);
            }
            return;
        }

        // 第5步：使用 _tutorialTargetGridsStep2 + 期望方块校验（fingerStartNodes[4]）
        if (this._tutorialStep >= 5) {
            const expectedStep5 = this.guideUIController ? this.guideUIController.fingerStartNodes[4] : null;
            const completedStep5 = this.isTutorialPlacementCompleted(block, targetGrid, this._tutorialTargetGridsStep2, expectedStep5 || undefined);
            if (completedStep5) {
                EventBus.getInstance().emit(GameEvents.TUTORIAL_BLOCK_4_PLACED);
                this._tutorialStep = 6;
                console.log(`[BlockManager] 教程第五步完成`);
            }
            return;
        }

        // 第4步：使用 _tutorialTargetGridsStep4 + 期望方块校验（fingerStartNodes[3]）
        if (this._tutorialStep >= 4) {
            const expected = this.guideUIController ? this.guideUIController.fingerStartNodes[3] : null;
            const completed = this.isTutorialPlacementCompleted(block, targetGrid, this._tutorialTargetGridsStep4, expected || undefined);
            if (completed) {
                EventBus.getInstance().emit(GameEvents.TUTORIAL_BLOCK_3_PLACED);
                this._tutorialStep = 5;
                console.log(`[BlockManager] 教程第四步完成`);
            }
            return;
        }

        // 第2步：使用 _tutorialTargetGridsStep2 + 期望方块校验（fingerStartNodes[1]）
        if (this._tutorialStep >= 2) {
            const expected = this.guideUIController ? this.guideUIController.fingerStartNodes[1] : null;
            const completed = this.isTutorialPlacementCompleted(block, targetGrid, this._tutorialTargetGridsStep2, expected || undefined);
            if (!completed) return;
            EventBus.getInstance().emit(GameEvents.TUTORIAL_BLOCK_2_PLACED);
            this._tutorialStep = 3;
            console.log(`[BlockManager] 教程第二步完成`);
            return;
        }

        // 第1步：使用 _tutorialTargetGrids + 期望方块校验（fingerStartNodes[0]）
        {
            const expected = this.guideUIController ? this.guideUIController.fingerStartNodes[0] : null;
            const completed = this.isTutorialPlacementCompleted(block, targetGrid, this._tutorialTargetGrids, expected || undefined);
            if (!completed) return;
            EventBus.getInstance().emit(GameEvents.TUTORIAL_BLOCK_1_PLACED);

            // 运行时注入 Drag[2] 的起点为刚刚放置到场上的方块（Drag[0] 的结果）
            if (this.guideUIController) {
                try {
                    this.guideUIController.setStartNodeForDragConfigIndex(2, block);
                } catch (e) {
                    console.warn(`[BlockManager] 注入 Drag[2] 起点失败: ${e}`);
                }
            }

            this._tutorialStep = 2;
            console.log(`[BlockManager] 教程第一步完成`);
            return;
        }
    }
    
    // 检查方块是否可以放置在指定位置
    canPlaceBlockAt(block: Node, targetGrid: Node): boolean {
        
        if (!this.gridInitialized) {
            console.log(`[BlockManager] 网格未初始化`);
            return false;
        }
        
        const targetRowCol = this.getGridRowCol(targetGrid);
        if (!targetRowCol) {
            console.log(`[BlockManager] 无法获取目标网格的行列信息`);
            return false;
        }
                
        const parts = this.getBlockParts(block);
        
        for (let i = 0; i < parts.length; i++) {
            const part = parts[i];
            const row = targetRowCol.row - part.y;
            const col = targetRowCol.col + part.x;
            
            
            if (row < 0 || row >= this.GRID_ROWS || col < 0 || col >= this.GRID_COLS) {
                console.log(`[BlockManager] 部件${i} 超出网格边界: row=${row}, col=${col}, 网格大小=${this.GRID_ROWS}x${this.GRID_COLS}`);
                return false;
            }
            
            if (this.gridOccupationMap[row][col] === 1) {
                console.log(`[BlockManager] 部件${i} 位置已被占用: row=${row}, col=${col}`);
                return false;
            }
        }
        
        return true;
    }
    
    // 获取网格行列索引
    getGridRowCol(gridNode: Node): { row: number, col: number } | null {
        if (!gridNode || !gridNode.name.startsWith('Grid_')) return null;
        
        const parts = gridNode.name.split('_');
        if (parts.length === 3) {
            const row = parseInt(parts[1]);
            const col = parseInt(parts[2]);
            
            if (row >= 0 && row < this.GRID_ROWS && col >= 0 && col < this.GRID_COLS) {
                return { row, col };
            }
        }
        
        return null;
    }
    
    // 获取指定行列的网格世界坐标（用于调试绘制）
    public getGridWorldPosition(row: number, col: number): Vec3 | null {
        if (!this.gridInitialized || !this.gridNodes[row] || !this.gridNodes[row][col]) {
            return null;
        }
        
        const gridNode = this.gridNodes[row][col];
        return this.gridContainer.getComponent(UITransform).convertToWorldSpaceAR(gridNode.position);
    }
    
    // 获取方块的所有部分节点及其相对坐标
    getBlockParts(block: Node): { node: Node, x: number, y: number }[] {
        const parts: { node: Node, x: number, y: number }[] = [];
        
        // 检查根节点是否有B1子节点，如果有，则B1是实际的形状根节点
        const b1Node = block.getChildByName('B1');
        if (b1Node) {
            // B1节点作为形状的根节点和坐标原点(0,0)
            // 将B1节点本身添加为第一个部分
            parts.push({ node: b1Node, x: 0, y: 0 });
            // 然后递归查找B1的子节点，但要避免重复添加B1本身
            this.findBlockParts(b1Node, parts, 0, 0, true);
        } else {
            // 没有B1节点，使用根节点作为形状根节点
            parts.push({ node: block, x: 0, y: 0 });
            this.findBlockParts(block, parts, 0, 0, false);
        }
        
        return parts;
    }
    
    // 递归查找方块的所有部分
    findBlockParts(node: Node, result: { node: Node, x: number, y: number }[], parentX: number, parentY: number, skipRoot: boolean = false) {
        for (let i = 0; i < node.children.length; i++) {
            const child = node.children[i];
            
            if (this.NON_BLOCK_NODES.indexOf(child.name) !== -1) {
                continue;
            }
            
            let x = parentX;
            let y = parentY;
            
            const match = child.name.match(/^\((-?\d+),(-?\d+)\)$/);
            if (match) {
                x = parseInt(match[1]);
                y = parseInt(match[2]);
                result.push({ node: child, x, y });
            } else if (child.name.startsWith('B')) {
                const relativeX = Math.round(child.position.x / this.gridSpacing);
                const relativeY = -Math.round(child.position.y / this.gridSpacing);
                
                x = parentX + relativeX;
                y = parentY + relativeY;
                
                // 避免重复添加已经在result中的节点
                const existingPart = result.find(part => part.node === child);
                if (!existingPart) {
                    result.push({ node: child, x, y });
                }
            }
            
            this.findBlockParts(child, result, x, y, false);
        }
    }
    
    // 标记方块占用的格子
    public markOccupiedPositions(block: Node, targetGrid: Node) {
        if (!this.gridInitialized) return;
        
        const targetRowCol = this.getGridRowCol(targetGrid);
        if (!targetRowCol) return;
        
        const parts = this.getBlockParts(block);
        
        block['occupiedGrids'] = [];
        
        for (const part of parts) {
            const row = targetRowCol.row - part.y;
            const col = targetRowCol.col + part.x;
            
            if (row >= 0 && row < this.GRID_ROWS && col >= 0 && col < this.GRID_COLS) {
                this.gridOccupationMap[row][col] = 1;
                
                block['occupiedGrids'] = block['occupiedGrids'] || [];
                block['occupiedGrids'].push({ row, col });
            }
        }
    }
    
    // 清除方块
    clearBlocks() {
        console.log('[BlockManager] clearBlocks开始，当前方块总数:', this.blocks.length);
        const blocksToRemove = [];
        
        for (const block of this.blocks) {
            if (block.isValid) {
                const location = this.blockLocations.get(block);
                // 清除kuang区域和Block容器中的方块
                if (location === 'kuang' || location === 'block1' || location === 'block2' || location === 'block3') {
                    blocksToRemove.push(block);
                }
            }
        }
        
        console.log('[BlockManager] 找到需要清理的方块数量:', blocksToRemove.length);
        
        for (const block of blocksToRemove) {
            const dbNode = block['dbNode'];
            if (dbNode && dbNode.isValid) {
                block.off(Node.EventType.TRANSFORM_CHANGED);
                
                const kuangNode = this.kuangContainer;
                if (kuangNode) {
                    const dbName = dbNode.name;
                    if (!kuangNode.getChildByName(dbName)) {
                        dbNode.parent = kuangNode;
                    }
                }
            }
            
            const index = this.blocks.indexOf(block);
            if (index !== -1) {
                this.blocks.splice(index, 1);
            }
            
            this.originalPositions.delete(block);
            this.blockLocations.delete(block);
            this.blockPriceMap.delete(block);
            // 清理武器配置映射
            this.blockWeaponConfigs.delete(block);
            
            console.log('[BlockManager] 销毁方块:', block.name, '位置:', this.blockLocations.get(block));
            block.destroy();
        }
        
        console.log('[BlockManager] clearBlocks完成，剩余方块总数:', this.blocks.length);
    }
    
    // 游戏开始时调用
    onGameStart() {
        this.gameStarted = true;
        
        for (const block of this.blocks) {
            if (block.isValid) {
                const location = this.blockLocations.get(block);
                
                if (location === 'grid') {
                    const dbNode = block['dbNode'];
                    if (dbNode) {
                        dbNode.active = false;
                    }
                    
                    this.moveBlockToPlacedBlocks(block);
                    this.addLockedVisualHint(block);
                    
                    // 游戏开始后放置的方块移除标签，不能再放回kuang
                    BlockTag.removeTag(block);
                }
            }
        }
    }
    
    // 游戏重置时调用
    onGameReset() {
        console.log('[BlockManager] 游戏重置，清理所有状态');
        console.log('[BlockManager] 重置前方块总数:', this.blocks.length);
        
        this.gameStarted = false;
        this.clearAllCooldowns();
        
        // 清理已放置的方块
        console.log('[BlockManager] 开始清理已放置的方块');
        this.clearPlacedBlocks();
        
        // 重置网格占用状态
        console.log('[BlockManager] 开始重置网格占用状态');
        this.resetGridOccupation();
        
        // 清理kuang区域的方块
        console.log('[BlockManager] 开始清理kuang区域的方块');
        this.clearBlocks();
        
        // 清理所有方块标签
        console.log('[BlockManager] 开始清理所有方块标签');
        BlockTag.clearAllTags();
        
        console.log('[BlockManager] 清理后方块总数:', this.blocks.length);
        
        console.log('[BlockManager] 游戏重置完成 - 方块生成将由StartGame流程处理');
    }
    
    // 清理已放置的方块
    private clearPlacedBlocks() {
        if (!this.placedBlocksContainer || !this.placedBlocksContainer.isValid) {
            console.log('[BlockManager] PlacedBlocks容器无效，跳过清理');
            return;
        }
        
        console.log(`[BlockManager] 清理已放置方块，当前数量: ${this.placedBlocksContainer.children.length}`);
        
        // 清理PlacedBlocks容器中的所有方块
        const placedBlocks = [...this.placedBlocksContainer.children];
        let clearedCount = 0;
        
        for (const block of placedBlocks) {
            if (block && block.isValid) {
                // 从blocks数组中移除
                const index = this.blocks.indexOf(block);
                if (index !== -1) {
                    this.blocks.splice(index, 1);
                }
                
                // 清理相关映射
                this.originalPositions.delete(block);
                this.blockLocations.delete(block);
                this.blockPriceMap.delete(block);
                this.blockWeaponConfigs.delete(block);
                
                console.log('[BlockManager] 销毁已放置方块:', block.name);
                // 销毁方块
                block.destroy();
                clearedCount++;
            }
        }
        
        console.log(`[BlockManager] 已清理 ${clearedCount} 个已放置方块`);
    }
    
    // 重置网格占用状态
    public resetGridOccupation() {
        console.log('[BlockManager] 重置网格占用状态');
        
        // 重新初始化网格占用地图
        this.gridOccupationMap = [];
        for (let row = 0; row < this.GRID_ROWS; row++) {
            this.gridOccupationMap[row] = [];
            for (let col = 0; col < this.GRID_COLS; col++) {
                this.gridOccupationMap[row][col] = 0;
            }
        }
        // 清理临时存储的占用状态
        this.tempRemovedOccupiedGrids = [];
    }
    
    // 添加视觉提示，表明方块已锁定
    addLockedVisualHint(block: Node) {
        const children = block.children;
        for (let i = 0; i < children.length; i++) {
            const child = children[i];
            if (this.NON_BLOCK_NODES.indexOf(child.name) !== -1) {
                continue;
            }
            
            child.setScale(new Vec3(0.95, 0.95, 1));
        }
        
    }
    
    // 将方块移动到PlacedBlocks节点下
    moveBlockToPlacedBlocks(block: Node) {
        if (!this.placedBlocksContainer) {
            console.error('PlacedBlocks容器未设置');
            return;
        }
        
        if (!this.placedBlocksContainer.isValid) {
            console.error('PlacedBlocks容器已失效');
            return;
        }
        
        const worldPosition = new Vec3();
        block.getWorldPosition(worldPosition);
        
        // 移除旧的触摸事件监听器
        block.off(Node.EventType.TOUCH_START);
        block.off(Node.EventType.TOUCH_MOVE);
        block.off(Node.EventType.TOUCH_END);
        block.off(Node.EventType.TOUCH_CANCEL);
        
        block.removeFromParent();
        this.placedBlocksContainer.addChild(block);
        block.setWorldPosition(worldPosition);
        
        // 通过事件机制重新设置拖拽事件
        const eventBus = EventBus.getInstance();
        eventBus.emit(GameEvents.SETUP_BLOCK_DRAG_EVENTS, [block]);
        console.log(`[BlockManager] 为移动到PlacedBlocks的方块 ${block.name} 重新设置拖拽事件`);
    }
    
    // 根据武器配置选择合适的预制体
    private selectPrefabForWeapon(weaponConfig: WeaponConfig, targetShapeId?: string): Prefab | null {
        if (this.blockPrefabs.length === 0) {
            return null;
        }
        
        // 如果指定了目标形状ID，尝试找到匹配的预制体
        if (targetShapeId) {
            const matchingPrefab = this.findPrefabByShape(targetShapeId);
            if (matchingPrefab) {
                console.log(`[BlockManager] 为武器 ${weaponConfig.name} 找到匹配形状 ${targetShapeId} 的预制体`);
                return matchingPrefab;
            }
        }
        
        // 如果没有指定形状或没有找到匹配的预制体，使用随机选择
        const randomIndex = Math.floor(Math.random() * this.blockPrefabs.length);
        const selectedPrefab = this.blockPrefabs[randomIndex];
        
        console.log(`[BlockManager] 为武器 ${weaponConfig.name} 选择随机预制体 (索引: ${randomIndex})`);
        
        return selectedPrefab;
    }
    
    // 根据形状ID查找匹配的预制体（按照Block+形状ID的命名规则）
    private findPrefabByShape(targetShapeId: string): Prefab | null {
        // 构建预期的预制体名称：Block + 形状ID
        const expectedPrefabName = `Block${targetShapeId}`;
        
        console.log(`[BlockManager] 寻找形状 ${targetShapeId} 的预制体，期望名称: ${expectedPrefabName}`);
        console.log(`[BlockManager] 当前可用预制体数量: ${this.blockPrefabs.length}`);
        
        // 输出所有可用预制体的详细信息
        this.blockPrefabs.forEach((prefab, index) => {
            console.log(`[BlockManager] 预制体[${index}]: ${prefab.name} (匹配: ${prefab.name === expectedPrefabName})`);
        });
        
        for (const prefab of this.blockPrefabs) {
            if (prefab.name === expectedPrefabName) {
                console.log(`[BlockManager] ✓ 找到匹配形状 ${targetShapeId} 的预制体: ${prefab.name}`);
                return prefab;
            }
        }
        
        console.log(`[BlockManager] ✗ 未找到匹配形状 ${targetShapeId} 的预制体 (期望名称: ${expectedPrefabName})`);
        return null;
    }
    
    // 根据武器配置和方块形状设置价格
    private setBlockPriceByWeaponConfig(block: Node, priceNode: Node) {
        const label = priceNode.getComponent(Label);
        if (!label) {
            return;
        }

        // 从Node子节点获取BlockInfo组件（新预制体结构）
        const nodeChild = block.getChildByName('Node');
        const blockInfo = nodeChild ? nodeChild.getComponent(BlockInfo) : null;
        
        if (!blockInfo) {
            label.string = "10";
            return;
        }
        
        // 直接使用BlockInfo的shapePrice，如果为0则使用默认价格10
        let basePrice = blockInfo.shapePrice > 0 ? blockInfo.shapePrice : 10;

        // 应用便宜技能效果
        const skillManager = SkillManager.getInstance();
        let finalPrice = basePrice;
        if (skillManager) {
            const cheaperSkillLevel = skillManager.getSkillLevel('cheaper_units');
            finalPrice = Math.ceil(SkillManager.calculateCheaperUnitsPrice(basePrice, cheaperSkillLevel));
        }

        label.string = finalPrice.toString();
    }

    // 计算方块占用的格子数量

    
    // 设置方块的武器外观
    private setupBlockWeaponVisual(block: Node, weaponConfig: WeaponConfig, targetShapeId?: string) {
        // 确保方块节点上也有 weaponConfig 属性
        block['weaponConfig'] = weaponConfig;
        
        // 如果提供了目标形状ID，直接使用它加载对应的稀有度图片
        if (targetShapeId) {
            this.loadBlockRarityImageByShape(block, weaponConfig.rarity || 'common', targetShapeId);
        } else {
            // 否则使用原有逻辑从方块结构推断形状
            this.loadBlockRarityImage(block, weaponConfig.rarity || 'common');
        }
        
        // 加载武器图标
        this.loadWeaponIcon(block, weaponConfig);
    }
    
    /**
     * 设置方块的BlockInfo组件信息
     * @param block 方块节点
     * @param weaponConfig 武器配置
     * @param targetShapeId 目标形状ID
     * @param blockLocation 方块所在位置
     */
    private setupBlockInfo(block: Node, weaponConfig: WeaponConfig, targetShapeId?: string, blockLocation?: string) {
        // 从Node子节点获取BlockInfo组件（新预制体结构）
        const nodeChild = block.getChildByName('Node');
        const blockInfo = nodeChild ? nodeChild.getComponent(BlockInfo) : null;
        if (!blockInfo) {
            console.warn(`[BlockManager] 方块 ${block.name} 没有BlockInfo组件`);
            return;
        }
        
        // 设置基础信息
        blockInfo.blockName = weaponConfig.name || block.name;
        blockInfo.blockId = weaponConfig.id || weaponConfig.name;
        
        // 设置稀有度
        const rarityMap = { 'common': 0, 'uncommon': 1, 'rare': 2, 'epic': 3 };
        blockInfo.rarity = rarityMap[weaponConfig.rarity] || 0;
        
        // 设置稀有度颜色
        blockInfo.rarityColor = this.getRarityColor(weaponConfig.rarity);

        // 设置形状信息
        if (targetShapeId) {
            blockInfo.shapeId = targetShapeId;
            const shapeInfo = this.getBlockShapeInfo(block);
            if (shapeInfo && shapeInfo.shape) {
                // 计算形状大小
                const rows = shapeInfo.shape.length;
                const cols = shapeInfo.shape[0] ? shapeInfo.shape[0].length : 0;
                blockInfo.shapeSize = new cc.Vec2(cols, rows);
            }
        }
        
        // 设置武器配置（在形状ID设置之后，这样可以正确计算形状价格）
        blockInfo.setWeaponConfig(weaponConfig);
        
        // 设置位置信息
        blockInfo.currentLocation = blockLocation || 'kuang';
        blockInfo.gridPosition = new cc.Vec2(-1, -1);
        
        // 设置状态信息
        blockInfo.isPlaced = false;
        blockInfo.isDraggable = true;
        blockInfo.isMergeable = true;
        
        // 设置方块标签
        const tags = [];
        if (weaponConfig.type) tags.push(weaponConfig.type);
        if (weaponConfig.rarity) tags.push(weaponConfig.rarity);
        if (targetShapeId) tags.push(targetShapeId);
        blockInfo.setBlockTags(tags);
        
        // 查找稀有度和武器图标
        // 根据新的预制体结构，武器节点直接位于方块根节点下
        let weaponNode = block.getChildByName('Weapon');
        
        // 兼容旧结构：如果直接查找失败，尝试B1/Weapon路径
        if (!weaponNode) {
            const b1Node = block.getChildByName('B1');
            if (b1Node) {
                weaponNode = b1Node.getChildByName('Weapon');
            }
        }
        
        if (weaponNode) {
            const weaponSprite = weaponNode.getComponent(Sprite);
            if (weaponSprite) {
                blockInfo.weaponSprite = weaponSprite;
            }
        }
        
        // 更新显示
        blockInfo.updatePriceDisplay();
        blockInfo.updateRarityDisplay();
        
        console.log(`[BlockManager] 已设置方块 ${block.name} 的BlockInfo组件信息`);
    }
    
    /**
     * 获取稀有度对应的颜色
     * @param rarity 稀有度
     * @returns 颜色对象
     */
    private getRarityColor(rarity: string): cc.Color {
        switch (rarity) {
            case 'common':
                return cc.Color.WHITE;
            case 'uncommon':
                return cc.Color.GREEN;
            case 'rare':
                return cc.Color.BLUE;
            case 'epic':
                return cc.Color.MAGENTA;
            default:
                return cc.Color.WHITE;
        }
    }
    
    // 设置方块稀有度颜色
    private setBlockRarityColor(block: Node, rarity: string) {
        this.loadBlockRarityImage(block, rarity);
    }
    
    // 公共方法：应用方块稀有度图片（供外部调用）
    public applyBlockRarityColor(block: Node, rarity: string) {
        // Add null safety check for block
        if (!block || !block.isValid) {
            return;
        }
        
        // 使用图片替代颜色
        this.loadBlockRarityImage(block, rarity);
    }
    
    // 根据稀有度和指定形状ID加载对应的图片
    private async loadBlockRarityImageByShape(block: Node, rarity: string, shapeId: string) {
        if (!block || !block.isValid) {
            return;
        }
        
        console.log(`[BlockManager] 直接使用形状ID ${shapeId} 加载稀有度图片`);
        
        // 首先尝试从BlockInfo组件获取稀有度图标（新预制体结构）
        const nodeChild = block.getChildByName('Node');
        const blockInfo = nodeChild ? nodeChild.getComponent(BlockInfo) : null;
        if (blockInfo) {
            const rarityIcon = blockInfo.getRarityIcon();
            if (rarityIcon) {
                this.applySpriteFrameToBlock(block, rarityIcon);
                console.log(`[BlockManager] ✓ 从BlockInfo组件获取稀有度图标: ${rarity}`);
                return;
            } else {
                console.warn(`[BlockManager] BlockInfo组件中没有找到稀有度图标，稀有度: ${rarity}`);
            }
        } else {
            console.warn(`[BlockManager] 方块没有BlockInfo组件，回退到路径加载模式`);
        }
        
        // 回退到原有的路径加载逻辑
        const baseImageName = this.getBaseImageNameByShape(shapeId);
        if (!baseImageName) {
            console.warn(`[BlockManager] 无法映射形状ID ${shapeId} 到图片名称`);
            this.applyBlockRarityColorFallback(block, rarity);
            return;
        }
        
        // 构建图片路径
        const imagePath = `images/Blocks/${rarity}/${baseImageName}/spriteFrame`;
        console.log(`[BlockManager] 回退加载图片路径: ${imagePath}`);
        
        try {
            // 优先使用 assetManager.getBundle('resources')
            const resourcesBundle = cc.assetManager.getBundle('resources');
            if (resourcesBundle) {
                resourcesBundle.load(imagePath, SpriteFrame, (err, spriteFrame) => {
                    if (err) {
                        console.warn(`[BlockManager] Bundle加载失败: ${err.message}，尝试使用resources.load`);
                        this.loadImageWithResourcesLoad(block, imagePath);
                    } else {
                        this.applySpriteFrameToBlock(block, spriteFrame);
                        console.log(`[BlockManager] ✓ Bundle成功加载图片: ${imagePath}`);
                    }
                });
            } else {
                console.warn('[BlockManager] resources bundle不可用，使用resources.load');
                this.loadImageWithResourcesLoad(block, imagePath);
            }
        } catch (error) {
            console.error(`[BlockManager] 加载图片时发生错误: ${error}`);
            this.applyBlockRarityColorFallback(block, rarity);
        }
    }
    
    // 根据稀有度和方块形状加载对应的图片
    private async loadBlockRarityImage(block: Node, rarity: string) {
        if (!block || !block.isValid) {
            return;
        }
        
        // 首先尝试从BlockInfo组件获取稀有度图标（新预制体结构）
        const nodeChild = block.getChildByName('Node');
        const blockInfo = nodeChild ? nodeChild.getComponent(BlockInfo) : null;
        if (blockInfo) {
            const rarityIcon = blockInfo.getRarityIcon();
            if (rarityIcon) {
                this.applySpriteFrameToBlock(block, rarityIcon);
                console.log(`[BlockManager] ✓ 从BlockInfo组件获取稀有度图标: ${rarity}`);
                return;
            } else {
                console.warn(`[BlockManager] BlockInfo组件中没有找到稀有度图标，稀有度: ${rarity}`);
            }
        } else {
            console.warn(`[BlockManager] 方块没有BlockInfo组件，回退到路径加载模式`);
        }
        
        // 回退到原有的路径加载逻辑
        const shapeId = this.getBlockShape(block);
        if (!shapeId) {
            console.warn('[BlockManager] 无法获取方块形状，跳过图片加载');
            this.applyBlockRarityColorFallback(block, rarity);
            return;
        }
        
        // 使用形状ID加载图片
        this.loadBlockRarityImageByShape(block, rarity, shapeId);
    }
    
    // 辅助方法：使用resources.load加载图片
    private loadImageWithResourcesLoad(block: Node, imagePath: string) {
        resources.load(imagePath, SpriteFrame, (err, spriteFrame) => {
            if (err) {
                console.error(`[BlockManager] ✗ 图片加载失败: ${imagePath}, 错误: ${err.message}`);
                // 使用颜色回退方案
                const rarity = this.getBlockRarity(block) || 'common';
                this.applyBlockRarityColorFallback(block, rarity);
            } else {
                this.applySpriteFrameToBlock(block, spriteFrame);
                console.log(`[BlockManager] ✓ Resources成功加载图片: ${imagePath}`);
            }
        });
    }
    
    // 辅助方法：将SpriteFrame应用到方块
    private applySpriteFrameToBlock(block: Node, spriteFrame: SpriteFrame) {
        // 新的预制体结构：Sprite组件在Node子节点上
        const nodeChild = block.getChildByName('Node');
        if (nodeChild) {
            const sprite = nodeChild.getComponent(Sprite);
            if (sprite) {
                sprite.spriteFrame = spriteFrame;
            } else {
                console.warn('[BlockManager] Node子节点没有Sprite组件');
            }
        } else {
            console.warn('[BlockManager] 方块节点没有找到Node子节点');
        }
    }
    
    // 根据形状ID映射到基础图片名称
    private getBaseImageNameByShape(shapeId: string): string | null {
        // 根据实际图片文件名映射，不包含文件扩展名
        switch (shapeId) {
            case 'I':
                return 'BlockI';
            case 'H-I':
                return 'BlockH-I';
            case 'L':
            case 'L2':
            case 'L3':
            case 'L4':
                return 'BlockL';
            case 'S':
            case 'F-S':
                return 'BlockS';
            case 'T':
            case 'D-T':
                return 'BlockD-T';
            default:
                // 对于未知形状，尝试直接使用形状ID
                return `Block${shapeId}`;
        }
    }
    
    // 颜色模式回退方法（当图片加载失败时使用）
    private applyBlockRarityColorFallback(block: Node, rarity: string) {
        // 新的预制体结构：Sprite组件在Node子节点上
        const nodeChild = block.getChildByName('Node');
        if (!nodeChild) {
            console.warn('[BlockManager] 方块节点没有找到Node子节点');
            return;
        }
        
        const sprite = nodeChild.getComponent(Sprite);
        if (!sprite || !sprite.isValid) {
            console.warn('[BlockManager] Node子节点没有Sprite组件');
            return;
        }
        
        // 根据稀有度设置颜色
        let color: Color;
        switch (rarity) {
            case 'common':
                color = new Color(255, 255, 255); // 白色
                break;
            case 'uncommon':
                color = new Color(0, 255, 0); // 绿色
                break;
            case 'rare':
                color = new Color(0, 100, 255); // 蓝色
                break;
            case 'epic':
                color = new Color(160, 32, 240); // 紫色
                break;
            default:
                color = new Color(255, 255, 255); // 默认白色
        }
        
        sprite.color = color;
        console.log(`[BlockManager] 回退到颜色模式设置方块稀有度: ${rarity}`, color);
    }
    

    
    // 加载武器图标
    private async loadWeaponIcon(block: Node, weaponConfig: WeaponConfig) {
        // 根据新的预制体结构，武器节点直接位于方块根节点下
        let weaponNode = block.getChildByName('Weapon');
        
        // 兼容旧结构：如果直接查找失败，尝试B1/Weapon路径
        if (!weaponNode) {
            const b1Node = block.getChildByName('B1');
            if (b1Node) {
                weaponNode = b1Node.getChildByName('Weapon');
            }
        }
        
        if (!weaponNode) {
            console.warn('找不到Weapon节点');
            return;
        }
        
        const weaponSprite = weaponNode.getComponent(Sprite);
        if (!weaponSprite) {
            console.warn('Weapon节点上没有Sprite组件');
            return;
        }
        
        // 获取武器配置中的图片路径
        const weaponSprites = weaponConfig.visualConfig?.weaponSprites;
        if (!weaponSprites) {
            console.warn(`武器 ${weaponConfig.name} 没有配置图片信息`);
            return;
        }
        
        // 获取第一个可用的精灵路径（通常是'I'形状）
         let spritePath: string;
         if (typeof weaponSprites === 'string') {
             spritePath = weaponSprites;
         } else {
             // 优先使用'I'形状，如果没有则使用第一个可用的
             const keys = Object.keys(weaponSprites);
             spritePath = weaponSprites['I'] || (keys.length > 0 ? weaponSprites[keys[0]] : null);
         }
        
        if (!spritePath) {
            console.warn(`武器 ${weaponConfig.name} 没有可用的精灵路径`);
            return;
        }
        
        // 转换路径格式，去除"images/"前缀
        const bundlePath = spritePath.replace(/^images\//, '');
        
        try {
            // 使用BundleLoader从images Bundle加载SpriteFrame，添加/spriteFrame后缀
            const spriteFrame = await this.bundleLoader.loadSpriteFrame(`${bundlePath}/spriteFrame`);
            
            // Add comprehensive null safety checks before setting spriteFrame
            if (weaponSprite && weaponSprite.isValid && 
                weaponNode && weaponNode.isValid && 
                block && block.isValid && 
                spriteFrame && spriteFrame.isValid) {
                weaponSprite.spriteFrame = spriteFrame;
                
                // 设置武器图标初始大小为0.4倍
                weaponNode.setScale(0.4, 0.4, 1.0);
                console.log(`[BlockManager] 武器图标加载完成，设置初始缩放为0.4倍: ${weaponConfig.name}`);
                
                // 应用武器图标的旋转（不再使用位置偏移）
                const blockShape = this.getBlockShape(block);
                this.rotateWeaponIconByShape(weaponNode, blockShape, weaponConfig.id);
            }
        } catch (err) {
            console.warn(`加载武器图片失败: ${bundlePath}`, err);
        }
    }
    
    // 武器类型和方块形状组合的旋转角度配置
    private readonly WEAPON_SHAPE_ROTATION_ANGLES: { [weaponId: string]: { [shapeId: string]: number } } = {
        'pea_shooter': {
            'I': 0,      // 毛豆射手竖条形状
            'H-I': 90,   // 毛豆射手横条形状
            'L': 0,      // 毛豆射手L型
            'S': 0,      // 毛豆射手S型
            'D-T': 0     // 毛豆射手倒T型
        },
        'sharp_carrot': {
            'I': 0,      // 尖胡萝卜竖条形状
            'H-I': 90,   // 尖胡萝卜横条形状，旋转适配水平方向
            'L': -15,    // 尖胡萝卜L型，轻微调整
            'S': 15,     // 尖胡萝卜S型，轻微调整
            'D-T': 0     // 尖胡萝卜倒T型
        },
        'saw_grass': {
            'I': 0,      // 锯齿草竖条形状
            'H-I': 0,   // 锯齿草横条形状
            'L': -45,    // 锯齿草L型，更大角度适配锯齿形状
            'S': 30,     // 锯齿草S型，适配锯齿弯曲
            'D-T': 0     // 锯齿草倒T型
        },
        'watermelon_bomb': {
            'I': 0,      // 西瓜炸弹竖条形状
            'H-I': 0,    // 西瓜炸弹横条形状，圆形炸弹不需要旋转
            'L': 0,      // 西瓜炸弹L型
            'S': 0,      // 西瓜炸弹S型
            'D-T': 0     // 西瓜炸弹倒T型
        },
        'boomerang_plant': {
            'I': 0,      // 回旋镖植物竖条形状
            'H-I': 90,   // 回旋镖植物横条形状，旋转适配飞行方向
            'L': -30,    // 回旋镖植物L型
            'S': -10,     // 回旋镖植物S型，适配回旋轨迹
            'D-T': -80     // 回旋镖植物倒T型
        },
        'hot_pepper': {
            'I': 0,      // 辣椒竖条形状
            'H-I': 90,   // 辣椒横条形状
            'L': 0,      // 辣椒L型
            'S': 0,      // 辣椒S型
            'D-T': 0     // 辣椒倒T型
        },
        'cactus_shotgun': {
            'I': 0,      // 仙人掌霰弹枪竖条形状
            'H-I': 90,   // 仙人掌霰弹枪横条形状
            'L': -20,    // 仙人掌霰弹枪L型
            'S': 20,     // 仙人掌霰弹枪S型
            'D-T': 0     // 仙人掌霰弹枪倒T型
        },
        'okra_missile': {
            'I': 0,      // 秋葵导弹竖条形状
            'H-I': 90,   // 秋葵导弹横条形状，旋转适配发射方向
            'L': -10,    // 秋葵导弹L型
            'S': 10,     // 秋葵导弹S型
            'D-T': 0     // 秋葵导弹倒T型
        },
        'mace_club': {
            'I': -45,      // 狼牙棒竖条形状
            'H-I': 0,   // 狼牙棒横条形状
            'L': -90,    // 狼牙棒L型，适配棒状武器
            'S': -90,     // 狼牙棒S型
            'D-T': 0     // 狼牙棒倒T型
        }
    };
    
    // 默认旋转角度配置（当武器类型未配置时使用）
    private readonly DEFAULT_SHAPE_ROTATION_ANGLES: { [key: string]: number } = {
        'I': 0,      // 竖条形状，保持原始方向
        'H-I': 90,   // 横I型，旋转90度适配水平方向
        'L': -15,    // L型，轻微左倾适配L形状的转角
        'S': 15,     // S型，轻微右倾适配S形状的弯曲
        'D-T': 0     // 倒T型，保持原始方向
    };
    
    // 根据武器类型和方块形状调整武器图标位置（完全保留预制体原始旋转值，不应用额外旋转）
    private rotateWeaponIconByShape(weaponNode: Node, shapeId: string | null, weaponId?: string) {
        if (!weaponNode || !shapeId) return;
        
        // 保存预制体的原始旋转角度
        const originalAngle = weaponNode.angle;
        
        console.log(`保留预制体原始旋转角度: ${originalAngle}度，不应用额外旋转`);
    }
    
    // 设置特定武器和形状的旋转角度
    public setWeaponShapeRotationAngle(weaponId: string, shapeId: string, angle: number) {
        if (!this.WEAPON_SHAPE_ROTATION_ANGLES[weaponId]) {
            this.WEAPON_SHAPE_ROTATION_ANGLES[weaponId] = {};
        }
        this.WEAPON_SHAPE_ROTATION_ANGLES[weaponId][shapeId] = angle;
        console.log(`已更新武器 ${weaponId} 形状 ${shapeId} 的旋转角度为: ${angle}度`);
    }
    
    // 设置默认形状的旋转角度
    public setDefaultShapeRotationAngle(shapeId: string, angle: number) {
        this.DEFAULT_SHAPE_ROTATION_ANGLES[shapeId] = angle;
        console.log(`已更新默认形状 ${shapeId} 的旋转角度为: ${angle}度`);
    }
    

    
    // 获取特定武器和形状的旋转角度
    public getWeaponShapeRotationAngle(weaponId: string, shapeId: string): number {
        if (this.WEAPON_SHAPE_ROTATION_ANGLES[weaponId]) {
            return this.WEAPON_SHAPE_ROTATION_ANGLES[weaponId][shapeId] || 0;
        }
        return 0;
    }
    
    // 获取默认形状的旋转角度
    public getDefaultShapeRotationAngle(shapeId: string): number {
        return this.DEFAULT_SHAPE_ROTATION_ANGLES[shapeId] || 0;
    }
    

    
    // 设置特定武器和形状的旋转角度
    public setWeaponShapeTransform(weaponId: string, shapeId: string, angle: number) {
        this.setWeaponShapeRotationAngle(weaponId, shapeId, angle);
        console.log(`已更新武器 ${weaponId} 形状 ${shapeId} 的旋转角度: ${angle}度`);
    }
    
    // 设置默认形状的旋转角度
    public setDefaultShapeTransform(shapeId: string, angle: number) {
        this.setDefaultShapeRotationAngle(shapeId, angle);
        console.log(`已更新默认形状 ${shapeId} 的旋转角度: ${angle}度`);
    }
    
    // 重新应用所有已放置方块的武器图标位置和旋转
    public refreshAllWeaponIconRotations() {
        // 遍历所有已放置的方块
        if (this.placedBlocksContainer) {
            this.placedBlocksContainer.children.forEach(block => {
                const weaponConfig = this.getBlockWeaponConfig(block);
                if (weaponConfig) {
                    // 根据新的预制体结构：Weapon节点直接在方块根节点下
                    let weaponNode = block.getChildByName('Weapon');
                    // 向后兼容：如果没找到，尝试旧的B1/Weapon路径
                    if (!weaponNode) {
                        const b1Node = block.getChildByName('B1');
                        if (b1Node) {
                            weaponNode = b1Node.getChildByName('Weapon');
                        }
                    }
                    if (weaponNode) {
                        const shapeId = this.getBlockShape(block);
                        this.rotateWeaponIconByShape(weaponNode, shapeId, weaponConfig.id);
                    }
                }
            });
        }
        
        // 遍历kuang区域的方块
        this.blocks.forEach(block => {
            const weaponConfig = this.getBlockWeaponConfig(block);
            if (weaponConfig) {
                // 根据新的预制体结构：Weapon节点直接在方块根节点下
                let weaponNode = block.getChildByName('Weapon');
                // 向后兼容：如果没找到，尝试旧的B1/Weapon路径
                if (!weaponNode) {
                    const b1Node = block.getChildByName('B1');
                    if (b1Node) {
                        weaponNode = b1Node.getChildByName('Weapon');
                    }
                }
                if (weaponNode) {
                    const shapeId = this.getBlockShape(block);
                    this.rotateWeaponIconByShape(weaponNode, shapeId, weaponConfig.id);
                }
            }
        });
    }
    
    // 根据方块获取武器配置
    public getBlockWeaponConfig(block: Node): WeaponConfig | null {
        return this.blockWeaponConfigs.get(block) || block['weaponConfig'] || null;
    }
    
    // 获取方块的武器ID
    public getBlockWeaponId(block: Node): string | null {
        const weaponConfig = this.getBlockWeaponConfig(block);
        return weaponConfig ? weaponConfig.id : null;
    }

    // 获取方块的形状
    public getBlockShape(block: Node): string | null {
        const weaponConfig = this.getBlockWeaponConfig(block);
        if (!weaponConfig) return null;
        
        // 从方块结构推断形状
        const shapeInfo = this.getBlockShapeInfo(block);
        return shapeInfo ? shapeInfo.id : 'I';
    }
    
    // 获取方块的详细形状信息（包括形状ID和名称）
    public getBlockShapeInfo(block: Node): { id: string, name: string, shape: number[][] } | null {
        const actualShape = this.extractShapeFromBlock(block);
        console.log(`[BlockManager] 提取的实际形状矩阵:`, actualShape);
        
        let blockShapes = null;
        
        // 优先使用预加载的配置
        if (this.isWeaponsConfigPreloaded && this.preloadedWeaponsConfig) {
            blockShapes = this.preloadedWeaponsConfig.blockSizes;
            console.log(`[BlockManager] 使用预加载配置，形状数量: ${blockShapes ? blockShapes.length : 0}`);
        } else {
            // 回退到ConfigManager
            blockShapes = this.configManager.getBlockShapes();
            console.log(`[BlockManager] 使用ConfigManager，形状数量: ${blockShapes ? blockShapes.length : 0}`);
        }
        
        if (!blockShapes) {
            console.log(`[BlockManager] 警告：无法获取形状配置`);
            return null;
        }
        
        // 寻找匹配的形状配置
        for (const shapeConfig of blockShapes) {
            console.log(`[BlockManager] 比较形状 ${shapeConfig.id}:`, shapeConfig.shape);
            if (this.compareShapeMatrices(actualShape, shapeConfig.shape)) {
                console.log(`[BlockManager] 找到匹配形状: ${shapeConfig.id}`);
                return {
                    id: shapeConfig.id,
                    name: shapeConfig.name,
                    shape: shapeConfig.shape
                };
            }
        }
        
        console.log(`[BlockManager] 警告：未找到匹配的形状，使用默认形状 I`);
        return null;
    }

    // 从方块结构推断形状
    private inferBlockShapeFromStructure(block: Node): string {
        // 直接从B1节点结构读取形状矩阵
        const actualShape = this.extractShapeFromBlock(block);
        
        // 返回默认形状ID，实际形状矩阵已通过extractShapeFromBlock获取
        return 'I';
    }
    

    
    // 从方块实例中提取形状矩阵
    private extractShapeFromBlock(block: Node): number[][] {
        const parts = this.getBlockParts(block);
        
        // 创建4x4矩阵
        const matrix: number[][] = [];
        for (let i = 0; i < 4; i++) {
            matrix[i] = [0, 0, 0, 0];
        }
        
        // 找到最小坐标作为偏移基准
        let minX = 0, minY = 0;
        for (const part of parts) {
            minX = Math.min(minX, part.x);
            minY = Math.min(minY, part.y);
        }
        
        // 填充矩阵，将坐标标准化到从(0,0)开始
        for (const part of parts) {
            const matrixX = part.x - minX;
            const matrixY = (part.y - minY); // 不需要Y轴翻转，直接使用相对坐标
            
            if (matrixX >= 0 && matrixX < 4 && matrixY >= 0 && matrixY < 4) {
                matrix[matrixY][matrixX] = 1;
            }
        }
        
        // 移除矩阵翻转操作，保持原始坐标系
        
        return matrix;
    }
    
    // 比较两个形状矩阵是否相同
    private compareShapeMatrices(matrix1: number[][], matrix2: number[][]): boolean {
        if (matrix1.length !== matrix2.length) return false;
        
        for (let i = 0; i < matrix1.length; i++) {
            if (matrix1[i].length !== matrix2[i].length) return false;
            for (let j = 0; j < matrix1[i].length; j++) {
                if (matrix1[i][j] !== matrix2[i][j]) return false;
            }
        }
        
        return true;
    }

    // 检查两个方块是否可以合成（相同形状相同种类）
    private canMergeBlocks(block1: Node, block2: Node): boolean {
        console.log(`[BlockManager] 开始检查方块合成条件`);
        console.log(`[BlockManager] 方块1名称: ${block1.name}, 方块2名称: ${block2.name}`);
        
        // 检查稀有度
        const rarity1 = this.getBlockRarity(block1);
        const rarity2 = this.getBlockRarity(block2);
        console.log(`[BlockManager] 稀有度检查: ${rarity1} vs ${rarity2}`);
        if (rarity1 !== rarity2) {
            console.log(`[BlockManager] 稀有度不匹配: ${rarity1} vs ${rarity2}`);
            return false;
        }
        
        // 检查武器ID（种类）
        const weaponId1 = this.getBlockWeaponId(block1);
        const weaponId2 = this.getBlockWeaponId(block2);
        console.log(`[BlockManager] 武器ID检查: ${weaponId1} vs ${weaponId2}`);
        if (weaponId1 !== weaponId2) {
            console.log(`[BlockManager] 武器种类不匹配: ${weaponId1} vs ${weaponId2}`);
            return false;
        }
        
        // 使用精确的形状矩阵比较
        const shape1 = this.extractShapeFromBlock(block1);
        const shape2 = this.extractShapeFromBlock(block2);
        console.log(`[BlockManager] 形状矩阵1:`, shape1);
        console.log(`[BlockManager] 形状矩阵2:`, shape2);
        
        if (!this.compareShapeMatrices(shape1, shape2)) {
            console.log(`[BlockManager] 形状矩阵不匹配`);
            return false;
        }
        
        console.log(`[BlockManager] 方块可以合成: 稀有度=${rarity1}, 种类=${weaponId1}`);
        return true;
    }
    
    /**
     * 显示所有db标签节点
     */
    showAllDbNodes() {
        if (this.block1DbNode) {
            this.block1DbNode.active = true;
            console.log("显示Block1的db标签节点");
        }
        if (this.block2DbNode) {
            this.block2DbNode.active = true;
            console.log("显示Block2的db标签节点");
        }
        if (this.block3DbNode) {
            this.block3DbNode.active = true;
            console.log("显示Block3的db标签节点");
        }
    }

    // 刷新方块 - 重新生成三个新的武器方块
    public refreshBlocks() {
        // 移除PlacedBlocks容器中所有方块的标签
        if (this.placedBlocksContainer && this.placedBlocksContainer.isValid) {
            BlockTag.removeTagsInContainer(this.placedBlocksContainer);
        }
        
        // 保存已放置方块的占用信息
        const placedBlocksOccupation: { block: Node, occupiedGrids: { row: number, col: number }[] }[] = [];
        if (this.placedBlocksContainer && this.placedBlocksContainer.isValid) {
            for (let i = 0; i < this.placedBlocksContainer.children.length; i++) {
                const block = this.placedBlocksContainer.children[i];
                const occupiedGrids = block['occupiedGrids'];
                if (occupiedGrids && occupiedGrids.length > 0) {
                    placedBlocksOccupation.push({
                        block: block,
                        occupiedGrids: [...occupiedGrids]
                    });
                }
            }
        }
        
        // 生成新的方块
        this.generateRandomBlocksInKuang();
        
        // 显示所有db标签节点
        this.showAllDbNodes();
        
    }

    // 检查是否有已放置的方块
    public hasPlacedBlocks(): boolean {
        if (!this.placedBlocksContainer || !this.placedBlocksContainer.isValid) {
            console.log('[BlockManager] PlacedBlocks容器无效');
            return false;
        }
        const blockCount = this.placedBlocksContainer.children.length;
        console.log(`[BlockManager] 已放置方块数量: ${blockCount}`);
        
        // 检查容器中是否有子节点（方块）
        return blockCount > 0;
    }

    /* =================== 合成逻辑 =================== */

    private readonly rarityOrder: string[] = ['common','uncommon','rare','epic'];

    /** 检查当前放置的方块能否与相同稀有度的方块合成 */
    public async tryMergeBlock(block: Node) {
        try {
            const rarity = this.getBlockRarity(block);
            if (!rarity) return;

            // 在 placedBlocksContainer 中寻找与之重叠且可以合成的其他方块
            if (!this.placedBlocksContainer) return;

            const blockBB = this.getWorldAABB(block);
            for (const other of this.placedBlocksContainer.children) {
                if (other === block) continue;
                
                // 使用新的合成检查方法
                if (!this.canMergeBlocks(block, other)) continue;

                const otherBB = this.getWorldAABB(other);
                if (this.rectIntersects(blockBB, otherBB)) {
                    // 找到合成目标
                    await this.performMerge(block, other, rarity);
                    break;
                }
            }
        } catch (error) {
            console.error('[BlockManager] tryMergeBlock 发生错误:', error);
            // 合成失败不影响游戏继续，只记录错误
        }
    }

    private async performMerge(target: Node, source: Node, rarity: string) {
        try {
            console.log(`[BlockManager] 开始合成方块: 目标=${target.name}, 源=${source.name}, 稀有度=${rarity}`);
            // 先立即触发合成特效，避免后续异步逻辑造成播放延迟
            const worldPos = new Vec3();
            target.getWorldPosition(worldPos);
            this.spawnMergeSmoke(worldPos);
            this.playUpgradeEffect(target);
            
            // 注意：参与合成的方块都在网格中，它们的db标签本来就应该是隐藏的
            // 不需要调用hideDbLabel，因为这些方块已经不在block容器中了

            // 在扩展教程（第5-6步）中，合成即可视为完成，触发教程完成判断
            if (this.isExtendedTutorialEventContext()) {
                let gridNode: Node | null = null;
                const occupied = (target as any)['occupiedGrids'];
                if (occupied && occupied.length > 0) {
                    const first = occupied[0];
                    if (first && this.gridNodes[first.row] && this.gridNodes[first.row][first.col]) {
                        gridNode = this.gridNodes[first.row][first.col];
                    }
                }
                // 如果能定位到目标格子，则用源方块+该格子进行教程完成判定
                if (gridNode) {
                    this.handleTutorialBlockPlacement(source, gridNode);
                }
            }

            // 销毁被合并方块
            source.destroy();

            // 升级稀有度
            const nextRarity = this.getNextRarity(rarity);
            if (nextRarity) {
                console.log(`[BlockManager] 合成成功，稀有度升级: ${rarity} -> ${nextRarity}`);
                
                // 播放合成成功音效
                Audio.playSFX('data/弹球音效/level up 2');
                
                // 获取当前武器配置
                const currentConfig = this.blockWeaponConfigs.get(target);
                if (currentConfig) {
                    // 保存原始武器名称用于日志输出
                    const originalWeaponName = currentConfig.name;
                    
                    try {
                        // 获取当前关卡允许的武器列表
                        const levelWeapons = await this.getCurrentLevelWeapons();
                        
                        // 检查是否应该限制在关卡配置的武器范围内
                        if (levelWeapons.length > 0) {
                            // 如果当前武器不在关卡配置中，说明是通过合成获得的，应该保持原武器不变，只升级稀有度
                            if (!levelWeapons.some(weapon => weapon === originalWeaponName)) {
                                console.log(`[BlockManager] 武器 ${originalWeaponName} 不在关卡配置中，保持原武器，只升级稀有度`);
                            }
                            
                            // 无论如何，都只升级稀有度，不改变武器类型
                            const upgradedConfig = { ...currentConfig };
                            upgradedConfig.rarity = nextRarity;
                            this.blockWeaponConfigs.set(target, upgradedConfig);
                            // 同时更新方块节点的 weaponConfig 属性，供 BallController 使用
                            (target as any)['weaponConfig'] = upgradedConfig;
                            console.log(`[BlockManager] 武器配置升级: ${originalWeaponName} 稀有度 ${rarity} -> ${nextRarity}`);
                        } else {
                            // 如果没有关卡配置限制，正常升级稀有度
                            const upgradedConfig = { ...currentConfig };
                            upgradedConfig.rarity = nextRarity;
                            this.blockWeaponConfigs.set(target, upgradedConfig);
                            // 同时更新方块节点的 weaponConfig 属性，供 BallController 使用
                            (target as any)['weaponConfig'] = upgradedConfig;
                            console.log(`[BlockManager] 武器配置升级: ${originalWeaponName} 稀有度 ${rarity} -> ${nextRarity}`);
                        }
                    } catch (weaponError) {
                        console.error('[BlockManager] 获取关卡武器配置失败:', weaponError);
                        // 武器配置获取失败时，仍然升级稀有度
                        const upgradedConfig = { ...currentConfig };
                        upgradedConfig.rarity = nextRarity;
                        this.blockWeaponConfigs.set(target, upgradedConfig);
                        // 同时更新方块节点的 weaponConfig 属性，供 BallController 使用
                        (target as any)['weaponConfig'] = upgradedConfig;
                        console.log(`[BlockManager] 武器配置升级(降级处理): ${originalWeaponName} 稀有度 ${rarity} -> ${nextRarity}`);
                    }
                }
                // 同步更新BlockInfo组件的稀有度（新预制体结构）
                const nodeChild = target.getChildByName('Node');
                const blockInfo = nodeChild ? nodeChild.getComponent(BlockInfo) : null;
                if (blockInfo) {
                    // 将稀有度字符串转换为数字
                    const rarityMap = { 'common': 0, 'uncommon': 1, 'rare': 2, 'epic': 3 };
                    const rarityNumber = rarityMap[nextRarity] !== undefined ? rarityMap[nextRarity] : 0;
                    blockInfo.rarity = rarityNumber;
                    
                    // 更新稀有度显示
                    blockInfo.updateRarityDisplay();
                    
                    console.log(`[BlockManager] BlockInfo稀有度已更新: ${rarity} -> ${nextRarity} (${rarityNumber})`);
                } else {
                    console.warn(`[BlockManager] 未找到BlockInfo组件，无法更新稀有度显示`);
                }
                
                // 更新方块图片
                this.loadBlockRarityImage(target, nextRarity);
            }

            // 递归检查是否还能继续合成
            if (nextRarity) {
                await this.tryMergeBlock(target);
            }
            
            console.log(`[BlockManager] 合成完成`);
        } catch (error) {
            console.error('[BlockManager] performMerge 发生错误:', error);
            // 合成失败时重新抛出错误，让上层处理
            throw error;
        }
    }

    private getBlockRarity(block: Node): string | null {
        console.log(`[BlockManager] getBlockRarity 调用，方块名称: ${block.name}, UUID: ${block.uuid}`);
        
        // 从Node子节点获取BlockInfo组件（适配新的预制体结构）
        const nodeChild = block.getChildByName('Node');
        const blockInfo = nodeChild ? nodeChild.getComponent(BlockInfo) : null;
        if (blockInfo) {
            const rarityName = blockInfo.getRarityName();
            console.log(`[BlockManager] 从BlockInfo组件获取稀有度: ${rarityName}`);
            return rarityName;
        }
        
        console.log(`[BlockManager] 未找到BlockInfo组件`);
        return null;
    }

    private getNextRarity(rarity: string): string | null {
        const idx = this.rarityOrder.indexOf(rarity);
        if (idx === -1 || idx >= this.rarityOrder.length - 1) return null;
        return this.rarityOrder[idx + 1];
    }

    private getWorldAABB(node: Node): Rect {
        const ui = node.getComponent(UITransform);
        if (!ui) return new Rect();
        const pos = node.worldPosition;
        const width = ui.width;
        const height = ui.height;
        return new Rect(pos.x - width/2, pos.y - height/2, width, height);
    }

    private rectIntersects(a: Rect, b: Rect): boolean {
        return a.x < b.x + b.width &&
               a.x + a.width > b.x &&
               a.y < b.y + b.height &&
               a.y + a.height > b.y;
    }

    /** 生成烟雾特效 */
    private spawnMergeSmoke(worldPos: Vec3) {
        // 使用BundleLoader加载Animation Bundle中的特效资源
        // 转换路径格式，去除"Animation/"前缀
        const bundlePath = 'WeaponTx/tx0003/tx0003';
        
        BundleLoader.loadSkeletonData(bundlePath).then((sData: sp.SkeletonData) => {
            if (!sData) {
                console.warn('加载合成烟雾动画失败: 资源为空');
                return;
            }
            const node = new Node('MergeSmoke');
            const skeleton = node.addComponent(sp.Skeleton);
            skeleton.skeletonData = sData;
            skeleton.premultipliedAlpha = false;
            skeleton.setAnimation(0, 'animation', false);
            skeleton.setCompleteListener(() => node.destroy());

            const canvas = find('Canvas');
            if (canvas) canvas.addChild(node);
            node.setWorldPosition(worldPos);
        }).catch((err) => {
            console.warn('加载合成烟雾动画失败:', err);
        });
    }

    /** 播放升级特效动画 */
    private playUpgradeEffect(target: Node) {
        try {
            // 获取目标方块的世界坐标
            const worldPos = new Vec3();
            target.getWorldPosition(worldPos);
            
            // 使用BundleLoader加载升级特效动画
            const path = 'WeaponBurnAni/shengji';
            BundleLoader.loadSkeletonData(path).then((sData: sp.SkeletonData) => {
                if (!sData) {
                    console.warn('[BlockManager] 加载升级特效动画失败: 资源为空');
                    return;
                }
                
                // 创建特效节点
                const effectNode = new Node('UpgradeEffect');
                const skeleton = effectNode.addComponent(sp.Skeleton);
                skeleton.skeletonData = sData;
                skeleton.premultipliedAlpha = false;
                
                // 播放动画
                skeleton.setAnimation(0, 'animation', false);
                
                // 监听动画完成事件，播放完成后销毁节点
                skeleton.setCompleteListener(() => {
                    effectNode.destroy();
                    console.log('[BlockManager] 升级特效播放完成');
                });
                
                // 添加到Canvas并设置位置
                const canvas = find('Canvas');
                if (canvas) {
                    canvas.addChild(effectNode);
                    effectNode.setWorldPosition(worldPos);
                    console.log('[BlockManager] 开始播放升级特效动画');
                } else {
                    console.warn('[BlockManager] 未找到Canvas节点，无法播放升级特效');
                    effectNode.destroy();
                }
            }).catch((err) => {
                console.warn('[BlockManager] 加载升级特效动画失败:', err);
            });
            
        } catch (error) {
            console.error('[BlockManager] 播放升级特效失败:', error);
        }
    }

    /** 在放置失败时尝试与现有方块进行合成 */
    public tryMergeOnOverlap(draggedBlock: Node): boolean {
        console.log(`[BlockManager] tryMergeOnOverlap 开始检查合成`);
        console.log(`[BlockManager] 拖拽方块名称: ${draggedBlock.name}`);
        
        if (!this.placedBlocksContainer) {
            console.log(`[BlockManager] placedBlocksContainer 不存在`);
            return false;
        }
        
        const rarity = this.getBlockRarity(draggedBlock);
        if (!rarity) {
            console.log(`[BlockManager] 拖拽方块稀有度为空`);
            return false;
        }
        
        console.log(`[BlockManager] 拖拽方块稀有度: ${rarity}`);
        console.log(`[BlockManager] 已放置方块数量: ${this.placedBlocksContainer.children.length}`);

        const dragBB = this.getWorldAABB(draggedBlock);
        for (const target of this.placedBlocksContainer.children) {
            if (target === draggedBlock) continue;
            
            console.log(`[BlockManager] 检查与方块 ${target.name} 的合成可能性`);
            
            // 使用新的合成检查方法
            if (!this.canMergeBlocks(draggedBlock, target)) {
                console.log(`[BlockManager] 与方块 ${target.name} 无法合成`);
                continue;
            }

            const targetBB = this.getWorldAABB(target);
            console.log(`[BlockManager] 检查方块碰撞`);
            if (this.rectIntersects(dragBB, targetBB)) {
                console.log(`[BlockManager] 方块重叠，执行合成`);
                // 扩展教程（第5-6步）：仅允许在指定格子处合成
                if (this._tutorialStep >= 5 && this._tutorialStep < 7) {
                    const basePair = this._tutorialStep >= 6 ? this._tutorialTargetGridsStep4 : this._tutorialTargetGridsStep2;
                    if (basePair && basePair.length === 2) {
                        const pairKey = (arr: string[]) => arr.slice().sort().join('|');
                        const occupied = (target as any)['occupiedGrids'] as { row: number, col: number }[] | undefined;
                        if (occupied && occupied.length >= 2) {
                            const occupiedNames = occupied.map(g => `Grid_${g.row}_${g.col}`);
                            const parse = (name: string) => {
                                const m = name.match(/^Grid_(\d+)_(\d+)$/);
                                return m ? { row: parseInt(m[1]), col: parseInt(m[2]) } : null;
                            };
                            const p0 = parse(basePair[0]);
                            const p1 = parse(basePair[1]);
                            if (p0 && p1) {
                                let anchor = p0;
                                if (p0.row !== p1.row) {
                                    anchor = p0.row < p1.row ? p0 : p1;
                                } else if (p0.col !== p1.col) {
                                    anchor = p0.col < p1.col ? p0 : p1;
                                }
                                const horizontalPair = [`Grid_${anchor.row}_${anchor.col}`, `Grid_${anchor.row}_${anchor.col + 1}`];
                                const verticalPair = [`Grid_${anchor.row}_${anchor.col}`, `Grid_${anchor.row + 1}_${anchor.col}`];
                                const allowedPairs = new Set<string>([
                                    pairKey(horizontalPair),
                                    pairKey(verticalPair),
                                    pairKey(basePair),
                                ]);
                                const occupiedKey = pairKey(occupiedNames);
                                if (!allowedPairs.has(occupiedKey)) {
                                    console.log(`[BlockManager] 扩展教程：目标位置不在要求格子，禁止合成`);
                                    continue;
                                }
                            }
                        }
                    }
                }
                // 执行合并：目标保留，拖拽方块销毁
                this.performMerge(target, draggedBlock, rarity);
                return true;
            } else {
                console.log(`[BlockManager] 方块不重叠，跳过合成`);
            }
        }
        console.log(`[BlockManager] 没有找到可合成的方块`);
        return false;
    }
    
    // 调试绘制功能已迁移到GameBlockSelection
    
    // 输出格子占用情况矩阵
    public printGridOccupationMatrix() {
        console.log('[BlockManager] 格子占用情况de矩阵 (6行11列):');
        for (let row = 0; row < this.GRID_ROWS; row++) {
            let rowStr = '';
            for (let col = 0; col < this.GRID_COLS; col++) {
                rowStr += this.gridOccupationMap[row][col] + ' ';
            }
            console.log(`第${row + 1}行: ${rowStr.trim()}`);
        }
    }
    
    // 通过GameBlockSelection刷新方块占用情况

    
    onDestroy() {
        // 调试绘制功能已迁移到GameBlockSelection
        
        // 清理事件监听
        const eventBus = EventBus.getInstance();
        eventBus.off(GameEvents.RESET_BLOCK_MANAGER, this.onResetBlockManagerEvent, this);
        eventBus.off(GameEvents.GENERATE_BLOCKS, this.onGenerateBlocksEvent, this);
        // 移除GAME_START事件清理，因为已不再监听该事件
        // eventBus.off(GameEvents.GAME_START, this.onGameStartEvent, this);
        eventBus.off(GameEvents.WAVE_COMPLETED, this.onWaveCompletedEvent, this);
    }
}