heros/assets/script/game/map/RogueConfig.ts

/**
 * 肉鸽模式配置脚本 - 简化版
 * 
 * 功能说明：
 * - 提供基于怪物类型的属性加成配置
 * - 使用Attrs枚举定义属性增强
 * - 供游戏系统调用获取怪物增强数据
 * 
 * @author 游戏开发团队
 * @version 3.0 简化版
 * @date 2025-07-12
 */

import { QualitySet } from "../common/config/BoxSet";
import { Attrs } from "../common/config/SkillSet";
import { getMonList } from "../common/config/heroSet";

/**
 * 怪物类型枚举
 */
export enum MonsterType {
    NORMAL = "normal",    // 普通怪物
    ELITE = "elite",      // 精英怪物
    BOSS = "boss"         // Boss怪物
}

/**
 * 怪物类型增强属性个数配置
 */
export const MonsterEnhancementCountConfig = {
    [MonsterType.NORMAL]: 0,   // 普通怪物：0个增强属性
    [MonsterType.ELITE]: 1,    // 精英怪物：1个增强属性
    [MonsterType.BOSS]: 2      // Boss怪物：2个增强属性
};

/**
 * 关卡类型枚举
 */
export enum StageType {
    NORMAL = "normal",      // 普通关卡（1-4关）
    ELITE = "elite",        // 精英关卡（5关）
    BOSS = "boss"          // Boss关卡（10关）
}

/**
 * 关卡配置数据接口
 */
export interface StageConfig {
    stageNumber: number;
    stageType: StageType;
    description: string;
    monsters: Array<{
        type: MonsterType;
        count: number;
    }>;
}

/**
 * 关卡配置规则
 */
export const StageConfigRules = {
    // 普通关卡（1-4关）
    [StageType.NORMAL]: {
        description: "普通关卡",
        monsters: [
            { type: MonsterType.NORMAL, count: 5 }  // 5个小怪
        ]
    },
    
    // 精英关卡（5关）
    [StageType.ELITE]: {
        description: "精英关卡", 
        monsters: [
            { type: MonsterType.ELITE, count: 2 },   // 2个精英
            { type: MonsterType.NORMAL, count: 3 }   // 3个小怪
        ]
    },
    
    // Boss关卡（10关）
    [StageType.BOSS]: {
        description: "Boss关卡",
        monsters: [
            { type: MonsterType.BOSS, count: 1 },    // 1个Boss
            { type: MonsterType.ELITE, count: 2 },   // 2个精英
            { type: MonsterType.NORMAL, count: 2 }   // 2个小怪
        ]
    }
};

/**
 * 可用的增强属性池
 * 按权重排序，数值越大优先级越高
 */
export const AvailableEnhancementPool = [
    { buffType: Attrs.HP_MAX, weight: 10, baseValue: 80, name: "生命值增强" },
    { buffType: Attrs.AP, weight: 9, baseValue: 50, name: "攻击力增强" },
    { buffType: Attrs.CRITICAL, weight: 8, baseValue: 30, name: "暴击率增强" },
    { buffType: Attrs.DEF, weight: 7, baseValue: 40, name: "防御增强" },
    { buffType: Attrs.CRITICAL_DMG, weight: 6, baseValue: 60, name: "暴击伤害增强" },
    { buffType: Attrs.DODGE, weight: 5, baseValue: 25, name: "闪避增强" },
    { buffType: Attrs.AS, weight: 4, baseValue: 20, name: "攻击速度增强" },
    { buffType: Attrs.LIFESTEAL, weight: 3, baseValue: 15, name: "吸血" },
];

/**
 * 基于怪物类型的基础配置
 */
export const MonsterTypeBaseConfig = {
    [MonsterType.NORMAL]: {
        name: "普通怪物",
        description: "基础属性无增强"
    },
    [MonsterType.ELITE]: {
        name: "精英怪物", 
        description: "单一属性增强"
    },
    [MonsterType.BOSS]: {
        name: "Boss怪物",
        description: "双重属性增强"
    }
};

/**
 * 怪物增强数据接口
 */
export interface MonsterEnhancementData {
    name: string;
    description: string;
    buffs: { [key in Attrs]?: number };
    buffList: Array<{ buffType: Attrs; value: number; name: string }>;
}

/**
 * 根据权重随机选择增强属性
 * @param count 需要选择的属性个数
 * @param excludeTypes 排除的属性类型
 * @returns 选中的增强属性数组
 */
