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

/**
 * 肉鸽模式配置脚本 - 增强版
 * 
 * 功能说明：
 * - 提供基础的刷怪配置：刷什么怪，刷多少怪
 * - 支持程序化关卡生成逻辑，每一关的怪物组合、数量和强度应随关卡进度递增而变化
 * - 支持随机事件系统
 * 
 * @author 游戏开发团队
 * @version 2.0 增强版
 * @date 2025-10-19
 */

import { getMonList, HeroInfo } from "../common/config/heroSet";
import { BuffConf } from "../common/config/SkillSet";


// 精英怪物配置表
export const EliteMons = [  5201, 5202, 5203, 5213 ];
// Boss怪物配置表
export const BossMons = [  5201, 5202, ];
export enum IMons{  ORC=1, HUMAN=2, ELF=3,}
export const Mons={
    [IMons.ORC]:[5201,5202],
    [IMons.HUMAN]:[5201,5202],
    [IMons.ELF]:[5201,5202]
}

/**
 * 怪物类型枚举
 */
export enum MonType {  NORMAL = 0,  ELITE = 1,  BOSS = 2  }
export const EliteStage =[5,10,15,20,25]
export const BossStage=[30,40,50,60,70,80,90,100]

export enum EventType {
    TREASURE = 1,          // 额外奖励
    TRAP =2,                  // 陷阱伤害
    BUFF = 3,                  // 临时增益效果
    DEBUFF = 4              // 临时减益效果
}

/**
 * 关卡生怪物相关配置
 */
export const StageRule = {
    MonsNum: 5,   // 关卡中默认怪物数量
    LimitMonNum: 10,   // 30关以后是极限模式，怪物数量
    /** 额外怪物出现概率（在固定5个怪物基础上，有概率多刷1个） */
    extraMonsterRate: 0.3,        // 30%概率出现第6个怪物
    /** 事件怪物出现概率（5个怪物中有1个替换为事件怪） */
    eventMonsterRate: 0.25,       // 25%概率出现事件怪物
    /** 特殊属性怪物出现概率（5个怪物中有怪物携带特殊属性） */
    specialAttributeRate: 0.4,    // 40%概率出现特殊属性怪物
    /** 特殊属性怪物数量范围 */
    specialAttributeCount: { min: 1, max: 2 }  // 出现时，1-2个怪物会有特殊属性
};

interface IMonsConfig {
    /** 怪物波次 */
    uuid: number; // 怪物ID
    /** 怪物数量 */
    buff: BuffConf[]; //附加属性
    /** 怪物等级 */
    level: number; // 怪物等级
    /** 是否为精英怪物 */
    monType:MonType;
}

export const MonAttrSet={
    [MonType.NORMAL]:{  HP_MAX:1.1, AP:1.05,  MP:1.1, DEF:1.05, MDEF:1.05, MAP:1.05,},
    [MonType.ELITE]: {  HP_MAX:2, AP:1.1,  MP:1.1, DEF:1.1, MDEF:1.1, MAP:1.1,},
    [MonType.BOSS]:  {  HP_MAX:5, AP:2,  MP:5, DEF:2, MDEF:2, MAP:2,},
}

export const MonBuffSet={
    
}

export const getMonAttr=(lv:number,uuid:number,MonType:MonType)=>{
    let mon=HeroInfo[uuid]
    let hp=mon.hp*lv*MonAttrSet[MonType].HP_MAX
    let mp=mon.mp*lv*MonAttrSet[MonType].MP
    let ap=mon.ap*lv*MonAttrSet[MonType].AP
    let map=mon.map*lv*MonAttrSet[MonType].MAP
    let def=mon.def*lv*MonAttrSet[MonType].DEF
    let mdef=mon.mdef*lv*MonAttrSet[MonType].MDEF
    return {hp:hp,mp:mp,ap:ap,map:map,def:def,mdef:mdef}
}

/**
 * 根据波次生成怪物配置
 * @param stage 当前波次
 * @returns IMonsConfig数组
 */
export function getStageMonConfigs(stage: number): IMonsConfig[] {
    const monsterConfigs: IMonsConfig[] = [];
    
    // 确定基础怪物数量
    let baseMonsterCount = StageRule.MonsNum;
    
    // 判断是否为Boss波次
    const isBossStage = BossStage.includes(stage);
    
    // 判断是否为精英波次
    const isEliteStage = EliteStage.includes(stage);
    
    // 如果是Boss波次，增加一个Boss怪物
    if (isBossStage) {
        // 从Boss怪物列表中随机选择一个
        const bossUUID = BossMons[Math.floor(Math.random() * BossMons.length)] || 5201;
        monsterConfigs.push({
            uuid: bossUUID,
            buff: [],
            level: stage, // Boss等级等于波次
            monType: MonType.BOSS
        });
        
        // Boss波次减少普通怪物数量
        baseMonsterCount = Math.max(1, baseMonsterCount - 2);
    }
    
    // 如果是精英波次，增加精英怪物
    if (isEliteStage) {
        // 添加1-2个精英怪物
        const eliteCount = isBossStage ? 1 : Math.floor(Math.random() * 2) + 1;
        for (let i = 0; i < eliteCount; i++) {
            const eliteUUID = EliteMons[Math.floor(Math.random() * EliteMons.length)] || 5201;
            monsterConfigs.push({
                uuid: eliteUUID,
                buff: [],
                level: stage, // 精英等级等于波次
                monType: MonType.ELITE
            });
        }
        
        // 精英波次减少普通怪物数量
        baseMonsterCount = Math.max(1, baseMonsterCount - eliteCount);
    }
    
    // 添加普通怪物
    const remainingCount = baseMonsterCount;
    for (let i = 0; i < remainingCount; i++) {
        // 从普通怪物列表中随机选择一个
        const normalMonsters = getMonList();
        const normalUUID = normalMonsters.length > 0 
            ? normalMonsters[Math.floor(Math.random() * normalMonsters.length)] 
            : 5201;
            
        monsterConfigs.push({
            uuid: normalUUID,
            buff: [],
            level: stage, // 普通怪物等级等于波次
            monType: MonType.NORMAL
        });
    }
    
    // 判断是否生成额外怪物
    if (Math.random() < StageRule.extraMonsterRate) {
        const normalMonsters = getMonList();
        const extraUUID = normalMonsters.length > 0 
            ? normalMonsters[Math.floor(Math.random() * normalMonsters.length)] 
            : 5201;
            
        monsterConfigs.push({
            uuid: extraUUID,
            buff: [],
            level: stage,
            monType: MonType.NORMAL
        });
    }
    
    return monsterConfigs;
}