增加了烟幕弹和末敏弹毫米波干扰器，完善了注释

docs/articles/jammer-spec.md

@@ -0,0 +1,591 @@
+# 干扰机技术说明书
+
+## 1. 概述
+
+### 1.1 文档目的
+
+本文档旨在详细描述主动防护系统中干扰机子系统的设计实现，包括：
+
+1. 各型干扰机的工作原理和关键算法
+2. 系统组件的交互机制和接口定义
+3. 关键参数的配置和验证方法
+4. 测试用例和验证流程
+
+本文档可用于：
+
+- 系统设计和实现的参考依据
+- 测试验证的指导文档
+- 系统维护和升级的技术支持
+- 新功能开发的基础文档
+
+### 1.2 适用范围
+
+本文档适用于以下人员和场景：
+
+1. 开发人员
+   - 系统功能实现
+   - 接口开发和维护
+   - 算法优化和改进
+   - 新功能扩展开发
+
+2. 测试人员
+   - 功能测试设计
+   - 性能测试验证
+   - 系统集成测试
+   - 回归测试执行
+
+3. 维护人员
+   - 系统问题诊断
+   - 参数配置调整
+   - 性能监控分析
+   - 系统升级维护
+
+### 1.3 系统功能
+
+1. 干扰机类型支持
+   - 激光干扰器
+   - 红外干扰器
+   - 毫米波干扰器
+
+2. 核心功能
+   - 干扰功率控制
+   - 冷却时间管理
+   - 目标跟踪
+   - 事件响应
+   - 数据记录
+
+3. 验证功能
+   - 单元测试验证
+   - 系统集成验证
+   - 性能指标验证
+   - 数据分析验证
+
+### 1.4 参考文献
+
+1. 干扰技术参考
+   - 《电子对抗原理》，国防工业出版社
+   - 《激光对抗技术》，国防工业出版社
+   - 《红外对抗技术》，国防工业出版社
+
+2. 系统设计参考
+   - 《软件工程：实践者的研究方法》
+   - 《面向对象分析与设计》
+   - 《设计模式：可复用面向对象软件的基础》
+
+## 2. 系统架构
+
+### 2.1 总体架构
+
+#### 2.1.1 核心组件
+
+1. 基础干扰器类 (JammerBase)
+   - 干扰状态管理
+   - 干扰功率控制
+   - 冷却时间管理
+   - 位置跟随功能
+
+2. 具体干扰器实现
+   - 激光干扰器 (LaserJammer)
+   - 红外干扰器 (InfraredJammer)
+   - 毫米波干扰器 (MillimeterWaveJammer)
+
+3. 干扰器接口 (IJammer)
+   - 干扰控制接口
+   - 状态查询接口
+   - 事件处理接口
+
+#### 2.1.2 事件系统
+
+1. 告警响应事件
+   - 激光告警事件
+   - 红外告警事件
+   - 毫米波告警事件
+
+2. 干扰控制事件
+   - 干扰开始事件
+   - 干扰停止事件
+   - 干扰状态更新事件
+
+### 2.2 接口定义
+
+#### 2.2.1 IJammer 接口
+
+```csharp
+public interface IJammer
+{
+    bool IsJamming { get; }
+    double CurrentJammingPower { get; }
+    void StartJamming();
+    void StopJamming();
+    string GetJammingStatus();
+}
+```
+
+#### 2.2.2 事件接口
+
+1. 干扰事件基类
+   - SenderId：事件发送者ID
+   - Timestamp：事件时间戳
+   - TargetId：目标ID
+
+2. 具体事件类型
+   - LaserJammingEvent
+   - InfraredJammingEvent
+   - MillimeterWaveJammingEvent
+
+### 2.3 数据流
+
+#### 2.3.1 干扰控制流程
+
+```mermaid
+graph LR
+    A[告警器] --> B[告警事件]
+    B --> C[干扰器]
+    C --> D[干扰控制]
+    D --> E[干扰事件]
+```
+
+#### 2.3.2 状态更新流程
+
+```mermaid
+graph LR
+    A[干扰器] --> B[状态更新]
+    B --> C[功率控制]
+    C --> D[冷却管理]
+    D --> E[事件发布]
+```
+
+## 3. 具体实现
+
+### 3.1 激光干扰器
+
+#### 3.1.1 工作原理
+
+激光干扰器通过发射高功率激光来干扰敌方的激光制导系统。其基本工作过程如下：
+
+1. 干扰启动
+   - 接收激光告警信号
+   - 启动干扰器
+   - 设置初始功率（最大功率的40%）
+   - 开始功率增长
+
+2. 干扰过程
+   - 逐步增加干扰功率
+   - 监控目标位置
+   - 维持干扰输出
+   - 发布干扰事件
+
+3. 冷却管理
+   - 停止干扰时进入冷却
+   - 冷却时间为5秒
+   - 冷却完成后可重新启动
+   - 重置干扰功率
+
+#### 3.1.2 关键参数
+
+1. 功率参数
+   - 最大功率：10kW
+   - 初始功率：4kW
+   - 功率增长率：2kW/s
+
+2. 时间参数
+   - 冷却时间：5秒
+   - 更新周期：与仿真步长一致
+
+### 3.2 红外干扰器
+
+#### 3.2.1 工作原理
+
+红外干扰器通过发射调制的红外辐射来干扰敌方的红外制导系统。其基本工作过程如下：
+
+1. 干扰启动
+   - 接收红外告警信号
+   - 启动干扰器
+   - 设置初始功率
+   - 开始功率增长
+
+2. 干扰过程
+   - 动态调整干扰功率
+   - 跟踪目标位置
+   - 维持干扰输出
+   - 发布干扰事件
+
+3. 冷却管理
+   - 停止干扰时进入冷却
+   - 监控冷却时间
+   - 管理功率重置
+   - 准备下次启动
+
+#### 3.2.2 关键参数
+
+1. 功率参数
+   - 最大功率：由配置指定
+   - 初始功率：最大功率的40%
+   - 功率增长率：由配置指定
+
+2. 波长参数
+   - 工作波长范围：由配置指定
+   - 调制频率：由配置指定
+
+### 3.3 毫米波干扰器
+
+#### 3.3.1 工作原理
+
+毫米波干扰器通过发射干扰信号来干扰敌方的毫米波制导系统。其基本工作过程如下：
+
+1. 干扰启动
+   - 接收毫米波告警信号
+   - 启动干扰器
+   - 设置初始功率（400W）
+   - 开始功率增长
+
+2. 干扰过程
+   - 增加干扰功率（最大1kW）
+   - 功率增长率200W/s
+   - 维持干扰输出
+   - 发布干扰事件
+
+3. 冷却管理
+   - 冷却时间5秒
+   - 监控冷却状态
+   - 管理功率重置
+   - 准备下次启动
+
+#### 3.3.2 关键参数
+
+1. 功率参数
+   - 最大功率：1kW
+   - 初始功率：400W
+   - 功率增长率：200W/s
+
+2. 时间参数
+   - 冷却时间：5秒
+   - 更新周期：与仿真步长一致
+
+### 3.4 烟幕弹
+
+#### 3.4.1 工作原理
+
+烟幕弹通过发射烟幕弹并形成烟幕云来实现多谱段干扰。其基本工作过程如下：
+
+1. 发射阶段
+   - 设置发射角度（默认45度）
+   - 选择烟幕类型
+   - 确定发射数量
+   - 执行发射动作
+
+2. 扩散阶段
+   - 达到预定高度爆炸
+   - 形成初始烟幕云
+   - 逐步扩散到预定直径
+   - 维持预定浓度
+
+3. 干扰阶段
+   - 监控烟幕状态
+   - 计算干扰效果
+   - 考虑风场影响
+   - 更新烟幕参数
+
+4. 衰减阶段
+   - 浓度逐渐降低
+   - 体积缓慢增大
+   - 干扰效果减弱
+   - 最终消散
+
+#### 3.4.2 关键参数
+
+1. 发射参数
+   - 发射角度：45度（π/4弧度）
+   - 烟幕种类：红外/毫米波/多谱段
+   - 发射数量：默认1发
+
+2. 性能参数
+   - 爆炸高度：10米
+   - 烟幕直径：20米
+   - 辐射吸收率：0.8
+   - 初始浓度：0.5kg/m³
+
+3. 时间参数
+   - 扩散时间：3秒
+   - 响应时间：1秒
+   - 有效时间：60秒
+   - 冷却时间：5秒
+
+
+#### 3.4.3 状态参数
+
+1. 空间参数
+   - 烟幕位置：三维坐标
+   - 烟幕高度：米
+   - 烟幕宽度：米
+   - 烟幕厚度：米
+
+2. 物理参数
+   - 当前浓度：kg/m³
+   - 当前距离：米
+   - 持续时间：秒
+   - 剩余时间：秒
+
+### 3.5 末敏弹毫米波干扰器
+
+#### 3.5.1 工作原理
+
+末敏弹毫米波干扰器通过毫米波干扰方式来对抗末制导阶段的毫米波制导武器。其基本工作过程如下：
+
+1. 威胁探测
+   - 监测毫米波辐射
+   - 判断威胁类型
+   - 确定目标距离
+   - 选择干扰方式
+
+2. 干扰准备
+   - 设置干扰参数
+   - 调整波长范围
+   - 计算角度范围
+   - 准备干扰信号
+
+3. 干扰执行
+   - 发射干扰信号
+   - 调整干扰功率
+   - 监控干扰效果
+   - 维持干扰输出
+
+#### 3.5.2 干扰方式
+
+1. 欺骗干扰
+   - 产生虚假毫米波反射特性
+
+#### 3.5.3 关键参数
+
+1. 波长参数
+   - 工作波长：2-4毫米
+   - 角度范围：±30度
+
+2. 距离参数
+   - 探测距离：2000米
+   - 有效距离：1000米
+   - 干扰概率：80%
+   - 响应时间：0.1秒
+
+3. 功率参数
+   - 最大功率：1000W
+
+#### 3.5.4 性能特点
+
+1. 探测能力
+   - 远距离探测
+   - 快速响应
+   - 高精度测距
+   - 目标识别
+
+2. 干扰能力
+   - 多种干扰方式
+   - 高干扰概率
+   - 快速功率调整
+   - 动态策略选择
+
+3. 生存能力
+   - 合理冷却时间
+   - 功率动态调整
+   - 状态实时监控
+   - 自动防护措施
+
+## 4. 验证方法
+
+### 4.1 单元测试
+
+1. 基础功能测试
+   - 干扰器初始化测试
+   - 状态转换测试
+   - 参数设置测试
+   - 事件处理测试
+
+2. 功率控制测试
+   - 功率增长测试
+   - 最大功率限制测试
+   - 冷却重置测试
+   - 功率计算精度测试
+
+3. 冷却管理测试
+   - 冷却时间计算测试
+   - 状态转换测试
+   - 重启条件测试
+   - 异常处理测试
+
+### 4.2 系统测试
+
+1. 集成测试
+   - 告警响应测试
+   - 事件处理测试
+   - 状态同步测试
+   - 数据记录测试
+
+2. 性能测试
+   - 响应时间测试
+   - 资源占用测试
+   - 并发处理测试
+   - 稳定性测试
+
+### 4.3 验证要点
+
+1. 功能验证
+   - 干扰启动可靠性
+   - 功率控制准确性
+   - 冷却管理有效性
+   - 事件处理及时性
+
+2. 性能验证
+   - 响应延迟
+   - 功率控制精度
+   - 状态转换时间
+   - 系统稳定性
+
+## 5. 附录
+
+### 5.1 关键参数表
+
+#### 5.1.1 激光干扰器参数
+
+| 参数       | 值    | 单位 | 说明             |
+| ---------- | ----- | ---- | ---------------- |
+| 最大功率   | 10000 | W    | 最大干扰输出功率 |
+| 初始功率   | 4000  | W    | 启动时的功率     |
+| 功率增长率 | 2000  | W/s  | 功率增长速度     |
+| 冷却时间   | 5     | s    | 停止后的冷却时间 |
+
+#### 5.1.2 红外干扰器参数
+
+| 参数       | 值       | 单位 | 说明             |
+| ---------- | -------- | ---- | ---------------- |
+| 最大功率   | 配置指定 | W    | 最大干扰输出功率 |
+| 初始功率   | 40%      | %    | 最大功率的百分比 |
+| 功率增长率 | 配置指定 | W/s  | 功率增长速度     |
+| 冷却时间   | 5        | s    | 停止后的冷却时间 |
+
+#### 5.1.3 毫米波干扰器参数
+
+| 参数       | 值   | 单位 | 说明             |
+| ---------- | ---- | ---- | ---------------- |
+| 最大功率   | 1000 | W    | 最大干扰输出功率 |
+| 初始功率   | 400  | W    | 启动时的功率     |
+| 功率增长率 | 200  | W/s  | 功率增长速度     |
+| 冷却时间   | 5    | s    | 停止后的冷却时间 |
+
+#### 5.1.4 烟幕弹参数
+
+| 参数     | 值  | 单位  | 说明             |
+| -------- | --- | ----- | ---------------- |
+| 发射角度 | π/4 | rad   | 烟幕弹发射角度   |
+| 爆炸高度 | 10  | m     | 烟幕弹爆炸高度   |
+| 烟幕直径 | 20  | m     | 烟幕云最大直径   |
+| 吸收率   | 0.8 | -     | 电磁波吸收率     |
+| 初始浓度 | 0.5 | kg/m³ | 形成时的浓度     |
+| 扩散时间 | 3   | s     | 达到预定直径时间 |
+| 响应时间 | 1   | s     | 形成有效干扰时间 |
+| 有效时间 | 60  | s     | 维持干扰效果时间 |
+
+#### 5.1.5 末敏弹毫米波干扰器参数
+
+| 参数     | 值   | 单位 | 说明             |
+| -------- | ---- | ---- | ---------------- |
+| 波长范围 | 2-4  | mm   | 干扰波长范围     |
+| 角度范围 | ±30  | deg  | 工作角度范围     |
+| 响应时间 | 0.1  | s    | 形成干扰所需时间 |
+| 有效距离 | 1000 | m    | 有效干扰最大距离 |
+| 探测距离 | 2000 | m    | 威胁探测最大距离 |
+| 干扰概率 | 0.8  | -    | 有效干扰概率     |
+| 最大功率 | 1000 | W    | 最大干扰输出功率 |
+
+### 5.2 标准测试用例
+
+#### 5.2.1 功能测试用例
+
+1. 干扰器启动测试
+   ```csharp
+   [Test]
+   public void TestJammerStart()
+   {
+       var jammer = new LaserJammer(/*参数*/);
+       jammer.StartJamming();
+       Assert.IsTrue(jammer.IsJamming);
+       Assert.AreEqual(4000, jammer.CurrentJammingPower);
+   }
+   ```
+
+2. 功率增长测试
+   ```csharp
+   [Test]
+   public void TestPowerIncrease()
+   {
+       var jammer = new LaserJammer(/*参数*/);
+       jammer.StartJamming();
+       jammer.Update(1.0); // 更新1秒
+       Assert.AreEqual(6000, jammer.CurrentJammingPower);
+   }
+   ```
+
+3. 冷却管理测试
+   ```csharp
+   [Test]
+   public void TestCooldown()
+   {
+       var jammer = new LaserJammer(/*参数*/);
+       jammer.StartJamming();
+       jammer.StopJamming();
+       Assert.IsFalse(jammer.IsJamming);
+       // 等待冷却
+       jammer.Update(5.0);
+       jammer.StartJamming();
+       Assert.IsTrue(jammer.IsJamming);
+   }
+   ```
+
+4. 末敏弹毫米波干扰器测试
+   ```csharp
+   [Test]
+   public void TestTerminalJammer()
+   {
+       var jammer = new TerminalMillimeterWaveJammer(/*参数*/);
+       
+       // 测试威胁探测
+       var evt = new TerminalThreatDetectionEvent 
+       { 
+           Distance = 1500,
+           TargetId = "Tank001" 
+       };
+       jammer.OnThreatDetected(evt);
+       Assert.IsTrue(jammer.IsJamming);
+       
+       // 测试干扰效果
+       jammer.Update(1.0);
+       Assert.AreEqual(0.8, jammer.JammingProbability);
+       Assert.Less(jammer.CurrentTargetDistance, jammer.DetectionRange);
+   }
+   ```
+
+### 5.3 数据格式说明
+
+#### 5.3.1 配置数据格式
+
+```json
+{
+    "jammerId": "string",
+    "maxJammingPower": "double",
+    "initialJammingPower": "double",
+    "powerIncreaseRate": "double",
+    "maxCooldownTime": "double"
+}
+```
+
+#### 5.3.2 事件数据格式
+
+```json
+{
+    "eventType": "JammingEvent",
+    "senderId": "string",
+    "timestamp": "long",
+    "targetId": "string",
+    "jammingPower": "double",
+    "status": "string"
+}
+``` 

