tanqiu/assets/scripts/BlockManager.ts

import { _decorator, Component, Node, Prefab, instantiate, Vec3, EventTouch, Vec2, UITransform, find, Rect, Label, Color, Size, Contact2DType, Collider2D, IPhysics2DContact } from 'cc';
const { ccclass, property } = _decorator;

@ccclass('BlockManager')
export class BlockManager extends Component {
    // 预制体数组，存储5个预制体
    @property([Prefab])
    public blockPrefabs: Prefab[] = [];
    
    // 网格容器节点
    @property({
        type: Node,
        tooltip: '拖拽GridContainer节点到这里'
    })
    public gridContainer: Node = null;
    
    // 方块容器节点（kuang）
    @property({
        type: Node,
        tooltip: '拖拽kuang节点到这里'
    })
    public kuangContainer: Node = null;
    
    // 金币标签节点
    @property({
        type: Node,
        tooltip: '拖拽CoinLabel节点到这里'
    })
    public coinLabelNode: Node = null;
    
    // 子弹预制体
    @property({
        type: Prefab,
        tooltip: '拖拽子弹预制体到这里'
    })
    public bulletPrefab: Prefab = null;
    
    // 游戏是否已开始
    public gameStarted: boolean = false;
    
    // 方块移动冷却时间（秒）
    @property({
        tooltip: '游戏开始后方块移动的冷却时间（秒）'
    })
    public blockMoveCooldown: number = 10;
    
    // 子弹发射冷却时间（秒）
    @property({
        tooltip: '方块发射子弹的冷却时间（秒）'
    })
    public bulletCooldown: number = 0.5;
    
    // 玩家金币数量
    private playerCoins: number = 699;
    
    // 方块价格标签映射
    private blockPriceMap: Map<Node, Node> = new Map();
    
    // 已经生成的块
    private blocks: Node[] = [];
    // 当前拖拽的块
    private currentDragBlock: Node | null = null;
    // 拖拽起始位置
    private startPos = new Vec2();
    // 块的起始位置
    private blockStartPos: Vec3 = new Vec3();
    // 网格占用情况，用于控制台输出
    private gridOccupationMap: number[][] = [];
    // 网格行数和列数
    private readonly GRID_ROWS = 6;
    private readonly GRID_COLS = 11;
    // 是否已初始化网格信息
    private gridInitialized = false;
    // 存储网格节点信息
    private gridNodes: Node[][] = [];
    // 网格间距
    private gridSpacing = 54;
    // 不参与占用的节点名称列表
    private readonly NON_BLOCK_NODES: string[] = ['Weapon', 'Price'];
    // 临时保存方块的原始占用格子
    private tempRemovedOccupiedGrids: { block: Node, occupiedGrids: { row: number, col: number }[] }[] = [];
    // 方块原始位置（在kuang中的位置）
    private originalPositions: Map<Node, Vec3> = new Map();
    // 方块当前所在的区域
    private blockLocations: Map<Node, string> = new Map();
    
    // 方块移动冷却状态管理
    private blockCooldowns: Map<Node, number> = new Map(); // 存储每个方块的冷却结束时间
    private globalCooldownEndTime: number = 0; // 全局冷却结束时间
    
    // 子弹发射冷却状态
    private canFireBullet: boolean = true;
    
    // 碰撞的方块ID记录，避免重复发射
    private collidedBlockIds: Set<string> = new Set();
    
    // 检查方块是否可以移动（冷却检查）
    private canMoveBlock(block: Node): boolean {
        if (!this.gameStarted) {
            // 游戏未开始（备战阶段），可以自由移动
            return true;
        }
        
        const currentTime = Date.now() / 1000; // 转换为秒
        
        // 检查全局冷却
        if (currentTime < this.globalCooldownEndTime) {
            const remainingTime = Math.ceil(this.globalCooldownEndTime - currentTime);
            console.log(`方块移动冷却中，剩余时间: ${remainingTime}秒`);
            return false;
        }
        
        return true;
    }
    
    // 设置方块移动冷却
    private setBlockCooldown(block: Node) {
        if (!this.gameStarted) {
            // 游戏未开始，不设置冷却
            return;
        }
        
        const currentTime = Date.now() / 1000; // 转换为秒
        const cooldownEndTime = currentTime + this.blockMoveCooldown;
        
        // 设置全局冷却
        this.globalCooldownEndTime = cooldownEndTime;
        
        console.log(`方块移动冷却已设置，持续时间: ${this.blockMoveCooldown}秒`);
    }
    
