tanqiu/assets/scripts/FourUI/SkillSystem/SkillConfigManager.ts

import { _decorator, Component, resources, JsonAsset } from 'cc';
import { BundleLoader } from '../../Core/BundleLoader';
const { ccclass, property } = _decorator;

/**
 * 技能类型配置接口
 */
export interface SkillTypeConfig {
    id: number;
    name: string;
    displayName: string;
    nameTemplate: string;
    type: string;
}

/**
 * 技能组配置接口
 */
export interface SkillGroupConfig {
    group: number;
    effectPercent: number;
    diamondCost: number;
}

/**
 * 技能配置数据接口
 */
export interface SkillConfig {
    skillTypes: SkillTypeConfig[];
    skillGroups: SkillGroupConfig[];
    totalGroups: number;
    skillsPerGroup: number;
}

/**
 * 技能配置管理器 - 单例模式
 * 负责加载和管理技能配置数据
 */
@ccclass('SkillConfigManager')
export class SkillConfigManager extends Component {
    private static _instance: SkillConfigManager | null = null;
    private _skillConfig: SkillConfig | null = null;
    private _isLoaded: boolean = false;

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

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

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

    /**
     * 加载技能配置
     */
    private async loadSkillConfig() {
        try {
            const bundleLoader = BundleLoader.getInstance();
            const skillConfigData = await bundleLoader.loadDataJson('skill_config');
            
            if (!skillConfigData) {
                console.error('技能配置文件内容为空');
                this.createDefaultConfig();
                return;
            }

            this._skillConfig = skillConfigData.json as SkillConfig;
            this._isLoaded = true;
            console.log('技能配置加载成功:', this._skillConfig);
        } catch (error) {
            console.error('加载技能配置失败:', error);
            this.createDefaultConfig();
        }
    }

    /**
     * 创建默认配置（当JSON加载失败时使用）
     */
    private createDefaultConfig() {
        console.log('使用默认技能配置');
        this._skillConfig = {
            skillTypes: [
                {
                    id: 0,
                    name: "Damage",
                    displayName: "伤害",
                    nameTemplate: "Damage +{}%",
                    type: "damage"
                },
                {
                    id: 1,
                    name: "Ball Speed",
                    displayName: "球速",
                    nameTemplate: "Ball Speed +{}%",
                    type: "ball_speed"
                },
                {
                    id: 2,
                    name: "Crit Damage",
                    displayName: "暴击伤害",
                    nameTemplate: "Crit Damage +{}%",
                    type: "crit_damage"
                }
            ],
            skillGroups: [],
            totalGroups: 12,
            skillsPerGroup: 3
        };

        // 生成默认的技能组配置
        for (let group = 1; group <= 12; group++) {
            this._skillConfig.skillGroups.push({
                group: group,
                effectPercent: group * 5,
                diamondCost: 10 + (group - 1) * 10
            });
        }

        this._isLoaded = true;
    }

    /**
     * 获取技能配置
     */
    public getSkillConfig(): SkillConfig | null {
        return this._skillConfig;
    }

    /**
     * 检查配置是否已加载
     */
    public isLoaded(): boolean {
        return this._isLoaded;
    }

    /**
     * 获取技能类型配置
     */
    public getSkillTypeConfig(skillIndex: number): SkillTypeConfig | null {
        if (!this._skillConfig || skillIndex < 0 || skillIndex >= this._skillConfig.skillTypes.length) {
            return null;
        }
        return this._skillConfig.skillTypes[skillIndex];
    }

    /**
     * 获取技能组配置
     */
    public getSkillGroupConfig(group: number): SkillGroupConfig | null {
        if (!this._skillConfig) {
            return null;
        }
        return this._skillConfig.skillGroups.find(config => config.group === group) || null;
    }

    /**
     * 获取技能名称
     */
    public getSkillName(skillIndex: number, group: number): string {
        const skillTypeConfig = this.getSkillTypeConfig(skillIndex);
        const skillGroupConfig = this.getSkillGroupConfig(group);
        
        if (!skillTypeConfig || !skillGroupConfig) {
            return `Unknown Skill ${skillIndex + 1}`;
        }

        return skillTypeConfig.nameTemplate.replace('{}', skillGroupConfig.effectPercent.toString());
    }

    /**
     * 获取技能消耗
     */
    public getSkillCost(group: number): number {
        const skillGroupConfig = this.getSkillGroupConfig(group);
        return skillGroupConfig ? skillGroupConfig.diamondCost : 0;
    }

    /**
     * 获取技能效果百分比
     */
    public getSkillEffectPercent(group: number): number {
        const skillGroupConfig = this.getSkillGroupConfig(group);
        return skillGroupConfig ? skillGroupConfig.effectPercent : 0;
    }

    /**
     * 获取技能类型字符串
     */
    public getSkillType(skillIndex: number): string {
        const skillTypeConfig = this.getSkillTypeConfig(skillIndex);
        return skillTypeConfig ? skillTypeConfig.type : 'unknown';
    }

    /**
     * 获取技能显示名称
     */
    public getSkillDisplayName(skillIndex: number): string {
        const skillTypeConfig = this.getSkillTypeConfig(skillIndex);
        return skillTypeConfig ? skillTypeConfig.displayName : '未知技能';
    }

    /**
     * 获取总组数
     */
    public getTotalGroups(): number {
        return this._skillConfig ? this._skillConfig.totalGroups : 12;
    }

    /**
     * 获取每组技能数
     */
    public getSkillsPerGroup(): number {
        return this._skillConfig ? this._skillConfig.skillsPerGroup : 3;
    }

    /**
     * 等待配置加载完成
     */
    public async waitForLoad(): Promise<void> {
        return new Promise((resolve) => {
            if (this._isLoaded) {
                resolve();
                return;
            }

            const checkLoaded = () => {
                if (this._isLoaded) {
                    resolve();
                } else {
                    setTimeout(checkLoaded, 50);
                }
            };
            checkLoaded();
        });
    }
}