tanqiu/assets/scripts/CombatSystem/Wall.ts

import { _decorator, Component, Node, Label, find } from 'cc';
import { SaveDataManager } from '../LevelSystem/SaveDataManager';
import EventBus, { GameEvents } from '../Core/EventBus';

import { SkillManager } from './SkillSelection/SkillManager';
const { ccclass, property } = _decorator;

/**
 * 墙体组件
 * 负责管理墙体的血量、伤害处理、等级升级等功能
 */
@ccclass('Wall')
export class Wall extends Component {
    
    @property({
        type: Node,
        tooltip: '血量显示节点 (HeartLabel)'
    })
    public heartLabelNode: Node = null;

    // === 私有属性 ===
    private currentHealth: number = 100;
    private heartLabel: Label = null;
    private saveDataManager: SaveDataManager = null;

    // 墙体等级血量映射
    private wallHpMap: Record<number, number> = {
        1: 100,
        2: 1000,
        3: 1200,
        4: 1500,
        5: 2000
    };

    start() {
        this.initializeWall();
    }

    /**
     * 初始化墙体
     */
    private initializeWall() {
        // 初始化存档管理器
        this.saveDataManager = SaveDataManager.getInstance();
        if (!this.saveDataManager) {
            console.error('[Wall] SaveDataManager not found');
            return;
        }

        // 查找血量显示节点
        this.findHeartLabelNode();
        
        // 从存档读取墙体血量
        this.loadWallHealthFromSave();
        
        // 初始化血量显示
        this.updateHealthDisplay();
        
        // 监听治疗技能变化
        this.setupSkillListeners();
        
        // 设置事件监听器
        this.setupEventListeners();
    }

    /**
     * 查找血量显示节点
     */
    private findHeartLabelNode() {
        // 查找心血显示节点
        if (!this.heartLabelNode) {
            this.heartLabelNode = find('Canvas-001/TopArea/HeartNode/HeartLabeld') || find('Canvas/GameLevelUI/HeartNode/HeartLabeld');
        }
        
        if (this.heartLabelNode) {
            this.heartLabel = this.heartLabelNode.getComponent(Label);
        }
    }

    /**
     * 从存档加载墙体血量
     */
    private loadWallHealthFromSave() {
        const pd = this.saveDataManager.getPlayerData();
        if (pd && typeof pd.wallBaseHealth === 'number') {
            this.currentHealth = pd.wallBaseHealth;
        } else {
            // 如果没有存档数据，使用默认血量
            this.currentHealth = this.getWallHealthByLevel(1);
        }
        
        // 确保当前血量不超过最大血量（考虑技能加成）
        const maxHealth = this.getMaxHealth();
        if (this.currentHealth > maxHealth) {
            this.currentHealth = maxHealth;
        }
    }

    /**
     * 墙体受到伤害
     */
    public takeDamage(damage: number) {
        if (damage <= 0) return;

        const previousHealth = this.currentHealth;
        this.currentHealth = Math.max(0, this.currentHealth - damage);
        
        // 触发受到伤害事件
        const eventBus = EventBus.getInstance();
        eventBus.emit(GameEvents.WALL_TAKE_DAMAGE, {
            damage: damage,
            previousHealth: previousHealth,
            currentHealth: this.currentHealth
        });
        
        // 触发血量变化事件
        eventBus.emit(GameEvents.WALL_HEALTH_CHANGED, {
            previousHealth: previousHealth,
            currentHealth: this.currentHealth,
            maxHealth: this.getMaxHealth()
        });
        
        // 更新血量显示
        this.updateHealthDisplay();
        
        console.log(`[Wall] 墙体受到伤害: ${damage}, 当前血量: ${this.currentHealth}`);
        
        // 检查墙体是否被摧毁
        if (this.currentHealth <= 0) {
            this.onWallDestroyed();
        }
    }

    /**
     * 墙体被摧毁时的处理
     */
    private onWallDestroyed() {
        console.log('[Wall] 墙体被摧毁，触发游戏失败');
        
        // 通过事件系统触发墙体被摧毁事件
        const eventBus = EventBus.getInstance();
        eventBus.emit(GameEvents.WALL_DESTROYED, {
            finalHealth: this.currentHealth,
            maxHealth: this.getMaxHealth()
        });
        
        // 触发游戏失败
        eventBus.emit(GameEvents.GAME_DEFEAT);
    }

    /**
     * 更新血量显示
     */
    public updateHealthDisplay() {
        if (this.heartLabel) {
            this.heartLabel.string = Math.floor(this.currentHealth).toString();
        }
    }

    /**
     * 设置墙体血量
     */
    public setHealth(health: number) {
        const previousHealth = this.currentHealth;
        this.currentHealth = Math.max(0, health);
        
        // 如果血量发生变化，触发血量变化事件
        if (previousHealth !== this.currentHealth) {
            const eventBus = EventBus.getInstance();
            eventBus.emit(GameEvents.WALL_HEALTH_CHANGED, {
                previousHealth: previousHealth,
                currentHealth: this.currentHealth,
                maxHealth: this.getMaxHealth()
            });
        }
        
        this.updateHealthDisplay();
    }

    /**
     * 获取当前墙体血量
     */
    public getCurrentHealth(): number {
        return this.currentHealth;
    }

    /**
     * 获取最大血量（基于当前等级和技能加成）
     */
    public getMaxHealth(): number {
        const currentLevel = this.getCurrentWallLevel();
        const baseMaxHealth = this.getWallHealthByLevel(currentLevel);
        
        // 应用治疗技能的最大血量加成
        const skillManager = SkillManager.getInstance();
        if (skillManager) {
            const healSkillLevel = skillManager.getSkillLevel('heal');
            const healthBonus = SkillManager.getHealSkillHealthBonus(healSkillLevel);
            return Math.floor(baseMaxHealth * (1 + healthBonus));
        }
        
        return baseMaxHealth;
    }

