/** * @file MissionCardComp.ts * @description 卡牌系统核心控制器（战斗 UI 层 + 业务逻辑层） * * 职责： * 1. **卡牌分发管理** —— 从卡池抽取 3 张英雄卡，分发到 3 个 CHeroComp 槽位。 * 抽卡规则：从基础英雄卡池按权重抽取，同一次抽卡内英雄不重复； * 场上已召唤的英雄不再刷出。 * 2. **金币费用管理** —— 抽卡费用（refreshCost）的扣除。 * 3. **英雄数量上限校验** —— 在 UseHeroCard 事件的 guard 阶段判断是否允许再召唤英雄。 * 4. **场上英雄信息面板（HInfoComp 列表）同步** —— * 英雄上场时实例化面板，死亡时移除，定时刷新属性显示。 * 5. **特殊卡执行** —— 处理英雄升级卡（SpecialUpgrade，按 UUID 精确升级）和 * 英雄刷新卡（SpecialRefresh）。 * 6. **准备/战斗阶段切换** —— 控制卡牌面板的 展开/收起 动画。 * * 关键设计： * - 3 个 CHeroComp 由 cardPrefab 动态实例化生成，通过 cacheCardComps() 映射为有序数组 cardComps[]， * 之后所有分发、清空操作均通过此数组进行。 * - buildDrawCards() 从基础英雄卡池按权重抽取 3 张，不足时循环补齐。 * - 英雄上限校验（onUseHeroCard）采用 guard/cancel 模式： * CHeroComp 发出 UseHeroCard 事件并传入 guard 对象， * 本组件可通过 guard.cancel=true 阻止使用。 * * 历史： * 旧版本曾包含"卡池等级（poolLv）"机制和"三合一合成腾位"判断，已全部移除： * - 卡牌不再分级，所有英雄卡统一 lv1。 * - 升级卡机制已移除，英雄卡池只出普通英雄卡；英雄升级仅通过升级卡（SpecialUpgrade）触发。 * * 依赖： * - CHeroComp —— 单卡槽位 * - HInfoComp —— 英雄信息面板 * - CardSet 模块 —— 卡池配置、抽卡规则、特殊卡数据 * - HeroAttrsComp —— 英雄属性（升级） * - smc.vmdata.mission_data —— 局内数据（coin / hero_num / hero_max_num） */ import { mLogger } from "../common/Logger"; import { _decorator, instantiate, Label, Node, NodeEventType, Prefab, Tween, tween, Vec3, UITransform, Widget } from "cc"; import { ecs } from "../../../../extensions/oops-plugin-framework/assets/libs/ecs/ECS"; import { CCComp } from "../../../../extensions/oops-plugin-framework/assets/module/common/CCComp"; import { GameEvent } from "../common/config/GameEvent"; import { CardConfig, CardPoolList, CardType, drawCardsByRule, SpecialRefreshCardList, SpecialRefreshHeroType } from "../common/config/CardSet"; import { drawEquipCards } from "../common/config/EquipSet"; import { drawItemCards } from "../common/config/ICardSet"; import { drawSkillCards } from "../common/config/SCardSet"; import { CHeroComp } from "./CHeroComp"; import { EquipListComp } from "./EquipListComp"; import { HeroBoxComp } from "./HeroBoxComp"; import { SCardComp } from "./SCardComp"; import { oops } from "db://oops-framework/core/Oops"; import { HeroAttrsComp } from "../hero/HeroAttrsComp"; import { smc } from "../common/SingletonModuleComp"; import { HeroInfo, HType } from "../common/config/heroSet"; import { HeroViewComp } from "../hero/HeroViewComp"; import { FacSet, FightSet } from "../common/config/GameSet"; import { MissionEconomy } from "./MissionEconomy"; import { UIID } from "../common/config/GameUIConfig"; import { ItemListComp } from "./ItemListComp"; const { ccclass, property } = _decorator; /** * MissionCardComp —— 卡牌系统核心控制器 * * 管理 3 个卡牌槽位的抽卡分发、金币费用、 * 英雄上限校验、场上英雄信息面板同步以及特殊卡执行。 */ @ccclass('MissionCardComp') @ecs.register('MissionCard', false) export class MissionCardComp extends CCComp { /** 是否启用调试日志 */ private debugMode: boolean = false; /** 按钮正常缩放 */ private readonly buttonNormalScale: number = 1; /** 按钮按下缩放 */ private readonly buttonPressScale: number = 0.94; /** 按钮弹起缩放（峰值） */ private readonly buttonClickScale: number = 1.06; /** 抽卡（刷新）费用 */ refreshCost: number = FightSet.REFRESH_COST; /** 卡牌面板展开/收起动画时长（秒） */ cardsPanelMoveDuration: number = 0.2; // ======================== 编辑器绑定节点 ======================== /** 英雄抽卡面板（战斗阶段收起，准备阶段展开） */ @property(Node) showCards: Node = null! @property(Node) cardPanNode: Node = null! @property(Node) cards_node: Node = null! /** 卡牌槽位预制体（动态实例化 3 个） */ @property(Prefab) cardPrefab: Prefab = null! @property(Node) closeCards: Node = null! @property(Node) nock_node: Node = null! /** 英雄面板显示按钮 */ @property(Node) showHeros: Node = null! @property(Node) herosPanNode: Node = null! @property(Node) herosBoxNode: Node = null! @property(Prefab) heroPrefab: Prefab = null! /** 装备面板显示按钮 */ @property(Node) showEquips: Node = null! @property(Node) equipsPanNode: Node = null! @property(Node) equipsBoxNode: Node = null! @property(Prefab) equipPrefab: Prefab = null! /** 技能面板显示按钮 */ @property(Node) showSkills: Node = null! @property(Node) skillPanNode: Node = null! @property(Node) skillBoxNode: Node = null! @property(Prefab) sCardPrefab: Prefab = null! /** 药品面板显示按钮 */ @property(Node) showShop: Node = null! @property(Node) shopPanNode: Node = null! @property(Node) shopBoxNode: Node = null! @property(Prefab) itemPrefab: Prefab = null! /** 技能刷新按钮节点 */ @property(Node) skill_refresh: Node = null! /** 装备刷新按钮节点 */ @property(Node) equip_refresh: Node = null!; /** 药品刷新按钮节点 */ @property(Node) shop_refresh: Node = null!; /** 抽卡（刷新）按钮节点 */ @property(Node) cards_chou: Node = null! /** 金币显示节点（含 icon + num 子节点） */ @property(Node) coins_node: Node = null! /** 英雄数量显示节点（含 icon + num 子节点） */ @property(Node) hero_num_node: Node = null! // ======================== 运行时状态 ======================== /** 槽位水平坐标（屏幕 720 三等分，卡片 230，列宽 240） */ private readonly slotPosX: number[] = [-240, 0, 240]; /** 三个槽位对应的 CHeroComp 控制器缓存（有序数组） */ private cardComps: CHeroComp[] = []; /** 英雄面板 HeroBoxComp 控制器缓存（与场上英雄一一对应，最多 3 个） */ private heroBoxComps: HeroBoxComp[] = []; /** 装备卡槽控制器缓存 */ private equipCardComps: EquipListComp[] = []; /** 技能卡槽控制器缓存 */ private skillCardComps: SCardComp[] = []; /** 药品卡槽控制器缓存 */ private itemCardComps: ItemListComp[] = []; /** 是否已召唤过英雄（用于控制其他面板按钮是否可点击） */ private hasCalledHero: boolean = false; /** 已购买装备的 UUID 集合（跨波次保持，防止重复购买） */ private purchasedEquipUuids: Set = new Set(); /** 已购买商品的 UUID 集合（跨波次保持，防止重复购买） */ private purchasedItemUuids: Set = new Set(); // ======================== 面板轮播状态 ======================== /** 面板滑动间距（单面板宽度，运行时由 initPanelLayout 推导） */ private panelSlideWidth: number = 720; /** 当前激活的面板索引：0=英雄, 1=装备, 2=技能, 3=药品 */ private currentPanelIndex: number = 0; /** 各面板基准 Y 坐标缓存 */ private panelBaseYs: number[] = []; /** 是否已初始化面板布局 */ private hasInitPanelLayout: boolean = false; /** 是否已缓存卡牌面板基准缩放 */ private hasCachedCardsBaseScale: boolean = false; /** 卡牌面板基准缩放（从场景读取） */ private cardsBaseScale: Vec3 = new Vec3(1, 1, 1); /** 卡牌面板展开态缩放 */ private cardsShowScale: Vec3 = new Vec3(1, 1, 1); /** 卡牌面板收起态缩放（scale=0 隐藏） */ private cardsHideScale: Vec3 = new Vec3(0, 0, 1); /** 卡牌面板显示位置 Y 坐标 */ private readonly cardPanelShowY: number = 0; /** 卡牌面板隐藏位置 Y 坐标（向下 700） */ private readonly cardPanelHideY: number = -700; /** 卡牌面板显示/隐藏动画时长 */ private readonly cardPanelAnimDuration: number = 0.25; // ======================== 生命周期 ======================== /** * 组件加载： * 1. 绑定生命周期事件和按钮交互事件。 * 2. 缓存 3 个 CHeroComp 子控制器引用。 * 3. 计算并设置槽位水平布局。 * 4. 初始化卡牌面板缩放参数。 * 5. 初始化面板轮播布局。 */ onLoad() { this.bindEvents(); this.cacheCardComps(); this.initCardsPanelPos(); this.initPanelLayout(); mLogger.log(this.debugMode, "MissionCardComp", "onLoad init", { slots: this.cardComps.length, }); } /** 组件销毁时解绑所有事件并清理英雄信息面板 */ onDestroy() { super.onDestroy(); if (this.cards_chou && this.cards_chou.isValid) { this.cards_chou.off(NodeEventType.TOUCH_START, this.onDrawTouchStart, this); this.cards_chou.off(NodeEventType.TOUCH_END, this.onDrawTouchEnd, this); this.cards_chou.off(NodeEventType.TOUCH_CANCEL, this.onDrawTouchCancel, this); } if (this.showHeros && this.showHeros.isValid) { this.showHeros.off(NodeEventType.TOUCH_END, this.onShowHerosClick, this); } if (this.showCards && this.showCards.isValid) { this.showCards.off(NodeEventType.TOUCH_END, this.onShowCardsClick, this); } if (this.closeCards && this.closeCards.isValid) { this.closeCards.off(NodeEventType.TOUCH_END, this.onCloseCardsClick, this); } if (this.showEquips && this.showEquips.isValid) { this.showEquips.off(NodeEventType.TOUCH_END, this.onShowEquipsClick, this); } if (this.showSkills && this.showSkills.isValid) { this.showSkills.off(NodeEventType.TOUCH_END, this.onShowSkillsClick, this); } if (this.showShop && this.showShop.isValid) { this.showShop.off(NodeEventType.TOUCH_END, this.onShowShopClick, this); } this.unbindEvents(); } /** 外部初始化入口（由 CardController 调用） */ init() { this.onMissionStart(); } /** * 任务开始： * 1. 进入准备阶段（展开卡牌面板）。 * 2. 初始化局内数据（金币、英雄数量上限）。 * 3. 清空旧英雄信息面板和卡牌槽位。 * 4. 重置按钮状态和 UI 显示。 * 5. 执行首次抽卡并分发到 3 个槽位。 */ onMissionStart() { this.enterPreparePhase(); const missionData = this.getMissionData(); if (missionData) { missionData.coin = Math.max(0, Math.floor(missionData.coin ?? 0)); missionData.hero_num = 0; missionData.hero_max_num = FightSet.HERO_MAX_NUM; missionData.hero_extend_max_num = FightSet.HERO_MAX_NUM + 1; } // 确保卡牌组件列表已被正确缓存 if (!this.cardComps || this.cardComps.length === 0) { this.cacheCardComps(); } this.layoutCardSlots(); this.clearAllCards(); this.resetButtonScale(this.cards_chou); this.updateCoinAndCostUI(); this.updateHeroNumUI(false, false); if (this.node && this.node.isValid) { this.node.active = true; } const cards = this.buildDrawCards(); mLogger.log(this.debugMode, "MissionCardComp", "onMissionStart buildDrawCards", { cardsLength: cards.length, cards: cards.map(c => ({ uuid: c.uuid, type: c.type, name: c.name })) }); this.dispatchCardsToSlots(cards); // 重置购买记录并填充装备商店 this.purchasedEquipUuids.clear(); this.populateEquipments(); // 填充技能卡槽（英雄三槽模式：sCardPrefab 实例化 3 个槽位） this.populateSkillCards(); // 重置商品购买记录并填充商品商店 this.purchasedItemUuids.clear(); this.populateShopItems(); // 重置英雄召唤状态（游戏刚开始时其他面板不可点击） this.hasCalledHero = false; this.updatePanelButtonsInteractable(); // 初始化英雄信息盒（3 个空槽位） this.refreshHeroBoxSlots(); mLogger.log(this.debugMode, "MissionCardComp", "mission start"); } /** 任务结束：清空 3 槽 + 装备商店 + 技能卡槽 + 英雄面板并隐藏整个节点 */ onMissionEnd() { this.clearAllCards(); this.clearEquipments(); this.clearSkillCards(); this.clearShopItems(); for (const comp of this.heroBoxComps) { if (comp && comp.node && comp.node.isValid) { comp.applyEmpty(); } } if (this.node && this.node.isValid) { this.node.active = false; } } start() { } /** * 帧更新：每 0.15 秒刷新一次场上英雄信息面板（降频）。 * 检测已死亡 / 已失效的面板并移除，刷新存活面板属性。 */ update(dt: number) { } /** 关闭面板（不销毁数据模型，仅隐藏） */ close() { if (this.node && this.node.isValid) { this.node.active = false; } } // ======================== 事件绑定 ======================== /** * 绑定所有事件监听： * - 节点级事件：MissionStart / MissionEnd / FightStart * - 全局消息：CoinAdd / MasterCalled / HeroDead / UseHeroCard / UseSpecialCard * - 按钮触控：抽卡（cards_chou） */ private bindEvents() { /** 生命周期事件（节点级） */ this.on(GameEvent.MissionStart, this.onMissionStart, this); this.on(GameEvent.MissionEnd, this.onMissionEnd, this); this.on(GameEvent.FightStart, this.onFightStart, this); this.on("PhasePrepareStart", this.onPhasePrepareStart, this); oops.message.on(GameEvent.CoinAdd, this.onCoinAdd, this); oops.message.on(GameEvent.RefreshStone, this.onRefreshStone, this); oops.message.on(GameEvent.MasterCalled, this.onMasterCalled, this); oops.message.on(GameEvent.HeroDead, this.onHeroDead, this); oops.message.on(GameEvent.HeroSell, this.onHeroSell, this); oops.message.on(GameEvent.HeroLvUp, this.onHeroLvUp, this); oops.message.on(GameEvent.UseHeroCard, this.onUseHeroCard, this); // 监听装备购买事件，追踪已购记录 oops.message.on(GameEvent.UseEquipCard, this.onUseEquipCard, this); // 监听商品购买事件，追踪已购记录 oops.message.on(GameEvent.UseItemCard, this.onUseItemCard, this); oops.message.on(GameEvent.UseSpecialCard, this.onUseSpecialCard, this); oops.message.on(GameEvent.ShowSmallTip, this.onShowSmallTip, this); oops.message.on(GameEvent.CardUsed, this.onCardUsed, this); oops.message.on(GameEvent.HeroBoxEmptyClick, this.onHeroBoxEmptyClick, this); /** 按钮触控事件：抽卡 */ this.cards_chou?.on(NodeEventType.TOUCH_START, this.onDrawTouchStart, this); this.cards_chou?.on(NodeEventType.TOUCH_END, this.onDrawTouchEnd, this); this.cards_chou?.on(NodeEventType.TOUCH_CANCEL, this.onDrawTouchCancel, this); /** 显示卡牌面板按钮 */ this.showCards?.on(NodeEventType.TOUCH_END, this.onShowCardsClick, this); /** 隐藏卡牌面板按钮 */ this.closeCards?.on(NodeEventType.TOUCH_END, this.onCloseCardsClick, this); /** 英雄面板显示按钮 */ this.showHeros?.on(NodeEventType.TOUCH_END, this.onShowHerosClick, this); /** 装备面板显示按钮 */ this.showEquips?.on(NodeEventType.TOUCH_END, this.onShowEquipsClick, this); /** 技能面板显示按钮 */ this.showSkills?.on(NodeEventType.TOUCH_END, this.onShowSkillsClick, this); /** 药品面板显示按钮 */ this.showShop?.on(NodeEventType.TOUCH_END, this.onShowShopClick, this); /** 装备刷新按钮 */ this.equip_refresh?.on(NodeEventType.TOUCH_START, this.onEquipDrawTouchStart, this); this.equip_refresh?.on(NodeEventType.TOUCH_END, this.onEquipDrawTouchEnd, this); this.equip_refresh?.on(NodeEventType.TOUCH_CANCEL, this.onEquipDrawTouchCancel, this); /** 技能刷新按钮 */ this.skill_refresh?.on(NodeEventType.TOUCH_START, this.onSkillDrawTouchStart, this); this.skill_refresh?.on(NodeEventType.TOUCH_END, this.onSkillDrawTouchEnd, this); this.skill_refresh?.on(NodeEventType.TOUCH_CANCEL, this.onSkillDrawTouchCancel, this); /** 药品刷新按钮 */ this.shop_refresh?.on(NodeEventType.TOUCH_START, this.onShopDrawTouchStart, this); this.shop_refresh?.on(NodeEventType.TOUCH_END, this.onShopDrawTouchEnd, this); this.shop_refresh?.on(NodeEventType.TOUCH_CANCEL, this.onShopDrawTouchCancel, this); } // ======================== 事件回调 ======================== /** * 金币变化事件回调： * 仅负责 UI 更新和动画表现。数据更新已由 MissionEconomy 统一处理。 */ private onCoinAdd(event: string, args: any) { const payload = args ?? event; const v = typeof payload === 'number' ? payload : (payload?.delta ?? payload?.value ?? 0); this.updateCoinAndCostUI(); if (v !== 0) { this.playCoinChangeAnim(v > 0); } } /** 刷新石数量变更：刷新刷新按钮的可用状态与费用显示 */ private onRefreshStone() { this.updateDrawCostUI(); } /** 战斗开始：保留卡牌面板，允许玩家在战斗阶段继续抽卡和召唤英雄 */ private onFightStart() { this.enterBattlePhase(); // 第一次进入战斗阶段，关闭guide4 if (!smc.finish_guides.includes(4)) { smc.finish_guides.push(4); oops.gui.remove(UIID.Guide4); } } private onShowSmallTip(event: string, args: any) { const type = args as string; this.showSmallTip(type as any); } public showSmallTip(type: "refresh_coin" | "buy_coin" | "hero_full") { let targetNode: Node | null = null; switch (type) { case "refresh_coin": targetNode = this.cards_chou; break; case "buy_coin": targetNode = this.coins_node; break; case "hero_full": targetNode = this.hero_num_node; break; } if (targetNode && targetNode.isValid) { const tipNode = targetNode.getChildByName("smalltip"); if (tipNode) { tipNode.active = true; Tween.stopAllByTarget(tipNode); // 设置初始状态：缩放为 0 tipNode.setScale(new Vec3(0, 0, 1)); tween(tipNode) // 1. 弹出动画（微放大再回弹） .to(0.15, { scale: new Vec3(1.1, 1.1, 1) }, { easing: 'quadOut' }) .to(0.05, { scale: new Vec3(1, 1, 1) }) // 2. 停留 1 秒 .delay(1) // 3. 缩小消失动画 .to(0.15, { scale: new Vec3(0, 0, 1) }, { easing: 'quadIn' }) .call(() => { if (tipNode && tipNode.isValid) tipNode.active = false; }) .start(); } } } private onPhasePrepareStart() { this.updateHeroNumUI(true, true); } /** * 技能面板按钮回调：滑动到技能面板(index=2)。 */ private onShowSkillsClick() { oops.audio.playEffect("music/button"); this.slideToPanel(2); } // ======================== 商店面板 ======================== /** * 商店面板按钮回调：滑动到药品商店面板(index=3)。 */ private onShowShopClick() { oops.audio.playEffect("music/button"); this.slideToPanel(3); } /** * 填充商品列表（槽位复用模式）： * 从 ICardSet 按权重抽取 3 张商品卡， * 优先复用现有槽位（shopBoxNode 子节点），不足再实例化新槽位， * 每个商品项由 ItemListComp 渲染并处理购买。 * * 商品为一次性 buff 技能（Instant 触发，t_times=1）， * 购买后立即生效，由 MissSkillsComp 统一处理技能逻辑。 */ private populateShopItems() { if (!this.shopBoxNode || !this.itemPrefab) return; // 从商品卡池按权重抽取 3 张 const items = drawItemCards(3); const targetCount = items.length; // 确保槽位数量足够（复用 + 补充实例化） this.ensureItemSlots(targetCount); // 分发数据到槽位 for (let i = 0; i < this.itemCardComps.length; i++) { const comp = this.itemCardComps[i]; if (!comp) continue; if (i < targetCount) { comp.applyCardData(items[i]); // 已购买的商品标记为已购 if (this.purchasedItemUuids.has(items[i].uuid)) { comp.setPurchased(); } } else { // 多余槽位清空 comp.applyCardData(null as unknown as CardConfig); } } // 根据物品数量设置列表面板高度 this.resizeListBox(this.shopBoxNode, targetCount); // 三等分水平布局 this.layoutSlotsHorizontal(this.itemCardComps); // 默认显示商店面板 if (this.shopPanNode) { this.shopPanNode.active = true; } mLogger.log(this.debugMode, "MissionCardComp", "populate shop items", { count: items.length, slotCount: this.itemCardComps.length }); } /** * 确保药品槽位数量足够。 * 优先复用现有槽位，不足时从 itemPrefab 实例化补充。 * 实例化后立即按 slotPosX 定位，避免堆叠在 (0,0)。 */ private ensureItemSlots(targetCount: number) { if (!this.shopBoxNode || !this.itemPrefab) return; // 刷新缓存 this.cacheItemCardComps(); // 补充实例化不足的槽位 while (this.itemCardComps.length < targetCount) { const node = instantiate(this.itemPrefab); this.shopBoxNode.addChild(node); const comp = node.getComponent(ItemListComp) || node.addComponent(ItemListComp); this.itemCardComps.push(comp); } this.layoutSlotsHorizontal(this.itemCardComps); } /** 清空商品列表（复用槽位，仅清空数据） */ private clearShopItems() { for (const comp of this.itemCardComps) { if (comp && comp.node && comp.node.isValid) { comp.applyCardData(null as unknown as CardConfig); } } } /** 装备购买事件回调：记录已购 UUID，防止重复购买 */ private onUseEquipCard(event: string, args: any) { const usedCard = args as CardConfig; if (usedCard) { this.purchasedEquipUuids.add(usedCard.uuid); } } /** 商品购买事件回调：记录已购 UUID，防止重复购买 */ private onUseItemCard(event: string, args: any) { const usedCard = args as CardConfig; if (usedCard) { this.purchasedItemUuids.add(usedCard.uuid); } } /** 解除按钮监听，避免节点销毁后回调泄漏 */ private unbindEvents() { oops.message.off(GameEvent.CoinAdd, this.onCoinAdd, this); oops.message.off(GameEvent.RefreshStone, this.onRefreshStone, this); oops.message.off(GameEvent.MasterCalled, this.onMasterCalled, this); oops.message.off(GameEvent.HeroDead, this.onHeroDead, this); oops.message.off(GameEvent.HeroSell, this.onHeroSell, this); oops.message.off(GameEvent.HeroLvUp, this.onHeroLvUp, this); oops.message.off(GameEvent.UseHeroCard, this.onUseHeroCard, this); oops.message.off(GameEvent.UseEquipCard, this.onUseEquipCard, this); oops.message.off(GameEvent.UseItemCard, this.onUseItemCard, this); oops.message.off(GameEvent.UseSpecialCard, this.onUseSpecialCard, this); oops.message.off(GameEvent.ShowSmallTip, this.onShowSmallTip, this); oops.message.off(GameEvent.CardUsed, this.onCardUsed, this); oops.message.off(GameEvent.HeroBoxEmptyClick, this.onHeroBoxEmptyClick, this); if (this.cards_chou && this.cards_chou.isValid) { this.cards_chou.off(NodeEventType.TOUCH_START, this.onDrawTouchStart, this); this.cards_chou.off(NodeEventType.TOUCH_END, this.onDrawTouchEnd, this); this.cards_chou.off(NodeEventType.TOUCH_CANCEL, this.onDrawTouchCancel, this); } if (this.showHeros && this.showHeros.isValid) { this.showHeros.off(NodeEventType.TOUCH_END, this.onShowHerosClick, this); } if (this.showCards && this.showCards.isValid) { this.showCards.off(NodeEventType.TOUCH_END, this.onShowCardsClick, this); } if (this.closeCards && this.closeCards.isValid) { this.closeCards.off(NodeEventType.TOUCH_END, this.onCloseCardsClick, this); } if (this.showEquips && this.showEquips.isValid) { this.showEquips.off(NodeEventType.TOUCH_END, this.onShowEquipsClick, this); } if (this.showShop && this.showShop.isValid) { this.showShop.off(NodeEventType.TOUCH_END, this.onShowShopClick, this); } if (this.equip_refresh && this.equip_refresh.isValid) { this.equip_refresh.off(NodeEventType.TOUCH_START, this.onEquipDrawTouchStart, this); this.equip_refresh.off(NodeEventType.TOUCH_END, this.onEquipDrawTouchEnd, this); this.equip_refresh.off(NodeEventType.TOUCH_CANCEL, this.onEquipDrawTouchCancel, this); } if (this.skill_refresh && this.skill_refresh.isValid) { this.skill_refresh.off(NodeEventType.TOUCH_START, this.onSkillDrawTouchStart, this); this.skill_refresh.off(NodeEventType.TOUCH_END, this.onSkillDrawTouchEnd, this); this.skill_refresh.off(NodeEventType.TOUCH_CANCEL, this.onSkillDrawTouchCancel, this); } if (this.shop_refresh && this.shop_refresh.isValid) { this.shop_refresh.off(NodeEventType.TOUCH_START, this.onShopDrawTouchStart, this); this.shop_refresh.off(NodeEventType.TOUCH_END, this.onShopDrawTouchEnd, this); this.shop_refresh.off(NodeEventType.TOUCH_CANCEL, this.onShopDrawTouchCancel, this); } } /** * 英雄上场事件回调（MasterCalled）： * 为新上场英雄创建或更新信息面板，并刷新英雄数量 UI。 */ private onMasterCalled(event: string, args: any) { const payload = args ?? event; const eid = Number(payload?.eid ?? 0); const model = payload?.model as HeroAttrsComp | undefined; mLogger.log(this.debugMode, "MissionCardComp", "onMasterCalled received payload:", { eid, hasModel: !!model }); if (!eid || !model) return; const before = this.getAliveHeroCount(); const after = this.getAliveHeroCount(); this.updateHeroNumUI(true, after > before); // 第一次召唤英雄后，开放其他面板按钮 if (!this.hasCalledHero) { this.hasCalledHero = true; this.updatePanelButtonsInteractable(); } // 第一次召唤英雄后，关闭guide3 // 注：首个英雄召唤后战斗自动开始（见 MissionComp），不再需要 Guide4 引导点击开始按钮 if (!smc.finish_guides.includes(3)) { smc.finish_guides.push(3); oops.gui.remove(UIID.Guide3); } // 英雄登场后同步英雄信息盒 this.refreshHeroBoxSlots(); } /** 英雄死亡事件回调：刷新面板列表并更新英雄数量 UI */ private onHeroDead() { this.updateHeroNumUI(true, false); this.refreshHeroBoxSlots(); } /** 英雄被出售事件回调：更新英雄数量 UI 并清空对应英雄信息盒 */ private onHeroSell() { this.updateHeroNumUI(true, false); this.refreshHeroBoxSlots(); } /** 英雄升级事件回调：刷新英雄信息盒显示 */ private onHeroLvUp() { this.refreshHeroBoxSlots(); } /** 英雄面板空槽位点击回调：展示英雄卡池选择界面 */ private onHeroBoxEmptyClick() { this.onShowCardsClick(); } /** * 使用英雄卡的 guard 校验（由 CHeroComp 通过 UseHeroCard 事件调用）： * - 当前英雄数 < 上限 → 允许使用。 * - 已满 → 阻止使用（cancel=true），弹 toast。 * * 注意：英雄不再支持合成腾位，满员时一律阻止。 */ private onUseHeroCard(event: string, args: any) { const payload = args ?? event; if (!payload) return; const current = this.getAliveHeroCount(); this.syncMissionHeroData(current); const heroMax = this.getMissionHeroMaxNum(); if (current >= heroMax) { payload.cancel = true; payload.reason = "hero_limit"; this.showSmallTip("hero_full"); this.playHeroNumDeniedAnim(); } } /** * 使用特殊卡事件回调： * - SpecialUpgrade：按卡牌携带的 target_hero_eid 精确升级场上对应英雄实体。 * target_hero_eid 缺失或实体不存在时升级失败。 * - SpecialRefresh：按英雄类型重新抽取英雄卡。 */ private onUseSpecialCard(event: string, args: any) { const payload = args ?? event; const uuid = Number(payload?.uuid ?? 0); const type = Number(payload?.type ?? 0) as CardType; if (!uuid) return; let success = false; if (type === CardType.SpecialUpgrade) { const targetHeroEid = Number(payload?.target_hero_eid ?? 0); success = this.tryUpgradeHeroByEid(targetHeroEid); if (!success) { oops.gui.toast(`场上没有可升级的英雄`); } } else if (type === CardType.SpecialRefresh) { const card = SpecialRefreshCardList[uuid]; if (!card) return; success = this.tryRefreshHeroCardsByEffect(card.refreshHeroType); if (!success) oops.gui.toast("当前卡池无符合条件的英雄卡"); } mLogger.log(this.debugMode, "MissionCardComp", "use special card", { uuid, type, success }); } /** * 单张卡牌被成功使用后的整池刷新回调： * - payload 为该卡槽组件实例（CHeroComp / EquipListComp / ItemListComp）。 * - 命中英雄卡槽 → 重新构建 3 张英雄池卡牌并分发到所有英雄槽。 * - 命中装备卡槽 → 重新抽取装备并分发到所有装备槽。 * - 命中药品卡槽 → 重新抽取药品并分发到所有药品槽。 * - 未命中任何槽位 → 忽略。 * * Why: 购买一张卡后立即刷新整个卡池（不扣金币），让玩家持续从新池中挑选； * 所有卡池遵循同一逻辑。 * SpecialRefresh 自身效果（onUseSpecialCard 中的 tryRefreshHeroCards） * 已是整池刷新，因此 CHeroComp 对其不派发 CardUsed，避免双重刷新。 */ private onCardUsed(event: string, args: any) { const source = args; if (!source) return; const heroIdx = this.cardComps.findIndex(c => c === source); if (heroIdx >= 0) { const cards = this.buildDrawCards(); this.dispatchCardsToSlots(cards); // 召唤成功后收起英雄卡池面板 this.hideCardsPanel(); mLogger.log(this.debugMode, "MissionCardComp", "refresh hero pool after buy", { triggerSlot: heroIdx }); return; } const equipIdx = this.equipCardComps.findIndex(c => c === source); if (equipIdx >= 0) { this.populateEquipments(); mLogger.log(this.debugMode, "MissionCardComp", "refresh equip pool after buy", { triggerSlot: equipIdx }); return; } const skillIdx = this.skillCardComps.findIndex(c => c === source); if (skillIdx >= 0) { this.populateSkillCards(); mLogger.log(this.debugMode, "MissionCardComp", "refresh skill pool after buy", { triggerSlot: skillIdx }); return; } const itemIdx = this.itemCardComps.findIndex(c => c === source); if (itemIdx >= 0) { this.populateShopItems(); mLogger.log(this.debugMode, "MissionCardComp", "refresh item pool after buy", { triggerSlot: itemIdx }); return; } } // ======================== 按钮触控回调 ======================== /** 抽卡按钮按下反馈 */ private onDrawTouchStart() { this.playButtonPressAnim(this.cards_chou); } /** 抽卡按钮释放 → 执行抽卡逻辑 */ private onDrawTouchEnd() { oops.audio.playEffect("music/button"); this.playButtonClickAnim(this.cards_chou, () => this.onClickDraw()); } /** 抽卡按钮取消 → 恢复缩放 */ private onDrawTouchCancel() { this.playButtonResetAnim(this.cards_chou); } // ======================== 面板轮播系统 ======================== /** 面板节点数组（顺序：英雄→装备→技能→药品） */ private getPanelNodes(): Node[] { return [this.herosPanNode, this.equipsPanNode, this.skillPanNode, this.shopPanNode]; } /** 面板显示按钮数组（同上排序） */ private getPanelShowButtons(): Node[] { return [this.showHeros, this.showEquips, this.showSkills, this.showShop]; } /** * 初始化面板轮播布局： * 1. 缓存各面板基准 Y 坐标。 * 2. 推导面板滑动间距（取场景设计分辨率宽度或默认 720）。 * 3. 将所有面板排列为水平队列，初始显示英雄面板（index=0）。 */ private initPanelLayout() { if (this.hasInitPanelLayout) return; const panels = this.getPanelNodes(); this.panelBaseYs = []; // 以第一个有效面板的位置为基准，推导滑动间距 let refX = 0; for (const p of panels) { if (p && p.isValid) { refX = p.getPosition().x; break; } } this.panelSlideWidth = Math.abs(refX) * 2 || 720; if (this.panelSlideWidth < 400) this.panelSlideWidth = 720; for (let i = 0; i < panels.length; i++) { const node = panels[i]; if (!node || !node.isValid) { this.panelBaseYs.push(0); continue; } node.active = true; const pos = node.getPosition(); this.panelBaseYs.push(pos.y); // 初始位置：当前面板(英雄)居中，其余按序排列 const targetX = (i - this.currentPanelIndex) * this.panelSlideWidth; node.setPosition(targetX, pos.y, pos.z); } this.hasInitPanelLayout = true; this.updatePanelButtonStates(); } /** * 滑动到指定面板。 * @param index 0=英雄, 1=装备, 2=技能, 3=药品 */ private slideToPanel(index: number) { const panels = this.getPanelNodes(); if (index < 0 || index >= panels.length) return; this.currentPanelIndex = index; const duration = 0.25; for (let i = 0; i < panels.length; i++) { const node = panels[i]; if (!node || !node.isValid) continue; const targetX = (i - index) * this.panelSlideWidth; const baseY = this.panelBaseYs[i] ?? node.getPosition().y; Tween.stopAllByTarget(node); tween(node) .to(duration, { position: new Vec3(targetX, baseY, 0) }, { easing: 'quadOut' }) .start(); } this.updatePanelButtonStates(); } /** * 更新面板 tab 按钮的 active 子节点状态。 * 当前激活面板对应的按钮 active 高亮，其余关闭。 */ private updatePanelButtonStates() { const buttons = this.getPanelShowButtons(); for (let i = 0; i < buttons.length; i++) { const btn = buttons[i]; if (!btn || !btn.isValid) continue; const activeChild = btn.getChildByName("active"); if (activeChild) { activeChild.active = (i === this.currentPanelIndex); } } } /** * 更新面板按钮的可交互状态。 * 游戏刚开始时（未召唤英雄），只有英雄面板可打开； * 召唤第一个英雄后，其他面板才允许点击。 * 通过 nock_node（阻挡层）控制按钮是否可点击。 */ private updatePanelButtonsInteractable() { const interactable = this.hasCalledHero; if (this.nock_node && this.nock_node.isValid) { this.nock_node.active = !interactable; } } /** * 英雄面板按钮回调：滑动到英雄面板(index=0)。 */ private onShowHerosClick() { oops.audio.playEffect("music/button"); this.slideToPanel(0); } // ======================== 英雄信息盒（herosBoxNode） ======================== /** * 同步英雄信息盒槽位与场上英雄： * 1. 确保 herosBoxNode 下存在 3 个 HeroBoxComp 槽位（复用 + 实例化补充）。 * 2. 查询当前存活英雄列表，按序绑定到槽位。 * 3. 多余槽位显示空英雄信息。 * * Why: 英雄召唤 / 死亡 / 卖出 / 升级后调用，保证面板与场上一一对应。 */ private refreshHeroBoxSlots() { if (!this.herosBoxNode || !this.herosBoxNode.isValid) return; this.ensureHeroBoxSlots(3); // 查询场上存活英雄（含复活中的实体，按 eid 升序保证稳定顺序） const actors: Array<{ eid: number, model: HeroAttrsComp }> = []; ecs.query(ecs.allOf(HeroAttrsComp)).forEach((entity: ecs.Entity) => { const model = entity.get(HeroAttrsComp); if (!model) return; if (model.fac !== FacSet.HERO) return; if (model.is_dead) return; actors.push({ eid: entity.eid, model }); }); actors.sort((a, b) => a.eid - b.eid); for (let i = 0; i < this.heroBoxComps.length; i++) { const comp = this.heroBoxComps[i]; if (!comp || !comp.node || !comp.node.isValid) continue; const actor = actors[i]; if (actor) { comp.bindHero(actor.eid, actor.model); } else { comp.applyEmpty(); } } this.resizeListBox(this.herosBoxNode, Math.max(actors.length, 1)); } /** * 确保英雄信息盒槽位数量足够。 * 优先复用 herosBoxNode 现有子节点，不足时从 heroPrefab 实例化补充。 */ private ensureHeroBoxSlots(targetCount: number) { if (!this.herosBoxNode || !this.herosBoxNode.isValid) return; // 刷新缓存 this.heroBoxComps = this.herosBoxNode.children .map(node => node.getComponent(HeroBoxComp)) .filter((comp): comp is HeroBoxComp => !!comp); // 补充实例化不足的槽位 while (this.heroBoxComps.length < targetCount) { if (!this.heroPrefab) break; const node = instantiate(this.heroPrefab); // 先禁用根节点 Widget 再挂到父节点，避免 lateUpdate 覆盖 position const widget = node.getComponent(Widget); if (widget) widget.enabled = false; this.herosBoxNode.addChild(node); const comp = node.getComponent(HeroBoxComp) || node.addComponent(HeroBoxComp); this.heroBoxComps.push(comp); } } /** * 显示卡牌面板：从底部向上滑入到 Y=0 */ private onShowCardsClick() { oops.audio.playEffect("music/button"); if (!this.cardPanNode || !this.cardPanNode.isValid) return; this.cardPanNode.active = true; Tween.stopAllByTarget(this.cardPanNode); tween(this.cardPanNode) .to(this.cardPanelAnimDuration, { position: new Vec3(0, this.cardPanelShowY, 0) }, { easing: 'quadOut' }) .start(); } /** * 隐藏卡牌面板：向下滑出到 Y=-700 */ private onCloseCardsClick() { oops.audio.playEffect("music/button"); this.hideCardsPanel(); } /** 隐藏卡牌面板：向下滑出到 Y=-700（不含按钮音效，供系统逻辑复用） */ private hideCardsPanel() { if (!this.cardPanNode || !this.cardPanNode.isValid) return; Tween.stopAllByTarget(this.cardPanNode); tween(this.cardPanNode) .to(this.cardPanelAnimDuration, { position: new Vec3(0, this.cardPanelHideY, 0) }, { easing: 'quadIn' }) .call(() => { if (this.cardPanNode && this.cardPanNode.isValid) { this.cardPanNode.active = false; } }) .start(); } // ======================== 装备商店面板 ======================== /** * 装备面板按钮回调：滑动到装备商店面板(index=1)。 */ private onShowEquipsClick() { oops.audio.playEffect("music/button"); this.slideToPanel(1); } /** * 根据子项数量设置容器高度。 * 单项高度 100，间隔 5，上下各加 25 冗余（共 50）。 */ private resizeListBox(boxNode: Node, count: number) { if (!boxNode || !boxNode.isValid) return; const itemHeight = 100; const spacing = 5; const padding = 50; const height = Math.max(0, count) * (itemHeight + spacing) - spacing + padding; const uiTransform = boxNode.getComponent(UITransform) || boxNode.addComponent(UITransform); uiTransform.setContentSize(uiTransform.width, height); } /** * 填充装备列表（槽位复用模式）： * 从 EquipPoolList 按权重抽取 3 张装备卡， * 优先复用现有槽位（EquipsBoxNode 子节点），不足再实例化新槽位， * 每个装备项由 EquipListComp 渲染并处理购买。 * * 已购买的装备会标记为已购状态（隐藏购买按钮）。 */ private populateEquipments() { if (!this.equipsBoxNode || !this.equipPrefab) return; // 从装备卡池按权重抽取 3 张 const equips = drawEquipCards(3); const targetCount = equips.length; // 确保槽位数量足够（复用 + 补充实例化） this.ensureEquipSlots(targetCount); // 分发数据到槽位 for (let i = 0; i < this.equipCardComps.length; i++) { const comp = this.equipCardComps[i]; if (!comp) continue; if (i < targetCount) { comp.applyCardData(equips[i]); // 已购买的装备标记为已购 if (this.purchasedEquipUuids.has(equips[i].uuid)) { comp.setPurchased(); } } else { // 多余槽位清空 comp.applyCardData(null as unknown as CardConfig); } } // 根据物品数量设置列表面板高度 this.resizeListBox(this.equipsBoxNode, targetCount); // 三等分水平布局 this.layoutSlotsHorizontal(this.equipCardComps); // 默认显示装备面板 if (this.equipsPanNode) { this.equipsPanNode.active = true; } mLogger.log(this.debugMode, "MissionCardComp", "populate equipments", { count: equips.length, slotCount: this.equipCardComps.length }); } /** * 确保装备槽位数量足够。 * 优先复用现有槽位，不足时从 equipPrefab 实例化补充。 * 实例化后立即按 slotPosX 定位，避免堆叠在 (0,0)。 */ private ensureEquipSlots(targetCount: number) { if (!this.equipsBoxNode || !this.equipPrefab) return; // 刷新缓存 this.cacheEquipCardComps(); // 补充实例化不足的槽位 while (this.equipCardComps.length < targetCount) { const node = instantiate(this.equipPrefab); this.equipsBoxNode.addChild(node); const comp = node.getComponent(EquipListComp) || node.addComponent(EquipListComp); this.equipCardComps.push(comp); } this.layoutSlotsHorizontal(this.equipCardComps); } /** 清空装备列表（复用槽位，仅清空数据） */ private clearEquipments() { for (const comp of this.equipCardComps) { if (comp && comp.node && comp.node.isValid) { comp.applyCardData(null as unknown as CardConfig); } } } // ======================== 技能抽卡（英雄三槽模式） ======================== /** * 填充技能卡槽： * 从 SkillCardList 按权重抽取 3 张技能卡， * 优先复用现有槽位（skillBoxNode 子节点），不足再实例化新槽位， * 每个技能卡项由 SCardComp 渲染并处理购买。 */ private populateSkillCards() { if (!this.skillBoxNode || !this.sCardPrefab) return; // 从技能卡池按权重抽取 3 张 const skills = drawSkillCards(3); const targetCount = skills.length; // 确保槽位数量足够（复用 + 补充实例化） this.ensureSkillSlots(targetCount); // 分发数据到槽位 for (let i = 0; i < this.skillCardComps.length; i++) { const comp = this.skillCardComps[i]; if (!comp) continue; if (i < targetCount) { comp.applyDrawCard(skills[i]); } else { // 多余槽位清空 comp.applyDrawCard(null); } } // 根据技能数量设置列表面板高度 this.resizeListBox(this.skillBoxNode, targetCount); // 三等分水平布局 this.layoutSlotsHorizontal(this.skillCardComps); // 默认显示技能面板 if (this.skillPanNode) { this.skillPanNode.active = true; } mLogger.log(this.debugMode, "MissionCardComp", "populate skill cards", { count: skills.length, slotCount: this.skillCardComps.length }); } /** * 确保技能槽位数量足够。 * 优先复用现有槽位，不足时从 sCardPrefab 实例化补充。 * 实例化后立即按 slotPosX 定位，避免堆叠在 (0,0)。 */ private ensureSkillSlots(targetCount: number) { if (!this.skillBoxNode || !this.sCardPrefab) return; // 刷新缓存 this.cacheSkillCardComps(); // 补充实例化不足的槽位 while (this.skillCardComps.length < targetCount) { const node = instantiate(this.sCardPrefab); // 先禁用根节点 Widget 再挂到父节点： // 否则 addChild 激活当帧 lateUpdate 时 Widget 会对齐覆盖 position const widget = node.getComponent(Widget); if (widget) widget.enabled = false; this.skillBoxNode.addChild(node); const comp = node.getComponent(SCardComp) || node.addComponent(SCardComp); this.skillCardComps.push(comp); } this.layoutSlotsHorizontal(this.skillCardComps); } /** 清空技能卡槽（复用槽位，仅清空数据） */ private clearSkillCards() { for (const comp of this.skillCardComps) { if (comp && comp.node && comp.node.isValid) { comp.clearBySystem(); } } } /** * 缓存技能卡槽组件引用。 * 技能卡槽在编辑器中通过 sCardPrefab 实例化为 skillBoxNode 的子节点， * 每个子节点根节点挂载 SCardComp。 */ private cacheSkillCardComps() { if (!this.skillBoxNode || !this.skillBoxNode.isValid) { this.skillCardComps = []; return; } this.skillCardComps = this.skillBoxNode.children .map(node => node.getComponent(SCardComp)) .filter((comp): comp is SCardComp => !!comp); } // ======================== 装备/药品刷新按钮回调 ======================== private onEquipDrawTouchStart() { this.playButtonPressAnim(this.equip_refresh); } private onEquipDrawTouchEnd() { oops.audio.playEffect("music/button"); this.playButtonClickAnim(this.equip_refresh, () => this.onClickEquipRefresh()); } private onEquipDrawTouchCancel() { this.playButtonResetAnim(this.equip_refresh); } private onShopDrawTouchStart() { this.playButtonPressAnim(this.shop_refresh); } private onShopDrawTouchEnd() { oops.audio.playEffect("music/button"); this.playButtonClickAnim(this.shop_refresh, () => this.onClickShopRefresh()); } private onShopDrawTouchCancel() { this.playButtonResetAnim(this.shop_refresh); } private onSkillDrawTouchStart() { this.playButtonPressAnim(this.skill_refresh); } private onSkillDrawTouchEnd() { oops.audio.playEffect("music/button"); this.playButtonClickAnim(this.skill_refresh, () => this.onClickSkillRefresh()); } private onSkillDrawTouchCancel() { this.playButtonResetAnim(this.skill_refresh); } /** 装备刷新：扣费后重新抽取 3 张装备展示 */ private onClickEquipRefresh() { const cost = MissionEconomy.getRefreshCost(this.refreshCost); const success = MissionEconomy.executeRefresh(this.refreshCost); if (!success) { this.showSmallTip("refresh_coin"); return; } this.populateEquipments(); } /** 药品刷新：扣费后重新抽取 3 张商品展示 */ private onClickShopRefresh() { const cost = MissionEconomy.getRefreshCost(this.refreshCost); const success = MissionEconomy.executeRefresh(this.refreshCost); if (!success) { this.showSmallTip("refresh_coin"); return; } this.populateShopItems(); } /** 技能刷新：扣费后重新抽取 3 张技能卡展示 */ private onClickSkillRefresh() { const success = MissionEconomy.executeRefresh(this.refreshCost); if (!success) { this.showSmallTip("refresh_coin"); return; } this.populateSkillCards(); } /** 将 cardPrefab 实例化为 3 个卡槽并映射为 CHeroComp，形成固定顺序控制数组（幂等：已缓存则不重复实例化） */ private cacheCardComps() { // 幂等保护：卡槽已存在且节点有效时，仅刷新其他缓存，不重复实例化英雄卡槽 const hasValidHeroComps = this.cardComps.length === 3 && this.cardComps.every(c => c && c.node && c.node.isValid); if (hasValidHeroComps) { this.cacheEquipCardComps(); this.cacheItemCardComps(); return; } // 清理旧卡槽（如果存在） for (const comp of this.cardComps) { if (comp && comp.node && comp.node.isValid) { comp.node.destroy(); } } this.cardComps = []; // 从预制体实例化 3 个卡槽 if (this.cardPrefab && this.cards_node && this.cards_node.isValid) { for (let i = 0; i < 3; i++) { const node = instantiate(this.cardPrefab); // 先禁用根节点 Widget 再挂到父节点： // 否则 addChild 激活当帧 lateUpdate 时 Widget 会对齐覆盖 position const widget = node.getComponent(Widget); if (widget) widget.enabled = false; this.cards_node.addChild(node); const comp = node.getComponent(CHeroComp) || node.addComponent(CHeroComp); this.cardComps.push(comp); mLogger.log(this.debugMode, "MissionCardComp", "cacheCardComps instantiate", { index: i, nodeName: node.name, nodeActive: node.active, nodeWorldPos: node.worldPosition, parentName: this.cards_node.name, parentActive: this.cards_node.active, parentWorldPos: this.cards_node.worldPosition, cardPrefabValid: this.cardPrefab.isValid }); } // 实例化后立即按 slotPosX 定位，避免堆叠在 (0,0) this.layoutCardSlots(); } else { mLogger.log(this.debugMode, "MissionCardComp", "cacheCardComps failed", { cardPrefabValid: this.cardPrefab?.isValid, cards_nodeValid: this.cards_node?.isValid, cards_nodeActive: this.cards_node?.active }); } this.cacheEquipCardComps(); this.cacheItemCardComps(); } /** * 缓存装备卡槽组件引用。 * 装备卡槽在编辑器中通过 equipPrefab 实例化为 equipsBoxNode 的子节点， * 每个子节点根节点挂载 EquipListComp。 */ private cacheEquipCardComps() { if (!this.equipsBoxNode || !this.equipsBoxNode.isValid) { this.equipCardComps = []; return; } this.equipCardComps = this.equipsBoxNode.children .map(node => node.getComponent(EquipListComp)) .filter((comp): comp is EquipListComp => !!comp); } /** * 缓存药品卡槽组件引用。 * 药品卡槽在编辑器中通过 itemPrefab 实例化为 shopBoxNode 的子节点， * 每个子节点根节点挂载 ItemListComp。 */ private cacheItemCardComps() { if (!this.shopBoxNode || !this.shopBoxNode.isValid) { this.itemCardComps = []; return; } this.itemCardComps = this.shopBoxNode.children .map(node => node.getComponent(ItemListComp)) .filter((comp): comp is ItemListComp => !!comp); } // ======================== 核心业务：抽卡 ======================== /** * 抽卡按钮核心逻辑： * 1. 检查金币是否足够 → 不够则 toast 提示。 * 2. 扣除费用、播放金币动画。 * 3. 重新布局槽位 → 从卡池构建 3 张卡 → 分发到槽位。 */ private onClickDraw() { const cost = MissionEconomy.getRefreshCost(this.refreshCost); const success = MissionEconomy.executeRefresh(this.refreshCost); if (!success) { this.showSmallTip("refresh_coin"); this.updateCoinAndCostUI(); mLogger.log(this.debugMode, "MissionCardComp", "draw coin not enough", { currentCoin: MissionEconomy.getCoin(), cost }); return; } mLogger.log(this.debugMode, "MissionCardComp", "click draw", { cost, leftCoin: MissionEconomy.getCoin() }); this.layoutCardSlots(); const cards = this.buildDrawCards(); this.dispatchCardsToSlots(cards); } // ======================== 阶段切换 ======================== /** 缓存卡牌面板的基准缩放值（从场景初始状态读取，仅缓存一次） */ private initCardsPanelPos() { if (!this.cards_node || !this.cards_node.isValid) return; if (!this.hasCachedCardsBaseScale) { const scale = this.cards_node.scale; this.cardsBaseScale = new Vec3(scale.x, scale.y, scale.z); this.hasCachedCardsBaseScale = true; } this.cardsShowScale = new Vec3(this.cardsBaseScale.x, this.cardsBaseScale.y, this.cardsBaseScale.z); this.cardsHideScale = new Vec3(0, 0, this.cardsBaseScale.z); } /** * 进入准备阶段： * - 初始化面板轮播布局（如尚未初始化）。 * - 滑动到英雄面板（index=0），作为默认展示。 * - 激活 showHeros 按钮可见性。 * - 显示卡牌面板（从底部滑入）。 */ private enterPreparePhase() { if (!this.cards_node || !this.cards_node.isValid) return; this.initCardsPanelPos(); // 确保面板布局已初始化 if (!this.hasInitPanelLayout) { this.initPanelLayout(); } // 显式激活「显示英雄卡池」按钮本身，让玩家可见可点 if (this.showHeros && this.showHeros.isValid) { this.showHeros.active = true; } // 刷新所有刷新按钮的费用显示（含刷新石/金币切换与置灰状态） this.updateDrawCostUI(); // 显示卡牌面板（默认进入准备阶段时展开） if (this.cardPanNode && this.cardPanNode.isValid) { this.cardPanNode.active = true; this.cardPanNode.setPosition(0, this.cardPanelShowY, 0); mLogger.log(this.debugMode, "MissionCardComp", "enterPreparePhase cardPanNode", { active: this.cardPanNode.active, position: this.cardPanNode.position, worldPos: this.cardPanNode.worldPosition, parentName: this.cardPanNode.parent?.name, parentActive: this.cardPanNode.parent?.active, parentWorldPos: this.cardPanNode.parent?.worldPosition, cards_nodeActive: this.cards_node?.active, cards_nodeWorldPos: this.cards_node?.worldPosition, cards_nodeChildren: this.cards_node?.children.length }); } // 滑动到英雄面板 this.slideToPanel(0); mLogger.log(this.debugMode, "MissionCardComp", "enterPreparePhase herosPanNode", { herosPanNodeActive: this.herosPanNode?.active, herosPanNodePos: this.herosPanNode?.position, herosPanNodeWorldPos: this.herosPanNode?.worldPosition, currentPanelIndex: this.currentPanelIndex, panelSlideWidth: this.panelSlideWidth }); } private enterBattlePhase() { if (!this.cards_node || !this.cards_node.isValid) return; this.initCardsPanelPos(); // 战斗阶段允许抽卡：刷新所有刷新按钮的费用显示（含刷新石/金币切换与置灰状态） this.updateDrawCostUI(); } /** * 构建本次抽卡结果，返回 3 张英雄卡。 * * 规则： * 1. 从基础英雄卡池按权重抽取，同一次抽卡内英雄不重复。 * 2. 过滤掉场上已召唤的英雄（已召唤的英雄不再刷出，仅通过升级卡升级）。 * 3. 不足 3 张时循环补齐（允许重复）。 * * 注：升级卡机制已移除，英雄卡池只出普通英雄卡。 */ private buildDrawCards(): CardConfig[] { const heroCards = CardPoolList.filter(c => c.type === CardType.Hero); const aliveHeroUuids = this.getAliveHeroUuids(); const availableHeroCards = heroCards.filter(c => !aliveHeroUuids.has(c.uuid)); if (availableHeroCards.length === 0) return []; const result: CardConfig[] = []; const usedUuids = new Set(); // 按权重抽取，同一次抽卡内英雄不重复 while (result.length < 3) { const pool = availableHeroCards.filter(c => !usedUuids.has(c.uuid)); if (pool.length === 0) break; const pick = this.weightedPick(pool); if (!pick) break; result.push(pick); usedUuids.add(pick.uuid); } // 兜底：不足 3 张时循环补齐（允许重复） while (result.length < 3) { result.push(availableHeroCards[result.length % availableHeroCards.length]); } return result.slice(0, 3); } /** 单次按权重抽取一张卡 */ private weightedPick(cards: CardConfig[]): CardConfig | null { if (cards.length === 0) return null; const totalWeight = cards.reduce((total, card) => total + (card.weight ?? 0), 0); let random = Math.random() * totalWeight; for (const card of cards) { random -= (card.weight ?? 0); if (random <= 0) return card; } return cards[cards.length - 1]; } private tryRefreshHeroCards(heroType?: HType): boolean { const cards = drawCardsByRule({ count: 3, type: CardType.Hero, heroType, unique: true, // 保证一次刷新内的英雄卡不重复 }); // 过滤掉场上已召唤英雄的普通英雄卡（已召唤的英雄不再重复刷出） const aliveHeroUuids = this.getAliveHeroUuids(); const available = cards.filter(c => !aliveHeroUuids.has(c.uuid)); if (available.length <= 0) return false; this.layoutCardSlots(); this.dispatchCardsToSlots(available.slice(0, 3)); return true; } private tryRefreshHeroCardsByEffect(refreshHeroType: SpecialRefreshHeroType): boolean { const heroType = this.resolveRefreshHeroType(refreshHeroType); return this.tryRefreshHeroCards(heroType); } private resolveRefreshHeroType(refreshHeroType: SpecialRefreshHeroType): HType | undefined { if (refreshHeroType === SpecialRefreshHeroType.Melee) return HType.Melee; if (refreshHeroType === SpecialRefreshHeroType.Ranged) return HType.Long; return undefined; } /** 全量分发给 3 槽；每个槽位是否接收由 CHeroComp 自己判断（锁定可跳过） */ private dispatchCardsToSlots(cards: CardConfig[]) { if (!this.cardComps) return; for (let i = 0; i < this.cardComps.length; i++) { if (this.cardComps[i]) { const accepted = this.cardComps[i].applyDrawCard(cards[i] ?? null); const node = this.cardComps[i].node; mLogger.log(this.debugMode, "MissionCardComp", "dispatch card", { index: i, card: cards[i]?.uuid ?? 0, accepted, nodeActive: node?.active, nodeWorldPos: node?.worldPosition, nodeScale: node?.scale, parentName: node?.parent?.name, parentActive: node?.parent?.active, parentWorldPos: node?.parent?.worldPosition }); } } } /** 系统清空 3 槽（用于任务切换） */ private clearAllCards() { if (!this.cardComps) return; this.cardComps.forEach(comp => { if (comp) comp.clearBySystem(); }); } private layoutCardSlots() { // 走 CHeroComp.setSlotPosition，同步更新其 restPosition， // 避免 clearBySystem 恢复位置时与布局结果不一致 for (let i = 0; i < this.cardComps.length && i < this.slotPosX.length; i++) { const comp = this.cardComps[i]; if (comp && comp.node && comp.node.isValid) { const widget = comp.node.getComponent(Widget); if (widget) widget.enabled = false; comp.setSlotPosition(this.slotPosX[i]); } } } /** * 三等分水平布局： * 按固定坐标数组 slotPosX 排列槽位，超出数量的槽位不处理。 * * Why: 各卡池根节点的 Layout 组件已移除，槽位水平位置改由代码统一控制。 * 部分预制体根节点残留 Widget 组件（对齐父节点中心）， * 启用时会在 lateUpdate 覆盖代码设置的 position，需先禁用。 * * @param comps 槽位组件数组（CHeroComp / EquipListComp / SCardComp / ItemListComp） */ private layoutSlotsHorizontal(comps: Array) { for (let i = 0; i < comps.length && i < this.slotPosX.length; i++) { const node = comps[i]?.node; if (!node || !node.isValid) continue; // 禁用根节点 Widget，防止其在对齐刷新时覆盖 position const widget = node.getComponent(Widget); if (widget) widget.enabled = false; const pos = node.getPosition(); node.setPosition(this.slotPosX[i], pos.y, pos.z); } } /** * 延迟一帧执行布局： * 首次实例化的嵌套预制体在首帧会先恢复到原始位置， * 等下一帧预制体初始化完成后再定位，避免首帧堆叠在 (0,0)。 */ private layoutSlotsHorizontalDeferred(comps: Array) { this.scheduleOnce(() => { this.layoutSlotsHorizontal(comps); }, 0); } private playButtonPressAnim(node: Node | null) { this.playNodeScaleTo(node, this.buttonPressScale, 0.06); } private playButtonClickAnim(node: Node | null, onComplete: () => void) { if (!node || !node.isValid) { onComplete(); return; } this.playNodeScalePop(node, this.buttonClickScale, 0.05, 0.08, onComplete); } private playButtonResetAnim(node: Node | null) { this.playNodeScaleTo(node, this.buttonNormalScale, 0.08); } private resetButtonScale(node: Node | null) { if (!node || !node.isValid) return; Tween.stopAllByTarget(node); node.setScale(this.buttonNormalScale, this.buttonNormalScale, 1); } private canDrawCards() { // 有刷新石时可直接刷新，否则校验金币是否足够 return MissionEconomy.canRefresh(this.refreshCost); } private updateDrawCostUI() { const stones = MissionEconomy.getRefreshStone(); this.updateOneRefreshBtnUI(this.cards_chou, stones); this.updateOneRefreshBtnUI(this.equip_refresh, stones); this.updateOneRefreshBtnUI(this.shop_refresh, stones); this.updateOneRefreshBtnUI(this.skill_refresh, stones); } /** * 更新单个刷新按钮的费用显示与可用状态。 * * 统一 UI 结构（按钮节点下）： * - 背景 ：按钮底图 * - nobg ：置灰遮罩，不可刷新时激活 * - Node/ ：费用容器，下含 Label + coin + stone * - coin/ ：金币费用（含 num 子节点 Label），刷新石=0 时显示 * - stone/ ：刷新石费用（含 num 子节点 Label），刷新石>0 时显示 * * @param btnNode 刷新按钮节点 * @param stones 当前刷新石数量（外部统一读取，避免 4 次重复访问） */ private updateOneRefreshBtnUI(btnNode: Node | null, stones: number) { if (!btnNode || !btnNode.isValid) return; const useStone = stones > 0; // 置灰遮罩：有刷新石必定可刷新，否则按金币判断 const nobg = btnNode.getChildByName("nobg"); if (nobg) { nobg.active = useStone ? false : !this.canDrawCards(); } // 费用容器：按钮下的 Node 子节点（统一结构：背景 + Node[Label/coin/stone]） const container = btnNode.getChildByName("Node"); if (!container) return; // 金币费用节点 const coinNode = container.getChildByName("coin"); if (coinNode) { coinNode.active = !useStone; if (!useStone) { const numLabel = coinNode.getChildByName("num")?.getComponent(Label); if (numLabel) { numLabel.string = `${MissionEconomy.getRefreshCost(this.refreshCost)}`; } } } // 刷新石费用节点（显示当前持有数量） const stoneNode = container.getChildByName("stone"); if (stoneNode) { stoneNode.active = useStone; if (useStone) { const numLabel = stoneNode.getChildByName("num")?.getComponent(Label); if (numLabel) { numLabel.string = `${stones}`; } } } } private updateCoinAndCostUI() { this.updateDrawCostUI(); } private playCoinChangeAnim(isIncrease: boolean) { if (!this.coins_node || !this.coins_node.isValid) return; const icon = this.coins_node.getChildByName("icon"); if (!icon || !icon.isValid) return; const peak = isIncrease ? 1.2 : 1.2; this.playHeroNumNodePop(icon, peak); const num = this.coins_node.getChildByName("num"); if (!num || !num.isValid) return; this.playHeroNumNodePop(num, peak); } public setHeroMaxCount(max: number) { const missionData = this.getMissionData(); if (!missionData) return; const min = FightSet.HERO_MAX_NUM; const limit = Math.max(min, missionData.hero_extend_max_num ?? (FightSet.HERO_MAX_NUM + 1)); const next = Math.max(min, Math.min(limit, Math.floor(max || min))); if (next === missionData.hero_max_num) return; missionData.hero_max_num = next; this.updateHeroNumUI(true, false); } public tryExpandHeroMax(add: number = 1): boolean { const missionData = this.getMissionData(); if (!missionData) return false; const before = this.getMissionHeroMaxNum(); const next = before + Math.max(0, Math.floor(add)); this.setHeroMaxCount(next); return this.getMissionHeroMaxNum() > before; } public canUseHeroCard(): boolean { return this.getAliveHeroCount() < this.getMissionHeroMaxNum(); } private getAliveHeroCount(): number { let count = 0; ecs.query(ecs.allOf(HeroAttrsComp)).forEach((entity: ecs.Entity) => { const model = entity.get(HeroAttrsComp); if (model && model.fac === FacSet.HERO) { count++; } }); return count; } private queryAliveHeroActors(): Array<{ eid: number, model: HeroAttrsComp, view: HeroViewComp | null }> { const actors: Array<{ eid: number, model: HeroAttrsComp, view: HeroViewComp | null }> = []; ecs.query(ecs.allOf(HeroAttrsComp)).forEach((entity: ecs.Entity) => { const model = entity.get(HeroAttrsComp); if (!model) return; if (model.fac !== FacSet.HERO) return; if (model.is_dead) return; const view = entity.get(HeroViewComp); actors.push({ eid: entity.eid, model, view }); }); return actors; } /** * 获取场上所有存活英雄的 hero_uuid 集合。 * 用于抽卡时过滤：已召唤的英雄不再从普通英雄卡池中刷出。 */ private getAliveHeroUuids(): Set { const uuids = new Set(); ecs.query(ecs.allOf(HeroAttrsComp)).forEach((entity: ecs.Entity) => { const model = entity.get(HeroAttrsComp); if (!model) return; if (model.fac !== FacSet.HERO) return; if (model.is_dead) return; uuids.add(model.hero_uuid); }); return uuids; } /** * 按 eid 精确升级场上对应英雄实体。 * * @param heroEid 要升级的英雄实体 eid * @returns true = 升级成功 */ private tryUpgradeHeroByEid(heroEid: number): boolean { if (!heroEid) return false; const actor = this.queryAliveHeroActors().find(item => item.eid === heroEid); if (!actor) return false; if (actor.model.lv >= FightSet.HERO_MAX_LV) return false; const nextLv = Math.min(FightSet.HERO_MAX_LV, actor.model.lv + 1); this.applyHeroLevel(actor.model, nextLv); if (actor.view) { actor.view.playBuff("buff_lvup"); } return true; } /** * 应用英雄等级变化（属性按 HERO_LV_MULTIPLIER 重新计算）。 * 沿用旧版本 SkillLvUp 的技能等级映射规则。 */ private applyHeroLevel(model: HeroAttrsComp, targetLv: number) { const hero = HeroInfo[model.hero_uuid]; if (!hero) return; const nextLv = Math.max(1, Math.min(FightSet.HERO_MAX_LV, Math.floor(targetLv))); const hpRate = model.hp_max > 0 ? model.hp / model.hp_max : 1; model.lv = nextLv; model.ap = hero.ap * Math.pow(FightSet.HERO_LV_MULTIPLIER, nextLv - 1); model.hp_max = hero.hp * Math.pow(FightSet.HERO_LV_MULTIPLIER, nextLv - 1); model.hp = Math.max(1, Math.floor(model.hp_max * Math.max(0, Math.min(1, hpRate)))); model.skills = {}; for (const key in hero.skills) { const skill = hero.skills[key]; if (!skill) continue; model.skills[skill.uuid] = { ...skill, lv: Math.max(0, skill.lv + nextLv - 2), ccd: 0 }; } model.updateSkillDistanceCache(); model.dirty_hp = true; model.dirty_lv = true; oops.message.dispatchEvent(GameEvent.HeroLvUp, { uuid: model.hero_uuid, lv: nextLv }); } private updateHeroNumUI(animate: boolean, isIncrease: boolean) { this.syncMissionHeroData(); if (!animate || !isIncrease) return; this.playHeroNumGainAnim(); } private playHeroNumGainAnim() { if (!this.hero_num_node || !this.hero_num_node.isValid) return; const iconNode = this.hero_num_node.getChildByName("icon"); const numNode = this.hero_num_node.getChildByName("num"); this.playHeroNumNodePop(iconNode, 1.2); this.playHeroNumNodePop(numNode, 1.2); } private playHeroNumDeniedAnim() { if (!this.hero_num_node || !this.hero_num_node.isValid) return; const iconNode = this.hero_num_node.getChildByName("icon"); const numNode = this.hero_num_node.getChildByName("num"); this.playHeroNumNodePop(iconNode, 1.2); this.playHeroNumNodePop(numNode, 1.2); } private playHeroNumNodePop(node: Node | null, scalePeak: number) { this.playNodeScalePop(node, scalePeak, 0.08, 0.1); } private playNodeScaleTo(node: Node | null, scale: number, duration: number) { if (!node || !node.isValid) return; Tween.stopAllByTarget(node); tween(node) .to(duration, { scale: new Vec3(scale, scale, 1) }) .start(); } private playNodeScalePop(node: Node | null, scalePeak: number, toPeakDuration: number, toNormalDuration: number, onPeak?: () => void) { if (!node || !node.isValid) return; Tween.stopAllByTarget(node); node.setScale(1, 1, 1); const seq = tween(node) .to(toPeakDuration, { scale: new Vec3(scalePeak, scalePeak, 1) }); if (onPeak) { seq.call(onPeak); } seq.to(toNormalDuration, { scale: new Vec3(1, 1, 1) }) .start(); } private getMissionData(): any { return smc?.vmdata?.mission_data ?? null; } private getMissionHeroNum(): number { const missionData = this.getMissionData(); return Math.max(0, Math.floor(missionData?.hero_num ?? 0)); } private getMissionHeroMaxNum(): number { return FightSet.HERO_MAX_NUM } private syncMissionHeroData(count?: number) { const missionData = this.getMissionData(); if (!missionData) return; const safeCount = Math.max(0, Math.floor(count ?? this.getAliveHeroCount())); missionData.hero_num = safeCount; } /** 视图对象通过 ecs.Entity.remove(ModuleViewComp) 删除组件是触发组件处理自定义释放逻辑 */ reset() { this.resetButtonScale(this.cards_chou); // 关键：在 reset/销毁 时将 Map 置空，彻底切断引用 this.cardComps = []; this.heroBoxComps = []; this.skillCardComps = []; this.purchasedEquipUuids.clear(); this.purchasedItemUuids.clear(); if (this.node && this.node.isValid) { this.node.destroy(); } } }