docs/articles/warner-spec.md

@@ -0,0 +1,454 @@
+# 告警器技术说明书
+
+## 1. 概述
+
+### 1.1 文档目的
+
+本文档旨在详细描述主动防护系统中告警器子系统的设计实现，包括：
+
+1. 各型告警器的工作原理和关键算法
+2. 系统组件的交互机制和接口定义
+3. 关键参数的配置和验证方法
+4. 测试用例和验证流程
+
+本文档可用于：
+
+- 系统设计和实现的参考依据
+- 测试验证的指导文档
+- 系统维护和升级的技术支持
+- 新功能开发的基础文档
+
+### 1.2 适用范围
+
+本文档适用于以下人员和场景：
+
+1. 开发人员
+   - 系统功能实现
+   - 接口开发和维护
+   - 算法优化和改进
+   - 新功能扩展开发
+
+2. 测试人员
+   - 功能测试设计
+   - 性能测试验证
+   - 系统集成测试
+   - 回归测试执行
+
+3. 维护人员
+   - 系统问题诊断
+   - 参数配置调整
+   - 性能监控分析
+   - 系统升级维护
+
+### 1.3 系统功能
+
+1. 告警器类型支持
+   - 激光告警器
+   - 红外告警器
+   - 毫米波告警器
+   - 紫外告警器
+
+2. 核心功能
+   - 威胁探测
+   - 告警状态管理
+   - 告警事件发布
+   - 数据记录
+   - 位置跟随
+
+3. 验证功能
+   - 单元测试验证
+   - 系统集成验证
+   - 性能指标验证
+   - 数据分析验证
+
+### 1.4 参考文献
+
+1. 告警技术参考
+   - 《激光探测技术》，国防工业出版社
+   - 《红外探测原理》，科学出版社
+   - 《毫米波雷达技术》，电子工业出版社
+   - 《紫外探测技术》，国防工业出版社
+
+2. 系统设计参考
+   - 《软件工程：实践者的研究方法》
+   - 《面向对象分析与设计》
+   - 《设计模式：可复用面向对象软件的基础》
+
+## 2. 系统架构
+
+### 2.1 总体架构
+
+#### 2.1.1 核心组件
+
+1. 基础告警器类 (WarnerBase)
+   - 告警状态管理
+   - 灵敏度控制
+   - 告警持续时间管理
+   - 位置跟随功能
+
+2. 具体告警器实现
+   - 激光告警器 (LaserWarner)
+   - 红外告警器 (InfraredWarner)
+   - 毫米波告警器 (MillimeterWaveWarner)
+   - 紫外告警器 (UltravioletWarner)
+
+3. 告警器接口 (IWarner)
+   - 告警控制接口
+   - 状态查询接口
+   - 事件处理接口
+
+#### 2.1.2 事件系统
+
+1. 探测事件
+   - 激光照射事件
+   - 红外辐射事件
+   - 毫米波辐射事件
+   - 紫外辐射事件
+
+2. 告警控制事件
+   - 告警开始事件
+   - 告警停止事件
+   - 告警状态更新事件
+
+### 2.2 接口定义
+
+#### 2.2.1 IWarner 接口
+
+```csharp
+public interface IWarner
+{
+    bool IsWarning { get; }
+    void StartWarning();
+    void StopWarning();
+    string GetWarningStatus();
+}
+```
+
+#### 2.2.2 事件接口
+
+1. 告警事件基类
+   - SenderId：事件发送者ID
+   - Timestamp：事件时间戳
+   - TargetId：目标ID
+
+2. 具体事件类型
+   - LaserWarnerAlarmEvent
+   - InfraredWarnerAlarmEvent
+   - MillimeterWaveWarnerAlarmEvent
+   - UltravioletWarnerAlarmEvent
+
+### 2.3 数据流
+
+#### 2.3.1 告警控制流程
+
+```mermaid
+graph LR
+    A[威胁源] --> B[探测事件]
+    B --> C[告警器]
+    C --> D[告警控制]
+    D --> E[告警事件]
+```
+
+#### 2.3.2 状态更新流程
+
+```mermaid
+graph LR
+    A[告警器] --> B[状态更新]
+    B --> C[告警控制]
+    C --> D[持续时间管理]
+    D --> E[事件发布]
+```
+
+## 3. 具体实现
+
+### 3.1 激光告警器
+
+#### 3.1.1 工作原理
+
+激光告警器通过探测激光照射来发现威胁。其基本工作过程如下：
+
+1. 威胁探测
+   - 接收激光照射事件
+   - 计算照射功率密度
+   - 判断是否超过阈值
+   - 确认威胁有效性
+
+2. 告警过程
+   - 启动告警状态
+   - 维持告警持续时间
+   - 发布告警事件
+   - 更新告警状态
+
+3. 告警终止
+   - 检查告警条件
+   - 计算持续时间
+   - 停止告警
+   - 重置状态
+
+#### 3.1.2 关键参数
+
+1. 探测参数
+   - 灵敏度阈值：由配置指定
+   - 波长范围：由配置指定
+   - 视场角：由配置指定
+
+2. 时间参数
+   - 告警持续时间：5秒
+   - 更新周期：与仿真步长一致
+
+### 3.2 红外告警器
+
+#### 3.2.1 工作原理
+
+红外告警器通过探测红外辐射来发现威胁。其基本工作过程如下：
+
+1. 威胁探测
+   - 接收红外辐射事件
+   - 计算辐射强度
+   - 判断是否超过阈值
+   - 确认威胁有效性
+
+2. 告警过程
+   - 启动告警状态
+   - 维持告警持续时间
+   - 发布告警事件
+   - 更新告警状态
+
+3. 告警终止
+   - 检查告警条件
+   - 计算持续时间
+   - 停止告警
+   - 重置状态
+
+#### 3.2.2 关键参数
+
+1. 探测参数
+   - 灵敏度阈值：由配置指定
+   - 波长范围：由配置指定
+   - 视场角：由配置指定
+
+2. 时间参数
+   - 告警持续时间：5秒
+   - 更新周期：与仿真步长一致
+
+### 3.3 毫米波告警器
+
+#### 3.3.1 工作原理
+
+毫米波告警器通过探测毫米波辐射来发现威胁。其基本工作过程如下：
+
+1. 威胁探测
+   - 接收毫米波辐射事件
+   - 计算辐射强度
+   - 判断是否超过阈值
+   - 确认威胁有效性
+
+2. 告警过程
+   - 启动告警状态
+   - 维持告警持续时间
+   - 发布告警事件
+   - 更新告警状态
+
+3. 告警终止
+   - 检查告警条件
+   - 计算持续时间
+   - 停止告警
+   - 重置状态
+
+#### 3.3.2 关键参数
+
+1. 探测参数
+   - 灵敏度阈值：由配置指定
+   - 波长范围：由配置指定
+   - 视场角：由配置指定
+
+2. 时间参数
+   - 告警持续时间：5秒
+   - 更新周期：与仿真步长一致
+
+### 3.4 紫外告警器
+
+#### 3.4.1 工作原理
+
+紫外告警器通过探测紫外辐射来发现威胁。其基本工作过程如下：
+
+1. 威胁探测
+   - 接收紫外辐射事件
+   - 计算辐射强度
+   - 判断是否超过阈值
+   - 确认威胁有效性
+
+2. 告警过程
+   - 启动告警状态
+   - 维持告警持续时间
+   - 发布告警事件
+   - 更新告警状态
+
+3. 告警终止
+   - 检查告警条件
+   - 计算持续时间
+   - 停止告警
+   - 重置状态
+
+#### 3.4.2 关键参数
+
+1. 探测参数
+   - 灵敏度阈值：由配置指定
+   - 波长范围：由配置指定
+   - 视场角：由配置指定
+
+2. 时间参数
+   - 告警持续时间：5秒
+   - 更新周期：与仿真步长一致
+
+## 4. 验证方法
+
+### 4.1 单元测试
+
+1. 基础功能测试
+   - 告警器初始化测试
+   - 状态转换测试
+   - 参数设置测试
+   - 事件处理测试
+
+2. 探测功能测试
+   - 阈值判断测试
+   - 波长范围测试
+   - 视场角测试
+   - 探测精度测试
+
+3. 告警管理测试
+   - 告警时间计算测试
+   - 状态转换测试
+   - 重置条件测试
+   - 异常处理测试
+
+### 4.2 系统测试
+
+1. 集成测试
+   - 威胁响应测试
+   - 事件处理测试
+   - 状态同步测试
+   - 数据记录测试
+
+2. 性能测试
+   - 响应时间测试
+   - 资源占用测试
+   - 并发处理测试
+   - 稳定性测试
+
+### 4.3 验证要点
+
+1. 功能验证
+   - 探测可靠性
+   - 告警及时性
+   - 状态管理有效性
+   - 事件处理及时性
+
+2. 性能验证
+   - 响应延迟
+   - 探测精度
+   - 状态转换时间
+   - 系统稳定性
+
+## 5. 附录
+
+### 5.1 关键参数表
+
+#### 5.1.1 激光告警器参数
+
+| 参数         | 值       | 单位 | 说明         |
+| ------------ | -------- | ---- | ------------ |
+| 灵敏度阈值   | 配置指定 | W/m² | 告警触发阈值 |
+| 波长范围     | 配置指定 | nm   | 探测波长范围 |
+| 告警持续时间 | 5        | s    | 单次告警时间 |
+
+#### 5.1.2 红外告警器参数
+
+| 参数         | 值       | 单位 | 说明         |
+| ------------ | -------- | ---- | ------------ |
+| 灵敏度阈值   | 配置指定 | W/m² | 告警触发阈值 |
+| 波长范围     | 配置指定 | nm   | 探测波长范围 |
+| 告警持续时间 | 5        | s    | 单次告警时间 |
+
+#### 5.1.3 毫米波告警器参数
+
+| 参数         | 值       | 单位 | 说明         |
+| ------------ | -------- | ---- | ------------ |
+| 灵敏度阈值   | 配置指定 | W/m² | 告警触发阈值 |
+| 波长范围     | 配置指定 | nm   | 探测波长范围 |
+| 告警持续时间 | 5        | s    | 单次告警时间 |
+
+#### 5.1.4 紫外告警器参数
+
+| 参数         | 值       | 单位 | 说明         |
+| ------------ | -------- | ---- | ------------ |
+| 灵敏度阈值   | 配置指定 | W/m² | 告警触发阈值 |
+| 波长范围     | 配置指定 | nm   | 探测波长范围 |
+| 告警持续时间 | 5        | s    | 单次告警时间 |
+
+### 5.2 标准测试用例
+
+#### 5.2.1 功能测试用例
+
+1. 告警器启动测试
+   ```csharp
+   [Test]
+   public void TestWarnerStart()
+   {
+       var warner = new LaserWarner(/*参数*/);
+       warner.StartWarning();
+       Assert.IsTrue(warner.IsWarning);
+   }
+   ```
+
+2. 告警持续时间测试
+   ```csharp
+   [Test]
+   public void TestWarningDuration()
+   {
+       var warner = new LaserWarner(/*参数*/);
+       warner.StartWarning();
+       warner.Update(5.0); // 更新5秒
+       Assert.IsFalse(warner.IsWarning);
+   }
+   ```
+
+3. 阈值判断测试
+   ```csharp
+   [Test]
+   public void TestThreshold()
+   {
+       var warner = new LaserWarner(/*参数*/);
+       var evt = new LaserIlluminationEvent { Intensity = threshold + 1 };
+       warner.OnLaserIllumination(evt);
+       Assert.IsTrue(warner.IsWarning);
+   }
+   ```
+
+### 5.3 数据格式说明
+
+#### 5.3.1 配置数据格式
+
+```json
+{
+    "warnerId": "string",
+    "sensitivityThreshold": "double",
+    "wavelengthMin": "double",
+    "wavelengthMax": "double",
+    "alarmDuration": "double"
+}
+```
+
+#### 5.3.2 事件数据格式
+
+```json
+{
+    "eventType": "WarningEvent",
+    "senderId": "string",
+    "timestamp": "long",
+    "targetId": "string",
+    "intensity": "double",
+    "status": "string"
+}
+``` 