    // 清除所有冷却（游戏重置时调用）
    public clearAllCooldowns() {
        this.blockCooldowns.clear();
        this.globalCooldownEndTime = 0;
        console.log('所有方块移动冷却已清除');
    }
    
    // 递归查找Weapon节点
    private findWeaponNode(node: Node): Node | null {
        // 直接检查当前节点的子节点
        const weapon = node.getChildByName('Weapon');
        if (weapon) {
            return weapon;
        }
        
        // 递归查找所有子节点
        for (let i = 0; i < node.children.length; i++) {
            const child = node.children[i];
            const found = this.findWeaponNode(child);
            if (found) {
                return found;
            }
        }
        
        return null;
    }
    
    // 发射子弹
    public fireBullet(blockNode: Node) {
        console.log('发射子弹！击中方块:', blockNode.name);
        
        // 检查冷却状态
        if (!this.canFireBullet) {
            console.log('子弹冷却中，无法发射');
            return;
        }
        
        // 检查是否已经对这个方块发射过子弹
        const blockId = blockNode.uuid;
        if (this.collidedBlockIds.has(blockId)) {
            console.log('已经对此方块发射过子弹');
            return;
        }
        
        // 记录此方块ID
        this.collidedBlockIds.add(blockId);
        
        // 设置冷却
        this.canFireBullet = false;
        this.scheduleOnce(() => {
            this.canFireBullet = true;
            // 清理碰撞记录
            this.collidedBlockIds.clear();
        }, this.bulletCooldown);
        
        // 检查是否有子弹预制体
        if (!this.bulletPrefab) {
            console.error('未设置子弹预制体');
            return;
        } else {
            console.log('子弹预制体已设置:', this.bulletPrefab.name);
        }
        
        // 查找Weapon节点 - 递归查找，因为Weapon可能在B1子节点下
        let weaponNode = this.findWeaponNode(blockNode);
        
        if (!weaponNode) {
            console.warn(`方块 ${blockNode.name} 没有找到Weapon子节点，创建一个`);
            // 如果没有找到Weapon节点，在B1节点下创建一个
            const b1Node = blockNode.getChildByName('B1');
            if (b1Node) {
                weaponNode = new Node('Weapon');
                // 确保Weapon节点有UITransform组件
                if (!weaponNode.getComponent(UITransform)) {
                    weaponNode.addComponent(UITransform);
                }
                // 将Weapon添加到B1节点中
                b1Node.addChild(weaponNode);
                // 放置在B1中心
                weaponNode.position = new Vec3(0, 0, 0);
            } else {
                // 如果连B1节点都没有，直接添加到方块根节点
                weaponNode = new Node('Weapon');
                // 确保Weapon节点有UITransform组件
                if (!weaponNode.getComponent(UITransform)) {
                    weaponNode.addComponent(UITransform);
                }
                // 将Weapon添加到方块中
                blockNode.addChild(weaponNode);
                // 放置在方块中心
                weaponNode.position = new Vec3(0, 0, 0);
            }
        } else {
            console.log(`找到方块 ${blockNode.name} 的Weapon子节点:`, weaponNode.name);
        }
        
        // 实例化子弹
        const bullet = instantiate(this.bulletPrefab);
        
        // 将子弹添加到GameArea中
        const gameArea = find('Canvas/GameLevelUI/GameArea');
        if (gameArea) {
            gameArea.addChild(bullet);
            
            // 设置子弹初始位置为Weapon节点的位置
            const weaponWorldPos = weaponNode.worldPosition;
            bullet.worldPosition = weaponWorldPos;
            
            // 子弹已经有BulletController组件，不需要再添加
            // 让子弹自己找到最近的敌人并攻击
            console.log('子弹已创建，将自动寻找并攻击最近的敌人');
        }
    }