export function selectRandomEnhancements(count: number, excludeTypes: Attrs[] = []): Array<{buffType: Attrs, weight: number, baseValue: number, name: string}> {
    if (count <= 0) return [];
    
    // 过滤掉排除的属性类型
    const availablePool = AvailableEnhancementPool.filter(item => !excludeTypes.includes(item.buffType));
    
    if (availablePool.length === 0) return [];
    
    const selectedEnhancements = [];
    const usedTypes = new Set<Attrs>();
    
    for (let i = 0; i < count && i < availablePool.length; i++) {
        // 计算权重总和
        const totalWeight = availablePool
            .filter(item => !usedTypes.has(item.buffType))
            .reduce((sum, item) => sum + item.weight, 0);
        
        if (totalWeight === 0) break;
        
        // 随机选择
        let randomValue = Math.random() * totalWeight;
        
        for (const enhancement of availablePool) {
            if (usedTypes.has(enhancement.buffType)) continue;
            
            randomValue -= enhancement.weight;
            if (randomValue <= 0) {
                selectedEnhancements.push(enhancement);
                usedTypes.add(enhancement.buffType);
                break;
            }
        }
    }
    
    return selectedEnhancements;
}

/**
 * 获取怪物类型的属性加成配置
 * @param monsterType 怪物类型
 * @param useRandom 是否使用随机生成（默认true）
 * @returns 属性加成配置，包含buffs字段
 */
export function getMonsterEnhancement(monsterType: MonsterType, useRandom: boolean = true): MonsterEnhancementData {
    const baseConfig = MonsterTypeBaseConfig[monsterType];
    const enhancementCount = MonsterEnhancementCountConfig[monsterType];
    
    let selectedEnhancements: Array<{buffType: Attrs, weight: number, baseValue: number, name: string}> = [];
    
    if (useRandom) {
        // 随机生成增强属性
        selectedEnhancements = selectRandomEnhancements(enhancementCount);
    } else {
        // 使用固定的最高权重属性
        selectedEnhancements = AvailableEnhancementPool
            .slice(0, enhancementCount)
            .map(item => ({...item}));
    }
    
    // 构建buffs对象
    const buffs: { [key in Attrs]?: number } = {};
    const buffList: Array<{ buffType: Attrs; value: number; name: string }> = [];
    
    selectedEnhancements.forEach(enhancement => {
        buffs[enhancement.buffType] = enhancement.baseValue;
        buffList.push({
            buffType: enhancement.buffType,
            value: enhancement.baseValue,
            name: enhancement.name
        });
    });
        
        return {
        name: baseConfig.name,
        description: `${baseConfig.description} (${enhancementCount}个属性)`,
        buffs: buffs,
        buffList: buffList
        };
    }
    
    /**
 * 根据关卡号和等级判断关卡类型
 * @param stageNumber 关卡号（从1开始）
 * @param level 等级（1-5）
 * @returns 关卡类型
 */
export function getStageType(stageNumber: number, level: number = 1): StageType {
    // 第10关的特殊规则
    if (stageNumber % 10 === 0) {
        if (level === 5) {
            return StageType.BOSS;      // 第10关第5级为Boss关
        } else if (level === 4) {
            return StageType.ELITE;     // 第10关第4级为精英关
        } else {
            return StageType.NORMAL;    // 第10关1-3级为普通关
        }
    }
    // 1-9关的规则
    else {
        if (level === 5) {
            return StageType.ELITE;     // 1-9关第5级为精英关
        } else {
            return StageType.NORMAL;    // 1-9关1-4级为普通关
        }
    }
}

/**
 * 生成关卡配置
 * @param stageNumber 关卡号（从1开始）
 * @param level 等级（1-5）
 * @returns MonsterType数组格式
 */
export function generateStageConfig(stageNumber: number, level: number = 1): MonsterType[] {
    const stageType = getStageType(stageNumber, level);
    const rule = StageConfigRules[stageType];
    const monsterArray: MonsterType[] = [];
    
    // 根据配置生成怪物类型数组
    rule.monsters.forEach(monsterGroup => {
        for (let i = 0; i < monsterGroup.count; i++) {
            monsterArray.push(monsterGroup.type);
        }
    });
    
    return monsterArray;
}

/**
 * 根据怪物类型获取对应品质的怪物UUID数组
 * @param monsterType 怪物类型
 * @returns 怪物UUID数组
 */