src/Models/Jammer/IJammer.cs

@@ -3,32 +3,61 @@ namespace ActiveProtect.Models
 {
     /// <summary>
     /// 干扰设备接口
+    /// 定义了所有干扰设备必须实现的基本功能和属性
     /// </summary>
+    /// <remarks>
+    /// 该接口用于定义干扰设备的标准行为，包括：
+    /// - 干扰状态的控制（开启/关闭）
+    /// - 干扰功率的监控
+    /// - 干扰状态的查询
+    /// 所有具体的干扰器实现（如激光、红外、毫米波等）都必须实现此接口
+    /// </remarks>
     public interface IJammer
     {
         /// <summary>
-        /// 是否正在干扰
+        /// 获取一个值，该值指示干扰器当前是否处于工作状态
         /// </summary>
+        /// <value>
+        /// true 表示干扰器正在工作；false 表示干扰器处于停止状态
+        /// </value>
         bool IsJamming { get; }
 
         /// <summary>
-        /// 当前干扰功率
+        /// 获取当前干扰功率值
         /// </summary>
+        /// <value>
+        /// 当前干扰功率，单位：瓦特(W)
+        /// 当干扰器未工作时，返回0
+        /// </value>
         double CurrentJammingPower { get; }
 
         /// <summary>
-        /// 开始干扰
+        /// 启动干扰器，开始执行干扰操作
         /// </summary>
+        /// <remarks>
+        /// 调用此方法将使干扰器进入工作状态，开始输出干扰信号
+        /// 如果干扰器已经在工作，则此调用不会产生任何效果
+        /// </remarks>
         void StartJamming();
 
         /// <summary>
-        /// 停止干扰
+        /// 停止干扰器的工作
         /// </summary>
+        /// <remarks>
+        /// 调用此方法将使干扰器停止工作，终止干扰信号的输出
+        /// 如果干扰器已经停止，则此调用不会产生任何效果
+        /// </remarks>
         void StopJamming();
 
         /// <summary>
-        /// 获取干扰状态
+        /// 获取干扰器当前的工作状态描述
         /// </summary>
+        /// <returns>
+        /// 返回描述干扰器当前状态的字符串，包括：
+        /// - 工作状态（开启/关闭）
+        /// - 当前功率
+        /// - 其他相关状态信息
+        /// </returns>
         string GetJammingStatus();
     }
 }

src/Models/Jammer/InfraredJammer.cs

@@ -1,3 +1,4 @@
+
 using System;
 using ActiveProtect.Simulation;
 using ActiveProtect.Utility;
@@ -7,26 +8,45 @@ namespace ActiveProtect.Models
     /// <summary>
     /// 红外干扰器类，用于对抗红外制导武器
     /// </summary>
+    /// <remarks>
+    /// 该类实现了针对红外制导武器的主动干扰功能：
+    /// - 支持特定波长范围的红外干扰
+    /// - 自动响应红外告警器的告警信号
+    /// - 提供可调节的干扰功率输出
+    /// - 实现干扰功率的动态调整
+    /// - 支持自动冷却管理
+    /// </remarks>
     public class InfraredJammer : JammerBase
     {
         /// <summary>
-        /// 干扰波长范围(微米)
+        /// 获取干扰波长范围
         /// </summary>
+        /// <value>
+        /// 一个元组，包含最小和最大波长值
+        /// Min：最小波长，单位：微米(μm)
+        /// Max：最大波长，单位：微米(μm)
+        /// </value>
         private readonly (double Min, double Max) wavelengthRange;
 
         /// <summary>
-        /// 构造函数
+        /// 初始化红外干扰器的新实例
         /// </summary>
-        /// <param name="id">红外干扰器ID</param>
-        /// <param name="position">初始位置</param>
-        /// <param name="orientation">初始朝向</param>
-        /// <param name="manager">仿真管理器</param>
-        /// <param name="tankId">所属坦克ID</param>
-        /// <param name="maxJammingPower">最大干扰功率(瓦特)</param>
-        /// <param name="initialJammingPower">初始干扰功率(瓦特)</param>
-        /// <param name="powerIncreaseRate">功率增长率(瓦特/秒)</param>
-        /// <param name="maxCooldownTime">最大冷却时间(秒)</param>
-        /// <param name="wavelengthRange">干扰波长范围(微米)</param>
+        /// <param name="id">红外干扰器的唯一标识符</param>
+        /// <param name="position">干扰器的初始位置</param>
+        /// <param name="orientation">干扰器的初始朝向</param>
+        /// <param name="manager">仿真管理器实例</param>
+        /// <param name="tankId">所属坦克的ID</param>
+        /// <param name="maxJammingPower">最大干扰功率，单位：瓦特(W)</param>
+        /// <param name="initialJammingPower">初始干扰功率，单位：瓦特(W)</param>
+        /// <param name="powerIncreaseRate">功率增长率，单位：瓦特/秒(W/s)</param>
+        /// <param name="maxCooldownTime">最大冷却时间，单位：秒(s)</param>
+        /// <param name="wavelengthRange">干扰波长范围，单位：微米(μm)</param>
+        /// <remarks>
+        /// 构造函数完成以下初始化工作：
+        /// 1. 调用基类构造函数设置基本参数
+        /// 2. 设置红外干扰波长范围
+        /// 3. 订阅红外告警器的告警事件
+        /// </remarks>
         public InfraredJammer(string id, Vector3D position, Orientation orientation,
             ISimulationManager manager, string tankId, double maxJammingPower,
             double initialJammingPower, double powerIncreaseRate, double maxCooldownTime,
@@ -40,8 +60,12 @@ namespace ActiveProtect.Models
         }
 
         /// <summary>
-        /// 处理红外告警器警报事件
+        /// 处理来自红外告警器的告警事件
         /// </summary>
+        /// <param name="evt">红外告警事件参数</param>
+        /// <remarks>
+        /// 当收到针对本装甲车的红外告警时，自动启动干扰
+        /// </remarks>
         private void OnInfraredWarnerAlarm(InfraredWarnerAlarmEvent evt)
         {
             if (evt?.TargetId == TankId)
@@ -51,8 +75,12 @@ namespace ActiveProtect.Models
         }
 
         /// <summary>
-        /// 处理红外告警器警报停止事件
+        /// 处理来自红外告警器的告警停止事件
         /// </summary>
+        /// <param name="evt">红外告警停止事件参数</param>
+        /// <remarks>
+        /// 当收到告警停止信号时，停止干扰并进入冷却状态
+        /// </remarks>
         private void OnInfraredWarnerAlarmStop(InfraredWarnerAlarmStopEvent evt)
         {
             if (evt?.TargetId == TankId)
@@ -64,6 +92,10 @@ namespace ActiveProtect.Models
         /// <summary>
         /// 更新干扰功率
         /// </summary>
+        /// <param name="deltaTime">距离上次更新的时间间隔（秒）</param>
+        /// <remarks>
+        /// 在干扰状态下，按照设定的增长率逐步提升功率，直到达到最大功率
+        /// </remarks>
         protected override void UpdateJammingPower(double deltaTime)
         {
             if (IsJamming)
@@ -74,8 +106,16 @@ namespace ActiveProtect.Models
         }
 
         /// <summary>
-        /// 发布干扰事件
+        /// 发布红外干扰事件
         /// </summary>
+        /// <remarks>
+        /// 当处于干扰状态时，向仿真系统发布红外干扰事件，包含：
+        /// - 发送者ID
+        /// - 时间戳
+        /// - 目标ID
+        /// - 当前干扰功率
+        /// - 干扰波长范围
+        /// </remarks>
         protected override void PublishJammingEvent()
         {
             if (IsJamming)
@@ -93,8 +133,16 @@ namespace ActiveProtect.Models
         }
 
         /// <summary>
-        /// 获取干扰状态
+        /// 获取红外干扰器的当前状态信息
         /// </summary>
+        /// <returns>
+        /// 返回包含以下信息的状态描述字符串：
+        /// - 干扰器ID和类型
+        /// - 当前干扰状态
+        /// - 当前功率和最大功率
+        /// - 当前冷却时间和最大冷却时间
+        /// - 干扰波长范围
+        /// </returns>
         public override string GetJammingStatus()
         {
             return $"红外干扰器 {Id}:\n" +
@@ -104,6 +152,14 @@ namespace ActiveProtect.Models
                    $"  波长范围: {wavelengthRange.Min:F2}-{wavelengthRange.Max:F2}微米";
         }
 
+        /// <summary>
+        /// 激活红外干扰器
+        /// </summary>
+        /// <remarks>
+        /// 激活时执行以下操作：
+        /// 1. 调用基类的激活方法
+        /// 2. 重新订阅红外告警事件
+        /// </remarks>
         public override void Activate()
         {
             base.Activate();
@@ -111,6 +167,14 @@ namespace ActiveProtect.Models
             SimulationManager.SubscribeToEvent<InfraredWarnerAlarmStopEvent>(OnInfraredWarnerAlarmStop);
         }
 
+        /// <summary>
+        /// 停用红外干扰器
+        /// </summary>
+        /// <remarks>
+        /// 停用时执行以下操作：
+        /// 1. 调用基类的停用方法
+        /// 2. 取消订阅红外告警事件
+        /// </remarks>
         public override void Deactivate()
         {
             base.Deactivate();

src/Models/Jammer/JammerBase.cs

@@ -6,44 +6,86 @@ namespace ActiveProtect.Models
 {
     /// <summary>
     /// 干扰设备基类
+    /// 实现了干扰设备的基本功能和属性，为具体的干扰器类型提供通用实现
     /// </summary>
+    /// <remarks>
+    /// 该基类提供了：
+    /// - 干扰状态管理
+    /// - 干扰功率控制
+    /// - 冷却时间管理
+    /// - 位置跟随功能
+    /// 继承自SimulationElement以支持仿真功能，实现IJammer接口
+    /// </remarks>
     public abstract class JammerBase : SimulationElement, IJammer
     {
         /// <summary>
-        /// 是否正在干扰
+        /// 获取或设置一个值，该值指示干扰器是否正在工作
         /// </summary>
+        /// <value>
+        /// true表示正在干扰；false表示未在干扰
+        /// </value>
         public bool IsJamming { get; protected set; }
 
         /// <summary>
-        /// 当前干扰功率
+        /// 获取或设置当前干扰功率值
         /// </summary>
+        /// <value>
+        /// 当前干扰功率，单位：瓦特(W)
+        /// </value>
         public double CurrentJammingPower { get; protected set; }
 
         /// <summary>
-        /// 最大干扰功率
+        /// 获取或设置最大干扰功率
         /// </summary>
+        /// <value>
+        /// 干扰器能够输出的最大功率，单位：瓦特(W)
+        /// </value>
         protected double MaxJammingPower { get; set; }
 
         /// <summary>
-        /// 功率增长率
+        /// 获取或设置功率增长率
         /// </summary>
+        /// <value>
+        /// 干扰功率的增长速率，单位：瓦特/秒(W/s)
+        /// </value>
         protected double PowerIncreaseRate { get; set; }
 
         /// <summary>
-        /// 最大冷却时间
+        /// 获取或设置最大冷却时间
         /// </summary>
+        /// <value>
+        /// 干扰器停止后需要的最大冷却时间，单位：秒(s)
+        /// </value>
         protected double MaxCooldownTime { get; set; }
 
         /// <summary>
-        /// 当前冷却时间
+        /// 获取或设置当前冷却时间
         /// </summary>
+        /// <value>
+        /// 当前剩余的冷却时间，单位：秒(s)
+        /// </value>
         protected double CurrentCooldownTime { get; set; }
 
         /// <summary>
-        /// 所属坦克ID
+        /// 获取或设置所属坦克的唯一标识符
         /// </summary>
+        /// <value>
+        /// 坦克的ID字符串
+        /// </value>
         protected string TankId { get; set; }
 
+        /// <summary>
+        /// 初始化干扰器基类的新实例
+        /// </summary>
+        /// <param name="id">干扰器的唯一标识符</param>
+        /// <param name="position">初始位置</param>
+        /// <param name="orientation">初始朝向</param>
+        /// <param name="manager">仿真管理器实例</param>
+        /// <param name="tankId">所属坦克ID</param>
+        /// <param name="maxJammingPower">最大干扰功率</param>
+        /// <param name="initialJammingPower">初始干扰功率</param>
+        /// <param name="powerIncreaseRate">功率增长率</param>
+        /// <param name="maxCooldownTime">最大冷却时间</param>
         protected JammerBase(string id, Vector3D position, Orientation orientation,
             ISimulationManager manager, string tankId, double maxJammingPower,
             double initialJammingPower, double powerIncreaseRate, double maxCooldownTime)
@@ -58,6 +100,12 @@ namespace ActiveProtect.Models
             IsJamming = false;
         }
 
+        /// <summary>
+        /// 启动干扰器
+        /// </summary>
+        /// <remarks>
+        /// 仅在冷却完成且当前未处于干扰状态时才能启动
+        /// </remarks>
         public virtual void StartJamming()
         {
             if (CurrentCooldownTime <= 0 && !IsJamming)
@@ -67,6 +115,12 @@ namespace ActiveProtect.Models
             }
         }
 
+        /// <summary>
+        /// 停止干扰器
+        /// </summary>
+        /// <remarks>
+        /// 停止时会重置干扰功率并进入冷却状态
+        /// </remarks>
         public virtual void StopJamming()
         {
             if (IsJamming)
@@ -78,8 +132,22 @@ namespace ActiveProtect.Models
             }
         }
 
+        /// <summary>
+        /// 获取干扰器的状态信息
+        /// </summary>
+        /// <returns>描述干扰器当前状态的字符串</returns>
         public abstract string GetJammingStatus();
 
+        /// <summary>
+        /// 更新干扰器的状态
+        /// </summary>
+        /// <param name="deltaTime">距离上次更新的时间间隔（秒）</param>
+        /// <remarks>
+        /// 更新内容包括：
+        /// - 干扰功率
+        /// - 冷却时间
+        /// - 位置（跟随坦克）
+        /// </remarks>
         public override void Update(double deltaTime)
         {
             if (!IsActive) return;
@@ -102,19 +170,39 @@ namespace ActiveProtect.Models
             }
         }
 
+        /// <summary>
+        /// 激活干扰器
+        /// </summary>
+        /// <remarks>
+        /// 激活时会自动开始干扰
+        /// </remarks>
         public override void Activate()
         {
             base.Activate();
             StartJamming();
         }
 
+        /// <summary>
+        /// 停用干扰器
+        /// </summary>
+        /// <remarks>
+        /// 停用时会自动停止干扰
+        /// </remarks>
         public override void Deactivate()
         {
             StopJamming();
             base.Deactivate();
         }
 
+        /// <summary>
+        /// 更新干扰功率
+        /// </summary>
+        /// <param name="deltaTime">时间间隔（秒）</param>
         protected abstract void UpdateJammingPower(double deltaTime);
+
+        /// <summary>
+        /// 发布干扰事件
+        /// </summary>
         protected abstract void PublishJammingEvent();
     }
 }