    /**
     * 根据等级获取墙体血量
     */
    public getWallHealthByLevel(level: number): number {
        return this.wallHpMap[level] || (100 + (level - 1) * 200);
    }

    /**
     * 获取当前墙壁等级
     */
    public getCurrentWallLevel(): number {
        return this.saveDataManager?.getWallLevel() || 1;
    }

    /**
     * 升级墙体等级
     * 返回升级后信息，失败返回null
     */
    public upgradeWallLevel(): { currentLevel: number; currentHp: number; nextLevel: number; nextHp: number } | null {
        if (!this.saveDataManager) return null;

        // 检查是否可以升级
        if (!this.saveDataManager.canUpgradeWall()) return null;

        // 获取升级费用并扣除金币
        const cost = this.saveDataManager.getWallUpgradeCost();
        if (!this.saveDataManager.spendMoney(cost)) return null;

        // 执行升级
        if (!this.saveDataManager.upgradeWallLevel()) return null;

        const newLvl = this.saveDataManager.getWallLevel();
        const baseNewHp = this.getWallHealthByLevel(newLvl);
        const actualNewHp = this.getWallHealthByLevel(newLvl); // 使用当前等级的基础血量

        // 更新内存中的数值为当前等级的基础血量
        this.currentHealth = actualNewHp;
        this.updateHealthDisplay();

        return {
            currentLevel: newLvl,
            currentHp: actualNewHp,
            nextLevel: newLvl + 1,
            nextHp: this.getWallHealthByLevel(newLvl + 1) // 这里返回基础血量用于显示
        };
    }

    /**
     * 恢复墙体血量
     */
    public heal(amount: number) {
        const previousHealth = this.currentHealth;
        const maxHealth = this.getMaxHealth();
        this.currentHealth = Math.min(maxHealth, this.currentHealth + amount);
        
        // 如果血量发生变化，触发血量变化事件
        if (previousHealth !== this.currentHealth) {
            const eventBus = EventBus.getInstance();
            eventBus.emit(GameEvents.WALL_HEALTH_CHANGED, {
                previousHealth: previousHealth,
                currentHealth: this.currentHealth,
                maxHealth: maxHealth,
                healAmount: this.currentHealth - previousHealth
            });
        }
        
        this.updateHealthDisplay();
    }

    /**
     * 重置墙体血量到满血
     */
    public resetToFullHealth() {
        this.currentHealth = this.getMaxHealth();
        this.updateHealthDisplay();
    }

    /**
     * 获取血量百分比
     */
    public getHealthPercentage(): number {
        const maxHealth = this.getMaxHealth();
        return maxHealth > 0 ? this.currentHealth / maxHealth : 0;
    }

    /**
     * 检查墙体是否存活
     */
    public isAlive(): boolean {
        return this.currentHealth > 0;
    }
    
    /**
     * 设置事件监听器
     */
    private setupEventListeners() {
        const eventBus = EventBus.getInstance();
        
        // 监听重置墙体血量事件
        eventBus.on(GameEvents.RESET_WALL_HEALTH, this.onResetWallHealthEvent, this);
        
        // 监听墙体血量变化事件（用于升级后更新显示）
        eventBus.on(GameEvents.WALL_HEALTH_CHANGED, this.onWallHealthChangedEvent, this);
    }
    
    /**
     * 处理重置墙体血量事件
     */
    private onResetWallHealthEvent() {
        console.log('[Wall] 接收到重置墙体血量事件，重置到满血');
        this.resetToFullHealth();
    }
    
    /**
     * 处理墙体血量变化事件（用于升级后更新）
     */
    private onWallHealthChangedEvent(eventData?: any) {
        console.log('[Wall] 接收到墙体血量变化事件，重新加载血量数据');
        
        // 重新从存档加载墙体血量（升级后血量会更新）
        this.loadWallHealthFromSave();
        
        // 更新显示
        this.updateHealthDisplay();
    }
    
    /**
     * 设置技能监听器
     */
    private setupSkillListeners() {
        const skillManager = SkillManager.getInstance();
        if (skillManager) {
            // 监听治疗技能变化
            skillManager.onSkillChanged('heal', this.onHealSkillChanged.bind(this));
        }
    }
    
    /**
     * 治疗技能变化回调
     */
    private onHealSkillChanged(skillId: string, level: number) {
        console.log(`[Wall] 治疗技能等级变化: ${level}`);
        
        // 技能升级时，墙体最大血量可能增加，需要更新显示
        this.updateHealthDisplay();
        
        // 如果当前血量低于新的最大血量，可以考虑给予一些额外治疗
        // 这里暂时不做额外处理，因为SkillSelectionController已经处理了即时治疗
    }
    
    /**
     * 清理技能监听器
     */
    private cleanupSkillListeners() {
        const skillManager = SkillManager.getInstance();
        if (skillManager) {
            skillManager.offSkillChanged('heal', this.onHealSkillChanged.bind(this));
        }
    }
    
    onDestroy() {
        // 清理事件监听
        const eventBus = EventBus.getInstance();
        eventBus.off(GameEvents.RESET_WALL_HEALTH, this.onResetWallHealthEvent, this);
        eventBus.off(GameEvents.WALL_HEALTH_CHANGED, this.onWallHealthChangedEvent, this);
        
        this.cleanupSkillListeners();
    }
}