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

/**
 * 肉鸽模式配置脚本 - 简化版
 * 
 * 功能说明：
 * - 提供基础的刷怪配置：刷什么怪，刷多少怪
 * 
 * @author 游戏开发团队
 * @version 1.0 简化版
 * @date 2025-10-19
 */

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

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

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

/**
 * 关卡配置规则 - 只保留刷怪类型和数量
 */
export const StageConfigRules = {
    // 普通关卡
    [StageType.NORMAL]: {
        description: "普通关卡",
        monsters: [
            { type: MonsterType.NORMAL, count: 1 }  // 5个普通怪物
        ]
    },
    
    // 精英关卡
    [StageType.ELITE]: {
        description: "精英关卡", 
        monsters: [
            { type: MonsterType.ELITE, count: 1 },   // 2个精英怪物
            { type: MonsterType.NORMAL, count: 1 }   // 3个普通怪物
        ]
    },
    
    // Boss关卡
    [StageType.BOSS]: {
        description: "Boss关卡",
        monsters: [
            { type: MonsterType.BOSS, count: 1 },    // 1个Boss怪物
            { type: MonsterType.ELITE, count: 1 },   // 2个精英怪物
            { type: MonsterType.NORMAL, count: 1 }   // 2个普通怪物
        ]
    }
};

/**
 * 根据关卡号和等级判断关卡类型
 * @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）
 * @returns 怪物配置数组
 */
export function getStageMonsterConfigs(stageNumber: number, level: number = 1) {
    const monsterTypes = generateStageConfig(stageNumber, level);
    const monsterConfigs = [];
    
    monsterTypes.forEach((monsterType, index) => {
        const availableUUIDs = getMonsterUUIDsByType(monsterType);
        if (availableUUIDs.length > 0) {
            const randomUUID = availableUUIDs[Math.floor(Math.random() * availableUUIDs.length)];
            
            monsterConfigs.push({
                uuid: randomUUID,
                type: monsterType,
                stageNumber: stageNumber,
                level: level
            });
        }
    });
    
    return monsterConfigs;
}