export function getMonsterUUIDsByType(monsterType: MonsterType): number[] {
    switch (monsterType) {
        case MonsterType.NORMAL:
            return getMonList(QualitySet.GREEN);  // 绿色品质为普通怪物
        case MonsterType.ELITE:
            return getMonList(QualitySet.BLUE);   // 蓝色品质为精英怪物
        case MonsterType.BOSS:
            // 紫色及以上品质为Boss怪物
            const purpleMonsters = getMonList(QualitySet.PURPLE);
            const orangeMonsters = getMonList(QualitySet.ORANGE);
            return [...purpleMonsters, ...orangeMonsters];
        default:
            return [];
    }
}

/**
 * 获取当前关卡对应的所有怪物UUID数组
 * @param stageNumber 关卡号
 * @param level 等级（1-5）
 * @returns 怪物UUID数组，按关卡配置顺序排列
 */
export function getStageMonsterUUIDs(stageNumber: number, level: number = 1): number[] {
    const monsterTypes = generateStageConfig(stageNumber, level);
    const monsterUUIDs: number[] = [];
    
    monsterTypes.forEach(monsterType => {
        const availableUUIDs = getMonsterUUIDsByType(monsterType);
        if (availableUUIDs.length > 0) {
            // 随机选择一个该类型的怪物
            const randomUUID = availableUUIDs[Math.floor(Math.random() * availableUUIDs.length)];
            monsterUUIDs.push(randomUUID);
        }
    });
    
    return monsterUUIDs;
}

/**
 * 获取关卡怪物配置（包含UUID和增强属性）
 * @param stageNumber 关卡号
 * @param level 等级（1-5）
 * @param useRandomBuff 是否使用随机buff
 * @returns 完整的怪物配置数组
 */
export function getStageMonsterConfigs(stageNumber: number, level: number = 1, useRandomBuff: boolean = true) {
    const monsterTypes = generateStageConfig(stageNumber, level);
    const stageMultipliers = getStageAllMultipliers(stageNumber);
    const monsterConfigs = [];
    
    monsterTypes.forEach((monsterType, index) => {
        const availableUUIDs = getMonsterUUIDsByType(monsterType);
        if (availableUUIDs.length > 0) {
            const randomUUID = availableUUIDs[Math.floor(Math.random() * availableUUIDs.length)];
            const enhancement = getMonsterEnhancement(monsterType, useRandomBuff);
            
            monsterConfigs.push({
                id: `stage_${stageNumber}_level_${level}_${index}`,
                uuid: randomUUID,
                type: monsterType,
                stageNumber: stageNumber,
                level: level,
                enhancement: enhancement,
                stageMultipliers: stageMultipliers
            });
        }
    });
    
    return monsterConfigs;
}

/**
 * 关卡基础属性倍数配置
 */
export const StageMultiplierConfig = {
    // 每级提升的基础倍数
    baseMultiplierPerLevel: 0.05,    // 每级基础属性提升5%
    
    // 每10级的大幅提升倍数
    bigBoostMultiplier: 0.3,         // 每10级额外提升30%
    
    // 不同属性的提升权重
    attributeWeights: {
        hp: 1.2,        // 生命值提升权重较高
        attack: 1.0,    // 攻击力标准权重
    }
};

/**
 * 计算关卡的基础属性倍数
 * @param stageNumber 关卡号（从1开始）
 * @param attributeType 属性类型（hp, attack）
 * @returns 属性倍数
 */
export function calculateStageMultiplier(stageNumber: number, attributeType: 'hp' | 'attack'): number {
    const config = StageMultiplierConfig;
    
    // 基础倍数：1.0（第1关不变）
    let multiplier = 1.0;
    
    // 每级小提升：(关卡-1) * 每级提升率 * 属性权重
    const levelBoost = (stageNumber - 1) * config.baseMultiplierPerLevel * config.attributeWeights[attributeType];
    
    // 每10级大提升：向下取整(关卡/10) * 大幅提升率 * 属性权重
    const bigBoostCount = Math.floor(stageNumber / 10);
    const bigBoost = bigBoostCount * config.bigBoostMultiplier * config.attributeWeights[attributeType];
    
    multiplier += levelBoost + bigBoost;
    
    return multiplier;
}

/**
 * 获取关卡所有属性的倍数
 * @param stageNumber 关卡号
 * @returns 所有属性倍数对象
 */
export function getStageAllMultipliers(stageNumber: number) {
    return {
        stageNumber: stageNumber,
        hp: calculateStageMultiplier(stageNumber, 'hp'),
        attack: calculateStageMultiplier(stageNumber, 'attack'),
        description: `第${stageNumber}关基础属性倍数`
    };
}