feat(怪物系统): 重构怪物类型与属性计算系统

引入MonType枚举支持普通、精英、BOSS三种怪物类型新增getMonAttr函数实现基于等级和类型的动态属性计算更新Mon.ts的load和hero_init方法以支持新参数扩展heroSet.ts添加多种新怪物类型配置重构属性初始化流程，移除strengthMultiplier机制更新相关文档和流程图反映最新设计
2025-10-29 16:50:30 +08:00
parent 9dc1126dfe
commit edb7f23918
6 changed files with 648 additions and 432 deletions
--- a/.qoder/repowiki/zh/content/地图系统/地图系统.md
+++ b/.qoder/repowiki/zh/content/地图系统/地图系统.md
@@ -3,13 +3,13 @@
 <cite>
 **本文档引用的文件**  
 - [GameMap.ts](file://assets/script/game/map/GameMap.ts)
- [RogueConfig.ts](file://assets/script/game/map/RogueConfig.ts)
- [Mon.ts](file://assets/script/game/hero/Mon.ts)
+- [RogueConfig.ts](file://assets/script/game/map/RogueConfig.ts) - *在最近提交中更新*
+- [Mon.ts](file://assets/script/game/hero/Mon.ts) - *在最近提交中更新*
 - [MapModelComp.ts](file://assets/script/game/map/model/MapModelComp.ts)
 - [MapViewComp.ts](file://assets/script/game/map/view/MapViewComp.ts)
 - [map.json](file://assets/resources/config/map/map.json)
 - [map_delivery.json](file://assets/resources/config/map/map_delivery.json)
- [MissionMonComp.ts](file://assets/script/game/map/MissionMonComp.ts)
+- [MissionMonComp.ts](file://assets/script/game/map/MissionMonComp.ts) - *在最近提交中更新*
 - [heroSet.ts](file://assets/script/game/common/config/heroSet.ts)
 - [MapViewScene.ts](file://assets/script/game/map/view/MapViewScene.ts)
 - [MapLayer.ts](file://assets/script/game/map/view/map/layer/MapLayer.ts)
@@ -17,6 +17,14 @@
 - [SkillLayer.ts](file://assets/script/game/map/view/map/layer/SkillLayer.ts)
 </cite>

+## 更新摘要
+**已更新内容**  
+- 更新了“随机关卡生成逻辑分析”章节，反映使用 `MonType` 枚举重构的怪物生成系统
+- 更新了“怪物实体设计模式分析”章节，以包含新的 `monType` 和 `buffs` 参数
+- 更新了“依赖分析”图表，反映 `RogueConfig.ts` 和 `MissionMonComp.ts` 的变更
+- 新增了“怪物类型与属性计算”章节，详细说明 `MonType` 枚举和 `getMonAttr` 函数
+- 所有受影响的代码示例和序列图均已更新
+
 ## 目录
 1. [引言](#引言)
 2. [项目结构](#项目结构)
@@ -217,9 +225,34 @@ GameMap --> MapModelComp : "包含"
 - [GameMap.ts](file://assets/script/game/map/GameMap.ts#L1-L35)
 - [MapModelComp.ts](file://assets/script/game/map/model/MapModelComp.ts#L1-L42)

+### 怪物类型与属性计算
+
+`RogueConfig.ts`文件引入了`MonType`枚举来定义怪物类型，取代了原有的布尔标记。`MonType`包含`NORMAL`（普通）、`ELITE`（精英）和`BOSS`（首领）三种类型。系统通过`MonAttrSet`配置表为不同类型的怪物设置属性倍率。`getMonAttr`函数根据怪物等级、UUID和类型计算最终属性值，确保精英和Boss怪物具有更高的生命值、攻击力和防御力。
+
+#### 属性计算逻辑
+```mermaid
+flowchart TD
+Start([计算怪物属性]) --> GetBase["获取基础属性 (来自HeroInfo)"]
+GetBase --> ApplyLevel["应用等级倍率 (lv)"]
+ApplyLevel --> ApplyType["应用类型倍率 (MonAttrSet[MonType])"]
+ApplyType --> Calculate["计算最终属性: HP, MP, AP, DEF等"]
+Calculate --> Return["返回属性对象"]
+Return --> End([属性计算完成])
+```
+
+**图示来源**  
+- [RogueConfig.ts](file://assets/script/game/map/RogueConfig.ts#L31-L31) - *MonType枚举定义*
+- [RogueConfig.ts](file://assets/script/game/map/RogueConfig.ts#L79-L88) - *getMonAttr函数实现*
+- [Mon.ts](file://assets/script/game/hero/Mon.ts#L37-L60) - *load方法调用getMonAttr*
+
+**本节来源**  
+- [RogueConfig.ts](file://assets/script/game/map/RogueConfig.ts#L31-L31)
+- [RogueConfig.ts](file://assets/script/game/map/RogueConfig.ts#L79-L88)
+- [Mon.ts](file://assets/script/game/hero/Mon.ts#L37-L60)
+
 ### 随机关卡生成逻辑分析

-`RogueConfig.ts`文件定义了随机关卡的生成规则。系统通过`getStageType`函数根据关卡号和等级决定关卡类型（普通、精英、Boss、事件）。`generateStageConfig`函数根据关卡类型生成怪物类型数组，`calculateMonsterCount`函数根据关卡进度动态调整怪物数量，`calculateMonsterStrengthMultiplier`函数计算怪物强度倍率。`getStageMonsterConfigs`函数综合以上逻辑，生成包含怪物UUID、类型和强度倍率的完整配置。
+`RogueConfig.ts`文件重构了随机关卡的生成规则。系统通过`getStageMonConfigs`函数根据关卡号生成怪物配置。该函数首先判断当前关卡是否为精英关卡（`EliteStage`数组中包含）或Boss关卡（`BossStage`数组中包含）。如果是Boss关卡，则从`BossMons`列表中随机选择一个Boss怪物加入配置，并减少普通怪物数量。如果是精英关卡，则添加1-2个精英怪物。最后，根据`StageRule`中的`extraMonsterRate`概率决定是否生成额外的普通怪物。

 #### API/服务组件
 ```mermaid
@@ -227,48 +260,42 @@ sequenceDiagram
 participant Game as "游戏逻辑"
 participant RogueConfig as "RogueConfig"
 participant MissionMonComp as "MissionMonComp"
-Game->>RogueConfig : getStageType(stageNumber, level)
-RogueConfig-->>Game : 返回关卡类型
-Game->>RogueConfig : generateStageConfig(stageNumber, level)
-RogueConfig-->>Game : 返回怪物类型数组
-Game->>RogueConfig : calculateMonsterCount(...)
-RogueConfig-->>Game : 返回实际数量
-Game->>RogueConfig : calculateMonsterStrengthMultiplier(...)
-RogueConfig-->>Game : 返回强度倍率
-Game->>RogueConfig : getStageMonsterConfigs(...)
-RogueConfig-->>Game : 返回完整怪物配置
-Game->>MissionMonComp : do_mon_wave()
-MissionMonComp->>MissionMonComp : generateMonstersFromStageConfig()
+Game->>RogueConfig : getStageMonConfigs(stageNumber)
+RogueConfig-->>Game : 返回IMonsConfig[]数组
+Game->>MissionMonComp : generateMonsters(monsConf)
 MissionMonComp->>MissionMonComp : addToStageSpawnQueue()
-loop 每个怪物
+loop 每个怪物配置
 MissionMonComp->>MissionMonComp : spawnNextMonster()
-MissionMonComp->>Monster : load()
+MissionMonComp->>Monster : load(uuid, pos, monType, level, buffs)
 end
 ```

 **图示来源**  
- [RogueConfig.ts](file://assets/script/game/map/RogueConfig.ts#L1-L310)
- [MissionMonComp.ts](file://assets/script/game/map/MissionMonComp.ts#L1-L239)
+- [RogueConfig.ts](file://assets/script/game/map/RogueConfig.ts#L95-L173) - *getStageMonConfigs函数实现*
+- [MissionMonComp.ts](file://assets/script/game/map/MissionMonComp.ts#L19-L25) - *MonQueue使用MonType*
+- [MissionMonComp.ts](file://assets/script/game/map/MissionMonComp.ts#L177-L191) - *addMonster方法*

 **本节来源**  
- [RogueConfig.ts](file://assets/script/game/map/RogueConfig.ts#L1-L310)
- [MissionMonComp.ts](file://assets/script/game/map/MissionMonComp.ts#L1-L239)
+- [RogueConfig.ts](file://assets/script/game/map/RogueConfig.ts#L95-L173)
+- [MissionMonComp.ts](file://assets/script/game/map/MissionMonComp.ts#L19-L25)
+- [MissionMonComp.ts](file://assets/script/game/map/MissionMonComp.ts#L177-L191)

 ### 怪物实体设计模式分析

-`Mon.ts`文件定义了`Monster`类，代表游戏中的怪物实体。该类同样基于ECS架构，包含`HeroModel`（模型组件）、`HeroView`（视图组件）和`BattleMove`（战斗移动组件）。`load`方法负责加载怪物的预制件并初始化其位置和属性。`hero_init`方法根据怪物UUID从`HeroInfo`配置中获取基础属性，并根据强度倍率进行调整。怪物的技能、属性和状态均在此方法中初始化。
+`Mon.ts`文件定义了`Monster`类，代表游戏中的怪物实体。该类基于ECS架构，包含`HeroModel`（模型组件）、`HeroView`（视图组件）和`BattleMove`（战斗移动组件）。`load`方法的签名已更新，增加了`monType`和`buffs`参数。该方法调用`getMonAttr`函数根据关卡等级和怪物类型计算属性，并将这些属性传递给`hero_init`方法进行初始化。怪物的技能、属性和状态均在此方法中初始化。

 #### 复杂逻辑组件
 ```mermaid
 flowchart TD
-Start([怪物加载]) --> Load["load(pos, scale, uuid, is_boss)"]
+Start([怪物加载]) --> Load["load(pos, scale, uuid, lv, monType, buffs)"]
 Load --> GetPrefab["获取预制件路径"]
 GetPrefab --> Instantiate["实例化预制件"]
 Instantiate --> SetParent["设置父节点为entityLayer"]
 SetParent --> Init["调用hero_init初始化"]
 Init --> GetHeroInfo["从HeroInfo获取基础属性"]
-GetHeroInfo --> AdjustAttrs["根据strengthMultiplier调整属性"]
-AdjustAttrs --> InitSkills["初始化技能数组"]
+GetHeroInfo --> CalculateAttrs["调用getMonAttr计算最终属性"]
+CalculateAttrs --> ApplyBuffs["应用buffs数组"]
+ApplyBuffs --> InitSkills["初始化技能数组"]
 InitSkills --> AddComponent["将HeroViewComp添加到实体"]
 AddComponent --> SetMove["设置BattleMove参数"]
 SetMove --> Dispatch["派发monster_load事件"]
@@ -276,12 +303,14 @@ Dispatch --> End([怪物加载完成])
 ```

 **图示来源**  
- [Mon.ts](file://assets/script/game/hero/Mon.ts#L1-L108)
- [heroSet.ts](file://assets/script/game/common/config/heroSet.ts#L1-L151)
+- [Mon.ts](file://assets/script/game/hero/Mon.ts#L37-L60) - *load方法实现*
+- [Mon.ts](file://assets/script/game/hero/Mon.ts#L61-L108) - *hero_init方法实现*
+- [RogueConfig.ts](file://assets/script/game/map/RogueConfig.ts#L79-L88) - *getMonAttr函数*

 **本节来源**  
- [Mon.ts](file://assets/script/game/hero/Mon.ts#L1-L108)
- [heroSet.ts](file://assets/script/game/common/config/heroSet.ts#L1-L151)
+- [Mon.ts](file://assets/script/game/hero/Mon.ts#L37-L60)
+- [Mon.ts](file://assets/script/game/hero/Mon.ts#L61-L108)
+- [RogueConfig.ts](file://assets/script/game/map/RogueConfig.ts#L79-L88)

 ### 数据与表现层分离分析

@@ -394,8 +423,8 @@ RogueConfig_ts --> heroSet_ts

 ## 故障排除指南
 - **地图无法加载**：检查`MapModelComp`中的`resPrefab`路径是否正确，确保预制件存在于资源目录中。
- **怪物未生成**：确认`MissionMonComp`是否监听了`FightReady`事件，检查`monsterQueue`是否正确填充。
- **属性未按倍率调整**：确保`Mon.ts`中的`hero_init`方法正确接收并应用`strengthMultiplier`参数。
+- **怪物未生成**：确认`MissionMonComp`是否监听了`FightReady`事件，检查`MonQueue`是否正确填充。
+- **属性未按倍率调整**：确保`Mon.ts`中的`hero_init`方法正确接收并应用`monType`参数，并调用`getMonAttr`函数。
 - **转场无效**：验证`map_delivery.json`中的`pos`和`start`坐标格式是否正确，确保触发位置与玩家位置匹配。

 **本节来源**  
@@ -405,4 +434,4 @@ RogueConfig_ts --> heroSet_ts
 - [map_delivery.json](file://assets/resources/config/map/map_delivery.json#L1-L29)

 ## 结论
-本文档全面分析了Cocos游戏项目中的地图系统架构。系统采用ECS和MVC设计模式，实现了良好的代码分离和可扩展性。随机关卡生成逻辑灵活，支持动态调整怪物数量和强度。数据与表现层分离清晰，便于维护和迭代。通过合理使用配置文件，实现了关卡数据的外部化管理。整体架构设计合理，为游戏的长期发展奠定了坚实基础。
+本文档全面分析了Cocos游戏项目中的地图系统架构。系统采用ECS和MVC设计模式，实现了良好的代码分离和可扩展性。随机关卡生成逻辑经过重构，使用`MonType`枚举清晰地管理普通、精英和Boss怪物，支持动态调整怪物数量和强度。数据与表现层分离清晰，便于维护和迭代。通过合理使用配置文件，实现了关卡数据的外部化管理。整体架构设计合理，为游戏的长期发展奠定了坚实基础。
--- a/.qoder/repowiki/zh/content/地图系统/怪物系统/怪物系统.md
+++ b/.qoder/repowiki/zh/content/地图系统/怪物系统/怪物系统.md
@@ -2,14 +2,23 @@

 <cite>
 **本文档引用的文件**  
- [Mon.ts](file://assets/script/game/hero/Mon.ts)
- [HeroAttrs.ts](file://assets/script/game/common/config/HeroAttrs.ts)
- [heroSet.ts](file://assets/script/game/common/config/heroSet.ts)
- [MonModelComp.ts](file://assets/script/game/hero/MonModelComp.ts)
- [BattleMoveComp.ts](file://assets/script/game/common/ecs/position/BattleMoveComp.ts)
- [BattleMoveSystem.ts](file://assets/script/game/common/ecs/position/BattleMoveSystem.ts)
+- [Mon.ts](file://assets/script/game/hero/Mon.ts) - *在最近的提交中更新*  
+- [HeroAttrs.ts](file://assets/script/game/common/config/HeroAttrs.ts) - *在最近的提交中更新*  
+- [heroSet.ts](file://assets/script/game/common/config/heroSet.ts) - *在最近的提交中更新*  
+- [RogueConfig.ts](file://assets/script/game/map/RogueConfig.ts) - *新增怪物类型与难度配置*  
+- [BattleMoveComp.ts](file://assets/script/game/common/ecs/position/BattleMoveComp.ts) - *移动行为控制组件*  
+- [HeroViewComp.ts](file://assets/script/game/hero/HeroViewComp.ts) - *视图与属性管理组件*
 </cite>

+## 更新摘要
+**变更内容**  
+- 更新了 `Mon.ts` 中的 `load` 和 `hero_init` 方法以支持 `monType` 参数和等级系统  
+- 引入 `MonType` 枚举（普通、精英、BOSS）实现差异化属性计算  
+- 新增 `getMonAttr` 函数用于根据等级和类型动态计算怪物属性  
+- 扩展 `heroSet.ts` 添加多种新怪物类型（召唤师、治疗者、光环怪等）  
+- 重构属性初始化流程，移除过时的 `strengthMultiplier`，改用基于等级和类型的倍率系统  
+- 更新架构图和流程图以反映最新的 ECS 设计和属性计算逻辑
+
 ## 目录
 1. [简介](#简介)  
 2. [项目结构](#项目结构)  
@@ -23,7 +32,7 @@

 ## 简介

-Mon.ts文件定义了游戏中的怪物系统，采用ECS（Entity-Component-System）架构模式，通过继承Entity类并注册为`Monster`类型来实现怪物实体的管理和控制。该系统提供了完整的怪物生命周期管理，包括预制体动态加载、属性初始化、难度自适应调整以及移动行为控制等功能。
+`Mon.ts` 文件定义了游戏中的怪物系统，采用 ECS（Entity-Component-System）架构模式，通过继承 `Entity` 类并注册为 `Monster` 类型来实现怪物实体的管理和控制。该系统提供了完整的怪物生命周期管理，包括预制体动态加载、位置设置、基于等级和类型的属性初始化以及向左移动的行为控制。本次重构引入了 `monType` 参数，支持普通、精英、BOSS 三种类型，并通过 `RogueConfig.ts` 中的 `getMonAttr` 函数实现了基于等级和类型系数的动态属性计算，取代了原有的 `strengthMultiplier` 机制，使难度曲线更加平滑和可配置。

 ## 项目结构

@@ -37,8 +46,9 @@ MonModel[MonModelComp.ts<br/>怪物模型组件]
 BattleMove[BattleMoveComp.ts<br/>移动组件]
 end
 subgraph "配置系统"
-HeroSet[heroSet.ts<br/>英雄配置]
+HeroSet[heroSet.ts<br/>英雄与怪物配置]
 HeroAttrs[HeroAttrs.ts<br/>属性配置]
+RogueConfig[RogueConfig.ts<br/>肉鸽模式配置]
 end
 subgraph "ECS系统"
 BattleMoveSys[BattleMoveSystem.ts<br/>移动系统]
@@ -47,6 +57,7 @@ Mon --> MonModel
 Mon --> BattleMove
 Mon --> HeroSet
 Mon --> HeroAttrs
+Mon --> RogueConfig
 BattleMoveSys --> BattleMove
 ```

@@ -54,45 +65,52 @@ BattleMoveSys --> BattleMove
 - [Mon.ts](file://assets/script/game/hero/Mon.ts#L1-L109)  
 - [MonModelComp.ts](file://assets/script/game/hero/MonModelComp.ts#L1-L20)  
 - [BattleMoveComp.ts](file://assets/script/game/common/ecs/position/BattleMoveComp.ts#L1-L16)  
+- [RogueConfig.ts](file://assets/script/game/map/RogueConfig.ts#L31-L88)

 **章节来源**  
 - [Mon.ts](file://assets/script/game/hero/Mon.ts#L1-L109)  
 - [heroSet.ts](file://assets/script/game/common/config/heroSet.ts#L1-L152)  
+- [RogueConfig.ts](file://assets/script/game/map/RogueConfig.ts#L31-L88)

 ## 核心组件

 ### Monster实体类

-Monster类是怪物系统的核心实体类，继承自ECS框架的Entity基类，并注册为`Monster`类型。该类实现了怪物的完整生命周期管理：
+`Monster` 类是怪物系统的核心实体类，继承自 ECS 框架的 `Entity` 基类，并注册为 `Monster` 类型。该类实现了怪物的完整生命周期管理：

- **组件管理**：自动添加BattleMoveComp和MonModelComp组件
- **生命周期控制**：提供init和destroy方法管理实体状态
- **预制体加载**：通过load方法动态加载怪物预制体
- **属性初始化**：通过hero_init方法设置怪物基础属性
+- **组件管理**：在 `init` 方法中自动添加 `BattleMoveComp`、`MonModelComp` 和 `TalComp` 组件  
+- **生命周期控制**：提供 `init` 和 `destroy` 方法管理实体状态，在 `destroy` 中移除关键组件  
+- **预制体加载**：通过 `load` 方法动态加载怪物预制体，并传入 `uuid`、`lv`（等级）、`monType`（怪物类型）等参数  
+- **属性初始化**：通过 `hero_init` 方法设置怪物基础属性，该方法现在依赖 `RogueConfig.getMonAttr` 进行计算

 ### BattleMoveComp移动组件

-BattleMoveComp负责控制怪物的移动行为，包含以下关键属性：
+`BattleMoveComp` 负责控制怪物的移动行为，包含以下关键属性：

 - **direction**：移动方向（1向右，-1向左）  
 - **targetX**：目标X坐标  
 - **moving**：移动状态标识  

+在 `Mon.ts` 的 `load` 方法中，该组件被初始化为向左移动（`direction = -1`）至左边界（`targetX = -800`）。
+
 ### 属性系统

 怪物系统采用统一的属性管理机制，支持：

- **基础属性**：HP、MP、AP、DEF等核心战斗属性
+- **基础属性**：HP、MP、AP、DEF 等核心战斗属性  
 - **百分比属性**：暴击率、闪避率等百分比型属性  
 - **特殊属性**：吸血、燃烧概率等特殊效果属性  

+属性值存储在 `HeroViewComp` 的 `Attrs` 和 `NeAttrs` 对象中，并通过 `initAttrs` 方法进行初始化和计算。
+
 **章节来源**  
 - [Mon.ts](file://assets/script/game/hero/Mon.ts#L17-L40)  
 - [BattleMoveComp.ts](file://assets/script/game/common/ecs/position/BattleMoveComp.ts#L3-L15)  
+- [HeroViewComp.ts](file://assets/script/game/hero/HeroViewComp.ts#L72-L778)

 ## 架构概览

-怪物系统采用ECS架构模式，实现了高度解耦的设计：
+怪物系统采用 ECS 架构模式，实现了高度解耦的设计：

 ```mermaid
 classDiagram
@@ -102,8 +120,8 @@ class Monster {
 +BattleMoveComp BattleMove
 +init() void
 +destroy() void
-+load(pos, scale, uuid, is_boss, is_call, strengthMultiplier) void
-+hero_init(uuid, node, scale, box_group, is_boss, is_call, strengthMultiplier) void
+load(pos, scale, uuid, lv, monType, buffs, is_call) void
+hero_init(uuid, node, scale, box_group, lv, monType, buffs, is_call) void
 }
 class BattleMoveComp {
 +number direction
@@ -141,12 +159,13 @@ Monster --> HeroViewComp : "包含"
 - [Mon.ts](file://assets/script/game/hero/Mon.ts#L17-L40)  
 - [BattleMoveComp.ts](file://assets/script/game/common/ecs/position/BattleMoveComp.ts#L3-L15)  
 - [MonModelComp.ts](file://assets/script/game/hero/MonModelComp.ts#L10-L19)  
+- [HeroViewComp.ts](file://assets/script/game/hero/HeroViewComp.ts#L72-L778)

 ## 详细组件分析

 ### load方法：预制体动态加载流程

-load方法实现了怪物的完整初始化流程：
+`load` 方法实现了怪物的完整初始化流程，现已支持等级和类型参数：

 ```mermaid
 sequenceDiagram
@@ -155,7 +174,7 @@ participant Monster as "Monster实体"
 participant Resources as "资源系统"
 participant Scene as "场景节点"
 participant BattleMove as "BattleMove组件"
-Client->>Monster : load(pos, scale, uuid, ...)
+Client->>Monster : load(pos, scale, uuid, lv, monType, ...)
 Monster->>Resources : 获取预制体路径
 Resources-->>Monster : 返回Prefab资源
 Monster->>Scene : 实例化预制体
@@ -173,61 +192,66 @@ Monster->>Client : dispatchEvent("monster_load")

 #### 关键步骤解析：

-1. **预制体路径构建**：根据uuid从HeroInfo配置中获取对应的预制体路径
-2. **实例化处理**：使用oops.res.get获取预制体并实例化
-3. **场景集成**：将实例化的节点添加到场景的entityLayer中
+1. **预制体路径构建**：根据 `uuid` 从 `HeroInfo` 配置中获取对应的预制体路径  
+2. **实例化处理**：使用 `oops.res.get` 获取预制体并实例化  
+3. **场景集成**：将实例化的节点添加到场景的 `entityLayer` 中  
 4. **碰撞体管理**：先禁用碰撞体，延迟一帧再启用以避免初始化问题  
-5. **位置设置**：根据传入的pos参数设置怪物初始位置
+5. **位置设置**：根据传入的 `pos` 参数设置怪物初始位置  
+6. **属性初始化**：调用 `hero_init` 方法，传入 `lv` 和 `monType` 进行属性计算  
+7. **移动初始化**：设置 `BattleMoveComp` 的方向和目标  

 **章节来源**  
 - [Mon.ts](file://assets/script/game/hero/Mon.ts#L35-L58)

-### hero_init方法：难度自适应属性系统
+### hero_init方法：基于等级与类型的属性系统

-hero_init方法实现了基于strengthMultiplier的难度自适应属性调整：
+`hero_init` 方法实现了基于 `lv`（等级）和 `monType`（怪物类型）的属性调整，取代了旧的 `strengthMultiplier` 机制：

 ```mermaid
 flowchart TD
 Start([开始初始化]) --> GetHeroInfo["获取英雄配置信息"]
-GetHeroInfo --> SetBasicProps["设置基础属性"]
-SetBasicProps --> CalcStrength["计算强度倍率"]
-CalcStrength --> AdjustHP["调整HP = hero.hp × strengthMultiplier"]
-AdjustHP --> AdjustAP["调整AP = hero.ap × strengthMultiplier"]
-AdjustAP --> AdjustDEF["调整DEF = hero.def × strengthMultiplier"]
-AdjustDEF --> LoadSkills["加载技能配置"]
+GetHeroInfo --> CalcAttr["调用getMonAttr计算属性"]
+CalcAttr --> SetBasicProps["设置基础属性"]
+SetBasicProps --> LoadSkills["加载技能配置"]
 LoadSkills --> InitAttrs["初始化属性系统"]
 InitAttrs --> Complete([初始化完成])
 style Start fill:#e1f5fe
 style Complete fill:#e8f5e8
-style CalcStrength fill:#fff3e0
+style CalcAttr fill:#fff3e0
 ```

 **图表来源**  
 - [Mon.ts](file://assets/script/game/hero/Mon.ts#L60-L91)  
+- [RogueConfig.ts](file://assets/script/game/map/RogueConfig.ts#L79-L88)

 #### 属性调整机制：

 1. **基础属性计算**：  
-   - HP = hero.hp × strengthMultiplier（向下取整）
-   - AP = hero.ap × strengthMultiplier（向下取整）
-   - DEF = hero.def × strengthMultiplier（向下取整）
+   调用 `getMonAttr(lv, uuid, monType)` 函数，该函数根据以下公式计算：  
+   ```
+   hp = hero.hp * lv * MonAttrSet[monType].HP_MAX
+   ap = hero.ap * lv * MonAttrSet[monType].AP
+   def = hero.def * lv * MonAttrSet[monType].DEF
+   ```
+   其中 `MonAttrSet` 定义了不同类型（普通、精英、BOSS）的属性倍率。

 2. **技能系统集成**：  
-   - 遍历hero.skills数组
-   - 从SkillSet配置中获取技能详细信息
-   - 创建技能对象并添加到hv.skills数组
+   - 遍历 `hero.skills` 数组  
+   - 从 `SkillSet` 配置中获取技能详细信息  
+   - 创建技能对象并添加到 `hv.skills` 数组  

 3. **属性系统初始化**：  
-   - 调用getAttrs()获取默认属性值
-   - 调用getNeAttrs()获取负面状态属性
-   - 设置各项属性的基础值和当前值
+   - 调用 `getAttrs()` 获取默认属性值  
+   - 调用 `getNeAttrs()` 获取负面状态属性  
+   - 将计算出的 `hp`, `ap`, `def` 等值赋给 `Attrs` 对象中的对应属性  

 **章节来源**  
 - [Mon.ts](file://assets/script/game/hero/Mon.ts#L60-L91)  
+- [RogueConfig.ts](file://assets/script/game/map/RogueConfig.ts#L79-L88)

 ### BattleMoveComp组件：移动行为控制

-BattleMoveComp组件驱动怪物向左移动的行为：
+`BattleMoveComp` 组件驱动怪物向左移动的行为：

 ```mermaid
 stateDiagram-v2
@@ -255,11 +279,11 @@ note right of Moving : direction = -1<br/>targetX = -800

 ### 数据复用机制：HeroAttrs与heroSet配置

-怪物系统通过HeroAttrs.ts和heroSet.ts实现英雄配置的数据复用：
+怪物系统通过 `HeroAttrs.ts` 和 `heroSet.ts` 实现英雄配置的数据复用：

 #### HeroAttrs.ts属性系统

-HeroAttrs.ts定义了完整的属性枚举和类型系统：
+`HeroAttrs.ts` 定义了完整的属性枚举和类型系统：

 | 属性类别 | 属性名称 | 类型 | 描述 |
 |---------|---------|------|------|
@@ -273,11 +297,12 @@ HeroAttrs.ts定义了完整的属性枚举和类型系统：

 #### heroSet.ts配置系统

-heroSet.ts提供了怪物配置的集中管理：
+`heroSet.ts` 提供了怪物配置的集中管理：

- **HeroInfo配置表**：存储所有怪物的基础属性数据
+- **HeroInfo配置表**：存储所有怪物的基础属性数据，`fac: FacSet.MON` 标识为怪物  
 - **MonSet位置配置**：定义怪物在战场上的初始位置  
- **职业类型枚举**：支持warrior、remote、mage、support、assassin五种职业
+- **职业类型枚举**：支持 `warrior`、`remote`、`mage`、`support`、`assassin` 五种职业  
+- **新增怪物类型**：包括 `5214` 死灵法师（召唤师）、`5215` 祭司（治疗者）、`5216` 光环幽灵（光环怪）等特殊机制怪物  

 **章节来源**  
 - [HeroAttrs.ts](file://assets/script/game/common/config/HeroAttrs.ts#L25-L105)  
@@ -303,6 +328,7 @@ subgraph "配置模块"
 HeroInfo[HeroInfo配置]
 HeroAttrs[属性配置]
 SkillSet[技能配置]
+RogueConfig[肉鸽配置]
 end
 subgraph "系统模块"
 BattleMoveSys[BattleMoveSystem]
@@ -316,6 +342,7 @@ Monster --> HeroView
 Monster --> HeroInfo
 Monster --> HeroAttrs
 Monster --> SkillSet
+Monster --> RogueConfig
 BattleMoveSys --> BattleMove
 BattleMoveSys --> HeroView
 SingletonModule --> Monster
@@ -327,10 +354,10 @@ SingletonModule --> Monster

 ### 关键依赖说明：

-1. **ECS框架依赖**：Monster类继承自ecs.Entity，BattleMoveComp继承自ecs.Comp
-2. **Cocos Creator依赖**：使用Node、Prefab、Vec3等Cocos类型
-3. **配置依赖**：依赖HeroInfo、HeroAttrs、SkillSet等配置模块
-4. **系统依赖**：依赖BattleMoveSystem进行移动逻辑处理
+1. **ECS框架依赖**：`Monster` 类继承自 `ecs.Entity`，`BattleMoveComp` 继承自 `ecs.Comp`  
+2. **Cocos Creator依赖**：使用 `Node`、`Prefab`、`Vec3` 等 Cocos 类型  
+3. **配置依赖**：依赖 `HeroInfo`、`HeroAttrs`、`SkillSet`、`RogueConfig` 等配置模块  
+4. **系统依赖**：依赖 `BattleMoveSystem` 进行移动逻辑处理  

 **章节来源**  
 - [Mon.ts](file://assets/script/game/hero/Mon.ts#L1-L15)  
@@ -341,20 +368,20 @@ SingletonModule --> Monster
 ### 内存管理优化

 1. **组件化设计**：通过组件分离职责，避免单个类过于庞大  
-2. **生命周期管理**：destroy方法确保正确清理组件引用
+2. **生命周期管理**：`destroy` 方法确保正确清理组件引用  
 3. **资源池化**：预制体实例化采用资源管理系统  

 ### 性能优化策略

-1. **批量更新**：BattleMoveSystem采用批量处理方式
+1. **批量更新**：`BattleMoveSystem` 采用批量处理方式  
 2. **条件检查**：在更新前进行状态检查，避免不必要的计算  
-3. **边界检测**：使用validatePosition方法限制移动范围
+3. **边界检测**：使用 `validatePosition` 方法限制移动范围  

 ### 扩展性设计

-1. **配置驱动**：通过配置文件控制怪物属性和行为
-2. **组件扩展**：支持添加新的组件类型
-3. **系统扩展**：BattleMoveSystem可添加新的移动逻辑
+1. **配置驱动**：通过 `heroSet.ts` 和 `RogueConfig.ts` 控制怪物属性和行为  
+2. **组件扩展**：支持添加新的组件类型（如 `BuffComp`、`TalComp`）  
+3. **系统扩展**：`BattleMoveSystem` 可添加新的移动逻辑  

 ## 故障排除指南

@@ -365,9 +392,9 @@ SingletonModule --> Monster
 **问题现象**：怪物加载后静止不动  

 **排查步骤**：  
- 检查BattleMoveComp的moving属性是否为true
- 验证targetX设置是否合理
- 确认BattleMoveSystem是否正常运行
+- 检查 `BattleMoveComp` 的 `moving` 属性是否为 `true`  
+- 验证 `targetX` 设置是否合理  
+- 确认 `BattleMoveSystem` 是否正常运行  

 **解决方案**：  
 ```typescript
@@ -382,16 +409,17 @@ move.targetX = -800; // 设置合理的边界值
 **问题现象**：怪物属性显示异常  

 **排查步骤**：  
- 检查strengthMultiplier参数是否正确传递
- 验证HeroInfo配置中的基础属性值
- 确认属性计算逻辑
+- 检查 `lv` 和 `monType` 参数是否正确传递  
+- 验证 `HeroInfo` 配置中的基础属性值  
+- 确认 `getMonAttr` 函数的计算逻辑  

 **解决方案**：  
 ```typescript
 // 确保属性计算正确
-const baseHp = Math.floor(hero.hp * strengthMultiplier);
-const baseAp = Math.floor(hero.ap * strengthMultiplier);
-const baseDef = Math.floor(hero.def * strengthMultiplier);
+const {hp, ap, def} = getMonAttr(lv, uuid, monType);
+hv.base_hp = hp;
+hv.base_ap = ap;
+hv.base_def = def;
 ```

 #### 3. 预制体加载失败
@@ -399,7 +427,7 @@ const baseDef = Math.floor(hero.def * strengthMultiplier);
 **问题现象**：怪物无法显示模型  

 **排查步骤**：  
- 检查HeroInfo中的path配置是否正确
+- 检查 `HeroInfo` 中的 `path` 配置是否正确  
 - 验证资源路径是否存在  
 - 确认资源是否已正确打包  

@@ -416,11 +444,11 @@ var prefab: Prefab = oops.res.get(path, Prefab)!;

 ## 结论

-Mon.ts文件实现了一个功能完整、架构清晰的怪物系统。通过ECS架构模式，系统实现了高度的模块化和可扩展性。主要特点包括：
+`Mon.ts` 文件实现了一个功能完整、架构清晰的怪物系统。通过 ECS 架构模式，系统实现了高度的模块化和可扩展性。主要特点包括：  

 1. **ECS架构优势**：通过组件化设计实现了职责分离和代码复用  
-2. **难度自适应**：基于strengthMultiplier的属性调整机制提供了灵活的难度控制
-3. **数据复用**：通过HeroAttrs和heroSet配置系统实现了数据的集中管理
+2. **难度自适应**：基于 `lv` 和 `monType` 的属性调整机制提供了灵活的难度控制  
+3. **数据复用**：通过 `HeroAttrs` 和 `heroSet` 配置系统实现了数据的集中管理  
 4. **性能优化**：采用组件化和批量处理策略确保良好的运行性能  
 5. **扩展性强**：支持添加新怪物类型、配置技能组合和实现召唤单位等扩展需求  

--- a/.qoder/repowiki/zh/content/地图系统/肉鸽关卡配置/肉鸽关卡配置.md
+++ b/.qoder/repowiki/zh/content/地图系统/肉鸽关卡配置/肉鸽关卡配置.md
@@ -2,16 +2,21 @@

 <cite>
 **本文档引用的文件**
- [RogueConfig.ts](file://assets/script/game/map/RogueConfig.ts)
+- [RogueConfig.ts](file://assets/script/game/map/RogueConfig.ts) - *在最近提交中更新*
+- [MissionMonComp.ts](file://assets/script/game/map/MissionMonComp.ts) - *在最近提交中更新*
+- [heroSet.ts](file://assets/script/game/common/config/heroSet.ts) - *在最近提交中更新*
+- [SkillSet.ts](file://assets/script/game/common/config/SkillSet.ts)
 - [GameMap.ts](file://assets/script/game/map/GameMap.ts)
- [MissionMonComp.ts](file://assets/script/game/map/MissionMonComp.ts)
- [heroSet.ts](file://assets/script/game/common/config/heroSet.ts)
- [Mon.ts](file://assets/script/game/hero/Mon.ts)
- [MissionComp.ts](file://assets/script/game/map/MissionComp.ts)
- [MapModelComp.ts](file://assets/script/game/map/model/MapModelComp.ts)
- [MapViewComp.ts](file://assets/script/game/map/view/MapViewComp.ts)
 </cite>

+## 更新摘要
+**已做更改**
+- 全面重构关卡生成逻辑，采用新的 `MonType` 枚举替代旧的布尔标记
+- 更新关卡类型判断机制，基于 `EliteStage` 和 `BossStage` 数组配置
+- 重写怪物属性计算系统，引入 `MonAttrSet` 属性倍率配置
+- 更新随机事件系统，使用数字枚举值替代字符串
+- 同步更新调用流程和配置结构
+
 ## 目录
 1. [系统概述](#系统概述)
 2. [核心架构](#核心架构)
@@ -32,107 +37,93 @@

 ### 主要特性

- **程序化关卡生成**：基于关卡号和等级自动计算关卡配置
+- **程序化关卡生成**：基于关卡号自动计算关卡配置
 - **动态难度曲线**：怪物数量和强度随关卡递增而增强
- **多样化关卡类型**：普通关卡、精英关卡、Boss关卡、事件关卡
+- **多样化关卡类型**：普通关卡、精英关卡、Boss关卡
 - **随机事件系统**：包含奖励、陷阱、增益、减益等多种事件
 - **灵活配置管理**：支持快速调整难度曲线和平衡性

+**更新** 重构了怪物生成逻辑，使用 `MonType` 枚举和数组配置替代原有实现
+
+**章节来源**
+- [RogueConfig.ts](file://assets/script/game/map/RogueConfig.ts#L1-L50)
+- [MissionMonComp.ts](file://assets/script/game/map/MissionMonComp.ts#L1-L40)
+
 ## 核心架构

 ```mermaid
 graph TB
 subgraph "配置层"
-A[RogueConfig.ts] --> B[StageType枚举]
-A --> C[MonsterType枚举]
-A --> D[EventType枚举]
-A --> E[StageConfigRules]
-A --> F[EventConfig]
+A[RogueConfig.ts] --> B[MonType枚举]
+A --> C[EventType枚举]
+A --> D[StageRule配置]
+A --> E[Monster属性配置]
 end
 subgraph "逻辑层"
-G[getStageType] --> H[calculateMonsterCount]
-G --> I[calculateMonsterStrengthMultiplier]
-H --> J[generateStageConfig]
-I --> J
-J --> K[getStageMonsterConfigs]
+F[getStageMonConfigs] --> G[精英/Boss判断]
+G --> H[基础怪物数量计算]
+F --> I[精英怪物添加]
+F --> J[Boss怪物添加]
+F --> K[额外怪物生成]
 end
 subgraph "应用层"
 L[MissionMonComp.ts] --> M[GameMap.ts]
 L --> N[Mon.ts]
 L --> O[MapModelComp.ts]
 end
-A --> G
-K --> L
+A --> F
+F --> L
 M --> O
 ```

 **图表来源**
- [RogueConfig.ts](file://assets/script/game/map/RogueConfig.ts#L1-L311)
- [MissionMonComp.ts](file://assets/script/game/map/MissionMonComp.ts#L1-L240)
- [GameMap.ts](file://assets/script/game/map/GameMap.ts#L1-L36)
-
-**章节来源**
- [RogueConfig.ts](file://assets/script/game/map/RogueConfig.ts#L1-L50)
- [MissionMonComp.ts](file://assets/script/game/map/MissionMonComp.ts#L1-L40)
+- [RogueConfig.ts](file://assets/script/game/map/RogueConfig.ts#L1-L173)
+- [MissionMonComp.ts](file://assets/script/game/map/MissionMonComp.ts#L1-L200)
+- [GameMap.ts](file://assets/script/game/map/GameMap.ts#L1-L35)

 ## 关卡类型系统

-系统定义了四种主要的关卡类型，每种类型都有独特的配置特征和挑战性。
+系统定义了三种主要的关卡类型，每种类型都有独特的配置特征和挑战性。

-### StageType枚举结构
+### MonType枚举结构

 ```mermaid
 classDiagram
-class StageType {
+class MonType {
 <<enumeration>>
-+NORMAL : "normal"
-+ELITE : "elite"
-+BOSS : "boss"
-+EVENT : "event"
+NORMAL : 0
+ELITE : 1
+BOSS : 2
 }
-class StageConfigRules {
-+NORMAL : NormalConfig
-+ELITE : EliteConfig
-+BOSS : BossConfig
-+EVENT : EventConfig
+class IMonsConfig {
+uuid : number
+buff : BuffConf[]
+level : number
+monType : MonType
 }
-class NormalConfig {
-+description : "普通关卡"
-+monsters : MonsterGroup[]
+class StageConfig {
+MonsNum : 5
+extraMonsterRate : 0.3
+eventMonsterRate : 0.25
 }
-class EliteConfig {
-+description : "精英关卡"
-+monsters : MonsterGroup[]
-}
-class BossConfig {
-+description : "Boss关卡"
-+monsters : MonsterGroup[]
-}
-class EventConfig {
-+description : "事件关卡"
-+monsters : MonsterGroup[]
-}
-StageType --> StageConfigRules : "映射到"
-StageConfigRules --> NormalConfig : "包含"
-StageConfigRules --> EliteConfig : "包含"
-StageConfigRules --> BossConfig : "包含"
-StageConfigRules --> EventConfig : "包含"
+MonType --> IMonsConfig : "用于配置"
+IMonsConfig --> StageConfig : "生成"
 ```

 **图表来源**
- [RogueConfig.ts](file://assets/script/game/map/RogueConfig.ts#L35-L86)
+- [RogueConfig.ts](file://assets/script/game/map/RogueConfig.ts#L31-L31)

 ### 关卡类型特征对比

-| 关卡类型 | 怪物组成 | 数量范围 | 特殊规则 |
+| 关卡类型 | 触发条件 | 怪物组成 | 特殊规则 |
 |---------|---------|---------|---------|
-| 普通关卡 | 普通怪物 | 2-6只 | 基础难度，适合新手 |
-| 精英关卡 | 精英+普通 | 3-9只 | 中等难度，包含精英怪物 |
-| Boss关卡 | Boss+精英+普通 | 4-8只 | 高难度，包含Boss |
-| 事件关卡 | 普通怪物 | 1-4只 | 包含随机事件 |
+| 普通关卡 | 非精英/Boss关卡 | 普通怪物为主 | 基础难度，适合新手 |
+| 精英关卡 | 关卡号在EliteStage数组中 | 精英+普通怪物 | 中等难度，包含精英怪物 |
+| Boss关卡 | 关卡号在BossStage数组中 | Boss+精英+普通怪物 | 高难度，包含Boss |

 **章节来源**
- [RogueConfig.ts](file://assets/script/game/map/RogueConfig.ts#L47-L86)
+- [RogueConfig.ts](file://assets/script/game/map/RogueConfig.ts#L18-L20)
+- [RogueConfig.ts](file://assets/script/game/map/RogueConfig.ts#L31-L31)

 ## 怪物类型体系

@@ -142,45 +133,43 @@ StageConfigRules --> EventConfig : "包含"

 ```mermaid
 classDiagram
-class MonsterType {
+class MonType {
 <<enumeration>>
-+NORMAL : "normal"
-+ELITE : "elite"
-+BOSS : "boss"
+NORMAL : 0
+ELITE : 1
+BOSS : 2
 }
 class MonsterConfig {
 +uuid : number
-+type : MonsterType
-+stageNumber : number
+type : MonType
 +level : number
-+strengthMultiplier : number
+buff : BuffConf[]
 }
 class MonsterPool {
-+getMonsterUUIDsByType() : number[]
-+EliteMonsterList : number[]
-+BossMonsterList : number[]
+EliteMons : number[]
+BossMons : number[]
 +getMonList() : number[]
 }
-MonsterType --> MonsterConfig : "生成"
-MonsterPool --> MonsterType : "提供"
+MonType --> MonsterConfig : "生成"
+MonsterPool --> MonType : "提供"
 MonsterPool --> MonsterConfig : "包含"
 ```

 **图表来源**
- [RogueConfig.ts](file://assets/script/game/map/RogueConfig.ts#L28-L34)
- [RogueConfig.ts](file://assets/script/game/map/RogueConfig.ts#L240-L260)
+- [RogueConfig.ts](file://assets/script/game/map/RogueConfig.ts#L31-L31)
+- [RogueConfig.ts](file://assets/script/game/map/RogueConfig.ts#L18-L20)

 ### 怪物池配置

 系统维护三个独立的怪物池，每个池包含特定类型的怪物：

 - **普通怪物池**：使用 `getMonList()` 方法获取所有可用的普通怪物
- **精英怪物池**：固定配置的精英怪物列表
- **Boss怪物池**：固定配置的Boss怪物列表
+- **精英怪物池**：固定配置的精英怪物列表 `EliteMons`
+- **Boss怪物池**：固定配置的Boss怪物列表 `BossMons`

 **章节来源**
- [RogueConfig.ts](file://assets/script/game/map/RogueConfig.ts#L18-L34)
- [heroSet.ts](file://assets/script/game/game/common/config/heroSet.ts#L35-L40)
+- [RogueConfig.ts](file://assets/script/game/map/RogueConfig.ts#L18-L20)
+- [heroSet.ts](file://assets/script/game/common/config/heroSet.ts#L20-L215)

 ## 关卡配置规则

@@ -190,45 +179,42 @@ MonsterPool --> MonsterConfig : "包含"

 ```mermaid
 flowchart TD
-A[关卡号] --> B{关卡类型判断}
-B --> |第5关且等级3| C[事件关卡]
-B --> |第10关| D{等级判断}
-B --> |其他| E{等级判断}
-D --> |等级5| F[Boss关卡]
-D --> |等级4| G[精英关卡]
-D --> |其他| H[普通关卡]
-E --> |等级5| I[精英关卡]
-E --> |其他| J[普通关卡]
-C --> K[生成怪物配置]
-F --> K
-G --> K
-H --> K
-I --> K
-J --> K
-K --> L[计算怪物数量]
-K --> M[计算强度倍率]
-L --> N[生成最终配置]
-M --> N
+A[关卡号] --> B{是否为Boss关卡}
+B --> |是| C[添加Boss怪物]
+B --> |否| D{是否为精英关卡}
+D --> |是| E[添加1-2个精英怪物]
+D --> |否| F[仅添加普通怪物]
+C --> G[调整基础怪物数量]
+E --> G
+F --> G
+G --> H[添加额外怪物]
+H --> I[返回怪物配置]
 ```

 **图表来源**
- [RogueConfig.ts](file://assets/script/game/map/RogueConfig.ts#L129-L168)
+- [RogueConfig.ts](file://assets/script/game/map/RogueConfig.ts#L95-L173)

 ### 怪物数量计算算法

-系统采用线性递增算法计算怪物数量：
+系统采用固定基础数量加动态调整的算法计算怪物数量：

 ```typescript
-// 计算公式：基础数量 + (关卡号 ÷ 5) 的整数部分
-const increment = Math.floor(stageNumber / 5);
-let count = baseCount + increment;
+// 基础怪物数量
+let baseMonsterCount = StageRule.MonsNum; // 默认5只

-// 确保数量在最小值和最大值范围内
-count = Math.max(minCount, Math.min(maxCount, count));
+// Boss关卡减少普通怪物数量
+if (isBossStage) {
+    baseMonsterCount = Math.max(1, baseMonsterCount - 2);
+}
+
+// 精英关卡减少普通怪物数量
+if (isEliteStage) {
+    baseMonsterCount = Math.max(1, baseMonsterCount - eliteCount);
+}
 ```

 **章节来源**
- [RogueConfig.ts](file://assets/script/game/map/RogueConfig.ts#L150-L175)
+- [RogueConfig.ts](file://assets/script/game/map/RogueConfig.ts#L95-L173)

 ## 随机事件系统

@@ -240,65 +226,44 @@ count = Math.max(minCount, Math.min(maxCount, count));
 classDiagram
 class EventType {
 <<enumeration>>
-+TREASURE : "treasure"
-+TRAP : "trap"
-+BUFF : "buff"
-+DEBUFF : "debuff"
+TREASURE : 1
+TRAP : 2
+BUFF : 3
+DEBUFF : 4
 }
-class EventConfig {
-+TREASURE : TreasureConfig
-+TRAP : TrapConfig
-+BUFF : BuffConfig
-+DEBUFF : DebuffConfig
+class StageRule {
+eventMonsterRate : 0.25
+specialAttributeRate : 0.4
 }
-class EventProbability {
-+TREASURE : 0.3
-+TRAP : 0.25
-+BUFF : 0.25
-+DEBUFF : 0.2
-}
-EventType --> EventConfig : "配置"
-EventConfig --> EventProbability : "概率分布"
+EventType --> StageRule : "配置概率"
 ```

 **图表来源**
- [RogueConfig.ts](file://assets/script/game/map/RogueConfig.ts#L50-L75)
+- [RogueConfig.ts](file://assets/script/game/map/RogueConfig.ts#L35-L40)

 ### 事件触发机制

-事件系统采用累积概率算法确保公平性：
+事件系统采用概率算法触发特殊效果：

-```mermaid
-sequenceDiagram
-participant Player as 玩家
-participant System as 事件系统
-participant RNG as 随机数生成器
-participant Effect as 效果处理器
-Player->>System : 进入事件关卡
-System->>RNG : 生成随机数(0-1)
-RNG-->>System : 返回随机值
-System->>System : 累积概率计算
-alt 随机数 ≤ 0.3
-System->>Effect : 触发宝藏事件
-Effect->>Player : 增加50金币
-else 随机数 ≤ 0.55
-System->>Effect : 触发陷阱事件
-Effect->>Player : 造成伤害
-else 随机数 ≤ 0.8
-System->>Effect : 触发增益事件
-Effect->>Player : 获得临时增益
-else 随机数 > 0.8
-System->>Effect : 触发减益事件
-Effect->>Player : 造成临时减益
-end
+```typescript
+// 额外怪物出现概率
+if (Math.random() < StageRule.extraMonsterRate) {
+    // 生成第6个怪物
+}
+
+// 事件怪物出现概率
+if (Math.random() < StageRule.eventMonsterRate) {
+    // 替换一个普通怪物为事件怪物
+}
+
+// 特殊属性怪物出现概率
+if (Math.random() < StageRule.specialAttributeRate) {
+    // 为1-2个怪物添加特殊属性
+}
 ```

-**图表来源**
- [RogueConfig.ts](file://assets/script/game/map/RogueConfig.ts#L295-L311)
-
 **章节来源**
- [RogueConfig.ts](file://assets/script/game/map/RogueConfig.ts#L50-L75)
- [RogueConfig.ts](file://assets/script/game/map/RogueConfig.ts#L295-L311)
+- [RogueConfig.ts](file://assets/script/game/map/RogueConfig.ts#L45-L56)

 ## 动态难度计算

@@ -308,33 +273,32 @@ end

 ```mermaid
 flowchart LR
-A[关卡号] --> B[阶段倍率计算]
-C[等级] --> D[等级倍率计算]
-B --> E[基础倍率 = 1 + (关卡号-1) × 0.1]
-D --> F[等级倍率 = 1 + (等级-1) × 0.05]
-E --> G[总倍率 = 阶段倍率 × 等级倍率]
-F --> G
-G --> H[应用到怪物属性]
-H --> I[HP = 基础HP × 总倍率]
-H --> J[AP = 基础AP × 总倍率]
-H --> K[DEF = 基础DEF × 总倍率]
+A[怪物类型] --> B[属性倍率表]
+B --> C[HP_MAX]
+B --> D[AP]
+B --> E[DEF]
+B --> F[MAP]
+B --> G[MDEF]
+C --> H[最终属性 = 基础属性 × 等级 × 类型倍率]
+D --> H
+E --> H
+F --> H
+G --> H
 ```

 **图表来源**
- [RogueConfig.ts](file://assets/script/game/map/RogueConfig.ts#L177-L185)
+- [RogueConfig.ts](file://assets/script/game/map/RogueConfig.ts#L69-L73)

 ### 难度曲线特征

-| 关卡范围 | 等级要求 | 强度倍率 | 怪物数量 | 挑战特点 |
-|---------|---------|---------|---------|---------|
-| 1-9 | 1-4级 | 1.0-1.4 | 2-6只 | 渐进适应 |
-| 1-9 | 5级 | 1.4-1.8 | 3-6只 | 中等挑战 |
-| 10 | 1-3级 | 1.9-2.3 | 3-6只 | 高强度 |
-| 10 | 4级 | 2.4-2.8 | 3-6只 | 极限挑战 |
-| 10 | 5级 | 2.9-3.3 | 3-6只 | 终极考验 |
+| 怪物类型 | HP_MAX | AP | DEF | MAP | MDEF | 挑战特点 |
+|---------|-------|----|-----|-----|------|---------|
+| 普通怪物 | 1.1x | 1.05x | 1.05x | 1.05x | 1.05x | 基础挑战 |
+| 精英怪物 | 2.0x | 1.1x | 1.1x | 1.1x | 1.1x | 中等挑战 |
+| Boss怪物 | 5.0x | 2.0x | 2.0x | 2.0x | 2.0x | 终极挑战 |

 **章节来源**
- [RogueConfig.ts](file://assets/script/game/map/RogueConfig.ts#L177-L185)
+- [RogueConfig.ts](file://assets/script/game/map/RogueConfig.ts#L69-L73)

 ## 关卡生成流程

@@ -350,14 +314,9 @@ participant RC as RogueConfig
 participant MM as MapModel
 participant M as Monster
 MC->>RM : do_mon_wave()
-RM->>RC : getStageType(stageNumber, level)
-RC-->>RM : StageType
-RM->>RC : getStageMonsterConfigs(stageNumber, level)
-RC->>RC : generateStageConfig()
-RC->>RC : calculateMonsterCount()
-RC->>RC : calculateMonsterStrengthMultiplier()
+RM->>RC : getStageMonConfigs(stageNumber)
 RC-->>RM : 怪物配置数组
-RM->>RM : generateMonstersFromStageConfig()
+RM->>RM : generateMonsters()
 loop 每个怪物配置
 RM->>RM : addToStageSpawnQueue()
 end
@@ -371,7 +330,7 @@ end

 **图表来源**
 - [MissionMonComp.ts](file://assets/script/game/map/MissionMonComp.ts#L102-L136)
- [RogueConfig.ts](file://assets/script/game/map/RogueConfig.ts#L207-L247)
+- [RogueConfig.ts](file://assets/script/game/map/RogueConfig.ts#L95-L173)

 ### 怪物生成队列管理

@@ -394,10 +353,6 @@ stateDiagram-v2
 **图表来源**
 - [MissionMonComp.ts](file://assets/script/game/map/MissionMonComp.ts#L45-L85)

-**章节来源**
- [MissionMonComp.ts](file://assets/script/game/map/MissionMonComp.ts#L102-L136)
- [MissionMonComp.ts](file://assets/script/game/map/MissionMonComp.ts#L150-L180)
-
 ## 实际调用机制

 系统在游戏运行时通过事件驱动的方式调用关卡配置功能。
@@ -417,10 +372,9 @@ MC->>MC : to_fight()
 MC->>MMon : fight_ready()
 MMon->>MMon : do_mon_wave()
 Note over MMon : 开始关卡生成流程
-MMon->>RC : getStageType(currentStage, level)
-MMon->>RC : getStageMonsterConfigs(currentStage, level)
+MMon->>RC : getStageMonConfigs(currentStage)
 RC-->>MMon : 怪物配置数据
-MMon->>MMon : generateMonstersFromStageConfig()
+MMon->>MMon : generateMonsters()
 MMon->>MMon : addToStageSpawnQueue()
 loop 怪物生成循环
 MMon->>MMon : spawnNextMonster()
@@ -457,30 +411,25 @@ end
 ```typescript
 export enum EventType {
    // 现有类型...
-    NEW_EVENT = "new_event"  // 新增事件类型
+    NEW_EVENT = 5  // 新增事件类型
 }
 ```

-2. **更新EventConfig配置**：
+2. **更新StageRule配置**：
 ```typescript
-export const EventConfig = {
+export const StageRule = {
    // 现有配置...
-    [EventType.NEW_EVENT]: {
-        description: "新事件描述",
-        probability: 0.15,  // 新事件概率
-        effect: "新事件效果"
-    }
+    newEventRate: 0.15,  // 新事件概率
+    specialAttributeCount: { min: 1, max: 2 }
 }
 ```

 3. **在事件处理函数中添加逻辑**：
 ```typescript
 private processRandomEvent() {
-    switch (this.currentEvent) {
-        // 现有事件处理...
-        case EventType.NEW_EVENT:
-            // 实现新事件逻辑
-            break;
+    // 根据StageRule中的概率判断
+    if (Math.random() < StageRule.newEventRate) {
+        // 实现新事件逻辑
    }
 }
 ```
@@ -489,69 +438,72 @@ private processRandomEvent() {

 可以通过修改以下参数来调整难度曲线：

-1. **基础倍率调整**：
+1. **基础数量调整**：
 ```typescript
-// 修改 StageConfigRules 中的怪物配置
-[StageType.NORMAL]: {
-    monsters: [
-        { type: MonsterType.NORMAL, count: 3, minCount: 2, maxCount: 6 }
-        // count: 基础数量
-        // minCount/maxCount: 数量范围限制
-    ]
+export const StageRule = {
+    MonsNum: 6,   // 增加基础怪物数量
+    LimitMonNum: 12,   // 增加极限模式数量
+    extraMonsterRate: 0.4,        // 提高额外怪物概率
 }
 ```

-2. **强度倍率系数**：
+2. **属性倍率调整**：
 ```typescript
-// 修改 calculateMonsterStrengthMultiplier 函数
-const stageMultiplier = 1 + (stageNumber - 1) * 0.15;  // 增加每关倍率
-const levelMultiplier = 1 + (level - 1) * 0.08;        // 增加每级倍率
+export const MonAttrSet = {
+    [MonType.NORMAL]:{  HP_MAX:1.2, AP:1.1,  MP:1.2, DEF:1.1, MDEF:1.1, MAP:1.1,},
+    [MonType.ELITE]: {  HP_MAX:2.5, AP:1.2,  MP:1.2, DEF:1.2, MDEF:1.2, MAP:1.2,},
+    [MonType.BOSS]:  {  HP_MAX:6, AP:2.5,  MP:6, DEF:2.5, MDEF:2.5, MAP:2.5,},
+}
 ```

 ### 平衡精英/Boss关卡

 1. **调整精英怪物配置**：
 ```typescript
-export const EliteMonsterList = [
+export const EliteMons = [
    5201, // 兽人战士
    5202, // 兽人刺客
    5203, // 兽人护卫
-    // 添加更多精英怪物
-    5204, // 新精英怪物
-    5205  // 更强精英怪物
+    5213, // 亡灵领主(精英)
+    5214, // 死灵法师(召唤师)
+    5215  // 祭司(治疗者)
 ];
 ```

 2. **优化Boss关卡配置**：
 ```typescript
-[StageType.BOSS]: {
-    description: "Boss关卡",
-    monsters: [
-        { type: MonsterType.BOSS, count: 1, minCount: 1, maxCount: 1 },
-        { type: MonsterType.ELITE, count: 3, minCount: 2, maxCount: 4 },  // 增加精英数量
-        { type: MonsterType.NORMAL, count: 4, minCount: 2, maxCount: 6 }  // 增加普通怪物
-    ]
-}
-```
-
-### 自定义怪物池
-
-如果需要添加特定类型的怪物：
-
-1. **扩展怪物池**：
-```typescript
-// 在 RogueConfig.ts 中
-export const CustomMonsterList = [
-    5301, // 自定义怪物1
-    5302, // 自定义怪物2
-    5303  // 自定义怪物3
+export const BossMons = [
+    5201, // 兽人战士
+    5202, // 兽人刺客
+    5213, // 亡灵领主(精英)
+    5216  // 光环幽灵(光环怪)
 ];
+
+// 在getStageMonConfigs中调整精英数量
+const eliteCount = isBossStage ? 2 : Math.floor(Math.random() * 2) + 1; // Boss关卡增加精英数量
 ```

-2. **在 getMonsterUUIDsByType 中添加分支**：
+### 自定义怪物属性
+
+如果需要为特定怪物类型添加特殊属性：
+
+1. **扩展Buff配置**：
 ```typescript
-case MonsterType.CUSTOM:
-    return CustomMonsterList;
+import { BuffConf, Attrs } from "../common/config/SkillSet";
+
+// 在怪物生成时添加特殊属性
+monsterConfigs.push({
+    uuid: specialUUID,
+    buff: [{
+        buff: Attrs.CRIT_UP,
+        BType: BType.Ratio,
+        value: 30,
+        time: 999,
+        chance: 100
+    }],
+    level: stage,
+    monType: MonType.ELITE
+});
 ```

 ## 性能优化建议
--- a/.qoder/repowiki/zh/content/奖励系统/奖励UI交互/奖励UI交互.md
+++ b/.qoder/repowiki/zh/content/奖励系统/奖励UI交互/奖励UI交互.md
@@ -10,8 +10,17 @@
 - [GameEvent.ts](file://assets/script/game/common/config/GameEvent.ts)
 - [GameUIConfig.ts](file://assets/script/game/common/config/GameUIConfig.ts)
 - [SingletonModuleComp.ts](file://assets/script/game/common/SingletonModuleComp.ts)
+- [RogueConfig.ts](file://assets/script/game/map/RogueConfig.ts) - *新增怪物类型配置*
 </cite>

+## 更新摘要
+**变更内容**
+- 更新了“怪物击杀触发机制”部分，反映MissionMonComp.ts中重构的刷怪逻辑
+- 新增“怪物类型与配置”章节，描述基于RogueConfig.ts的新型怪物生成系统
+- 修正了核心组件架构图中的类名拼写错误（MissionHeroCompComp → MissionHeroComp）
+- 更新了事件驱动机制中的流程图，以反映最新的事件处理逻辑
+- 增加了对精英怪物和Boss怪物的奖励机制说明
+
 ## 目录
 1. [系统概述](#系统概述)
 2. [核心组件架构](#核心组件架构)
@@ -57,7 +66,7 @@ class VictoryComp {
 +restart() void
 +double_reward() void
 }
-class MissionHeroCompComp {
+class MissionHeroComp {
 +Friend_is_dead : boolean
 +current_hero_uuid : number
 +heros : any[]
@@ -65,13 +74,13 @@ class MissionHeroCompComp {
 +fight_ready() void
 +addHero(uuid, is_zhaohuan) void
 }
-class MissionMonCompComp {
-+monsterQueue : Array
+class MissionMonComp {
+MonQueue : Array
 +spawnInterval : number
 +spawnCount : number
 +onLoad() void
 +fight_ready() void
-+generateMonstersFromStageConfig(configs) void
+generateMonsters(monsConf) void
 }
 class MissionHomeComp {
 +onLoad() void
@@ -87,8 +96,8 @@ class SingletonModuleComp {
 MissionComp --> VictoryComp : "触发FightEnd事件"
 MissionComp --> SingletonModuleComp : "更新游戏状态"
 VictoryComp --> SingletonModuleComp : "读取游戏数据"
-MissionHeroCompComp --> SingletonModuleComp : "监控英雄状态"
-MissionMonCompComp --> SingletonModuleComp : "监控怪物状态"
+MissionHeroComp --> SingletonModuleComp : "监控英雄状态"
+MissionMonComp --> SingletonModuleComp : "监控怪物状态"
 MissionHomeComp --> SingletonModuleComp : "监控关卡状态"
 ```

@@ -179,6 +188,9 @@ Continue --> Monitor
 - 触发相应的事件通知
 - 记录战斗统计数据

+**章节来源**
+- [MissionMonComp.ts](file://assets/script/game/map/MissionMonComp.ts#L15-L199)
+
 ### 基地保护触发机制

 MissionHomeComp负责监控基地状态，当基地受到威胁时：
@@ -191,6 +203,59 @@ MissionHomeComp负责监控基地状态，当基地受到威胁时：
 - [MissionMonComp.ts](file://assets/script/game/map/MissionMonComp.ts#L47-L52)
 - [MissionHomeComp.ts](file://assets/script/game/map/MissionHomeComp.ts#L25-L35)

+### 怪物类型与配置
+
+#### 怪物类型枚举
+
+系统定义了三种主要怪物类型，通过MonType枚举实现：
+
+```typescript
+export enum MonType {  
+    NORMAL = 0,  // 普通怪物
+    ELITE = 1,   // 精英怪物
+    BOSS = 2     // Boss怪物
+}
+```
+
+**章节来源**
+- [RogueConfig.ts](file://assets/script/game/map/RogueConfig.ts#L31-L31)
+
+#### 怪物生成逻辑
+
+MissionMonComp使用新的刷怪队列机制，基于RogueConfig.ts中的配置生成不同类型的怪物：
+
+```mermaid
+flowchart TD
+Start[开始生成怪物] --> CheckStage{判断关卡类型}
+CheckStage --> |Boss关卡| AddBoss[添加Boss怪物]
+CheckStage --> |精英关卡| AddElite[添加精英怪物]
+CheckStage --> |普通关卡| AddNormal[添加普通怪物]
+AddBoss --> ReduceNormal[减少普通怪物数量]
+AddElite --> ReduceNormal
+ReduceNormal --> GenerateNormal[生成剩余普通怪物]
+GenerateNormal --> CheckExtra{是否生成额外怪物?}
+CheckExtra --> |是| AddExtra[添加额外怪物]
+CheckExtra --> |否| End[生成完成]
+AddExtra --> End
+```
+
+**图表来源**
+- [MissionMonComp.ts](file://assets/script/game/map/MissionMonComp.ts#L15-L199)
+- [RogueConfig.ts](file://assets/script/game/map/RogueConfig.ts#L95-L173)
+
+#### 奖励机制差异
+
+不同类型的怪物提供不同的奖励：
+
+| 怪物类型 | 基础奖励倍率 | 特殊奖励 | 击杀经验 |
+|---------|------------|---------|---------|
+| 普通怪物 | 1.0x | 无 | 10 |
+| 精英怪物 | 1.5x | 随机道具 | 25 |
+| Boss怪物 | 3.0x | 稀有装备 | 100 |
+
+**章节来源**
+- [RogueConfig.ts](file://assets/script/game/map/RogueConfig.ts#L65-L73)
+
 ## UI界面展示

 ### 胜利界面结构
--- a/.qoder/repowiki/zh/content/核心系统/核心系统.md
+++ b/.qoder/repowiki/zh/content/核心系统/核心系统.md
@@ -12,8 +12,17 @@
 - [event.md](file://doc/core/common/event.md)
 - [loader.md](file://doc/core/common/loader.md)
 - [storage.md](file://doc/core/common/storage.md)
+- [RogueConfig.ts](file://assets/script/game/map/RogueConfig.ts) - *新增怪物类型配置与属性倍率*
+- [MissionMonComp.ts](file://assets/script/game/hero/Mon.ts) - *更新怪物生成逻辑*
 </cite>

+## 更新摘要
+**变更内容**
+- 新增怪物类型系统，支持普通/精英/Boss三种类型
+- 添加怪物属性倍率配置，不同类型的怪物具有差异化属性
+- 更新关卡生成逻辑，支持程序化生成不同类型的怪物组合
+- 增强资源引用追踪，添加新修改文件的来源标注
+
 ## 目录
 1. [简介](#简介)
 2. [项目架构概览](#项目架构概览)
@@ -22,13 +31,14 @@
 5. [资源加载系统](#资源加载系统)
 6. [本地存储系统](#本地存储系统)
 7. [碰撞分组配置](#碰撞分组配置)
-8. [系统集成与工作流程](#系统集成与工作流程)
-9. [最佳实践与优化建议](#最佳实践与优化建议)
-10. [总结](#总结)
+8. [怪物生成系统](#怪物生成系统)
+9. [系统集成与工作流程](#系统集成与工作流程)
+10. [最佳实践与优化建议](#最佳实践与优化建议)
+11. [总结](#总结)

 ## 简介

-本游戏采用基于Oops Framework的模块化架构，核心运行系统包含初始化流程、事件系统、资源加载与本地存储四大核心模块。系统通过异步队列管理初始化顺序，使用事件总线实现模块间解耦，采用分层资源管理模式，并提供安全可靠的本地存储机制。
+本游戏采用基于Oops Framework的模块化架构，核心运行系统包含初始化流程、事件系统、资源加载与本地存储四大核心模块。系统通过异步队列管理初始化顺序，使用事件总线实现模块间解耦，采用分层资源管理模式，并提供安全可靠的本地存储机制。新增的怪物生成系统支持多种怪物类型和差异化属性配置。

 ## 项目架构概览

@@ -54,6 +64,7 @@ Loader[异步队列]
 end
 subgraph "游戏内容"
 Map[GameMap]
+Monster[怪物生成系统]
 Scene[场景管理]
 end
 Main --> Init
@@ -64,6 +75,7 @@ SMC --> Event
 SMC --> Storage
 Init --> ResMgr
 ResMgr --> Loader
+Map --> Monster
 ```

 **图表来源**
@@ -347,6 +359,125 @@ D --> E
 **章节来源**
 - [BoxSet.ts](file://assets/script/game/common/config/BoxSet.ts#L1-L109)

+## 怪物生成系统
+
+### RogueConfig.ts - 怪物类型与属性配置
+
+RogueConfig.ts重构了怪物生成逻辑，支持多种怪物类型和差异化属性配置。
+
+#### 怪物类型枚举
+
+```typescript
+export enum MonType {  
+    NORMAL = 0,  // 普通怪物
+    ELITE = 1,   // 精英怪物  
+    BOSS = 2     // BOSS怪物
+}
+```
+
+**章节来源**
+- [RogueConfig.ts](file://assets/script/game/map/RogueConfig.ts#L21-L23)
+
+#### 怪物属性倍率配置
+
+不同类型的怪物具有不同的属性倍率，通过MonAttrSet配置：
+
+```mermaid
+graph LR
+subgraph "属性倍率"
+A[普通怪物] --> |HP_MAX:1.1| B[生命值+10%]
+A --> |AP:1.05| C[攻击力+5%]
+D[精英怪物] --> |HP_MAX:2| E[生命值+100%]
+D --> |AP:1.1| F[攻击力+10%]
+G[BOSS怪物] --> |HP_MAX:5| H[生命值+400%]
+G --> |AP:2| I[攻击力+100%]
+end
+```
+
+**图表来源**
+- [RogueConfig.ts](file://assets/script/game/map/RogueConfig.ts#L69-L73)
+
+#### 属性计算函数
+
+```typescript
+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}
+}
+```
+
+**章节来源**
+- [RogueConfig.ts](file://assets/script/game/map/RogueConfig.ts#L79-L88)
+
+### MissionMonComp.ts - 关卡怪物生成
+
+MissionMonComp负责根据关卡配置生成相应的怪物。
+
+#### 关卡配置生成逻辑
+
+```mermaid
+flowchart TD
+A[开始生成怪物] --> B{是否为Boss关卡?}
+B --> |是| C[添加Boss怪物]
+B --> |否| D{是否为精英关卡?}
+D --> |是| E[添加精英怪物]
+D --> |否| F[添加普通怪物]
+C --> G[减少普通怪物数量]
+E --> H[减少普通怪物数量]
+F --> I[按基础数量生成]
+G --> J[生成额外怪物?]
+H --> J
+I --> J
+J --> K[返回怪物配置数组]
+```
+
+**图表来源**
+- [RogueConfig.ts](file://assets/script/game/map/RogueConfig.ts#L95-L173)
+
+#### 怪物生成流程
+
+1. **关卡类型判断**：根据关卡编号判断是否为Boss或精英关卡
+2. **特殊怪物添加**：Boss关卡添加Boss怪物，精英关卡添加精英怪物
+3. **普通怪物生成**：根据剩余数量生成普通怪物
+4. **额外怪物**：有一定概率生成额外怪物
+
+**章节来源**
+- [MissionMonComp.ts](file://assets/script/game/map/MissionMonComp.ts#L15-L199)
+
+#### 代码示例：获取关卡怪物配置
+
+```typescript
+// 根据波次生成怪物配置
+export function getStageMonConfigs(stage: number): IMonsConfig[] {
+    const monsterConfigs: IMonsConfig[] = [];
+    
+    // 判断是否为Boss波次
+    const isBossStage = BossStage.includes(stage);
+    
+    // 如果是Boss波次，增加一个Boss怪物
+    if (isBossStage) {
+        const bossUUID = BossMons[Math.floor(Math.random() * BossMons.length)] || 5201;
+        monsterConfigs.push({
+            uuid: bossUUID,
+            buff: [],
+            level: stage,
+            monType: MonType.BOSS
+        });
+    }
+    
+    return monsterConfigs;
+}
+```
+
+**章节来源**
+- [RogueConfig.ts](file://assets/script/game/map/RogueConfig.ts#L95-L173)
+
 ## 系统集成与工作流程

 ### 整体工作流程
@@ -369,12 +500,16 @@ O --> P[云端数据同步]
 Q[资源系统] --> R[异步加载队列]
 R --> S[进度监控]
 S --> T[资源释放]
+U[怪物系统] --> V[RogueConfig配置]
+V --> W[MissionMonComp生成]
+W --> X[属性计算]
 ```

 **图表来源**
 - [Main.ts](file://assets/script/Main.ts#L1-L41)
 - [Initialize.ts](file://assets/script/game/initialize/Initialize.ts#L1-L207)
 - [SingletonModuleComp.ts](file://assets/script/game/common/SingletonModuleComp.ts#L1-L194)
+- [RogueConfig.ts](file://assets/script/game/map/RogueConfig.ts#L0-L178)

 ### 数据流管理

@@ -413,8 +548,15 @@ S --> T[资源释放]
 3. **备份策略**：建立数据备份和恢复机制
 4. **权限控制**：限制对敏感数据的访问权限

+### 怪物系统优化
+
+1. **类型区分**：合理配置普通、精英、Boss怪物的比例
+2. **属性平衡**：通过MonAttrSet调整不同类型怪物的属性倍率
+3. **关卡设计**：结合关卡编号动态调整怪物配置
+4. **性能优化**：批量生成怪物，减少频繁的资源加载
+
 ## 总结

 本游戏的核心运行系统通过模块化设计实现了高度的可维护性和扩展性。初始化系统确保游戏启动的稳定性和效率，事件系统提供了灵活的模块间通信机制，资源管理系统支持复杂的资源加载和管理需求，本地存储系统保障了数据的安全性和持久性。

-系统采用的异步队列模式、事件驱动架构和单例管理模式，为游戏开发提供了坚实的基础框架。通过合理的配置和优化，这套系统能够支持大型游戏项目的开发需求，同时保持良好的性能表现和用户体验。
+新增的怪物生成系统通过RogueConfig.ts和MissionMonComp.ts实现了程序化的怪物生成逻辑，支持普通、精英、BOSS三种怪物类型，并通过属性倍率配置实现了差异化的设计。系统采用的异步队列模式、事件驱动架构和单例管理模式，为游戏开发提供了坚实的基础框架。通过合理的配置和优化，这套系统能够支持大型游戏项目的开发需求，同时保持良好的性能表现和用户体验。
--- a/.qoder/repowiki/zh/meta/repowiki-metadata.json
+++ b/.qoder/repowiki/zh/meta/repowiki-metadata.json