tanqiu/assets/scripts/CombatSystem/SkillSelection/SkillManager.ts

import { _decorator, Component, Node } from 'cc';
const { ccclass, property } = _decorator;

/**
 * 技能数据接口
 */
export interface SkillData {
    id: string;
    name: string;
    description: string;
    icon: string;
    maxLevel: number;
    currentLevel: number;
    effects: any;
}

/**
 * 技能效果事件
 */
export interface SkillEffectEvent {
    skillId: string;
    skillLevel: number;
    effectType: string;
    value: number;
}

/**
 * 技能管理器 - 单例模式
 * 负责技能数据管理和效果计算
 */
@ccclass('SkillManager')
export class SkillManager extends Component {
    private static _instance: SkillManager | null = null;
    private _skills: Map<string, SkillData> = new Map();
    private _eventCallbacks: Map<string, Function[]> = new Map();

    public static getInstance(): SkillManager | null {
        return SkillManager._instance;
    }

    onLoad() {
        if (SkillManager._instance === null) {
            SkillManager._instance = this;
        } else {
            this.destroy();
            return;
        }
    }

    onDestroy() {
        if (SkillManager._instance === this) {
            SkillManager._instance = null;
        }
    }

    /**
     * 初始化技能数据
     */
    public initSkills(skillsData: SkillData[]) {
        this._skills.clear();
        skillsData.forEach(skill => {
            this._skills.set(skill.id, { ...skill });
        });
    }

    /**
     * 获取技能等级
     */
    public getSkillLevel(skillId: string): number {
        const skill = this._skills.get(skillId);
        return skill ? skill.currentLevel : 0;
    }

    /**
     * 设置技能等级
     */
    public setSkillLevel(skillId: string, level: number): void {
        const skill = this._skills.get(skillId);
        if (skill) {
            skill.currentLevel = Math.max(0, Math.min(skill.maxLevel, level));
            this.notifySkillChanged(skillId);
        }
    }

    /**
     * 升级技能
     */
    public upgradeSkill(skillId: string): boolean {
        const skill = this._skills.get(skillId);
        if (skill && skill.currentLevel < skill.maxLevel) {
            skill.currentLevel++;
            this.notifySkillChanged(skillId);
            return true;
        }
        return false;
    }

    // ==================== 技能效果计算方法 ====================
    
    /**
     * 便宜单位技能效果 - 计算降价后的价格
     */
    public static calculateCheaperUnitsPrice(originalPrice: number, skillLevel: number): number {
        if (skillLevel <= 0) return originalPrice;
        const reductionRate = skillLevel * 0.1;
        return originalPrice * (1 - reductionRate);
    }

    /**
     * 暴击几率技能效果 - 计算新的暴击率
     */
    public static calculateCritChance(baseCritChance: number, skillLevel: number): number {
        if (skillLevel <= 0) return baseCritChance;
        const bonusCritChance = skillLevel * 0.1;
        return Math.min(1.0, baseCritChance + bonusCritChance);
    }

    /**
     * 暴击伤害计算
     */
    public static calculateCritDamage(baseDamage: number, skillLevel: number): number {
        if (skillLevel <= 0) return baseDamage;
        const critMultiplier = 1 + (skillLevel * 0.1);
        return baseDamage * critMultiplier;
    }

    /**
     * 治疗技能效果 - 计算增加后的生命值
     */
    public static calculateHealBonus(baseHealth: number, skillLevel: number): number {
        if (skillLevel <= 0) return baseHealth;
        const healthBonus = skillLevel * 0.1;
        return Math.floor(baseHealth * (1 + healthBonus));
    }
    
    /**
     * 计算治疗技能的即时治疗量
     */
    public static calculateInstantHeal(maxHealth: number, skillLevel: number): number {
        if (skillLevel <= 0) return 0;
        return Math.floor(maxHealth * 0.1 * skillLevel);
    }
    
    /**
     * 获取治疗技能的最大血量加成
     */
    public static getHealSkillHealthBonus(skillLevel: number): number {
        if (skillLevel <= 0) return 0;
        return skillLevel * 0.1;
    }

    /**
     * 多重射击技能效果 - 计算多射几率
     */
    public static calculateMultiShotChance(baseMultiShotChance: number, skillLevel: number): number {
        if (skillLevel <= 0) return baseMultiShotChance;
        const bonusChance = skillLevel * 0.1;
        return Math.min(1.0, baseMultiShotChance + bonusChance);
    }

    /**
     * 多重射击子弹数量计算
     */
    public static calculateMultiShotBulletCount(baseBulletCount: number, skillLevel: number): number {
        if (skillLevel <= 0) return baseBulletCount;
        return baseBulletCount + Math.floor(skillLevel / 2);
    }

    /**
     * 能量猎手技能效果 - 计算能量值加成
     */
    public static calculateEnergyBonus(baseEnergy: number, skillLevel: number): number {
        if (skillLevel <= 0) return baseEnergy;
        const energyMultiplier = 1 + (skillLevel * 0.1);
        return baseEnergy * energyMultiplier;
    }

    /**
     * 球速提升技能效果 - 计算新的球速
     */
    public static calculateBallSpeed(baseBallSpeed: number, skillLevel: number): number {
        if (skillLevel <= 0) return baseBallSpeed;
        const speedMultiplier = 1 + (skillLevel * 0.1);
        return baseBallSpeed * speedMultiplier;
    }

    /**
     * 检查是否触发暴击
     */
    public static rollCriticalHit(critChance: number): boolean {
        return Math.random() < critChance;
    }

    /**
     * 检查是否触发多重射击
     */
    public static rollMultiShot(multiShotChance: number): boolean {
        return Math.random() < multiShotChance;
    }

    // ==================== 事件系统 ====================
    
    /**
     * 注册技能变化监听
     */
    public onSkillChanged(skillId: string, callback: (skillId: string, level: number) => void): void {
        if (!this._eventCallbacks.has(skillId)) {
            this._eventCallbacks.set(skillId, []);
        }
        this._eventCallbacks.get(skillId)!.push(callback);
    }

    /**
     * 移除技能变化监听
     */
    public offSkillChanged(skillId: string, callback: Function): void {
        const callbacks = this._eventCallbacks.get(skillId);
        if (callbacks) {
            const index = callbacks.indexOf(callback);
            if (index > -1) {
                callbacks.splice(index, 1);
            }
        }
    }

    /**
     * 通知技能变化
     */
    private notifySkillChanged(skillId: string): void {
        const callbacks = this._eventCallbacks.get(skillId);
        const skill = this._skills.get(skillId);
        if (callbacks && skill) {
            callbacks.forEach(callback => {
                callback(skillId, skill.currentLevel);
            });
        }
    }

    /**
     * 获取所有技能数据（用于保存）
     */
    public getAllSkillsData(): SkillData[] {
        return Array.from(this._skills.values());
    }
}