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'; 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/PlacedBlocks）' }) public placedBlocksContainer: Node = null; // 游戏是否已开始 public gameStarted: boolean = false; // 移除移动冷却：相关属性/逻辑已废弃 // SaveDataManager 单例 private saveDataManager: SaveDataManager = null; // 仅用于局外数据 private session: LevelSessionManager = null; // 方块价格标签映射 private blockPriceMap: Map = 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 = new Map(); // 方块当前所在的区域 public blockLocations: Map = new Map(); // 配置管理器 private configManager: ConfigManager = null; // 关卡配置管理器 private levelConfigManager: LevelConfigManager = null; // 方块武器配置映射 private blockWeaponConfigs: Map = new Map(); // 预加载的武器配置数据 private preloadedWeaponsConfig: any = null; // 配置是否已预加载的标志 private isWeaponsConfigPreloaded: 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 { 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); } // 处理重置方块管理器事件 private onResetBlockManagerEvent() { console.log('[BlockManager] 接收到重置方块管理器事件'); this.onGameReset(); } // 处理方块生成事件 private onGenerateBlocksEvent() { console.log('[BlockManager] 接收到方块生成事件'); this.generateRandomBlocksInKuang(); } // 处理游戏开始事件 - 已废弃，避免与GameBlockSelection重复生成方块 // private onGameStartEvent() { // console.log('[BlockManager] 接收到游戏开始事件，生成初始方块'); // this.generateRandomBlocksInKuang(); // } // 处理波次完成事件 private onWaveCompletedEvent() { console.log('[BlockManager] 接收到波次完成事件，生成新方块'); this.generateRandomBlocksInKuang(); } 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实例获取成功'); } // 如果没有指定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/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(); // 调试绘制功能已迁移到GameBlockSelection // 移除自动生成方块逻辑，改为事件触发 // 方块生成现在通过以下事件触发： // - GAME_START: 游戏开始时 // - WAVE_COMPLETED: 每波敌人消灭后 // - GENERATE_BLOCKS: 手动触发生成 } // 确保有PlacedBlocks节点 ensurePlacedBlocksNode() { // 如果已经通过拖拽设置了节点，直接使用 if (this.placedBlocksContainer && this.placedBlocksContainer.isValid) { return; } // 尝试查找节点 this.placedBlocksContainer = find('Canvas/GameLevelUI/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(); 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; 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(); } // 将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); const priceNode = this.blockPriceMap.get(block); if (location === 'grid') { // 方块在网格区域时，隐藏价格标签 if (priceNode) { priceNode.active = false; } return; } // 检查方块是否正在被拖动，如果是则隐藏价格标签 if (block['isDragging']) { if (priceNode) { priceNode.active = false; } return; } // 方块在Block容器区域时，显示价格标签 if (priceNode && location && location.startsWith('block')) { priceNode.active = true; } } }); } // 保留原方法以兼容可能的调用（现在委托给新方法） 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; } } // 扣除玩家金币 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; } return this.tryPlaceBlockToSpecificGrid(block, nearestGrid); } // 找到最近的网格节点 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; } 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倍`); } return true; } // 检查方块是否可以放置在指定位置 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 setBlockPriceByRarity(priceNode: Node, rarity: string) { const label = priceNode.getComponent(Label); if (!label) { return; } let basePrice: number; switch (rarity) { case 'common': basePrice = 0; break; case 'uncommon': basePrice = 20; break; case 'rare': basePrice = 50; break; case 'epic': basePrice = 100; break; default: basePrice = 0; } // 应用便宜技能效果 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 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 spritePath = weaponConfig.visualConfig?.weaponSprites; if (!spritePath) { console.warn(`武器 ${weaponConfig.name} 没有配置图片信息`); return; } // 正确的SpriteFrame子资源路径 const spriteFramePath = `${spritePath}/spriteFrame`; // 加载SpriteFrame子资源 resources.load(spriteFramePath, SpriteFrame, (err, spriteFrame) => { if (err) { console.warn(`加载武器图片失败: ${spriteFramePath}`, err); return; } // 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); } }); } // 武器类型和方块形状组合的旋转角度配置 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}`); // 隐藏价格标签并处理 db 关联 this.hidePriceLabel(source); const srcDb = source['dbNode']; if (srcDb) srcDb.active = false; // 隐藏目标方块的db标签（合成后目标方块也应该隐藏db标签） const targetDb = target['dbNode']; if (targetDb) { targetDb.active = false; console.log(`[BlockManager] 隐藏目标方块db标签: ${targetDb.name}`); } // 销毁被合并方块 source.destroy(); // 升级稀有度 const nextRarity = this.getNextRarity(rarity); if (nextRarity) { console.log(`[BlockManager] 合成成功，稀有度升级: ${rarity} -> ${nextRarity}`); // 获取当前武器配置 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); } // 播放烟雾动画 const worldPos = new Vec3(); target.getWorldPosition(worldPos); this.spawnMergeSmoke(worldPos); // 播放升级特效动画 this.playUpgradeEffect(target); // 递归检查是否还能继续合成 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) { const path = 'Animation/WeaponTx/tx0003/tx0003'; resources.load(path, sp.SkeletonData, (err, sData: sp.SkeletonData) => { if (err || !sData) { console.warn('加载合成烟雾动画失败', err); 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); }); } /** 播放升级特效动画 */ private playUpgradeEffect(target: Node) { try { // 获取目标方块的世界坐标 const worldPos = new Vec3(); target.getWorldPosition(worldPos); // 加载升级特效动画 const path = 'Animation/WeaponBurnAni/shengji/skeleton'; resources.load(path, sp.SkeletonData, (err, sData: sp.SkeletonData) => { if (err || !sData) { console.warn('[BlockManager] 加载升级特效动画失败:', err); 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 (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] 方块重叠，执行合成`); // 执行合并：目标保留，拖拽方块销毁 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); } }