tanqiu/assets/scripts/ConfigManager.ts

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

// 武器配置接口
export interface WeaponConfig {
    id: string;
    name: string;
    type: string;
    rarity: string;
    weight: number;
    stats: {
        damage: number;
        fireRate: number;
        range: number;
        bulletSpeed: number;
        penetration: number;
        accuracy: number;
        explosionRadius?: number;
        explosionDamage?: number;
        burnDuration?: number;
        burnDamage?: number;
        returnSpeed?: number;
        homingStrength?: number;
    };
    bulletConfig: {
        bulletType: string;
        bulletPrefab: string;
        hitEffect: string;
        trailEffect?: string;
        ricochetCount?: number;
        ricochetAngle?: number;
        explosionDelay?: number;
        burnEffect?: string;
        arcHeight?: number;
        returnDelay?: number;
        homingDelay?: number;
    };
    attackPattern: {
        type: string;
        projectileCount: number;
        spreadAngle: number;
        burstCount: number;
        burstDelay: number;
    };
    visualConfig: {
        weaponSprites: {
            [size: string]: string;
        };
        muzzleFlash: string;
        fireSound: string;
    };
}

// 敌人配置接口
export interface EnemyConfig {
    id: string;
    name: string;
    type: string;
    rarity: string;
    weight: number;
    stats: {
        health: number;
        speed: number;
        damage: number;
        attackRange: number;
        attackSpeed: number;
        defense: number;
        coinReward: number;
        explosionDamage?: number;
        explosionRadius?: number;
    };
    movement: {
        type: string;
        pattern: string;
        speedVariation: number;
        swayAmplitude?: number;
        swayFrequency?: number;
    };
    combat: {
        attackType: string;
        attackDelay: number;
        attackCooldown: number;
        weaponType?: string;
        projectileType?: string;
        projectileSpeed?: number;
        canBlock: boolean;
        blockChance: number;
    };
    visualConfig: {
        spritePrefab: string;
        animations: {
            [state: string]: string;
        };
        scale: number;
        flipX: boolean;
        weapon?: string;
        armor?: string;
        prop?: string;
    };
    audioConfig: {
        [sound: string]: string;
    };
    specialAbilities: string[];
    stealthConfig?: {
        stealthDuration: number;
        stealthCooldown: number;
        revealOnAttack: boolean;
        visibilityAlpha: number;
    };
    armorConfig?: {
        armorHealth: number;
        armorReduction: number;
        breakThreshold: number;
    };
    explosionConfig?: {
        explosionDelay: number;
        explosionEffect: string;
        damageRadius: number;
        knockbackForce: number;
    };
    bossConfig?: {
        phases: number;
        phaseHealthThreshold: number;
        enrageBonus?: {
            speed: number;
            damage: number;
            attackSpeed: number;
        };
        summonAbility?: {
            minionType: string;
            summonCount: number;
            summonCooldown: number;
        };
        laserAbility?: {
            damage: number;
            range: number;
            chargeTime: number;
            cooldown: number;
        };
    };
    projectileConfig?: {
        bulletPrefab: string;
        hitEffect: string;
        trailEffect?: string;
    };
}

@ccclass('ConfigManager')
export class ConfigManager extends Component {
    private static instance: ConfigManager = null;
    
    private weaponsConfig: any = null;
    private enemiesConfig: any = null;
    private configLoaded: boolean = false;
    
    // 武器权重缓存
    private weaponWeightedList: WeaponConfig[] = [];
    // 敌人权重缓存
    private enemyWeightedList: EnemyConfig[] = [];

    onLoad() {
        console.log('ConfigManager onLoad()');
        
        if (ConfigManager.instance === null) {
            ConfigManager.instance = this;
            console.log('ConfigManager 单例创建成功');
            this.loadConfigs();
        } else if (ConfigManager.instance !== this) {
            console.log('ConfigManager 单例已存在，销毁当前实例');
            this.destroy();
            return;
        }
    }

    onDestroy() {
        if (ConfigManager.instance === this) {
            ConfigManager.instance = null;
        }
    }

    public static getInstance(): ConfigManager {
        return ConfigManager.instance;
    }

    // 加载所有配置文件
    private async loadConfigs() {
        console.log('开始加载配置文件...');
        this.configLoaded = false;
        
        try {
            // 加载武器配置
            await this.loadWeaponsConfig();
            // 加载敌人配置
            await this.loadEnemiesConfig();
            
            this.configLoaded = true;
            console.log('✅ 所有配置文件加载完成');
            console.log('武器数量:', this.weaponsConfig?.weapons?.length || 0);
            console.log('敌人数量:', this.enemiesConfig?.enemies?.length || 0);
        } catch (error) {
            console.error('❌ 配置文件加载失败:', error);
            this.configLoaded = false;
        }
    }

    // 加载武器配置
    private loadWeaponsConfig(): Promise<void> {
        return new Promise((resolve, reject) => {
            console.log('加载武器配置...');
            resources.load('data/weapons', JsonAsset, (err, asset) => {
                if (err) {
                    console.error('武器配置文件加载失败:', err);
                    reject(err);
                    return;
                }
                
                if (!asset || !asset.json) {
                    console.error('武器配置文件内容为空');
                    reject(new Error('武器配置文件内容为空'));
                    return;
                }
                
                this.weaponsConfig = asset.json as any;
                console.log('✅ 武器配置加载成功');
                this.buildWeaponWeightedList();
                resolve();
            });
        });
    }