    start() {
        // 如果没有指定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;
            }
        }
        
        // 如果没有指定coinLabelNode，尝试找到它
        if (!this.coinLabelNode) {
            this.coinLabelNode = find('Canvas/GameLevelUI/CoinNode/CoinLabel');
            if (!this.coinLabelNode) {
                console.error('找不到CoinLabel节点');
                return;
            }
        }
        
        // 确保有PlacedBlocks节点用于存放已放置的方块
        this.ensurePlacedBlocksNode();
        
        // 初始化玩家金币显示
        this.updateCoinDisplay();
        
        // 初始化网格信息
        this.initGridInfo();
        
        // 初始化网格占用情况
        this.initGridOccupationMap();
        
        // 在kuang下随机生成三个方块
        this.generateRandomBlocksInKuang();

        // 注册碰撞回调
        const collider = this.getComponent(Collider2D);
        if (collider) {
            collider.on(Contact2DType.BEGIN_CONTACT, this.onBeginContact, this);
            console.log('方块碰撞监听器已注册');
        }
    }
    
    // 确保有PlacedBlocks节点
    ensurePlacedBlocksNode() {
        const canvas = find('Canvas');
        if (!canvas) {
            console.error('找不到Canvas节点');
            return;
        }
        
        let placedBlocksNode = find('Canvas/PlacedBlocks');
        if (!placedBlocksNode) {
            placedBlocksNode = new Node('PlacedBlocks');
            canvas.addChild(placedBlocksNode);
            if (!placedBlocksNode.getComponent(UITransform)) {
                placedBlocksNode.addComponent(UITransform);
            }
            console.log('已创建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;
                    }
                }
            }
        }
        
        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);
            }
        }
        
        this.gridInitialized = true;
    }
    
    // 初始化网格占用情况
    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 generateRandomBlocksInKuang() {
        this.clearBlocks();
        
        if (this.blockPrefabs.length === 0) {
            console.error('没有可用的预制体');
            return;
        }
        
        const kuangNode = this.kuangContainer;
        if (!kuangNode) {
            console.error('找不到kuang节点');
            return;
        }
        
        const offsets = [
            new Vec3(-200, 0, 0),
            new Vec3(0, 0, 0),
            new Vec3(200, 0, 0)
        ];
        
        const dbNodes = [
            kuangNode.getChildByName('db01'),
            kuangNode.getChildByName('db02'),
            kuangNode.getChildByName('db03')
        ];
        
        console.log('开始在kuang容器中生成随机方块');
        
        for (let i = 0; i < 3; i++) {
            const randomIndex = Math.floor(Math.random() * this.blockPrefabs.length);
            const prefab = this.blockPrefabs[randomIndex];
            
            if (!prefab) {
                console.error(`方块预制体索引 ${randomIndex} 无效`);
                continue;
            }
            
            const block = instantiate(prefab);
            kuangNode.addChild(block);
            
            block.position = offsets[i];
            
            this.originalPositions.set(block, offsets[i].clone());
            this.blockLocations.set(block, 'kuang');
            this.blocks.push(block);
            
            if (dbNodes[i]) {
                const priceNode = dbNodes[i].getChildByName('Price');
                if (priceNode) {
                    this.blockPriceMap.set(block, priceNode);
                    priceNode.active = true;
                }
                
                this.associateDbNodeWithBlock(block, dbNodes[i]);
            }
            
            this.setupDragEvents(block);
            
            console.log(`生成方块 ${i + 1}/3: ${prefab.name} 在位置 (${offsets[i].x.toFixed(2)}, ${offsets[i].y.toFixed(2)})`);
        }
        
        console.log(`成功在kuang容器中生成了 ${this.blocks.length} 个方块`);
        this.updateCoinDisplay();
    }
    
    // 将db节点与方块关联
    associateDbNodeWithBlock(block: Node, dbNode: Node) {
        block['dbNode'] = dbNode;
        
        block.on(Node.EventType.TRANSFORM_CHANGED, () => {
            if (dbNode && block.parent) {
                const location = this.blockLocations.get(block);
                
                if (location === 'grid') {
                    dbNode.active = false;
                    return;
                }
                
                dbNode.active = true;
                
                const worldPos = block.parent.getComponent(UITransform).convertToWorldSpaceAR(block.position);
                const localPos = dbNode.parent.getComponent(UITransform).convertToNodeSpaceAR(worldPos);
                
                dbNode.position = new Vec3(localPos.x, localPos.y - 80, localPos.z);
            }
        });
    }
    
    // 更新金币显示
    updateCoinDisplay() {
        if (this.coinLabelNode) {
            const label = this.coinLabelNode.getComponent(Label);
            if (label) {
                label.string = this.playerCoins.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;
        }
    }
    
    // 扣除玩家金币
    deductPlayerCoins(amount: number): boolean {
        if (this.playerCoins >= amount) {
            this.playerCoins -= amount;
            this.updateCoinDisplay();
            return true;
        }
        return false;
    }
    
    // 归还玩家金币
    refundPlayerCoins(amount: number) {
        this.playerCoins += amount;
        this.updateCoinDisplay();
    }
    
    // 设置拖拽事件
    setupDragEvents(block: Node) {
        block.on(Node.EventType.TOUCH_START, (event: EventTouch) => {
            if (this.gameStarted && this.blockLocations.get(block) === 'grid') {
                if (!this.canMoveBlock(block)) {
                    return;
                }
            }
            
            this.currentDragBlock = block;
            this.startPos = event.getUILocation();
            this.blockStartPos.set(block.position);
            this.currentDragBlock['startLocation'] = this.blockLocations.get(block);
            
            block.setSiblingIndex(block.parent.children.length - 1);
            this.tempStoreBlockOccupiedGrids(block);
        }, this);
        
        block.on(Node.EventType.TOUCH_MOVE, (event: EventTouch) => {
            if (this.gameStarted && this.blockLocations.get(block) === 'grid') {
                if (!this.canMoveBlock(block)) {
                    return;
                }
            }
            
            if (!this.currentDragBlock) return;
            
            const location = event.getUILocation();
            const deltaX = location.x - this.startPos.x;
            const deltaY = location.y - this.startPos.y;
            
            this.currentDragBlock.position = new Vec3(
                this.blockStartPos.x + deltaX,
                this.blockStartPos.y + deltaY,
                this.blockStartPos.z
            );
        }, this);
        
        block.on(Node.EventType.TOUCH_END, (event: EventTouch) => {
            if (this.gameStarted && this.blockLocations.get(block) === 'grid') {
                if (!this.canMoveBlock(block)) {
                    return;
                }
            }
            
            if (this.currentDragBlock) {
                this.handleBlockDrop(event);
                
                // 如果成功移动且游戏已开始，设置冷却
                if (this.gameStarted && this.blockLocations.get(this.currentDragBlock) === 'grid') {
                    this.setBlockCooldown(this.currentDragBlock);
                }
                
                this.currentDragBlock = null;
            }
        }, this);
        
        block.on(Node.EventType.TOUCH_CANCEL, () => {
            if (this.currentDragBlock) {
                this.returnBlockToOriginalPosition();
                this.currentDragBlock = null;
            }
        }, this);
    }
    
    // 处理方块放下
    handleBlockDrop(event: EventTouch) {
        const touchPos = event.getUILocation();
        const startLocation = this.currentDragBlock['startLocation'];
        
        if (this.isInKuangArea(touchPos)) {
            this.returnBlockToKuang(startLocation);
        } else if (this.tryPlaceBlockToGrid(this.currentDragBlock)) {
            this.handleSuccessfulPlacement(startLocation);
            console.log('成功放置，移动到网格');
        } else {
            this.returnBlockToOriginalPosition();
        }
    }
    
    // 返回方块到kuang区域
    returnBlockToKuang(startLocation: string) {
        const originalPos = this.originalPositions.get(this.currentDragBlock);
        if (originalPos) {
            const kuangNode = this.kuangContainer;
            if (kuangNode && this.currentDragBlock.parent !== kuangNode) {
                this.currentDragBlock.removeFromParent();
                kuangNode.addChild(this.currentDragBlock);
            }
            
            this.currentDragBlock.position = originalPos.clone();
        }
        
        this.restoreBlockOccupiedGrids(this.currentDragBlock);
        this.blockLocations.set(this.currentDragBlock, 'kuang');
        this.showPriceLabel(this.currentDragBlock);
        
        if (startLocation === 'grid') {
            const price = this.getBlockPrice(this.currentDragBlock);
            this.refundPlayerCoins(price);
            this.currentDragBlock['placedBefore'] = false;
        }
        
        const dbNode = this.currentDragBlock['dbNode'];
        if (dbNode) {
            dbNode.active = true;
            this.currentDragBlock.emit(Node.EventType.TRANSFORM_CHANGED);
        }
    }
    
    // 处理成功放置
    handleSuccessfulPlacement(startLocation: string) {
        const price = this.getBlockPrice(this.currentDragBlock);
        
        if (startLocation === 'grid') {
            this.clearTempStoredOccupiedGrids(this.currentDragBlock);
            this.blockLocations.set(this.currentDragBlock, 'grid');
            this.hidePriceLabel(this.currentDragBlock);
            
            const dbNode = this.currentDragBlock['dbNode'];
            if (dbNode) {
                dbNode.active = false;
            }
            
            // 立即将方块移动到PlacedBlocks节点下，不等游戏开始
            this.moveBlockToPlacedBlocks(this.currentDragBlock);
            
            // 如果游戏已开始，添加锁定视觉提示
            if (this.gameStarted) {
                this.addLockedVisualHint(this.currentDragBlock);
            }
        } else {
            if (this.deductPlayerCoins(price)) {
                this.clearTempStoredOccupiedGrids(this.currentDragBlock);
                this.blockLocations.set(this.currentDragBlock, 'grid');
                this.hidePriceLabel(this.currentDragBlock);
                
                const dbNode = this.currentDragBlock['dbNode'];
                if (dbNode) {
                    dbNode.active = false;
                }
                
                this.currentDragBlock['placedBefore'] = true;
                
                // 立即将方块移动到PlacedBlocks节点下，不等游戏开始
                this.moveBlockToPlacedBlocks(this.currentDragBlock);
                
                // 如果游戏已开始，添加锁定视觉提示
                if (this.gameStarted) {
                    this.addLockedVisualHint(this.currentDragBlock);
                }
            } else {
                this.returnBlockToOriginalPosition();
            }
        }
    }
    
    // 返回方块到原位置
    returnBlockToOriginalPosition() {
        const currentLocation = this.blockLocations.get(this.currentDragBlock);
        if (currentLocation === 'kuang') {
            const originalPos = this.originalPositions.get(this.currentDragBlock);
            if (originalPos) {
                this.currentDragBlock.position = originalPos.clone();
            }
        } else {
            this.currentDragBlock.position = this.blockStartPos.clone();
        }
        
        this.restoreBlockOccupiedGrids(this.currentDragBlock);
        this.showPriceLabel(this.currentDragBlock);
        
        const dbNode = this.currentDragBlock['dbNode'];
        if (dbNode) {
            dbNode.active = true;
            this.currentDragBlock.emit(Node.EventType.TRANSFORM_CHANGED);
        }
    }
    
    // 检查是否在kuang区域内
    isInKuangArea(touchPos: Vec2): boolean {
        if (!this.kuangContainer) return false;
        
        const kuangTransform = this.kuangContainer.getComponent(UITransform);
        if (!kuangTransform) return false;
        
        const kuangBoundingBox = new Rect(
            this.kuangContainer.worldPosition.x - kuangTransform.width * kuangTransform.anchorX,
            this.kuangContainer.worldPosition.y - kuangTransform.height * kuangTransform.anchorY,
            kuangTransform.width,
            kuangTransform.height
        );
        
        return kuangBoundingBox.contains(new Vec2(touchPos.x, touchPos.y));
    }
    
    // 临时保存方块占用的网格
    tempStoreBlockOccupiedGrids(block: Node) {
        const occupiedGrids = block['occupiedGrids'];
        if (!occupiedGrids || occupiedGrids.length === 0) return;
        
        this.tempRemovedOccupiedGrids.push({
            block: block,
            occupiedGrids: [...occupiedGrids]
        });
        
        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'] = [];
    }
    
    // 恢复方块原来的占用状态
    restoreBlockOccupiedGrids(block: Node) {
        const index = this.tempRemovedOccupiedGrids.findIndex(item => item.block === block);
        if (index === -1) return;
        
        const savedItem = this.tempRemovedOccupiedGrids[index];
        
        for (const grid of savedItem.occupiedGrids) {
            if (grid.row >= 0 && grid.row < this.GRID_ROWS && 
                grid.col >= 0 && grid.col < this.GRID_COLS) {
                this.gridOccupationMap[grid.row][grid.col] = 1;
            }
        }
        
        block['occupiedGrids'] = [...savedItem.occupiedGrids];
        this.tempRemovedOccupiedGrids.splice(index, 1);
    }
    
    // 清除临时保存的占用状态
    clearTempStoredOccupiedGrids(block: Node) {
        const index = this.tempRemovedOccupiedGrids.findIndex(item => item.block === block);
        if (index === -1) return;
        
        this.tempRemovedOccupiedGrids.splice(index, 1);
    }
    
    // 尝试将方块放置到网格中
    tryPlaceBlockToGrid(block: Node): boolean {
        if (!this.gridContainer || !this.gridInitialized) return false;
        
        let b1Node = block;
        if (block.name !== 'B1') {
            b1Node = block.getChildByName('B1');
            if (!b1Node) {
                return false;
            }
        }
        
        const b1WorldPos = b1Node.parent.getComponent(UITransform).convertToWorldSpaceAR(b1Node.position);
        const gridPos = this.gridContainer.getComponent(UITransform).convertToNodeSpaceAR(b1WorldPos);
        
        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) {
            return false;
        }
        
        const nearestGrid = this.findNearestGridNode(gridPos);
        if (!nearestGrid) {
            return false;
        }
        
        return this.tryPlaceBlockToSpecificGrid(block, nearestGrid);
    }
    
    // 找到最近的网格节点
    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;
        }
        
        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);
        
        return true;
    }
    
    // 检查方块是否可以放置在指定位置
    canPlaceBlockAt(block: Node, targetGrid: Node): boolean {
        if (!this.gridInitialized) return false;
        
        const targetRowCol = this.getGridRowCol(targetGrid);
        if (!targetRowCol) return false;
        
        const parts = this.getBlockParts(block);
        
        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) {
                return false;
            }
            
            if (this.gridOccupationMap[row][col] === 1) {
                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;
    }
    
    // 获取方块的所有部分节点及其相对坐标
    getBlockParts(block: Node): { node: Node, x: number, y: number }[] {
        const parts: { node: Node, x: number, y: number }[] = [];
        
        parts.push({ node: block, x: 0, y: 0 });
        this.findBlockParts(block, parts, 0, 0);
        
        return parts;
    }
    
    // 递归查找方块的所有部分
    findBlockParts(node: Node, result: { node: Node, x: number, y: number }[], parentX: number, parentY: number) {
        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.push({ node: child, x, y });
            }
            
            this.findBlockParts(child, result, x, y);
        }
    }
    
    // 标记方块占用的格子
    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() {
        const blocksToRemove = [];
        
        for (const block of this.blocks) {
            if (block.isValid) {
                const location = this.blockLocations.get(block);
                if (location === 'kuang') {
                    blocksToRemove.push(block);
                }
            }
        }
        
        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);
            
            block.destroy();
        }
    }
    
    // 游戏开始时调用
    onGameStart() {
        this.gameStarted = true;
        console.log('游戏已开始，已放置的方块将有移动冷却时间');
        
        for (const block of this.blocks) {
            if (block.isValid) {
                const location = this.blockLocations.get(block);
                
                if (location === 'grid') {
                    this.hidePriceLabel(block);
                    
                    const dbNode = block['dbNode'];
                    if (dbNode) {
                        dbNode.active = false;
                    }
                    
                    this.moveBlockToPlacedBlocks(block);
                    this.addLockedVisualHint(block);
                }
            }
        }
    }
    
    // 游戏重置时调用
    onGameReset() {
        this.gameStarted = false;
        this.clearAllCooldowns();
        console.log('游戏已重置，方块可以自由移动');
    }
    
    // 添加视觉提示，表明方块已锁定
    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));
        }
        
        console.log(`已为方块 ${block.name} 添加锁定视觉提示`);
    }
    
    // 将方块移动到PlacedBlocks节点下
    moveBlockToPlacedBlocks(block: Node) {
        console.log('将方块移动到PlacedBlocks节点下');
        const placedBlocksNode = find('Canvas/PlacedBlocks');
        if (!placedBlocksNode) {
            console.error('找不到PlacedBlocks节点');
            return;
        }
        
        const worldPosition = new Vec3();
        block.getWorldPosition(worldPosition);
        
        block.removeFromParent();
        placedBlocksNode.addChild(block);
        block.setWorldPosition(worldPosition);
        
        console.log(`已将方块 ${block.name} 移动到PlacedBlocks节点下`);
    }

    // 碰撞回调
    onBeginContact(selfCollider: Collider2D, otherCollider: Collider2D, contact: IPhysics2DContact | null) {
        console.log('方块碰到了:', otherCollider.node.name);
        
        // 如果碰到球，发射子弹
        if (otherCollider.node.name === 'Ball') {
            console.log('方块被球击中！');
            
            // 获取被击中的方块节点
            const hitBlock = selfCollider.node;
            
            // 检查是否是已放置的方块（在网格中的方块）
            const blockLocation = this.blockLocations.get(hitBlock);
            if (blockLocation === 'grid') {
                // 发射子弹
                this.fireBullet(hitBlock);
            } else {
                console.log('只有已放置在网格中的方块才能发射子弹');
            }
        }
    }
}