src/Models/Jammer/LaserJammer.cs

@@ -1,3 +1,4 @@
+
 using System;
 using ActiveProtect.Simulation;
 using ActiveProtect.Utility;
@@ -7,58 +8,97 @@ namespace ActiveProtect.Models
     /// <summary>
     /// 激光干扰器类，用于对抗激光制导武器
     /// </summary>
+    /// <remarks>
+    /// 该类实现了针对激光制导武器的主动干扰功能：
+    /// - 自动响应激光告警器的告警信号
+    /// - 提供可调节的干扰功率输出
+    /// - 实现干扰功率的动态调整
+    /// - 支持自动冷却管理
+    /// - 位置跟随被保护目标
+    /// </remarks>
     public class LaserJammer : SimulationElement
     {
         /// <summary>
-        /// 是否正在进行干扰
+        /// 获取一个值，该值指示干扰器是否正在工作
         /// </summary>
+        /// <value>
+        /// true表示正在干扰；false表示未在干扰
+        /// </value>
         public bool IsJamming { get; private set; }
 
         /// <summary>
-        /// 当前干扰功率（瓦特）
+        /// 获取当前干扰功率值
         /// </summary>
+        /// <value>
+        /// 当前干扰功率，单位：瓦特(W)
+        /// </value>
         public double JammingPower { get; private set; }
 
         /// <summary>
-        /// 当前冷却时间（秒）
+        /// 获取或设置当前冷却时间
         /// </summary>
+        /// <value>
+        /// 当前已经冷却的时间，单位：秒(s)
+        /// </value>
         private double jammingCooldown = 0;
 
         /// <summary>
-        /// 最大冷却时间（秒）
+        /// 获取最大冷却时间
         /// </summary>
+        /// <value>
+        /// 干扰器需要的最大冷却时间，单位：秒(s)
+        /// </value>
         private readonly double maxJammingCooldown;
 
         /// <summary>
-        /// 最大干扰功率（瓦特）
+        /// 获取最大干扰功率
         /// </summary>
+        /// <value>
+        /// 干扰器能够输出的最大功率，单位：瓦特(W)
+        /// </value>
         private readonly double maxJammingPower;
 
         /// <summary>
-        /// 初始干扰功率（瓦特）
+        /// 获取初始干扰功率
         /// </summary>
+        /// <value>
+        /// 干扰器启动时的初始功率，单位：瓦特(W)
+        /// </value>
         private readonly double initialJammingPower;
 
         /// <summary>
-        /// 功率增加速率（瓦特/秒）
+        /// 获取功率增长率
         /// </summary>
+        /// <value>
+        /// 干扰功率的增长速率，单位：瓦特/秒(W/s)
+        /// </value>
         private readonly double powerIncreaseRate;
 
         /// <summary>
-        /// 被监视实体的ID
+        /// 获取被监视实体的唯一标识符
         /// </summary>
+        /// <value>
+        /// 被保护目标的ID字符串
+        /// </value>
         public string MonitoredEntityId { get; private set; }
 
         /// <summary>
-        /// 构造函数
+        /// 初始化激光干扰器的新实例
         /// </summary>
-        /// <param name="id">激光干扰器ID</param>
-        /// <param name="position">初始位置</param>
-        /// <param name="orientation">初始朝向</param>
-        /// <param name="simulationManager">仿真管理器</param>
+        /// <param name="id">激光干扰器的唯一标识符</param>
+        /// <param name="position">干扰器的初始位置</param>
+        /// <param name="orientation">干扰器的初始朝向</param>
+        /// <param name="simulationManager">仿真管理器实例</param>
         /// <param name="monitoredEntityId">被监视实体的ID</param>
-        /// <param name="config">激光干扰器配置</param>
-        public LaserJammer(string id, Vector3D position, Orientation orientation, ISimulationManager simulationManager, string monitoredEntityId, LaserJammerConfig config)
+        /// <param name="config">激光干扰器配置参数</param>
+        /// <remarks>
+        /// 构造函数完成以下初始化工作：
+        /// 1. 调用基类构造函数设置基本参数
+        /// 2. 设置干扰器的工作参数
+        /// 3. 订阅激光告警事件
+        /// </remarks>
+        public LaserJammer(string id, Vector3D position, Orientation orientation, 
+            ISimulationManager simulationManager, string monitoredEntityId, LaserJammerConfig config)
             : base(id, position, orientation, 0, simulationManager)
         {
             MonitoredEntityId = monitoredEntityId;
@@ -73,9 +113,16 @@ namespace ActiveProtect.Models
         }
 
         /// <summary>
-        /// 更新激光干扰器状态
+        /// 更新激光干扰器的状态
         /// </summary>
-        /// <param name="deltaTime">时间步长</param>
+        /// <param name="deltaTime">距离上次更新的时间间隔（秒）</param>
+        /// <remarks>
+        /// 更新过程包括：
+        /// 1. 更新位置（跟随被保护目标）
+        /// 2. 更新干扰功率
+        /// 3. 处理冷却时间
+        /// 4. 发布干扰事件
+        /// </remarks>
         public override void Update(double deltaTime)
         {
             if (!IsActive) return;
@@ -110,9 +157,12 @@ namespace ActiveProtect.Models
         }
 
         /// <summary>
-        /// 处理激光告警器警报事件
+        /// 处理来自激光告警器的告警事件
         /// </summary>
-        /// <param name="evt">激光告警器警报事件</param>
+        /// <param name="evt">激光告警事件参数</param>
+        /// <remarks>
+        /// 当收到针对被保护目标的激光告警时，自动启动干扰
+        /// </remarks>
         private void OnLaserWarnerAlarmEvent(LaserWarnerAlarmEvent evt)
         {
             if (evt.TargetId == MonitoredEntityId)
@@ -122,9 +172,12 @@ namespace ActiveProtect.Models
         }
 
         /// <summary>
-        /// 处理激光告警器警报停止事件
+        /// 处理来自激光告警器的告警停止事件
         /// </summary>
-        /// <param name="evt">激光告警器警报停止事件</param>
+        /// <param name="evt">激光告警停止事件参数</param>
+        /// <remarks>
+        /// 当收到告警停止信号时，停止干扰并进入冷却状态
+        /// </remarks>
         private void OnLaserWarnerAlarmStopEvent(LaserWarnerAlarmStopEvent evt)
         {
             if (evt.TargetId == MonitoredEntityId)
@@ -134,8 +187,14 @@ namespace ActiveProtect.Models
         }
 
         /// <summary>
-        /// 开始干扰
+        /// 启动激光干扰器
         /// </summary>
+        /// <remarks>
+        /// 启动时执行以下操作：
+        /// 1. 设置干扰状态为开启
+        /// 2. 设置初始干扰功率
+        /// 3. 重置冷却时间
+        /// </remarks>
         private void StartJamming()
         {
             if (!IsJamming)
@@ -148,8 +207,14 @@ namespace ActiveProtect.Models
         }
 
         /// <summary>
-        /// 停止干扰
+        /// 停止激光干扰器
         /// </summary>
+        /// <remarks>
+        /// 停止时执行以下操作：
+        /// 1. 设置干扰状态为关闭
+        /// 2. 清零干扰功率
+        /// 3. 重置冷却时间
+        /// </remarks>
         private void StopJamming()
         {
             if (IsJamming)
@@ -162,9 +227,16 @@ namespace ActiveProtect.Models
         }
 
         /// <summary>
-        /// 获取激光干扰器状态信息
+        /// 获取激光干扰器的当前状态信息
         /// </summary>
-        /// <returns>状态信息字符串</returns>
+        /// <returns>
+        /// 返回包含以下信息的状态描述字符串：
+        /// - 干扰器ID和类型
+        /// - 被监视目标ID
+        /// - 当前干扰状态
+        /// - 当前功率和最大功率
+        /// - 当前冷却时间和最大冷却时间
+        /// </returns>
         public override string GetStatus()
         {
             return $"激光干扰器 {Id}:\n" +
@@ -174,9 +246,14 @@ namespace ActiveProtect.Models
                    $"  冷却时间: {jammingCooldown:F2}/{maxJammingCooldown:F2}";
         }
 
-        /// <summary>   
+        /// <summary>
         /// 激活激光干扰器
         /// </summary>
+        /// <remarks>
+        /// 激活时执行以下操作：
+        /// 1. 调用基类的激活方法
+        /// 2. 订阅激光告警事件
+        /// </remarks>
         public override void Activate()
         {
             base.Activate();
@@ -187,6 +264,11 @@ namespace ActiveProtect.Models
         /// <summary>
         /// 停用激光干扰器
         /// </summary>
+        /// <remarks>
+        /// 停用时执行以下操作：
+        /// 1. 调用基类的停用方法
+        /// 2. 取消订阅激光告警事件
+        /// </remarks>
         public override void Deactivate()
         {
             base.Deactivate();

src/Models/Jammer/MillimeterWaveJammer.cs

@@ -1,3 +1,4 @@
+
 using System;
 using ActiveProtect.Simulation;
 using ActiveProtect.Utility;
@@ -5,48 +6,88 @@ using ActiveProtect.Utility;
 namespace ActiveProtect.Models
 {
     /// <summary>
-    /// 毫米波干扰器
+    /// 毫米波干扰器类，用于对抗毫米波制导武器
     /// </summary>
+    /// <remarks>
+    /// 该类实现了针对毫米波制导武器的主动干扰功能：
+    /// - 提供可调节的干扰功率输出
+    /// - 实现干扰功率的动态调整
+    /// - 支持自动冷却管理
+    /// - 位置跟随被保护目标
+    /// - 支持实时状态监控
+    /// </remarks>
     public class MillimeterWaveJammer : SimulationElement
     {
         /// <summary>
-        /// 最大干扰功率(瓦特)
+        /// 获取最大干扰功率
         /// </summary>
+        /// <value>
+        /// 干扰器能够输出的最大功率，单位：瓦特(W)
+        /// </value>
         private readonly double maxJammingPower;
 
         /// <summary>
-        /// 当前干扰功率(瓦特)
+        /// 获取或设置当前干扰功率
         /// </summary>
+        /// <value>
+        /// 当前干扰功率，单位：瓦特(W)
+        /// </value>
         private double currentJammingPower;
 
         /// <summary>
-        /// 干扰功率增长率(瓦特/秒)
+        /// 获取功率增长率
         /// </summary>
+        /// <value>
+        /// 干扰功率的增长速率，单位：瓦特/秒(W/s)
+        /// </value>
         private readonly double powerIncreaseRate;
 
         /// <summary>
-        /// 最大干扰冷却时间(秒)
+        /// 获取最大冷却时间
         /// </summary>
+        /// <value>
+        /// 干扰器需要的最大冷却时间，单位：秒(s)
+        /// </value>
         private readonly double maxJammingCooldown;
 
         /// <summary>
-        /// 当前冷却时间(秒)
+        /// 获取或设置当前冷却时间
         /// </summary>
+        /// <value>
+        /// 当前已经冷却的时间，单位：秒(s)
+        /// </value>
         private double currentCooldown;
 
         /// <summary>
-        /// 是否正在干扰
+        /// 获取或设置一个值，该值指示干扰器是否正在工作
         /// </summary>
+        /// <value>
+        /// true表示正在干扰；false表示未在干扰
+        /// </value>
         private bool isJamming;
 
         /// <summary>
-        /// 所属坦克ID
+        /// 获取所属坦克的唯一标识符
         /// </summary>
+        /// <value>
+        /// 被保护目标的ID字符串
+        /// </value>
         private readonly string tankId;
 
         /// <summary>
-        /// 干扰器构造函数
+        /// 初始化毫米波干扰器的新实例
         /// </summary>
+        /// <param name="id">干扰器的唯一标识符</param>
+        /// <param name="position">干扰器的初始位置</param>
+        /// <param name="orientation">干扰器的初始朝向</param>
+        /// <param name="manager">仿真管理器实例</param>
+        /// <param name="tankId">所属坦克的ID</param>
+        /// <param name="config">毫米波干扰器配置参数</param>
+        /// <remarks>
+        /// 构造函数完成以下初始化工作：
+        /// 1. 调用基类构造函数设置基本参数
+        /// 2. 设置干扰器的工作参数
+        /// </remarks>
         public MillimeterWaveJammer(string id, Vector3D position, Orientation orientation, 
             ISimulationManager manager, string tankId, MillimeterWaveJammerConfig config) 
             : base(id, position, orientation, 0, manager)
@@ -61,8 +102,16 @@ namespace ActiveProtect.Models
         }
 
         /// <summary>
-        /// 更新干扰器状态
+        /// 更新毫米波干扰器的状态
         /// </summary>
+        /// <param name="deltaTime">距离上次更新的时间间隔（秒）</param>
+        /// <remarks>
+        /// 更新过程包括：
+        /// 1. 更新干扰功率
+        /// 2. 发布干扰事件
+        /// 3. 处理冷却时间
+        /// 4. 更新位置（跟随被保护目标）
+        /// </remarks>
         public override void Update(double deltaTime)
         {
             if (!IsActive) return;
@@ -97,8 +146,14 @@ namespace ActiveProtect.Models
         }
 
         /// <summary>
-        /// 开始干扰
+        /// 启动毫米波干扰器
         /// </summary>
+        /// <remarks>
+        /// 启动时执行以下操作：
+        /// 1. 检查冷却状态
+        /// 2. 设置干扰状态为开启
+        /// 3. 输出日志信息
+        /// </remarks>
         public void StartJamming()
         {
             if (currentCooldown <= 0 && !isJamming)
@@ -109,8 +164,15 @@ namespace ActiveProtect.Models
         }
 
         /// <summary>
-        /// 停止干扰
+        /// 停止毫米波干扰器
         /// </summary>
+        /// <remarks>
+        /// 停止时执行以下操作：
+        /// 1. 设置干扰状态为关闭
+        /// 2. 设置冷却时间
+        /// 3. 重置干扰功率
+        /// 4. 输出日志信息
+        /// </remarks>
         public void StopJamming()
         {
             if (isJamming)
@@ -121,6 +183,15 @@ namespace ActiveProtect.Models
                 Console.WriteLine($"毫米波干扰器 {Id} 停止干扰，进入冷却");
             }
         }
+
+        /// <summary>
+        /// 激活毫米波干扰器
+        /// </summary>
+        /// <remarks>
+        /// 激活时执行以下操作：
+        /// 1. 调用基类的激活方法
+        /// 2. 自动启动干扰
+        /// </remarks>
         public override void Activate()
         {
             base.Activate();
@@ -128,8 +199,13 @@ namespace ActiveProtect.Models
         }
 
         /// <summary>
-        /// 销毁干扰器
+        /// 停用毫米波干扰器
         /// </summary>
+        /// <remarks>
+        /// 停用时执行以下操作：
+        /// 1. 停止干扰
+        /// 2. 调用基类的停用方法
+        /// </remarks>
         public override void Deactivate()
         {
             StopJamming();
@@ -137,8 +213,16 @@ namespace ActiveProtect.Models
         }
 
         /// <summary>
-        /// 获取干扰器状态
+        /// 获取毫米波干扰器的当前状态信息
         /// </summary>
+        /// <returns>
+        /// 返回包含以下信息的状态描述字符串：
+        /// - 干扰器ID和类型
+        /// - 当前位置
+        /// - 当前功率和最大功率
+        /// - 当前冷却时间和最大冷却时间
+        /// - 工作状态
+        /// </returns>
         public override string GetStatus()
         {
             return $"毫米波干扰器 {Id}:\n" +

src/Models/Jammer/SmokeJammer.cs

@@ -0,0 +1,355 @@
+using System;
+using ActiveProtect.Simulation;
+using ActiveProtect.Utility;
+
+namespace ActiveProtect.Models
+{
+    /// <summary>
+    /// 烟幕弹干扰器类，用于发射烟幕实现多谱段干扰
+    /// </summary>
+    /// <remarks>
+    /// 该类实现了以下功能：
+    /// - 烟幕弹发射控制
+    /// - 烟幕状态管理
+    /// - 干扰效果计算
+    /// - 烟幕扩散模拟
+    /// </remarks>
+    public class SmokeJammer : JammerBase
+    {
+        #region 发射参数
+        /// <summary>
+        /// 获取发射角度
+        /// </summary>
+        /// <value>
+        /// 烟幕弹发射角度，单位：弧度(rad)
+        /// </value>
+        public float LaunchAngle { get; private set; }
+
+        /// <summary>
+        /// 获取烟幕种类
+        /// </summary>
+        /// <value>
+        /// 烟幕弹的类型（红外、毫米波、多谱段）
+        /// </value>
+        public SmokeType Type { get; private set; }
+
+        /// <summary>
+        /// 获取发射数量
+        /// </summary>
+        /// <value>
+        /// 单次发射的烟幕弹数量
+        /// </value>
+        public int Count { get; private set; }
+        #endregion
+
+        #region 性能参数
+        /// <summary>
+        /// 获取爆炸高度
+        /// </summary>
+        /// <value>
+        /// 烟幕弹爆炸的理想高度，单位：米(m)
+        /// </value>
+        public float ExplosionHeight { get; private set; }
+
+        /// <summary>
+        /// 获取烟幕直径
+        /// </summary>
+        /// <value>
+        /// 烟幕形成的理想直径，单位：米(m)
+        /// </value>
+        public float SmokeDiameter { get; private set; }
+
+        /// <summary>
+        /// 获取辐射吸收率
+        /// </summary>
+        /// <value>
+        /// 烟幕对电磁波的吸收率，范围：0-1
+        /// </value>
+        public float AbsorptionRate { get; private set; }
+
+        /// <summary>
+        /// 获取初始浓度
+        /// </summary>
+        /// <value>
+        /// 烟幕形成时的初始浓度，单位：千克/立方米(kg/m³)
+        /// </value>
+        public float InitialDensity { get; private set; }
+
+        /// <summary>
+        /// 获取扩散时间
+        /// </summary>
+        /// <value>
+        /// 烟幕达到预期直径所需时间，单位：秒(s)
+        /// </value>
+        public float DiffusionTime { get; private set; }
+
+        /// <summary>
+        /// 获取干扰响应时间
+        /// </summary>
+        /// <value>
+        /// 从发射到形成有效干扰的时间，单位：秒(s)
+        /// </value>
+        public float ResponseTime { get; private set; }
+
+        /// <summary>
+        /// 获取有效时间
+        /// </summary>
+        /// <value>
+        /// 烟幕维持有效干扰的时间，单位：秒(s)
+        /// </value>
+        public float EffectiveTime { get; private set; }
+        #endregion
+
+        #region 烟幕状态参数
+        /// <summary>
+        /// 获取烟幕位置
+        /// </summary>
+        /// <value>
+        /// 烟幕中心的当前位置坐标
+        /// </value>
+        public Vector3D SmokePosition { get; private set; }
+
+        /// <summary>
+        /// 获取当前高度
+        /// </summary>
+        /// <value>
+        /// 烟幕云的当前高度，单位：米(m)
+        /// </value>
+        public float Height { get; private set; }
+
+        /// <summary>
+        /// 获取当前宽度
+        /// </summary>
+        /// <value>
+        /// 烟幕云的当前宽度，单位：米(m)
+        /// </value>
+        public float Width { get; private set; }
+
+        /// <summary>
+        /// 获取当前厚度
+        /// </summary>
+        /// <value>
+        /// 烟幕云的当前厚度，单位：米(m)
+        /// </value>
+        public float Thickness { get; private set; }
+
+        /// <summary>
+        /// 获取当前浓度
+        /// </summary>
+        /// <value>
+        /// 烟幕的当前浓度，单位：千克/立方米(kg/m³)
+        /// </value>
+        public float CurrentDensity { get; private set; }
+
+        /// <summary>
+        /// 获取当前距离
+        /// </summary>
+        /// <value>
+        /// 烟幕到防护目标的距离，单位：米(m)
+        /// </value>
+        public float Distance { get; private set; }
+
+        /// <summary>
+        /// 获取持续时间
+        /// </summary>
+        /// <value>
+        /// 烟幕已持续的时间，单位：秒(s)
+        /// </value>
+        public float Duration { get; private set; }
+
+        /// <summary>
+        /// 获取剩余时间
+        /// </summary>
+        /// <value>
+        /// 烟幕剩余的有效时间，单位：秒(s)
+        /// </value>
+        public float RemainingTime { get; private set; }
+        #endregion
+
+        /// <summary>
+        /// 初始化烟幕弹干扰器的新实例
+        /// </summary>
+        /// <param name="id">烟幕弹干扰器的唯一标识符</param>
+        /// <param name="position">干扰器的初始位置</param>
+        /// <param name="orientation">干扰器的初始朝向</param>
+        /// <param name="manager">仿真管理器实例</param>
+        /// <param name="tankId">所属坦克的ID</param>
+        /// <param name="config">烟幕弹配置参数</param>
+        public SmokeJammer(string id, Vector3D position, Orientation orientation,
+            ISimulationManager manager, string tankId, SmokeJammerConfig config)
+            : base(id, position, orientation, manager, tankId, config.MaxJammingPower,
+                  config.InitialJammingPower, config.PowerIncreaseRate, config.MaxJammingCooldown)
+        {
+            // 初始化发射参数
+            LaunchAngle = config.LaunchAngle;
+            Type = config.Type;
+            Count = config.Count;
+
+            // 初始化性能参数
+            ExplosionHeight = config.ExplosionHeight;
+            SmokeDiameter = config.SmokeDiameter;
+            AbsorptionRate = config.AbsorptionRate;
+            InitialDensity = config.InitialDensity;
+            DiffusionTime = config.DiffusionTime;
+            ResponseTime = config.ResponseTime;
+            EffectiveTime = config.EffectiveTime;
+
+            // 初始化状态参数
+            ResetSmokeStatus();
+        }
+
+        /// <summary>
+        /// 重置烟幕状态参数
+        /// </summary>
+        private void ResetSmokeStatus()
+        {
+            SmokePosition = Position;
+            Height = 0;
+            Width = 0;
+            Thickness = 0;
+            CurrentDensity = 0;
+            Distance = 0;
+            Duration = 0;
+            RemainingTime = EffectiveTime;
+        }
+
+        /// <summary>
+        /// 更新烟幕干扰器的状态
+        /// </summary>
+        /// <param name="deltaTime">距离上次更新的时间间隔（秒）</param>
+        /// <remarks>
+        /// 更新过程包括：
+        /// 1. 更新烟幕状态
+        /// 2. 计算干扰效果
+        /// 3. 发布干扰事件
+        /// </remarks>
+        public override void Update(double deltaTime)
+        {
+            if (!IsActive || !IsJamming) return;
+
+            // 更新烟幕状态
+            UpdateSmokeStatus(deltaTime);
+
+            // 计算并更新干扰功率
+            UpdateJammingPower(deltaTime);
+
+            // 发布干扰事件
+            PublishJammingEvent();
+
+            // 检查是否需要停止干扰
+            if (RemainingTime <= 0)
+            {
+                StopJamming();
+            }
+        }
+
+        /// <summary>
+        /// 更新烟幕状态
+        /// </summary>
+        /// <param name="deltaTime">时间间隔（秒）</param>
+        private void UpdateSmokeStatus(double deltaTime)
+        {
+            Duration += (float)deltaTime;
+            RemainingTime = Math.Max(0, EffectiveTime - Duration);
+
+            // 计算扩散阶段的烟幕参数
+            if (Duration <= DiffusionTime)
+            {
+                float progress = Duration / DiffusionTime;
+                Width = SmokeDiameter * progress;
+                Height = ExplosionHeight * progress;
+                Thickness = Width * 0.5f;
+                CurrentDensity = InitialDensity * (1 - progress * 0.5f);
+            }
+            else
+            {
+                // 扩散完成后的衰减阶段
+                float decayProgress = (Duration - DiffusionTime) / (EffectiveTime - DiffusionTime);
+                CurrentDensity = InitialDensity * 0.5f * (1 - decayProgress);
+            }
+
+            // 更新烟幕位置（考虑风向和风速）
+            // TODO: 实现风场影响
+        }
+
+        /// <summary>
+        /// 更新干扰功率
+        /// </summary>
+        /// <param name="deltaTime">时间间隔（秒）</param>
+        protected override void UpdateJammingPower(double deltaTime)
+        {
+            if (Duration < ResponseTime)
+            {
+                // 响应阶段，功率逐渐增加
+                CurrentJammingPower = Math.Min(MaxJammingPower,
+                    CurrentJammingPower + PowerIncreaseRate * deltaTime);
+            }
+            else
+            {
+                // 有效阶段，功率与浓度成正比
+                CurrentJammingPower = MaxJammingPower * (CurrentDensity / InitialDensity);
+            }
+        }
+
+        /// <summary>
+        /// 发布烟幕干扰事件
+        /// </summary>
+        protected override void PublishJammingEvent()
+        {
+            if (IsJamming)
+            {
+                SimulationManager.PublishEvent(new SmokeJammingEvent
+                {
+                    SenderId = Id,
+                    Timestamp = SimulationManager.CurrentTime,
+                    TargetId = TankId,
+                    SmokeType = Type,
+                    Density = CurrentDensity,
+                });
+            }
+        }
+
+        /// <summary>
+        /// 获取烟幕干扰器的当前状态信息
+        /// </summary>
+        /// <returns>
+        /// 返回包含以下信息的状态描述字符串：
+        /// - 干扰器ID和类型
+        /// - 烟幕状态参数
+        /// - 当前干扰功率
+        /// - 剩余有效时间
+        /// </returns>
+        public override string GetJammingStatus()
+        {
+            return $"烟幕干扰器 {Id}:\n" +
+                   $"  类型: {Type}\n" +
+                   $"  状态: {(IsJamming ? "干扰中" : "待机中")}\n" +
+                   $"  当前功率: {CurrentJammingPower:F2}/{MaxJammingPower:F2}\n" +
+                   $"  烟幕位置: {SmokePosition}\n" +
+                   $"  烟幕尺寸: {Width:F1}×{Height:F1}×{Thickness:F1}\n" +
+                   $"  当前浓度: {CurrentDensity:F3}\n" +
+                   $"  剩余时间: {RemainingTime:F1}s";
+        }
+    }
+
+    /// <summary>
+    /// 烟幕类型枚举
+    /// </summary>
+    public enum SmokeType
+    {
+        /// <summary>
+        /// 红外烟幕，用于对抗红外制导武器
+        /// </summary>
+        Infrared,
+
+        /// <summary>
+        /// 毫米波烟幕，用于对抗毫米波制导武器
+        /// </summary>
+        Millimeter,
+
+        /// <summary>
+        /// 多谱段烟幕，可同时对抗多种制导方式
+        /// </summary>
+        Multispectral
+    }
+} 

src/Models/Jammer/TerminalMillimeterWaveJammer.cs

@@ -0,0 +1,313 @@
+using System;
+using ActiveProtect.Simulation;
+using ActiveProtect.Utility;
+
+namespace ActiveProtect.Models
+{
+    /// <summary>
+    /// 末敏弹毫米波干扰器类，用于对抗末制导阶段的毫米波制导武器
+    /// </summary>
+    /// <remarks>
+    /// 该类实现了以下功能：
+    /// - 多种干扰方式（噪声、欺骗、箔条、组合）
+    /// - 干扰效果实时计算
+    /// - 状态参数管理
+    /// - 事件发布处理
+    /// </remarks>
+    public class TerminalMillimeterWaveJammer : JammerBase
+    {
+        #region 干扰参数
+        /// <summary>
+        /// 获取干扰波长范围
+        /// </summary>
+        /// <value>
+        /// 干扰器工作的波长范围，单位：毫米(mm)
+        /// </value>
+        public (double Min, double Max) WavelengthRange { get; private set; }
+
+        /// <summary>
+        /// 获取角度范围
+        /// </summary>
+        /// <value>
+        /// 干扰器的工作角度范围，单位：弧度(rad)
+        /// </value>
+        public (double Min, double Max) AngleRange { get; private set; }
+
+        /// <summary>
+        /// 获取响应时间
+        /// </summary>
+        /// <value>
+        /// 从接收到威胁到形成有效干扰的时间，单位：秒(s)
+        /// </value>
+        public double ResponseTime { get; private set; }
+
+        /// <summary>
+        /// 获取有效距离
+        /// </summary>
+        /// <value>
+        /// 干扰器能够产生有效干扰的最大距离，单位：米(m)
+        /// </value>
+        public double EffectiveRange { get; private set; }
+
+        /// <summary>
+        /// 获取干扰概率
+        /// </summary>
+        /// <value>
+        /// 在有效距离内产生有效干扰的概率，范围：0-1
+        /// </value>
+        public double JammingProbability { get; private set; }
+
+        /// <summary>
+        /// 获取探测距离
+        /// </summary>
+        /// <value>
+        /// 干扰器能够探测到威胁的最大距离，单位：米(m)
+        /// </value>
+        public double DetectionRange { get; private set; }
+
+        /// <summary>
+        /// 获取脉冲频率
+        /// </summary>
+        /// <value>
+        /// 干扰信号的脉冲重复频率，单位：赫兹(Hz)
+        /// </value>
+        public double PulseFrequency { get; private set; }
+
+        /// <summary>
+        /// 获取脉冲宽度
+        /// </summary>
+        /// <value>
+        /// 干扰信号的脉冲持续时间，单位：秒(s)
+        /// </value>
+        public double PulseWidth { get; private set; }
+        #endregion
+
+        #region 仿真状态
+        /// <summary>
+        /// 获取干扰类型
+        /// </summary>
+        /// <value>
+        /// 当前使用的干扰方式
+        /// </value>
+        public JammingType Type { get; private set; }
+
+        /// <summary>
+        /// 获取干扰开始时间
+        /// </summary>
+        /// <value>
+        /// 开始执行干扰的时间点，单位：秒(s)
+        /// </value>
+        public double JammingStartTime { get; private set; }
+
+        /// <summary>
+        /// 获取干扰持续时间
+        /// </summary>
+        /// <value>
+        /// 已经执行干扰的时间，单位：秒(s)
+        /// </value>
+        public double JammingDuration { get; private set; }
+
+        /// <summary>
+        /// 获取当前目标距离
+        /// </summary>
+        /// <value>
+        /// 当前威胁目标的距离，单位：米(m)
+        /// </value>
+        private double CurrentTargetDistance { get; set; }
+        #endregion
+
+        /// <summary>
+        /// 初始化末敏弹毫米波干扰器的新实例
+        /// </summary>
+        /// <param name="id">干扰器的唯一标识符</param>
+        /// <param name="position">干扰器的初始位置</param>
+        /// <param name="orientation">干扰器的初始朝向</param>
+        /// <param name="manager">仿真管理器实例</param>
+        /// <param name="tankId">所属坦克的ID</param>
+        /// <param name="config">干扰器配置参数</param>
+        public TerminalMillimeterWaveJammer(string id, Vector3D position, Orientation orientation,
+            ISimulationManager manager, string tankId, TerminalMillimeterWaveJammerConfig config)
+            : base(id, position, orientation, manager, tankId, config.MaxJammingPower,
+                  config.InitialJammingPower, config.PowerIncreaseRate, config.MaxJammingCooldown)
+        {
+            // 初始化干扰参数
+            WavelengthRange = config.WavelengthRange;
+            AngleRange = config.AngleRange;
+            ResponseTime = config.ResponseTime;
+            EffectiveRange = config.EffectiveRange;
+            JammingProbability = config.JammingProbability;
+            DetectionRange = config.DetectionRange;
+            PulseFrequency = config.PulseFrequency;
+            PulseWidth = config.PulseWidth;
+            Type = config.Type;
+
+            // 初始化状态参数
+            ResetJammingStatus();
+
+            // 订阅威胁探测事件
+            SimulationManager.SubscribeToEvent<TerminalThreatDetectionEvent>(OnThreatDetected);
+        }
+
+        /// <summary>
+        /// 重置干扰状态
+        /// </summary>
+        private void ResetJammingStatus()
+        {
+            JammingStartTime = 0;
+            JammingDuration = 0;
+            CurrentTargetDistance = double.MaxValue;
+        }
+
+        /// <summary>
+        /// 处理威胁探测事件
+        /// </summary>
+        /// <param name="evt">威胁探测事件参数</param>
+        private void OnThreatDetected(TerminalThreatDetectionEvent evt)
+        {
+            if (evt?.TargetId == TankId)
+            {
+                CurrentTargetDistance = evt.Distance;
+                if (CurrentTargetDistance <= DetectionRange)
+                {
+                    StartJamming();
+                }
+            }
+        }
+
+        /// <summary>
+        /// 更新干扰器状态
+        /// </summary>
+        /// <param name="deltaTime">距离上次更新的时间间隔（秒）</param>
+        public override void Update(double deltaTime)
+        {
+            if (!IsActive || !IsJamming) return;
+
+            // 更新干扰持续时间
+            JammingDuration += deltaTime;
+
+            // 检查是否在响应时间内
+            if (JammingDuration < ResponseTime)
+            {
+                // 响应阶段，功率逐渐增加
+                UpdateJammingPower(deltaTime);
+            }
+            else
+            {
+                // 根据距离计算干扰效果
+                UpdateJammingEffect();
+            }
+
+            // 发布干扰事件
+            PublishJammingEvent();
+
+            // 检查是否需要停止干扰
+            if (CurrentTargetDistance > EffectiveRange)
+            {
+                StopJamming();
+            }
+        }
+
+        /// <summary>
+        /// 更新干扰功率
+        /// </summary>
+        /// <param name="deltaTime">时间间隔（秒）</param>
+        protected override void UpdateJammingPower(double deltaTime)
+        {
+            CurrentJammingPower = Math.Min(MaxJammingPower,
+                CurrentJammingPower + PowerIncreaseRate * deltaTime);
+        }
+
+        /// <summary>
+        /// 更新干扰效果
+        /// </summary>
+        private void UpdateJammingEffect()
+        {
+            // 根据距离计算实际干扰功率
+            double distanceRatio = Math.Min(1, EffectiveRange / CurrentTargetDistance);
+            CurrentJammingPower = MaxJammingPower * distanceRatio * JammingProbability;
+
+            // 根据干扰类型调整功率
+            switch (Type)
+            {
+                case JammingType.NoiseJamming:
+                    // 噪声干扰，功率均匀分布
+                    break;
+                case JammingType.DeceptionJamming:
+                    // 欺骗干扰，功率集中
+                    CurrentJammingPower *= 1.5;
+                    break;
+                case JammingType.ChaffJamming:
+                    // 箔条干扰，功率分散
+                    CurrentJammingPower *= 0.8;
+                    break;
+                case JammingType.CombinedJamming:
+                    // 组合干扰，根据情况调整
+                    CurrentJammingPower *= 1.2;
+                    break;
+            }
+        }
+
+        /// <summary>
+        /// 发布干扰事件
+        /// </summary>
+        protected override void PublishJammingEvent()
+        {
+            if (IsJamming)
+            {
+                SimulationManager.PublishEvent(new TerminalMillimeterWaveJammingEvent
+                {
+                    SenderId = Id,
+                    Timestamp = SimulationManager.CurrentTime,
+                    TargetId = TankId,
+                    JammingPower = CurrentJammingPower,
+                    JammingType = Type,
+                    Distance = CurrentTargetDistance,
+                    Duration = JammingDuration,
+                    PulseFrequency = PulseFrequency,
+                    PulseWidth = PulseWidth
+                });
+            }
+        }
+
+        /// <summary>
+        /// 获取干扰器状态信息
+        /// </summary>
+        /// <returns>包含干扰器当前状态的描述字符串</returns>
+        public override string GetJammingStatus()
+        {
+            return $"末敏弹毫米波干扰器 {Id}:\n" +
+                   $"  干扰类型: {Type}\n" +
+                   $"  状态: {(IsJamming ? "干扰中" : "待机中")}\n" +
+                   $"  当前功率: {CurrentJammingPower:F2}/{MaxJammingPower:F2}\n" +
+                   $"  目标距离: {CurrentTargetDistance:F1}\n" +
+                   $"  持续时间: {JammingDuration:F1}s\n" +
+                   $"  干扰概率: {JammingProbability:P2}";
+        }
+    }
+
+    /// <summary>
+    /// 干扰类型枚举
+    /// </summary>
+    public enum JammingType
+    {
+        /// <summary>
+        /// 噪声干扰，产生宽带噪声信号
+        /// </summary>
+        NoiseJamming,
+
+        /// <summary>
+        /// 欺骗干扰，产生虚假目标信号
+        /// </summary>
+        DeceptionJamming,
+
+        /// <summary>
+        /// 箔条干扰，释放金属箔条形成干扰云
+        /// </summary>
+        ChaffJamming,
+
+        /// <summary>
+        /// 组合干扰，同时使用多种干扰方式
+        /// </summary>
+        CombinedJamming
+    }
+} 

src/Models/Warner/IWarner.cs

@@ -1,28 +1,53 @@
+
 namespace ActiveProtect.Models
 {
     /// <summary>
     /// 告警设备接口
+    /// 定义了所有告警设备必须实现的基本功能和属性
     /// </summary>
+    /// <remarks>
+    /// 该接口用于定义告警设备的标准行为，包括：
+    /// - 告警状态的控制（开启/关闭）
+    /// - 告警状态的监控和查询
+    /// 所有具体的告警器实现（如激光、红外、毫米波、紫外等）都必须实现此接口
+    /// </remarks>
     public interface IWarner
     {
         /// <summary>
-        /// 是否处于告警状态
+        /// 获取一个值，该值指示告警器当前是否处于告警状态
         /// </summary>
+        /// <value>
+        /// true 表示告警器正在发出告警；false 表示告警器处于正常状态
+        /// </value>
         bool IsWarning { get; }
 
         /// <summary>
-        /// 开始告警
+        /// 启动告警器，开始执行告警操作
         /// </summary>
+        /// <remarks>
+        /// 调用此方法将使告警器进入告警状态，开始输出告警信号
+        /// 如果告警器已经在告警状态，则此调用不会产生任何效果
+        /// </remarks>
         void StartWarning();
 
         /// <summary>
-        /// 停止告警
+        /// 停止告警器的告警状态
         /// </summary>
+        /// <remarks>
+        /// 调用此方法将使告警器停止告警，终止告警信号的输出
+        /// 如果告警器已经停止告警，则此调用不会产生任何效果
+        /// </remarks>
         void StopWarning();
 
         /// <summary>
-        /// 获取告警状态
+        /// 获取告警器当前的工作状态描述
         /// </summary>
+        /// <returns>
+        /// 返回描述告警器当前状态的字符串，包括：
+        /// - 告警状态（开启/关闭）
+        /// - 告警类型
+        /// - 其他相关状态信息
+        /// </returns>
         string GetWarningStatus();
     }
 } 

src/Models/Warner/InfraredWarner.cs

@@ -1,3 +1,4 @@
+
 using System;
 using ActiveProtect.Simulation;
 using ActiveProtect.Utility;
@@ -7,12 +8,58 @@ namespace ActiveProtect.Models
     /// <summary>
     /// 红外告警器类，用于检测红外辐射并发出警报
     /// </summary>
+    /// <remarks>
+    /// 该类实现了以下功能：
+    /// - 检测特定波长范围内的红外辐射
+    /// - 根据设定的灵敏度阈值判断是否需要告警
+    /// - 自动处理告警持续时间
+    /// - 发布告警事件供其他系统响应
+    /// - 支持实时状态监控
+    /// </remarks>
     public class InfraredWarner : WarnerBase
     {
+        /// <summary>
+        /// 获取告警灵敏度阈值
+        /// </summary>
+        /// <value>
+        /// 触发告警的最小红外辐射强度阈值
+        /// 单位：瓦特/平方米(W/m²)
+        /// </value>
         private readonly double _sensitivityThreshold;
+
+        /// <summary>
+        /// 获取最小检测波长
+        /// </summary>
+        /// <value>
+        /// 告警器可以检测的最小红外波长
+        /// 单位：微米(μm)
+        /// </value>
         private readonly double _wavelengthMin;
+
+        /// <summary>
+        /// 获取最大检测波长
+        /// </summary>
+        /// <value>
+        /// 告警器可以检测的最大红外波长
+        /// 单位：微米(μm)
+        /// </value>
         private readonly double _wavelengthMax;
 
+        /// <summary>
+        /// 初始化红外告警器的新实例
+        /// </summary>
+        /// <param name="id">告警器的唯一标识符</param>
+        /// <param name="position">告警器的初始位置</param>
+        /// <param name="orientation">告警器的初始朝向</param>
+        /// <param name="manager">仿真管理器实例</param>
+        /// <param name="tankId">所属坦克的ID</param>
+        /// <param name="config">红外告警器配置参数</param>
+        /// <remarks>
+        /// 构造函数完成以下初始化工作：
+        /// 1. 调用基类构造函数设置基本参数
+        /// 2. 设置告警器的检测参数
+        /// 3. 订阅红外检测事件
+        /// </remarks>
         public InfraredWarner(string id, Vector3D position, Orientation orientation,
             ISimulationManager manager, string tankId, InfraredWarnerConfig config)
             : base(id, position, orientation, manager, tankId, config.SensitivityThreshold,
@@ -24,6 +71,14 @@ namespace ActiveProtect.Models
             SimulationManager.SubscribeToEvent<InfraredDetectionEvent>(OnInfraredDetection);
         }
 
+        /// <summary>
+        /// 处理红外检测事件
+        /// </summary>
+        /// <param name="evt">红外检测事件参数</param>
+        /// <remarks>
+        /// 当检测到的红外辐射强度超过灵敏度阈值时，触发告警
+        /// 仅处理针对本装甲车的检测事件
+        /// </remarks>
         private void OnInfraredDetection(InfraredDetectionEvent evt)
         {
             if (evt?.TargetId == TankId && evt.Intensity >= _sensitivityThreshold)
@@ -32,6 +87,16 @@ namespace ActiveProtect.Models
             }
         }
 
+        /// <summary>
+        /// 获取红外告警器的当前状态信息
+        /// </summary>
+        /// <returns>
+        /// 返回包含以下信息的状态描述字符串：
+        /// - 告警器ID和类型
+        /// - 当前告警状态
+        /// - 告警持续时间
+        /// - 检测波长范围
+        /// </returns>
         public override string GetWarningStatus()
         {
             return $"红外告警器 {Id}:\n" +
@@ -40,6 +105,15 @@ namespace ActiveProtect.Models
                    $"  波长范围: {_wavelengthMin:F2}-{_wavelengthMax:F2}微米";
         }
 
+        /// <summary>
+        /// 更新红外告警器的状态
+        /// </summary>
+        /// <param name="deltaTime">距离上次更新的时间间隔（秒）</param>
+        /// <remarks>
+        /// 更新过程包括：
+        /// 1. 调用基类的更新方法处理基本状态
+        /// 2. 在告警状态下发布告警事件
+        /// </remarks>
         public override void Update(double deltaTime)
         {
             base.Update(deltaTime);
@@ -56,12 +130,28 @@ namespace ActiveProtect.Models
             }
         }
 
+        /// <summary>
+        /// 激活红外告警器
+        /// </summary>
+        /// <remarks>
+        /// 激活时执行以下操作：
+        /// 1. 调用基类的激活方法
+        /// 2. 订阅红外检测事件
+        /// </remarks>
         public override void Activate()
         {
             base.Activate();
             SimulationManager.SubscribeToEvent<InfraredDetectionEvent>(OnInfraredDetection);
         }
 
+        /// <summary>
+        /// 停用红外告警器
+        /// </summary>
+        /// <remarks>
+        /// 停用时执行以下操作：
+        /// 1. 调用基类的停用方法
+        /// 2. 取消订阅红外检测事件
+        /// </remarks>
         public override void Deactivate()
         {
             base.Deactivate();

src/Models/Warner/LaserWarner.cs

@@ -1,3 +1,4 @@
+
 using System;
 using ActiveProtect.Simulation;
 using ActiveProtect.Utility;
@@ -7,11 +8,30 @@ namespace ActiveProtect.Models
     /// <summary>
     /// 激光告警器类，用于检测激光照射并发出警报
     /// </summary>
+    /// <remarks>
+    /// 该类实现了以下功能：
+    /// - 检测激光照射事件
+    /// - 自动处理告警持续时间
+    /// - 发布告警事件供其他系统响应
+    /// - 支持实时状态监控
+    /// - 提供详细的日志信息用于调试
+    /// </remarks>
     public class LaserWarner : WarnerBase
     {
         /// <summary>
-        /// 构造函数
+        /// 初始化激光告警器的新实例
         /// </summary>
+        /// <param name="id">告警器的唯一标识符</param>
+        /// <param name="position">告警器的初始位置</param>
+        /// <param name="orientation">告警器的初始朝向</param>
+        /// <param name="manager">仿真管理器实例</param>
+        /// <param name="tankId">所属坦克的ID</param>
+        /// <param name="config">激光告警器配置参数</param>
+        /// <remarks>
+        /// 构造函数完成以下初始化工作：
+        /// 1. 调用基类构造函数设置基本参数
+        /// 2. 订阅激光照射事件
+        /// </remarks>
         public LaserWarner(string id, Vector3D position, Orientation orientation,
             ISimulationManager manager, string tankId, LaserWarnerConfig config)
             : base(id, position, orientation, manager, tankId, config.SensitivityThreshold,
@@ -22,8 +42,15 @@ namespace ActiveProtect.Models
         }
 
         /// <summary>
-        /// 处理激光照射事件
+        /// 处理激光照射开始事件
         /// </summary>
+        /// <param name="evt">激光照射开始事件参数</param>
+        /// <remarks>
+        /// 当检测到针对本装甲车的激光照射时：
+        /// 1. 记录调试日志
+        /// 2. 验证目标ID
+        /// 3. 触发告警
+        /// </remarks>
         private void OnLaserIlluminationStart(LaserIlluminationStartEvent evt)
         {
             // 添加日志以帮助调试
@@ -39,6 +66,13 @@ namespace ActiveProtect.Models
         /// <summary>
         /// 处理激光照射停止事件
         /// </summary>
+        /// <param name="evt">激光照射停止事件参数</param>
+        /// <remarks>
+        /// 当检测到激光照射停止时：
+        /// 1. 记录调试日志
+        /// 2. 验证目标ID
+        /// 3. 停止告警
+        /// </remarks>
         private void OnLaserIlluminationStop(LaserIlluminationStopEvent evt)
         {
             // 添加日志以帮助调试
@@ -52,8 +86,14 @@ namespace ActiveProtect.Models
         }
 
         /// <summary>
-        /// 获取告警状态信息
+        /// 获取激光告警器的当前状态信息
         /// </summary>
+        /// <returns>
+        /// 返回包含以下信息的状态描述字符串：
+        /// - 告警器ID和类型
+        /// - 当前告警状态
+        /// - 告警持续时间
+        /// </returns>
         public override string GetWarningStatus()
         {
             return $"激光告警器 {Id}:\n" +
@@ -61,6 +101,14 @@ namespace ActiveProtect.Models
                    $"  告警持续时间: {CurrentWarningTime:F2}/{WarningDuration:F2}";
         }
 
+        /// <summary>
+        /// 激活激光告警器
+        /// </summary>
+        /// <remarks>
+        /// 激活时执行以下操作：
+        /// 1. 调用基类的激活方法
+        /// 2. 订阅激光照射事件
+        /// </remarks>
         public override void Activate()
         {
             base.Activate();
@@ -68,6 +116,14 @@ namespace ActiveProtect.Models
             SimulationManager.SubscribeToEvent<LaserIlluminationStopEvent>(OnLaserIlluminationStop);
         }
 
+        /// <summary>
+        /// 停用激光告警器
+        /// </summary>
+        /// <remarks>
+        /// 停用时执行以下操作：
+        /// 1. 调用基类的停用方法
+        /// 2. 取消订阅激光照射事件
+        /// </remarks>
         public override void Deactivate()
         {
             base.Deactivate();
@@ -75,6 +131,15 @@ namespace ActiveProtect.Models
             SimulationManager.UnsubscribeFromEvent<LaserIlluminationStopEvent>(OnLaserIlluminationStop);
         }
 
+        /// <summary>
+        /// 更新激光告警器的状态
+        /// </summary>
+        /// <param name="deltaTime">距离上次更新的时间间隔（秒）</param>
+        /// <remarks>
+        /// 更新过程包括：
+        /// 1. 调用基类的更新方法处理基本状态
+        /// 2. 在告警状态下发布告警事件
+        /// </remarks>
         public override void Update(double deltaTime)
         {
             base.Update(deltaTime);

src/Models/Warner/MillimeterWaveWarner.cs

@@ -1,3 +1,4 @@
+
 using System;
 using ActiveProtect.Simulation;
 using ActiveProtect.Utility;
@@ -7,12 +8,58 @@ namespace ActiveProtect.Models
     /// <summary>
     /// 毫米波告警器类，用于检测毫米波辐射并发出警报
     /// </summary>
+    /// <remarks>
+    /// 该类实现了以下功能：
+    /// - 检测特定频率范围内的毫米波辐射
+    /// - 根据设定的灵敏度阈值判断是否需要告警
+    /// - 自动处理告警持续时间
+    /// - 发布告警事件供其他系统响应
+    /// - 支持实时状态监控
+    /// </remarks>
     public class MillimeterWaveWarner : WarnerBase
     {
+        /// <summary>
+        /// 获取告警灵敏度阈值
+        /// </summary>
+        /// <value>
+        /// 触发告警的最小毫米波辐射强度阈值
+        /// 单位：瓦特/平方米(W/m²)
+        /// </value>
         private readonly double _sensitivityThreshold;
+
+        /// <summary>
+        /// 获取最小检测频率
+        /// </summary>
+        /// <value>
+        /// 告警器可以检测的最小毫米波频率
+        /// 单位：吉赫兹(GHz)
+        /// </value>
         private readonly double _wavelengthMin;
+
+        /// <summary>
+        /// 获取最大检测频率
+        /// </summary>
+        /// <value>
+        /// 告警器可以检测的最大毫米波频率
+        /// 单位：吉赫兹(GHz)
+        /// </value>
         private readonly double _wavelengthMax;
 
+        /// <summary>
+        /// 初始化毫米波告警器的新实例
+        /// </summary>
+        /// <param name="id">告警器的唯一标识符</param>
+        /// <param name="position">告警器的初始位置</param>
+        /// <param name="orientation">告警器的初始朝向</param>
+        /// <param name="manager">仿真管理器实例</param>
+        /// <param name="tankId">所属坦克的ID</param>
+        /// <param name="config">毫米波告警器配置参数</param>
+        /// <remarks>
+        /// 构造函数完成以下初始化工作：
+        /// 1. 调用基类构造函数设置基本参数
+        /// 2. 设置告警器的检测参数
+        /// 3. 订阅毫米波检测事件
+        /// </remarks>
         public MillimeterWaveWarner(string id, Vector3D position, Orientation orientation,
             ISimulationManager manager, string tankId, MillimeterWaveWarnerConfig config)
             : base(id, position, orientation, manager, tankId, config.SensitivityThreshold,
@@ -24,6 +71,16 @@ namespace ActiveProtect.Models
             SimulationManager.SubscribeToEvent<MillimeterWaveDetectionEvent>(OnMillimeterWaveDetection);
         }
 
+        /// <summary>
+        /// 处理毫米波检测事件
+        /// </summary>
+        /// <param name="evt">毫米波检测事件参数</param>
+        /// <remarks>
+        /// 当满足以下条件时触发告警：
+        /// 1. 检测到的目标ID匹配
+        /// 2. 辐射强度超过灵敏度阈值
+        /// 3. 检测频率在设定范围内
+        /// </remarks>
         private void OnMillimeterWaveDetection(MillimeterWaveDetectionEvent evt)
         {
             if (evt?.TargetId == TankId && 
@@ -35,6 +92,16 @@ namespace ActiveProtect.Models
             }
         }
 
+        /// <summary>
+        /// 获取毫米波告警器的当前状态信息
+        /// </summary>
+        /// <returns>
+        /// 返回包含以下信息的状态描述字符串：
+        /// - 告警器ID和类型
+        /// - 当前告警状态
+        /// - 告警持续时间
+        /// - 检测频率范围
+        /// </returns>
         public override string GetWarningStatus()
         {
             return $"毫米波告警器 {Id}:\n" +
@@ -43,6 +110,15 @@ namespace ActiveProtect.Models
                    $"  频率范围: {_wavelengthMin:F2}-{_wavelengthMax:F2}GHz";
         }
 
+        /// <summary>
+        /// 更新毫米波告警器的状态
+        /// </summary>
+        /// <param name="deltaTime">距离上次更新的时间间隔（秒）</param>
+        /// <remarks>
+        /// 更新过程包括：
+        /// 1. 调用基类的更新方法处理基本状态
+        /// 2. 在告警状态下发布告警事件，使用中心频率作为检测频率
+        /// </remarks>
         public override void Update(double deltaTime)
         {
             base.Update(deltaTime);
@@ -60,12 +136,28 @@ namespace ActiveProtect.Models
             }
         }
 
+        /// <summary>
+        /// 激活毫米波告警器
+        /// </summary>
+        /// <remarks>
+        /// 激活时执行以下操作：
+        /// 1. 调用基类的激活方法
+        /// 2. 订阅毫米波检测事件
+        /// </remarks>
         public override void Activate()
         {
             base.Activate();
             SimulationManager.SubscribeToEvent<MillimeterWaveDetectionEvent>(OnMillimeterWaveDetection);
         }
 
+        /// <summary>
+        /// 停用毫米波告警器
+        /// </summary>
+        /// <remarks>
+        /// 停用时执行以下操作：
+        /// 1. 调用基类的停用方法
+        /// 2. 取消订阅毫米波检测事件
+        /// </remarks>
         public override void Deactivate()
         {
             base.Deactivate();

src/Models/Warner/UltravioletWarner.cs

@@ -1,3 +1,4 @@
+
 using System;
 using ActiveProtect.Simulation;
 using ActiveProtect.Utility;
@@ -7,12 +8,58 @@ namespace ActiveProtect.Models
     /// <summary>
     /// 紫外告警器类，用于检测紫外辐射并发出警报
     /// </summary>
+    /// <remarks>
+    /// 该类实现了以下功能：
+    /// - 检测特定波长范围内的紫外辐射
+    /// - 根据设定的灵敏度阈值判断是否需要告警
+    /// - 自动处理告警持续时间
+    /// - 发布告警事件供其他系统响应
+    /// - 支持实时状态监控
+    /// </remarks>
     public class UltravioletWarner : WarnerBase
     {
+        /// <summary>
+        /// 获取告警灵敏度阈值
+        /// </summary>
+        /// <value>
+        /// 触发告警的最小紫外辐射强度阈值
+        /// 单位：瓦特/平方米(W/m²)
+        /// </value>
         private readonly double _sensitivityThreshold;
+
+        /// <summary>
+        /// 获取最小检测波长
+        /// </summary>
+        /// <value>
+        /// 告警器可以检测的最小紫外波长
+        /// 单位：纳米(nm)
+        /// </value>
         private readonly double _wavelengthMin;
+
+        /// <summary>
+        /// 获取最大检测波长
+        /// </summary>
+        /// <value>
+        /// 告警器可以检测的最大紫外波长
+        /// 单位：纳米(nm)
+        /// </value>
         private readonly double _wavelengthMax;
 
+        /// <summary>
+        /// 初始化紫外告警器的新实例
+        /// </summary>
+        /// <param name="id">告警器的唯一标识符</param>
+        /// <param name="position">告警器的初始位置</param>
+        /// <param name="orientation">告警器的初始朝向</param>
+        /// <param name="manager">仿真管理器实例</param>
+        /// <param name="tankId">所属坦克的ID</param>
+        /// <param name="config">紫外告警器配置参数</param>
+        /// <remarks>
+        /// 构造函数完成以下初始化工作：
+        /// 1. 调用基类构造函数设置基本参数
+        /// 2. 设置告警器的检测参数
+        /// 3. 订阅紫外检测事件
+        /// </remarks>
         public UltravioletWarner(string id, Vector3D position, Orientation orientation,
             ISimulationManager manager, string tankId, UltravioletWarnerConfig config)
             : base(id, position, orientation, manager, tankId, config.SensitivityThreshold,
@@ -24,6 +71,15 @@ namespace ActiveProtect.Models
             SimulationManager.SubscribeToEvent<UltravioletDetectionEvent>(OnUltravioletDetection);
         }
 
+        /// <summary>
+        /// 处理紫外检测事件
+        /// </summary>
+        /// <param name="evt">紫外检测事件参数</param>
+        /// <remarks>
+        /// 当满足以下条件时触发告警：
+        /// 1. 检测到的目标ID匹配
+        /// 2. 辐射强度超过灵敏度阈值
+        /// </remarks>
         private void OnUltravioletDetection(UltravioletDetectionEvent evt)
         {
             if (evt?.TargetId == TankId && evt.Intensity >= _sensitivityThreshold)
@@ -32,6 +88,16 @@ namespace ActiveProtect.Models
             }
         }
 
+        /// <summary>
+        /// 获取紫外告警器的当前状态信息
+        /// </summary>
+        /// <returns>
+        /// 返回包含以下信息的状态描述字符串：
+        /// - 告警器ID和类型
+        /// - 当前告警状态
+        /// - 告警持续时间
+        /// - 检测波长范围
+        /// </returns>
         public override string GetWarningStatus()
         {
             return $"紫外告警器 {Id}:\n" +
@@ -40,6 +106,15 @@ namespace ActiveProtect.Models
                    $"  波长范围: {_wavelengthMin:F2}-{_wavelengthMax:F2}纳米";
         }
 
+        /// <summary>
+        /// 更新紫外告警器的状态
+        /// </summary>
+        /// <param name="deltaTime">距离上次更新的时间间隔（秒）</param>
+        /// <remarks>
+        /// 更新过程包括：
+        /// 1. 调用基类的更新方法处理基本状态
+        /// 2. 在告警状态下发布告警事件
+        /// </remarks>
         public override void Update(double deltaTime)
         {
             base.Update(deltaTime);
@@ -56,12 +131,28 @@ namespace ActiveProtect.Models
             }
         }
 
+        /// <summary>
+        /// 激活紫外告警器
+        /// </summary>
+        /// <remarks>
+        /// 激活时执行以下操作：
+        /// 1. 调用基类的激活方法
+        /// 2. 订阅紫外检测事件
+        /// </remarks>
         public override void Activate()
         {
             base.Activate();
             SimulationManager.SubscribeToEvent<UltravioletDetectionEvent>(OnUltravioletDetection);
         }
 
+        /// <summary>
+        /// 停用紫外告警器
+        /// </summary>
+        /// <remarks>
+        /// 停用时执行以下操作：
+        /// 1. 调用基类的停用方法
+        /// 2. 取消订阅紫外检测事件
+        /// </remarks>
         public override void Deactivate()
         {
             base.Deactivate();

src/Models/Warner/WarnerBase.cs

@@ -1,3 +1,4 @@
+
 using System;
 using ActiveProtect.Simulation;
 using ActiveProtect.Utility;
@@ -6,41 +7,84 @@ namespace ActiveProtect.Models
 {
     /// <summary>
     /// 告警设备基类
+    /// 实现了告警设备的基本功能和属性，为具体的告警器类型提供通用实现
     /// </summary>
+    /// <remarks>
+    /// 该基类提供了：
+    /// - 告警状态管理
+    /// - 告警灵敏度控制
+    /// - 告警频率范围设置
+    /// - 告警持续时间控制
+    /// - 位置跟随功能
+    /// 继承自SimulationElement以支持仿真功能，实现IWarner接口
+    /// </remarks>
     public abstract class WarnerBase : SimulationElement, IWarner
     {
         /// <summary>
-        /// 是否处于告警状态
+        /// 获取或设置一个值，该值指示告警器是否处于告警状态
         /// </summary>
+        /// <value>
+        /// true表示正在告警；false表示未在告警
+        /// </value>
         public bool IsWarning { get; protected set; }
 
         /// <summary>
-        /// 告警灵敏度阈值
+        /// 获取或设置告警灵敏度阈值
         /// </summary>
+        /// <value>
+        /// 告警器触发告警的最小信号强度阈值
+        /// 单位取决于具体告警器类型（如dB、W/m²等）
+        /// </value>
         protected double SensitivityThreshold { get; set; }
 
         /// <summary>
-        /// 告警频率范围
+        /// 获取或设置告警频率范围
         /// </summary>
+        /// <value>
+        /// 告警器可以检测的信号频率范围
+        /// Min：最小频率（Hz）
+        /// Max：最大频率（Hz）
+        /// </value>
         protected (double Min, double Max) FrequencyRange { get; set; }
 
         /// <summary>
-        /// 告警持续时间(秒)
+        /// 获取或设置告警持续时间
         /// </summary>
+        /// <value>
+        /// 单次告警的最大持续时间，单位：秒(s)
+        /// </value>
         protected double WarningDuration { get; set; }
 
         /// <summary>
-        /// 当前告警时间(秒)
+        /// 获取或设置当前告警持续时间
         /// </summary>
+        /// <value>
+        /// 当前告警已持续的时间，单位：秒(s)
+        /// </value>
         protected double CurrentWarningTime { get; set; }
 
         /// <summary>
-        /// 所属坦克ID
+        /// 获取或设置所属坦克的唯一标识符
         /// </summary>
+        /// <value>
+        /// 坦克的ID字符串
+        /// </value>
         protected string TankId { get; set; }
 
+        /// <summary>
+        /// 初始化告警器基类的新实例
+        /// </summary>
+        /// <param name="id">告警器的唯一标识符</param>
+        /// <param name="position">初始位置</param>
+        /// <param name="orientation">初始朝向</param>
+        /// <param name="manager">仿真管理器实例</param>
+        /// <param name="tankId">所属坦克ID</param>
+        /// <param name="sensitivityThreshold">告警灵敏度阈值</param>
+        /// <param name="frequencyRange">告警频率范围</param>
+        /// <param name="warningDuration">告警持续时间</param>
         protected WarnerBase(string id, Vector3D position, Orientation orientation, 
-            ISimulationManager manager, string tankId, double sensitivityThreshold, (double Min, double Max) frequencyRange, double warningDuration) 
+            ISimulationManager manager, string tankId, double sensitivityThreshold, 
+            (double Min, double Max) frequencyRange, double warningDuration) 
             : base(id, position, orientation, 0, manager)
         {
             TankId = tankId;
@@ -51,6 +95,13 @@ namespace ActiveProtect.Models
             IsWarning = false;
         }
 
+        /// <summary>
+        /// 启动告警器
+        /// </summary>
+        /// <remarks>
+        /// 启动时会重置当前告警时间并开始计时
+        /// 如果已经处于告警状态，则此调用不会产生任何效果
+        /// </remarks>
         public virtual void StartWarning()
         {
             if (!IsWarning)
@@ -61,6 +112,13 @@ namespace ActiveProtect.Models
             }
         }
 
+        /// <summary>
+        /// 停止告警器
+        /// </summary>
+        /// <remarks>
+        /// 停止时会重置当前告警时间
+        /// 如果未处于告警状态，则此调用不会产生任何效果
+        /// </remarks>
         public virtual void StopWarning()
         {
             if (IsWarning)
@@ -71,8 +129,23 @@ namespace ActiveProtect.Models
             }
         }
 
+        /// <summary>
+        /// 获取告警器的状态信息
+        /// </summary>
+        /// <returns>描述告警器当前状态的字符串</returns>
         public abstract string GetWarningStatus();
 
+        /// <summary>
+        /// 更新告警器的状态
+        /// </summary>
+        /// <param name="deltaTime">距离上次更新的时间间隔（秒）</param>
+        /// <remarks>
+        /// 更新内容包括：
+        /// - 告警持续时间
+        /// - 告警状态
+        /// - 位置（跟随坦克）
+        /// 当告警持续时间超过设定值时，自动停止告警
+        /// </remarks>
         public override void Update(double deltaTime)
         {
             if (!IsActive) return;
@@ -94,12 +167,24 @@ namespace ActiveProtect.Models
             }
         }
 
+        /// <summary>
+        /// 激活告警器
+        /// </summary>
+        /// <remarks>
+        /// 激活时会输出日志信息
+        /// </remarks>
         public override void Activate()
         {
             base.Activate();
             Console.WriteLine($"告警器 {Id} 已激活");
         }
 
+        /// <summary>
+        /// 停用告警器
+        /// </summary>
+        /// <remarks>
+        /// 停用时会先停止告警，然后输出日志信息
+        /// </remarks>
         public override void Deactivate()
         {
             StopWarning();

src/Simulation/SimulationEvents.cs

@@ -415,4 +415,26 @@ namespace ActiveProtect.Simulation
         public double WavelengthMax { get; set; }
     }
 
+    /// <summary>
+    /// 烟幕干扰事件
+    /// </summary>
+    public class SmokeJammingEvent : SimulationEvent
+    {
+        /// <summary>
+        /// 目标ID
+        /// </summary>
+        public string? TargetId { get; set; }
+
+        /// <summary>
+        /// 烟幕类型
+        /// </summary>
+        public SmokeType SmokeType { get; set; }
+
+        /// <summary>
+        /// 烟幕浓度(kg/m³)
+        /// </summary>
+        public float Density { get; set; }
+
+    }
+
 }