    // 加载敌人配置
    private loadEnemiesConfig(): Promise<void> {
        return new Promise((resolve, reject) => {
            console.log('加载敌人配置...');
            resources.load('data/enemies', JsonAsset, (err, asset) => {
                if (err) {
                    console.error('敌人配置文件加载失败:', err);
                    reject(err);
                    return;
                }
                
                if (!asset || !asset.json) {
                    console.error('敌人配置文件内容为空');
                    reject(new Error('敌人配置文件内容为空'));
                    return;
                }

                this.enemiesConfig = asset.json as any;
                console.log('✅ 敌人配置加载成功');
                this.buildEnemyWeightedList();
                resolve();
            });
        });
    }

    // 构建武器权重列表
    private buildWeaponWeightedList() {
        if (!this.weaponsConfig) return;
        
        this.weaponWeightedList = [];
        this.weaponsConfig.weapons.forEach(weapon => {
            // 根据权重添加多次到列表中
            for (let i = 0; i < weapon.weight; i++) {
                this.weaponWeightedList.push(weapon);
            }
        });
        
        console.log('武器权重列表构建完成，总权重:', this.weaponWeightedList.length);
    }

    // 构建敌人权重列表
    private buildEnemyWeightedList() {
        if (!this.enemiesConfig) return;
        
        this.enemyWeightedList = [];
        this.enemiesConfig.enemies.forEach(enemy => {
            // 根据权重添加多次到列表中
            for (let i = 0; i < enemy.weight; i++) {
                this.enemyWeightedList.push(enemy);
            }
        });
        
        console.log('敌人权重列表构建完成，总权重:', this.enemyWeightedList.length);
    }

    // 随机获取武器配置
    public getRandomWeapon(rarity?: string): WeaponConfig | null {
        if (!this.weaponsConfig || this.weaponWeightedList.length === 0) {
            console.warn('武器配置未加载或为空');
            return null;
        }

        if (rarity) {
            // 按稀有度筛选
            const filteredWeapons = this.weaponsConfig.weapons.filter(weapon => weapon.rarity === rarity);
            if (filteredWeapons.length === 0) {
                console.warn(`没有找到稀有度为 ${rarity} 的武器`);
                return null;
            }
            const randomIndex = Math.floor(Math.random() * filteredWeapons.length);
            return filteredWeapons[randomIndex];
        }

        // 从权重列表中随机选择
        const randomIndex = Math.floor(Math.random() * this.weaponWeightedList.length);
        return this.weaponWeightedList[randomIndex];
    }

    // 随机获取敌人配置
    public getRandomEnemy(rarity?: string): EnemyConfig | null {
        if (!this.enemiesConfig || this.enemyWeightedList.length === 0) {
            console.warn('敌人配置未加载或为空');
            return null;
        }

        if (rarity) {
            // 按稀有度筛选
            const filteredEnemies = this.enemiesConfig.enemies.filter(enemy => enemy.rarity === rarity);
            if (filteredEnemies.length === 0) {
                console.warn(`没有找到稀有度为 ${rarity} 的敌人`);
                return null;
            }
            const randomIndex = Math.floor(Math.random() * filteredEnemies.length);
            return filteredEnemies[randomIndex];
        }

        // 从权重列表中随机选择
        const randomIndex = Math.floor(Math.random() * this.enemyWeightedList.length);
        return this.enemyWeightedList[randomIndex];
    }

    // 根据ID获取武器配置
    public getWeaponById(id: string): WeaponConfig | null {
        if (!this.weaponsConfig) return null;
        return this.weaponsConfig.weapons.find(weapon => weapon.id === id) || null;
    }

    // 根据ID获取敌人配置
    public getEnemyById(id: string): EnemyConfig | null {
        if (!this.enemiesConfig) return null;
        return this.enemiesConfig.enemies.find(enemy => enemy.id === id) || null;
    }

    // 获取所有武器配置
    public getAllWeapons(): WeaponConfig[] {
        return this.weaponsConfig?.weapons || [];
    }

    // 获取所有敌人配置
    public getAllEnemies(): EnemyConfig[] {
        return this.enemiesConfig?.enemies || [];
    }

    // 根据稀有度获取武器列表
    public getWeaponsByRarity(rarity: string): WeaponConfig[] {
        if (!this.weaponsConfig) return [];
        return this.weaponsConfig.weapons.filter(weapon => weapon.rarity === rarity);
    }

    // 根据稀有度获取敌人列表
    public getEnemiesByRarity(rarity: string): EnemyConfig[] {
        if (!this.enemiesConfig) return [];
        return this.enemiesConfig.enemies.filter(enemy => enemy.rarity === rarity);
    }

    // 获取方块尺寸列表
    public getBlockSizes(): string[] {
        return this.weaponsConfig?.blockSizes || ['1x1', '1x2', '2x1', '2x2'];
    }

    // 获取波次进展配置
    public getWaveProgression(): any {
        return this.enemiesConfig?.waveProgression || {};
    }

    // 根据波次获取合适的敌人
    public getEnemyForWave(waveNumber: number): EnemyConfig | null {
        if (!this.enemiesConfig) return null;
        
        const progression = this.enemiesConfig.waveProgression;
        let enemyPool: string[] = [];
        
        if (waveNumber <= 5) {
            enemyPool = progression.earlyWaves || [];
        } else if (waveNumber <= 15) {
            enemyPool = [...(progression.earlyWaves || []), ...(progression.midWaves || [])];
        } else if (waveNumber <= 25) {
            enemyPool = [...(progression.midWaves || []), ...(progression.lateWaves || [])];
        } else {
            enemyPool = [...(progression.lateWaves || []), ...(progression.bossWaves || [])];
        }
        
        if (enemyPool.length === 0) {
            return this.getRandomEnemy();
        }
        
        const randomId = enemyPool[Math.floor(Math.random() * enemyPool.length)];
        return this.getEnemyById(randomId);
    }

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