tian/ThreatSourceLibaray
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

增加末敏弹红外探测器烟幕干扰处理，增加导引头对导弹ID的直接引用

Browse Source
This commit is contained in:
Tian jianyong 2025-05-03 23:07:08 +08:00
parent af88ac64ad
commit 27834ddf99
30 changed files with 495 additions and 243 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

9
CHANGELOG.md
View File

@ -15,10 +15,13 @@
- 毫米波跟踪和锁定阶段采用脉冲多普勒制导、目标 RCS 特征矩阵
- 多种发射弹道模式：低平弹道、高抛弹道、俯冲弹道
- 双模、多模制导
- 各组件返回当前状态信息
- Orientation 坐标系的调整（前向方向从 X 轴改为 Z 轴）
- 将 getRunningState 提取到 SimulationElement 基类中
- 末敏弹各探测组件的干扰处理
- 末敏弹各探测组件的干扰处理，增加毫米波补偿干扰
## [0.2.14] - 2025-05-03
- 用ElementStatusInfo类，统一实现运行态信息返回（getStatusInfo方法），同时修改GetStatus方法
## [0.2.13] - 2025-04-23
- 增加了烟幕弹对激光目标指示器、激光驾束仪、红外测角仪的干扰处理

3
ThreatSource.Tests/src/Guidance/LaserSemiActiveGuidanceSystemCodeTests.cs
View File

@ -23,13 +23,14 @@ namespace ThreatSource.Tests.Guidance
_guidanceSystem = new LaserSemiActiveGuidanceSystem(
"guidance1",
"missile1",
50, // maxAcceleration
3, // guidanceCoefficient
laserCodeConfig,
guidanceConfig,
_simulationManager
);
_guidanceSystem.ParentId = "missile1";
_guidanceSystem.MissileId = "missile1";
_simulationManager.RegisterEntity("guidance1", _guidanceSystem);
}

95
ThreatSource.Tests/src/Jamming/InfraredImagingGuidanceJammingTests.cs
View File

@ -5,6 +5,7 @@ using ThreatSource.Simulation;
using ThreatSource.Tests.Simulation;
using ThreatSource.Utils;
using ThreatSource.Equipment;
using ThreatSource.Missile;
namespace ThreatSource.Tests.Jamming
{
@ -15,6 +16,7 @@ namespace ThreatSource.Tests.Jamming
private TestSimulationAdapter? _testAdapter;
private InfraredImagingGuidanceSystem? _guidanceSystem;
private Tank? _target;
private InfraredImagingTerminalGuidedMissile? _missile;
[TestInitialize]
public void TestInitialize()
@ -59,9 +61,44 @@ namespace ThreatSource.Tests.Jamming
_simulationManager.RegisterEntity("target1", _target);
_testAdapter.AddTestEntity("target1", _target);
// 创建导弹对象
var initialPosition = new Vector3D(500, 0, 0);
var initialVelocity = new Vector3D(100, 0, 0);
var missileMotion = new MotionParameters
{
Position = initialPosition,
InitialSpeed = initialVelocity.Magnitude()
};
missileMotion.Orientation = new Orientation(0, 0, 0);
var missileProperties = new MissileProperties
{
MaxSpeed = 1000,
MaxAcceleration = 100,
MaxEngineBurnTime = 1.0,
ProportionalNavigationCoefficient = 3.0,
MaxFlightTime = 60,
MaxFlightDistance = 10000,
ExplosionRadius = 10,
Mass = 50,
Type = MissileType.InfraredImagingTerminalGuidance
};
_missile = new InfraredImagingTerminalGuidedMissile(
"missile1",
EquipmentType.Tank,
missileProperties,
missileMotion,
config,
_simulationManager
);
_simulationManager.RegisterEntity("missile1", _missile);
_testAdapter.AddTestEntity("missile1", _missile);
// 创建红外引导系统
_guidanceSystem = new InfraredImagingGuidanceSystem(
"infraredGuidance1",
"missile1",
config,
EquipmentType.Tank,
100, // 最大加速度
@ -75,11 +112,14 @@ namespace ThreatSource.Tests.Jamming
// 激活引导系统
_guidanceSystem.Activate();
_missile.Activate();
_missile.Fire();
}
public void Dispose()
{
_guidanceSystem?.Deactivate();
_missile?.Deactivate();
}
[TestMethod]
@ -88,15 +128,12 @@ namespace ThreatSource.Tests.Jamming
// 确保组件不为空
Assert.IsNotNull(_simulationManager);
Assert.IsNotNull(_guidanceSystem);
Assert.IsNotNull(_missile);
// Arrange
var initialPosition = new Vector3D(500, 0, 0);
var initialVelocity = new Vector3D(100, 0, 0);
System.Diagnostics.Debug.WriteLine($"测试开始 - 初始位置: {initialPosition}, 初始速度: {initialVelocity}");
System.Diagnostics.Debug.WriteLine($"测试开始 - 初始位置: {_missile.Position}, 初始速度: {_missile.Velocity}");
// 更新一次系统，使其跟踪目标
_guidanceSystem.Update(0.1, initialPosition, initialVelocity);
_guidanceSystem.Update(0.1);
// 创建干扰事件
var jammingEvent = new JammingEvent
@ -117,7 +154,7 @@ namespace ThreatSource.Tests.Jamming
// Act
_simulationManager.PublishEvent(jammingEvent);
_guidanceSystem.Update(0.1, initialPosition, initialVelocity);
_guidanceSystem.Update(0.1);
// Assert
System.Diagnostics.Debug.WriteLine($"测试结果 - IsJammed: {_guidanceSystem.IsJammed}, HasGuidance: {_guidanceSystem.HasGuidance}");
@ -132,12 +169,8 @@ namespace ThreatSource.Tests.Jamming
Assert.IsNotNull(_simulationManager);
Assert.IsNotNull(_guidanceSystem);
// Arrange
var initialPosition = new Vector3D(500, 0, 0);
var initialVelocity = new Vector3D(100, 0, 0);
// 更新一次系统，使其跟踪目标
_guidanceSystem.Update(0.1, initialPosition, initialVelocity);
_guidanceSystem.Update(0.1);
// 创建角度范围外的干扰事件
var jammingEvent = new JammingEvent
@ -155,7 +188,7 @@ namespace ThreatSource.Tests.Jamming
// Act
_simulationManager.PublishEvent(jammingEvent);
_guidanceSystem.Update(0.1, initialPosition, initialVelocity);
_guidanceSystem.Update(0.1);
// Assert
Assert.IsFalse(_guidanceSystem.IsJammed, "引导系统不应该被干扰，因为干扰源不在角度范围内");
@ -168,12 +201,8 @@ namespace ThreatSource.Tests.Jamming
Assert.IsNotNull(_simulationManager);
Assert.IsNotNull(_guidanceSystem);
// Arrange
var initialPosition = new Vector3D(500, 0, 0);
var initialVelocity = new Vector3D(100, 0, 0);
// 更新一次系统，使其跟踪目标
_guidanceSystem.Update(0.1, initialPosition, initialVelocity);
_guidanceSystem.Update(0.1);
// 创建低功率干扰事件
var jammingEvent = new JammingEvent
@ -191,7 +220,7 @@ namespace ThreatSource.Tests.Jamming
// Act
_simulationManager.PublishEvent(jammingEvent);
_guidanceSystem.Update(0.1, initialPosition, initialVelocity);
_guidanceSystem.Update(0.1);
// Assert
Assert.IsFalse(_guidanceSystem.IsJammed, "引导系统不应该被干扰，因为干扰功率低于阈值");
@ -204,12 +233,8 @@ namespace ThreatSource.Tests.Jamming
Assert.IsNotNull(_simulationManager);
Assert.IsNotNull(_guidanceSystem);
// Arrange
var initialPosition = new Vector3D(500, 0, 0);
var initialVelocity = new Vector3D(100, 0, 0);
// 更新一次系统，使其跟踪目标
_guidanceSystem.Update(0.1, initialPosition, initialVelocity);
_guidanceSystem.Update(0.1);
// 创建有限时间的干扰事件
var jammingEvent = new JammingEvent
@ -228,7 +253,7 @@ namespace ThreatSource.Tests.Jamming
// Act - 应用干扰
_simulationManager.PublishEvent(jammingEvent);
_guidanceSystem.Update(0.1, initialPosition, initialVelocity);
_guidanceSystem.Update(0.1);
// Assert - 确认已被干扰
Assert.IsTrue(_guidanceSystem.IsJammed, "红外引导系统应该处于被干扰状态");
@ -237,7 +262,7 @@ namespace ThreatSource.Tests.Jamming
// 通过多次更新引导系统，让JammingHandler处理时间
for (int i = 0; i < 10; i++)
{
_guidanceSystem.Update(0.1, initialPosition, initialVelocity); // 总共更新1秒，超过干扰持续时间
_guidanceSystem.Update(0.1); // 总共更新1秒，超过干扰持续时间
}
// Assert - 确认干扰已清除
@ -251,12 +276,8 @@ namespace ThreatSource.Tests.Jamming
Assert.IsNotNull(_simulationManager);
Assert.IsNotNull(_guidanceSystem);
// Arrange
var initialPosition = new Vector3D(500, 0, 0);
var initialVelocity = new Vector3D(100, 0, 0);
// 更新一次系统，使其跟踪目标
_guidanceSystem.Update(0.1, initialPosition, initialVelocity);
_guidanceSystem.Update(0.1);
// 创建持续干扰事件
var jammingEvent = new JammingEvent
@ -275,14 +296,14 @@ namespace ThreatSource.Tests.Jamming
// Act - 应用干扰
_simulationManager.PublishEvent(jammingEvent);
_guidanceSystem.Update(0.1, initialPosition, initialVelocity);
_guidanceSystem.Update(0.1);
// Assert - 确认已被干扰
Assert.IsTrue(_guidanceSystem.IsJammed, "红外引导系统应该处于被干扰状态");
// Act - 手动清除干扰
_guidanceSystem.ClearJamming(jammingEvent.Parameters);
_guidanceSystem.Update(0.1, initialPosition, initialVelocity);
_guidanceSystem.Update(0.1);
// Assert - 确认干扰已清除
Assert.IsFalse(_guidanceSystem.IsJammed, "手动清除后，引导系统应该恢复正常");
@ -295,12 +316,8 @@ namespace ThreatSource.Tests.Jamming
Assert.IsNotNull(_simulationManager);
Assert.IsNotNull(_guidanceSystem);
// Arrange
var initialPosition = new Vector3D(500, 0, 0);
var initialVelocity = new Vector3D(100, 0, 0);
// 更新一次系统，使其跟踪目标
_guidanceSystem.Update(0.1, initialPosition, initialVelocity);
_guidanceSystem.Update(0.1);
// 创建干扰事件
var jammingEvent = new JammingEvent
@ -319,7 +336,7 @@ namespace ThreatSource.Tests.Jamming
// Act - 应用干扰
_simulationManager.PublishEvent(jammingEvent);
_guidanceSystem.Update(0.1, initialPosition, initialVelocity);
_guidanceSystem.Update(0.1);
// Assert - 确认系统切换到搜索模式
Assert.IsTrue(_guidanceSystem.IsJammed, "红外引导系统应该处于被干扰状态");

104
ThreatSource.Tests/src/Jamming/LaserBeamRiderGuidanceJammingTests.cs
View File

@ -5,6 +5,7 @@ using ThreatSource.Simulation;
using ThreatSource.Tests.Simulation;
using ThreatSource.Utils;
using ThreatSource.Equipment;
using ThreatSource.Missile;
namespace ThreatSource.Tests.Jamming
{
@ -15,6 +16,7 @@ namespace ThreatSource.Tests.Jamming
private TestSimulationAdapter? _testAdapter;
private LaserBeamRiderGuidanceSystem? _guidanceSystem;
private Tank? _target;
private LaserBeamRiderMissile? _missile;
[TestInitialize]
public void TestInitialize()
@ -71,9 +73,48 @@ namespace ThreatSource.Tests.Jamming
_simulationManager.RegisterEntity("target1", _target);
_testAdapter.AddTestEntity("target1", _target);
// 创建导弹对象
var initialPosition = new Vector3D(500, 0, 0);
var initialVelocity = new Vector3D(100, 0, 0);
var missileMotion = new MotionParameters
{
Position = initialPosition,
InitialSpeed = initialVelocity.Magnitude()
};
missileMotion.Orientation = new Orientation(0, 0, 0);
var missileProperties = new MissileProperties
{
MaxSpeed = 1000,
MaxAcceleration = 100,
MaxEngineBurnTime = 1.0,
ProportionalNavigationCoefficient = 3.0,
MaxFlightTime = 60,
MaxFlightDistance = 10000,
ExplosionRadius = 10,
Mass = 50,
SelfDestructHeight = -10,
HitProbability = 0.9,
LaunchAcceleration = 100,
Type = MissileType.LaserBeamRiderGuidance,
LaserCodeConfig = laserCodeConfig
};
_missile = new LaserBeamRiderMissile(
"missile1",
missileProperties,
missileMotion,
laserCodeConfig,
config,
_simulationManager
);
_simulationManager.RegisterEntity("missile1", _missile);
_testAdapter.AddTestEntity("missile1", _missile);
// 创建激光驾束引导系统
_guidanceSystem = new LaserBeamRiderGuidanceSystem(
"laserBeamRider1",
"missile1",
100, // 最大加速度
3.0, // 比例导引系数
laserCodeConfig,
@ -87,11 +128,14 @@ namespace ThreatSource.Tests.Jamming
// 激活引导系统
_guidanceSystem.Activate();
_missile.Activate();
_missile.Fire();
}
public void Dispose()
{
_guidanceSystem?.Deactivate();
_missile?.Deactivate();
}
[TestMethod]
@ -100,12 +144,9 @@ namespace ThreatSource.Tests.Jamming
// 断言测试所需的组件已正确初始化
Assert.IsNotNull(_simulationManager, "模拟管理器不应为空");
Assert.IsNotNull(_guidanceSystem, "激光驾束引导系统不应为空");
Assert.IsNotNull(_missile, "导弹不应为空");
// Arrange
var initialPosition = new Vector3D(500, 0, 0);
var initialVelocity = new Vector3D(100, 0, 0);
System.Diagnostics.Debug.WriteLine($"测试开始 - 初始位置: {initialPosition}, 初始速度: {initialVelocity}");
System.Diagnostics.Debug.WriteLine($"测试开始 - 初始位置: {_missile.Position}, 初始速度: {_missile.Velocity}");
// 更新激光波束参数
_guidanceSystem.UpdateLaserBeamRider(
@ -115,7 +156,7 @@ namespace ThreatSource.Tests.Jamming
);
// 更新一次系统，使其跟踪目标
_guidanceSystem.Update(0.1, initialPosition, initialVelocity);
_guidanceSystem.Update(0.1);
// 创建干扰事件
var jammingEvent = new JammingEvent
@ -137,7 +178,7 @@ namespace ThreatSource.Tests.Jamming
// Act
_simulationManager.PublishEvent(jammingEvent);
_guidanceSystem.Update(0.1, initialPosition, initialVelocity);
_guidanceSystem.Update(0.1);
// Assert
System.Diagnostics.Debug.WriteLine($"测试结果 - IsJammed: {_guidanceSystem.IsJammed}, HasGuidance: {_guidanceSystem.HasGuidance}");
@ -151,10 +192,7 @@ namespace ThreatSource.Tests.Jamming
// 断言测试所需的组件已正确初始化
Assert.IsNotNull(_simulationManager, "模拟管理器不应为空");
Assert.IsNotNull(_guidanceSystem, "激光驾束引导系统不应为空");
// Arrange
var initialPosition = new Vector3D(500, 0, 0);
var initialVelocity = new Vector3D(100, 0, 0);
Assert.IsNotNull(_missile, "导弹不应为空");
// 更新激光波束参数
_guidanceSystem.UpdateLaserBeamRider(
@ -164,7 +202,7 @@ namespace ThreatSource.Tests.Jamming
);
// 更新一次系统，使其跟踪目标
_guidanceSystem.Update(0.1, initialPosition, initialVelocity);
_guidanceSystem.Update(0.1);
// 创建角度范围外的干扰事件
var jammingEvent = new JammingEvent
@ -182,7 +220,7 @@ namespace ThreatSource.Tests.Jamming
// Act
_simulationManager.PublishEvent(jammingEvent);
_guidanceSystem.Update(0.1, initialPosition, initialVelocity);
_guidanceSystem.Update(0.1);
// Assert
Assert.IsFalse(_guidanceSystem.IsJammed, "引导系统不应该被干扰，因为干扰源不在角度范围内");
@ -194,10 +232,7 @@ namespace ThreatSource.Tests.Jamming
// 断言测试所需的组件已正确初始化
Assert.IsNotNull(_simulationManager, "模拟管理器不应为空");
Assert.IsNotNull(_guidanceSystem, "激光驾束引导系统不应为空");
// Arrange
var initialPosition = new Vector3D(500, 0, 0);
var initialVelocity = new Vector3D(100, 0, 0);
Assert.IsNotNull(_missile, "导弹不应为空");
// 更新激光波束参数
_guidanceSystem.UpdateLaserBeamRider(
@ -207,7 +242,7 @@ namespace ThreatSource.Tests.Jamming
);
// 更新一次系统，使其跟踪目标
_guidanceSystem.Update(0.1, initialPosition, initialVelocity);
_guidanceSystem.Update(0.1);
// 创建低功率干扰事件
var jammingEvent = new JammingEvent
@ -225,7 +260,7 @@ namespace ThreatSource.Tests.Jamming
// Act
_simulationManager.PublishEvent(jammingEvent);
_guidanceSystem.Update(0.1, initialPosition, initialVelocity);
_guidanceSystem.Update(0.1);
// Assert
Assert.IsFalse(_guidanceSystem.IsJammed, "引导系统不应该被干扰，因为干扰功率低于阈值");
@ -237,10 +272,7 @@ namespace ThreatSource.Tests.Jamming
// 断言测试所需的组件已正确初始化
Assert.IsNotNull(_simulationManager, "模拟管理器不应为空");
Assert.IsNotNull(_guidanceSystem, "激光驾束引导系统不应为空");
// Arrange
var initialPosition = new Vector3D(500, 0, 0);
var initialVelocity = new Vector3D(100, 0, 0);
Assert.IsNotNull(_missile, "导弹不应为空");
// 更新激光波束参数
_guidanceSystem.UpdateLaserBeamRider(
@ -250,7 +282,7 @@ namespace ThreatSource.Tests.Jamming
);
// 更新一次系统，使其跟踪目标
_guidanceSystem.Update(0.1, initialPosition, initialVelocity);
_guidanceSystem.Update(0.1);
// 创建有限时间的干扰事件
var jammingEvent = new JammingEvent
@ -270,7 +302,7 @@ namespace ThreatSource.Tests.Jamming
// Act - 应用干扰
_simulationManager.PublishEvent(jammingEvent);
_guidanceSystem.Update(0.1, initialPosition, initialVelocity);
_guidanceSystem.Update(0.1);
// Assert - 确认已被干扰
Assert.IsTrue(_guidanceSystem.IsJammed, "激光驾束引导系统应该处于被干扰状态");
@ -279,7 +311,7 @@ namespace ThreatSource.Tests.Jamming
// 通过多次更新引导系统，让JammingHandler处理时间
for (int i = 0; i < 10; i++)
{
_guidanceSystem.Update(0.1, initialPosition, initialVelocity); // 总共更新1秒，超过干扰持续时间
_guidanceSystem.Update(0.1); // 总共更新1秒，超过干扰持续时间
}
// Assert - 确认干扰已清除
@ -292,10 +324,7 @@ namespace ThreatSource.Tests.Jamming
// 断言测试所需的组件已正确初始化
Assert.IsNotNull(_simulationManager, "模拟管理器不应为空");
Assert.IsNotNull(_guidanceSystem, "激光驾束引导系统不应为空");
// Arrange
var initialPosition = new Vector3D(500, 0, 0);
var initialVelocity = new Vector3D(100, 0, 0);
Assert.IsNotNull(_missile, "导弹不应为空");
// 更新激光波束参数
_guidanceSystem.UpdateLaserBeamRider(
@ -305,7 +334,7 @@ namespace ThreatSource.Tests.Jamming
);
// 更新一次系统，使其跟踪目标
_guidanceSystem.Update(0.1, initialPosition, initialVelocity);
_guidanceSystem.Update(0.1);
// 创建持续干扰事件
var jammingEvent = new JammingEvent
@ -325,14 +354,14 @@ namespace ThreatSource.Tests.Jamming
// Act - 应用干扰
_simulationManager.PublishEvent(jammingEvent);
_guidanceSystem.Update(0.1, initialPosition, initialVelocity);
_guidanceSystem.Update(0.1);
// Assert - 确认已被干扰
Assert.IsTrue(_guidanceSystem.IsJammed, "激光驾束引导系统应该处于被干扰状态");
// Act - 手动清除干扰
_guidanceSystem.ClearJamming(jammingEvent.Parameters);
_guidanceSystem.Update(0.1, initialPosition, initialVelocity);
_guidanceSystem.Update(0.1);
// Assert - 确认干扰已清除
Assert.IsFalse(_guidanceSystem.IsJammed, "手动清除后，引导系统应该恢复正常");
@ -344,10 +373,7 @@ namespace ThreatSource.Tests.Jamming
// 断言测试所需的组件已正确初始化
Assert.IsNotNull(_simulationManager, "模拟管理器不应为空");
Assert.IsNotNull(_guidanceSystem, "激光驾束引导系统不应为空");
// Arrange
var initialPosition = new Vector3D(500, 0, 0);
var initialVelocity = new Vector3D(100, 0, 0);
Assert.IsNotNull(_missile, "导弹不应为空");
// 更新激光波束参数
_guidanceSystem.UpdateLaserBeamRider(
@ -357,7 +383,7 @@ namespace ThreatSource.Tests.Jamming
);
// 更新一次系统，使其跟踪目标
_guidanceSystem.Update(0.1, initialPosition, initialVelocity);
_guidanceSystem.Update(0.1);
// 创建干扰事件
var jammingEvent = new JammingEvent
@ -377,7 +403,7 @@ namespace ThreatSource.Tests.Jamming
// Act - 应用干扰
_simulationManager.PublishEvent(jammingEvent);
_guidanceSystem.Update(0.1, initialPosition, initialVelocity);
_guidanceSystem.Update(0.1);
// Assert - 确认系统切换到搜索模式
Assert.IsTrue(_guidanceSystem.IsJammed, "激光驾束引导系统应该处于被干扰状态");

67
ThreatSource.Tests/src/Jamming/LaserDecoyTests.cs
View File

@ -7,6 +7,7 @@ using ThreatSource.Equipment;
using ThreatSource.Indicator;
using System.Diagnostics;
using ThreatSource.Jammer;
using ThreatSource.Missile;
namespace ThreatSource.Tests.Jamming
{
@ -18,6 +19,7 @@ namespace ThreatSource.Tests.Jamming
private LaserSemiActiveGuidanceSystem? _guidanceSystem;
private Tank? _target;
private Tank? _decoySource;
private LaserSemiActiveGuidedMissile? _missile;
// 默认的激光诱偏配置参数
private const double DefaultDecoyLaserDivergenceAngle = 0.001;
@ -109,9 +111,39 @@ namespace ThreatSource.Tests.Jamming
}
}
// 创建导弹对象
var missileInitialMotion = new MotionParameters
{
Position = new Vector3D(10, 0, 0),
Orientation = new Orientation(0, 0, 0),
InitialSpeed = 50
};
var missileProperties = new MissileProperties
{
Type = MissileType.LaserSemiActiveGuidance,
MaxAcceleration = 100,
MaxSpeed = 300,
Mass = 50,
ProportionalNavigationCoefficient = 3.0
};
_missile = new LaserSemiActiveGuidedMissile(
"missile1",
missileProperties,
missileInitialMotion,
laserCodeConfig,
config,
_simulationManager
);
_simulationManager.RegisterEntity("missile1", _missile);
_testAdapter.AddTestEntity("missile1", _missile);
// 创建激光半主动制导系统
_guidanceSystem = new LaserSemiActiveGuidanceSystem(
"laserGuidance1",
"missile1",
100, // 最大加速度
3.0, // 比例导引系数
laserCodeConfig,
@ -121,10 +153,6 @@ namespace ThreatSource.Tests.Jamming
if (_guidanceSystem != null)
{
// 设置导弹的初始位置和速度 - 更靠近激光源和目标
_guidanceSystem.Position = new Vector3D(10, 0, 0);
_guidanceSystem.Velocity = new Vector3D(50, 0, 0);
// 注册制导系统
_simulationManager.RegisterEntity("laserGuidance1", _guidanceSystem);
if (_testAdapter != null)
@ -132,8 +160,10 @@ namespace ThreatSource.Tests.Jamming
_testAdapter.AddTestEntity("laserGuidance1", _guidanceSystem);
}
// 激活制导系统
// 激活制导系统和导弹
_guidanceSystem.Activate();
_missile.Activate();
_missile.Fire();
// 通过反射设置CurrentTargetId字段为target1，确保制导系统能正确识别目标
var targetIdField = typeof(LaserSemiActiveGuidanceSystem).GetField("CurrentTargetId",
@ -149,6 +179,7 @@ namespace ThreatSource.Tests.Jamming
public void Dispose()
{
_guidanceSystem?.Deactivate();
_missile?.Deactivate();
}
/// <summary>
@ -282,7 +313,7 @@ namespace ThreatSource.Tests.Jamming
_simulationManager?.Update(0.1);
designator?.Update(0.1);
_target?.Update(0.1);
_guidanceSystem?.Update(0.1, _guidanceSystem?.Position ?? Vector3D.Zero, _guidanceSystem?.Velocity ?? Vector3D.Zero);
_guidanceSystem?.Update(0.1);
}
// 检查是否锁定真实目标 - 由于测试环境限制，跳过初始锁定检查
@ -311,7 +342,7 @@ namespace ThreatSource.Tests.Jamming
designator?.Update(0.1);
_target?.Update(0.1);
_decoySource?.Update(0.1);
_guidanceSystem?.Update(0.1, _guidanceSystem?.Position ?? Vector3D.Zero, _guidanceSystem?.Velocity ?? Vector3D.Zero);
_guidanceSystem?.Update(0.1);
}
// 记录受诱偏影响后的制导加速度
@ -418,7 +449,7 @@ namespace ThreatSource.Tests.Jamming
_simulationManager?.Update(0.1);
designator?.Update(0.1);
_target?.Update(0.1);
_guidanceSystem?.Update(0.1, _guidanceSystem?.Position ?? Vector3D.Zero, _guidanceSystem?.Velocity ?? Vector3D.Zero);
_guidanceSystem?.Update(0.1);
}
// 记录初始目标位置
@ -442,7 +473,7 @@ namespace ThreatSource.Tests.Jamming
designator?.Update(0.1);
_target?.Update(0.1);
_decoySource?.Update(0.1);
_guidanceSystem?.Update(0.1, _guidanceSystem?.Position ?? Vector3D.Zero, _guidanceSystem?.Velocity ?? Vector3D.Zero);
_guidanceSystem?.Update(0.1);
}
// 记录诱偏后的制导加速度
@ -543,7 +574,7 @@ namespace ThreatSource.Tests.Jamming
_simulationManager?.Update(0.1);
designator?.Update(0.1);
_target?.Update(0.1);
_guidanceSystem?.Update(0.1, _guidanceSystem?.Position ?? Vector3D.Zero, _guidanceSystem?.Velocity ?? Vector3D.Zero);
_guidanceSystem?.Update(0.1);
}
// 确保锁定成功 - 由于测试环境限制，跳过初始锁定检查
@ -572,7 +603,7 @@ namespace ThreatSource.Tests.Jamming
designator?.Update(0.1);
_target?.Update(0.1);
_decoySource?.Update(0.1);
_guidanceSystem?.Update(0.1, _guidanceSystem?.Position ?? Vector3D.Zero, _guidanceSystem?.Velocity ?? Vector3D.Zero);
_guidanceSystem?.Update(0.1);
}
// 记录诱偏后的制导加速度
@ -588,7 +619,7 @@ namespace ThreatSource.Tests.Jamming
if (i % 5 == 0) // 每隔0.5秒更新一次制导系统，减少计算量
{
_guidanceSystem?.Update(0.5, _guidanceSystem?.Position ?? Vector3D.Zero, _guidanceSystem?.Velocity ?? Vector3D.Zero);
_guidanceSystem?.Update(0.5);
}
}
@ -598,7 +629,7 @@ namespace ThreatSource.Tests.Jamming
_simulationManager?.Update(0.1);
designator?.Update(0.1);
_target?.Update(0.1);
_guidanceSystem?.Update(0.1, _guidanceSystem?.Position ?? Vector3D.Zero, _guidanceSystem?.Velocity ?? Vector3D.Zero);
_guidanceSystem?.Update(0.1);
}
// 记录诱偏消失后的制导加速度
@ -703,7 +734,7 @@ namespace ThreatSource.Tests.Jamming
_simulationManager?.Update(0.1);
designator?.Update(0.1);
_target?.Update(0.1);
_guidanceSystem?.Update(0.1, _guidanceSystem?.Position ?? Vector3D.Zero, _guidanceSystem?.Velocity ?? Vector3D.Zero);
_guidanceSystem?.Update(0.1);
}
// 记录初始状态下的目标位置
@ -730,7 +761,7 @@ namespace ThreatSource.Tests.Jamming
designator?.Update(0.1);
_target?.Update(0.1);
_decoySource?.Update(0.1);
_guidanceSystem?.Update(0.1, _guidanceSystem?.Position ?? Vector3D.Zero, _guidanceSystem?.Velocity ?? Vector3D.Zero);
_guidanceSystem?.Update(0.1);
}
// 获取诱偏目标位置
@ -976,7 +1007,7 @@ namespace ThreatSource.Tests.Jamming
_simulationManager?.Update(0.1);
designator?.Update(0.1);
_target?.Update(0.1);
_guidanceSystem?.Update(0.1, _guidanceSystem?.Position ?? Vector3D.Zero, _guidanceSystem?.Velocity ?? Vector3D.Zero);
_guidanceSystem?.Update(0.1);
}
// 记录初始状态下的目标位置
@ -1017,7 +1048,7 @@ namespace ThreatSource.Tests.Jamming
designator?.Update(0.1);
_target?.Update(0.1);
_decoySource?.Update(0.1);
_guidanceSystem?.Update(0.1, _guidanceSystem?.Position ?? Vector3D.Zero, _guidanceSystem?.Velocity ?? Vector3D.Zero);
_guidanceSystem?.Update(0.1);
}
// 手动调用UpdateLaserSources方法
@ -1045,7 +1076,7 @@ namespace ThreatSource.Tests.Jamming
designator?.Update(0.1);
_target?.Update(0.1);
_decoySource?.Update(0.1);
_guidanceSystem?.Update(0.1, _guidanceSystem?.Position ?? Vector3D.Zero, _guidanceSystem?.Velocity ?? Vector3D.Zero);
_guidanceSystem?.Update(0.1);
}
// 获取诱偏目标位置

89
ThreatSource.Tests/src/Jamming/LaserSemiActiveGuidanceJammingTests.cs
View File

@ -5,6 +5,7 @@ using ThreatSource.Simulation;
using ThreatSource.Tests.Simulation;
using ThreatSource.Utils;
using ThreatSource.Equipment;
using ThreatSource.Missile;
namespace ThreatSource.Tests.Jamming
{
@ -15,6 +16,7 @@ namespace ThreatSource.Tests.Jamming
private TestSimulationAdapter? _testAdapter;
private LaserSemiActiveGuidanceSystem? _guidanceSystem;
private Tank? _target;
private LaserSemiActiveGuidedMissile? _missile;
[TestInitialize]
public void TestInitialize()
@ -68,9 +70,38 @@ namespace ThreatSource.Tests.Jamming
_simulationManager.RegisterEntity("target1", _target);
_testAdapter.AddTestEntity("target1", _target);
// 创建并注册导弹实体
var missileInitialMotion = new MotionParameters
{
Position = new Vector3D(500, 0, 0),
Orientation = new Orientation(0, 0, 0),
InitialSpeed = 100
};
var missileProperties = new MissileProperties
{
Type = MissileType.LaserSemiActiveGuidance,
MaxAcceleration = 100,
MaxSpeed = 300,
Mass = 50
};
_missile = new LaserSemiActiveGuidedMissile(
"missile1",
missileProperties,
missileInitialMotion,
laserCodeConfig,
config,
_simulationManager
);
_simulationManager.RegisterEntity("missile1", _missile);
_testAdapter.AddTestEntity("missile1", _missile);
// 创建激光半主动制导系统
_guidanceSystem = new LaserSemiActiveGuidanceSystem(
"laserGuidance1",
"missile1",
100, // 最大加速度
3.0, // 比例导引系数
laserCodeConfig,
@ -97,6 +128,7 @@ namespace ThreatSource.Tests.Jamming
// 确保组件不为空
Assert.IsNotNull(_simulationManager);
Assert.IsNotNull(_guidanceSystem);
Assert.IsNotNull(_missile);
// Arrange
var initialPosition = new Vector3D(500, 0, 0);
@ -104,8 +136,12 @@ namespace ThreatSource.Tests.Jamming
System.Diagnostics.Debug.WriteLine($"测试开始 - 初始位置: {initialPosition}, 初始速度: {initialVelocity}");
// 更新导弹位置和速度
_missile.Position = initialPosition;
_missile.Velocity = initialVelocity;
// 更新一次系统，使其跟踪目标
_guidanceSystem.Update(0.1, initialPosition, initialVelocity);
_guidanceSystem.Update(0.1);
// 创建干扰事件
var jammingEvent = new JammingEvent
@ -127,7 +163,7 @@ namespace ThreatSource.Tests.Jamming
// Act
_simulationManager.PublishEvent(jammingEvent);
_guidanceSystem.Update(0.1, initialPosition, initialVelocity);
_guidanceSystem.Update(0.1);
// Assert
System.Diagnostics.Debug.WriteLine($"测试结果 - IsJammed: {_guidanceSystem.IsJammed}, HasGuidance: {_guidanceSystem.HasGuidance}");
@ -141,13 +177,18 @@ namespace ThreatSource.Tests.Jamming
// 确保组件不为空
Assert.IsNotNull(_simulationManager);
Assert.IsNotNull(_guidanceSystem);
Assert.IsNotNull(_missile);
// Arrange
var initialPosition = new Vector3D(500, 0, 0);
var initialVelocity = new Vector3D(100, 0, 0);
// 更新导弹位置和速度
_missile.Position = initialPosition;
_missile.Velocity = initialVelocity;
// 更新一次系统，使其跟踪目标
_guidanceSystem.Update(0.1, initialPosition, initialVelocity);
_guidanceSystem.Update(0.1);
// 创建角度范围外的干扰事件
var jammingEvent = new JammingEvent
@ -167,7 +208,7 @@ namespace ThreatSource.Tests.Jamming
// Act
_simulationManager.PublishEvent(jammingEvent);
_guidanceSystem.Update(0.1, initialPosition, initialVelocity);
_guidanceSystem.Update(0.1);
// Assert
Assert.IsFalse(_guidanceSystem.IsJammed, "制导系统不应该被干扰，因为干扰源不在角度范围内");
@ -179,13 +220,18 @@ namespace ThreatSource.Tests.Jamming
// 确保组件不为空
Assert.IsNotNull(_simulationManager);
Assert.IsNotNull(_guidanceSystem);
Assert.IsNotNull(_missile);
// Arrange
var initialPosition = new Vector3D(500, 0, 0);
var initialVelocity = new Vector3D(100, 0, 0);
// 更新导弹位置和速度
_missile.Position = initialPosition;
_missile.Velocity = initialVelocity;
// 更新一次系统，使其跟踪目标
_guidanceSystem.Update(0.1, initialPosition, initialVelocity);
_guidanceSystem.Update(0.1);
// 创建低功率干扰事件
var jammingEvent = new JammingEvent
@ -205,7 +251,7 @@ namespace ThreatSource.Tests.Jamming
// Act
_simulationManager.PublishEvent(jammingEvent);
_guidanceSystem.Update(0.1, initialPosition, initialVelocity);
_guidanceSystem.Update(0.1);
// Assert
Assert.IsFalse(_guidanceSystem.IsJammed, "制导系统不应该被干扰，因为干扰功率低于阈值");
@ -217,13 +263,18 @@ namespace ThreatSource.Tests.Jamming
// 确保组件不为空
Assert.IsNotNull(_simulationManager);
Assert.IsNotNull(_guidanceSystem);
Assert.IsNotNull(_missile);
// Arrange
var initialPosition = new Vector3D(500, 0, 0);
var initialVelocity = new Vector3D(100, 0, 0);
// 更新导弹位置和速度
_missile.Position = initialPosition;
_missile.Velocity = initialVelocity;
// 更新一次系统，使其跟踪目标
_guidanceSystem.Update(0.1, initialPosition, initialVelocity);
_guidanceSystem.Update(0.1);
// 创建有限时间的干扰事件
var jammingEvent = new JammingEvent
@ -243,7 +294,7 @@ namespace ThreatSource.Tests.Jamming
// Act - 应用干扰
_simulationManager.PublishEvent(jammingEvent);
_guidanceSystem.Update(0.1, initialPosition, initialVelocity);
_guidanceSystem.Update(0.1);
// Assert - 确认已被干扰
Assert.IsTrue(_guidanceSystem.IsJammed, "激光半主动制导系统应该处于被干扰状态");
@ -252,7 +303,7 @@ namespace ThreatSource.Tests.Jamming
// 通过多次更新制导系统，让JammingHandler处理时间
for (int i = 0; i < 10; i++)
{
_guidanceSystem.Update(0.1, initialPosition, initialVelocity); // 总共更新1秒，超过干扰持续时间
_guidanceSystem.Update(0.1); // 总共更新1秒，超过干扰持续时间
}
// Assert - 确认干扰已清除
@ -265,13 +316,18 @@ namespace ThreatSource.Tests.Jamming
// 确保组件不为空
Assert.IsNotNull(_simulationManager);
Assert.IsNotNull(_guidanceSystem);
Assert.IsNotNull(_missile);
// Arrange
var initialPosition = new Vector3D(500, 0, 0);
var initialVelocity = new Vector3D(100, 0, 0);
// 更新导弹位置和速度
_missile.Position = initialPosition;
_missile.Velocity = initialVelocity;
// 更新一次系统，使其跟踪目标
_guidanceSystem.Update(0.1, initialPosition, initialVelocity);
_guidanceSystem.Update(0.1);
// 创建持续干扰事件
var jammingEvent = new JammingEvent
@ -291,14 +347,14 @@ namespace ThreatSource.Tests.Jamming
// Act - 应用干扰
_simulationManager.PublishEvent(jammingEvent);
_guidanceSystem.Update(0.1, initialPosition, initialVelocity);
_guidanceSystem.Update(0.1);
// Assert - 确认已被干扰
Assert.IsTrue(_guidanceSystem.IsJammed, "激光半主动制导系统应该处于被干扰状态");
// Act - 手动清除干扰
_guidanceSystem.ClearJamming(jammingEvent.Parameters);
_guidanceSystem.Update(0.1, initialPosition, initialVelocity);
_guidanceSystem.Update(0.1);
// Assert - 确认干扰已清除
Assert.IsFalse(_guidanceSystem.IsJammed, "手动清除后，制导系统应该恢复正常");
@ -310,13 +366,18 @@ namespace ThreatSource.Tests.Jamming
// 确保组件不为空
Assert.IsNotNull(_simulationManager);
Assert.IsNotNull(_guidanceSystem);
Assert.IsNotNull(_missile);
// Arrange
var initialPosition = new Vector3D(500, 0, 0);
var initialVelocity = new Vector3D(100, 0, 0);
// 更新导弹位置和速度
_missile.Position = initialPosition;
_missile.Velocity = initialVelocity;
// 更新一次系统，使其跟踪目标
_guidanceSystem.Update(0.1, initialPosition, initialVelocity);
_guidanceSystem.Update(0.1);
// 创建干扰事件
var jammingEvent = new JammingEvent
@ -336,7 +397,7 @@ namespace ThreatSource.Tests.Jamming
// Act - 应用干扰
_simulationManager.PublishEvent(jammingEvent);
_guidanceSystem.Update(0.1, initialPosition, initialVelocity);
_guidanceSystem.Update(0.1);
// Assert - 确认系统切换到搜索模式
Assert.IsTrue(_guidanceSystem.IsJammed, "激光半主动制导系统应该处于被干扰状态");

88
ThreatSource.Tests/src/Jamming/MillimeterWaveGuidanceJammingTests.cs
View File

@ -5,6 +5,7 @@ using ThreatSource.Simulation;
using ThreatSource.Tests.Simulation;
using ThreatSource.Utils;
using ThreatSource.Equipment;
using ThreatSource.Missile;
namespace ThreatSource.Tests.Jamming
{
@ -15,6 +16,7 @@ namespace ThreatSource.Tests.Jamming
private TestSimulationAdapter? _testAdapter;
private MillimeterWaveGuidanceSystem? _guidanceSystem;
private Tank? _target;
private MillimeterWaveTerminalGuidedMissile? _missile;
[TestInitialize]
public void TestInitialize()
@ -66,9 +68,37 @@ namespace ThreatSource.Tests.Jamming
_simulationManager.RegisterEntity("target1", _target);
_testAdapter.AddTestEntity("target1", _target);
// 创建并注册导弹实体
var missileInitialMotion = new MotionParameters
{
Position = new Vector3D(500, 0, 0),
Orientation = new Orientation(0, 0, 0),
InitialSpeed = 100
};
var missileProperties = new MissileProperties
{
Type = MissileType.MillimeterWaveTerminalGuidance,
MaxAcceleration = 100,
MaxSpeed = 300,
Mass = 50
};
_missile = new MillimeterWaveTerminalGuidedMissile(
"missile1",
missileProperties,
missileInitialMotion,
config,
_simulationManager
);
_simulationManager.RegisterEntity("missile1", _missile);
_testAdapter.AddTestEntity("missile1", _missile);
// 创建毫米波制导系统
_guidanceSystem = new MillimeterWaveGuidanceSystem(
"millimeterWaveGuidance1",
"missile1",
100, // 最大加速度
3.0, // 比例导引系数
config,
@ -94,6 +124,7 @@ namespace ThreatSource.Tests.Jamming
// 确保组件不为空
Assert.IsNotNull(_simulationManager);
Assert.IsNotNull(_guidanceSystem);
Assert.IsNotNull(_missile);
// Arrange
var initialPosition = new Vector3D(500, 0, 0);
@ -101,8 +132,12 @@ namespace ThreatSource.Tests.Jamming
System.Diagnostics.Debug.WriteLine($"测试开始 - 初始位置: {initialPosition}, 初始速度: {initialVelocity}");
// 更新导弹位置和速度
_missile.Position = initialPosition;
_missile.Velocity = initialVelocity;
// 更新一次系统，使其跟踪目标
_guidanceSystem.Update(0.1, initialPosition, initialVelocity);
_guidanceSystem.Update(0.1);
// 创建干扰事件
var jammingEvent = new JammingEvent
@ -124,7 +159,7 @@ namespace ThreatSource.Tests.Jamming
// Act
_simulationManager.PublishEvent(jammingEvent);
_guidanceSystem.Update(0.1, initialPosition, initialVelocity);
_guidanceSystem.Update(0.1);
// Assert
System.Diagnostics.Debug.WriteLine($"测试结果 - IsJammed: {_guidanceSystem.IsJammed}, HasGuidance: {_guidanceSystem.HasGuidance}");
@ -138,13 +173,18 @@ namespace ThreatSource.Tests.Jamming
// 确保组件不为空
Assert.IsNotNull(_simulationManager);
Assert.IsNotNull(_guidanceSystem);
Assert.IsNotNull(_missile);
// Arrange
var initialPosition = new Vector3D(500, 0, 0);
var initialVelocity = new Vector3D(100, 0, 0);
// 更新导弹位置和速度
_missile.Position = initialPosition;
_missile.Velocity = initialVelocity;
// 更新一次系统，使其跟踪目标
_guidanceSystem.Update(0.1, initialPosition, initialVelocity);
_guidanceSystem.Update(0.1);
// 创建角度范围外的干扰事件
var jammingEvent = new JammingEvent
@ -163,7 +203,7 @@ namespace ThreatSource.Tests.Jamming
// Act
_simulationManager.PublishEvent(jammingEvent);
_guidanceSystem.Update(0.1, initialPosition, initialVelocity);
_guidanceSystem.Update(0.1);
// Assert
Assert.IsFalse(_guidanceSystem.IsJammed, "制导系统不应该被干扰，因为干扰源不在角度范围内");
@ -175,13 +215,18 @@ namespace ThreatSource.Tests.Jamming
// 确保组件不为空
Assert.IsNotNull(_simulationManager);
Assert.IsNotNull(_guidanceSystem);
Assert.IsNotNull(_missile);
// Arrange
var initialPosition = new Vector3D(500, 0, 0);
var initialVelocity = new Vector3D(100, 0, 0);
// 更新导弹位置和速度
_missile.Position = initialPosition;
_missile.Velocity = initialVelocity;
// 更新一次系统，使其跟踪目标
_guidanceSystem.Update(0.1, initialPosition, initialVelocity);
_guidanceSystem.Update(0.1);
// 创建低功率干扰事件
var jammingEvent = new JammingEvent
@ -198,7 +243,7 @@ namespace ThreatSource.Tests.Jamming
// Act
_simulationManager.PublishEvent(jammingEvent);
_guidanceSystem.Update(0.1, initialPosition, initialVelocity);
_guidanceSystem.Update(0.1);
// Assert
Assert.IsFalse(_guidanceSystem.IsJammed, "制导系统不应该被干扰，因为干扰功率低于阈值");
@ -210,13 +255,18 @@ namespace ThreatSource.Tests.Jamming
// 确保组件不为空
Assert.IsNotNull(_simulationManager);
Assert.IsNotNull(_guidanceSystem);
Assert.IsNotNull(_missile);
// Arrange
var initialPosition = new Vector3D(500, 0, 0);
var initialVelocity = new Vector3D(100, 0, 0);
// 更新导弹位置和速度
_missile.Position = initialPosition;
_missile.Velocity = initialVelocity;
// 更新一次系统，使其跟踪目标
_guidanceSystem.Update(0.1, initialPosition, initialVelocity);
_guidanceSystem.Update(0.1);
// 创建有限时间的干扰事件
var jammingEvent = new JammingEvent
@ -236,7 +286,7 @@ namespace ThreatSource.Tests.Jamming
// Act - 应用干扰
_simulationManager.PublishEvent(jammingEvent);
_guidanceSystem.Update(0.1, initialPosition, initialVelocity);
_guidanceSystem.Update(0.1);
// Assert - 确认已被干扰
Assert.IsTrue(_guidanceSystem.IsJammed, "毫米波制导系统应该处于被干扰状态");
@ -245,7 +295,7 @@ namespace ThreatSource.Tests.Jamming
// 通过多次更新制导系统，让JammingHandler处理时间
for (int i = 0; i < 10; i++)
{
_guidanceSystem.Update(0.1, initialPosition, initialVelocity); // 总共更新1秒，超过干扰持续时间
_guidanceSystem.Update(0.1); // 总共更新1秒，超过干扰持续时间
}
// Assert - 确认干扰已清除
@ -258,13 +308,18 @@ namespace ThreatSource.Tests.Jamming
// 确保组件不为空
Assert.IsNotNull(_simulationManager);
Assert.IsNotNull(_guidanceSystem);
Assert.IsNotNull(_missile);
// Arrange
var initialPosition = new Vector3D(500, 0, 0);
var initialVelocity = new Vector3D(100, 0, 0);
// 更新导弹位置和速度
_missile.Position = initialPosition;
_missile.Velocity = initialVelocity;
// 更新一次系统，使其跟踪目标
_guidanceSystem.Update(0.1, initialPosition, initialVelocity);
_guidanceSystem.Update(0.1);
// 创建持续干扰事件
var jammingEvent = new JammingEvent
@ -284,14 +339,14 @@ namespace ThreatSource.Tests.Jamming
// Act - 应用干扰
_simulationManager.PublishEvent(jammingEvent);
_guidanceSystem.Update(0.1, initialPosition, initialVelocity);
_guidanceSystem.Update(0.1);
// Assert - 确认已被干扰
Assert.IsTrue(_guidanceSystem.IsJammed, "毫米波制导系统应该处于被干扰状态");
// Act - 手动清除干扰
_guidanceSystem.ClearJamming(jammingEvent.Parameters);
_guidanceSystem.Update(0.1, initialPosition, initialVelocity);
_guidanceSystem.Update(0.1);
// Assert - 确认干扰已清除
Assert.IsFalse(_guidanceSystem.IsJammed, "手动清除后，制导系统应该恢复正常");
@ -303,13 +358,18 @@ namespace ThreatSource.Tests.Jamming
// 确保组件不为空
Assert.IsNotNull(_simulationManager);
Assert.IsNotNull(_guidanceSystem);
Assert.IsNotNull(_missile);
// Arrange
var initialPosition = new Vector3D(500, 0, 0);
var initialVelocity = new Vector3D(100, 0, 0);
// 更新导弹位置和速度
_missile.Position = initialPosition;
_missile.Velocity = initialVelocity;
// 更新一次系统，使其跟踪目标
_guidanceSystem.Update(0.1, initialPosition, initialVelocity);
_guidanceSystem.Update(0.1);
// 创建干扰事件
var jammingEvent = new JammingEvent
@ -329,7 +389,7 @@ namespace ThreatSource.Tests.Jamming
// Act - 应用干扰
_simulationManager.PublishEvent(jammingEvent);
_guidanceSystem.Update(0.1, initialPosition, initialVelocity);
_guidanceSystem.Update(0.1);
// Assert - 确认系统切换到搜索模式
Assert.IsTrue(_guidanceSystem.IsJammed, "毫米波制导系统应该处于被干扰状态");

49
ThreatSource/src/Guidance/BaseGuidanceSystem.cs
View File

@ -1,9 +1,10 @@
using System;
using ThreatSource.Utils;
using ThreatSource.Simulation;
using ThreatSource.Jammable;
using System.Diagnostics;
using ThreatSource.Jammer;
using ThreatSource.Missile;
namespace ThreatSource.Guidance
{
/// <summary>
@ -53,7 +54,7 @@ namespace ThreatSource.Guidance
/// 记录所属导弹的ID
/// 用于事件发布和状态关联
/// </remarks>
public string? ParentId { get; set; }
public string MissileId { get; set; }
/// <summary>
/// 获取或设置是否有有效的制导信息
@ -98,6 +99,7 @@ namespace ThreatSource.Guidance
/// 初始化基础制导系统的新实例
/// </summary>
/// <param name="id">制导系统ID</param>
/// <param name="missileId">导弹ID</param>
/// <param name="maxAcceleration">最大加速度，单位：米/平方秒</param>
/// <param name="proportionalNavigationCoefficient">比例导引系数</param>
/// <param name="simulationManager">仿真管理器实例</param>
@ -109,9 +111,17 @@ namespace ThreatSource.Guidance
/// - 配置制导参数
/// - 初始化干扰处理
/// </remarks>
public BaseGuidanceSystem(string id, double maxAcceleration, double proportionalNavigationCoefficient, ISimulationManager simulationManager)
public BaseGuidanceSystem(string id, string missileId, double maxAcceleration, double proportionalNavigationCoefficient, ISimulationManager simulationManager)
: base(id, new MotionParameters(), simulationManager)
{
MissileId = missileId;
if (SimulationManager.GetEntityById(MissileId) is BaseMissile missile)
{
Position = missile.Position;
Orientation = missile.Orientation;
Velocity = missile.Velocity;
}
HasGuidance = false;
GuidanceAcceleration = Vector3D.Zero;
MaxAcceleration = maxAcceleration;
@ -161,8 +171,7 @@ namespace ThreatSource.Guidance
}
HasGuidance = false; // 停用时失去制导
GuidanceAcceleration = Vector3D.Zero;
// 调用 SimulationElement 的基类 Deactivate (如果存在)
// base.Deactivate(); // SimulationElement 似乎没有公开的 Deactivate
base.Deactivate();
}
/// <summary>
@ -178,14 +187,14 @@ namespace ThreatSource.Guidance
/// - 更新干扰状态
/// - 准备制导计算
/// </remarks>
public virtual void Update(double deltaTime, Vector3D missilePosition, Vector3D missileVelocity)
{
Position = missilePosition;
Velocity = missileVelocity;
// public virtual void Update(double deltaTime, Vector3D missilePosition, Vector3D missileVelocity)
// {
// Position = missilePosition;
// Velocity = missileVelocity;
// 更新干扰状态
_jammingComponent.UpdateJammingStatus(deltaTime);
}
// // 更新干扰状态
// _jammingComponent.UpdateJammingStatus(deltaTime);
// }
/// <summary>
/// 更新制导系统状态
@ -193,13 +202,17 @@ namespace ThreatSource.Guidance
/// <param name="deltaTime">时间步长，单位：秒</param>
/// <remarks>
/// 实现 SimulationElement 的抽象方法
/// 在此方法中不执行实际操作，制导系统通过 Update(deltaTime, position, velocity) 更新
/// </remarks>
public override void Update(double deltaTime)
{
// 警告：制导系统不应直接由仿真系统调用
Trace.WriteLine("警告：BasicGuidanceSystem的Update(deltaTime)方法被直接调用，这可能是一个错误。");
// 制导系统应通过Update(deltaTime, position, velocity)方法更新
if (SimulationManager.GetEntityById(MissileId) is BaseMissile missile)
{
Position = missile.Position;
Orientation = missile.Orientation;
Velocity = missile.Velocity;
}
// 更新干扰状态
_jammingComponent.UpdateJammingStatus(deltaTime);
}
/// <summary>
@ -236,9 +249,9 @@ namespace ThreatSource.Guidance
statusInfo.ExtendedProperties["ProportionalNavigationCoefficient"] = ProportionalNavigationCoefficient;
// 如果有父实体，添加父实体ID
if (!string.IsNullOrEmpty(ParentId))
if (!string.IsNullOrEmpty(MissileId))
{
statusInfo.ExtendedProperties["ParentId"] = ParentId;
statusInfo.ExtendedProperties["ParentId"] = MissileId;
}
return statusInfo;

2
ThreatSource/src/Guidance/IGuidanceSystem.cs
View File

@ -37,7 +37,7 @@ namespace ThreatSource.Guidance
/// - 更新制导状态
/// - 生成制导指令
/// </remarks>
void Update(double deltaTime, Vector3D missilePosition, Vector3D missileVelocity);
//void Update(double deltaTime, Vector3D missilePosition, Vector3D missileVelocity);
/// <summary>
/// 获取制导加速度指令

11
ThreatSource/src/Guidance/InfraredCommandGuidanceSystem.cs
View File

@ -87,6 +87,7 @@ namespace ThreatSource.Guidance
/// 初始化红外指令导引系统的新实例
/// </summary>
/// <param name="id">系统标识</param>
/// <param name="missileId">导弹ID</param>
/// <param name="guidanceConfig">红外指令导引系统配置</param>
/// <param name="maxAcceleration">最大加速度，单位：米/平方秒</param>
/// <param name="guidanceCoefficient">制导系数</param>
@ -97,8 +98,8 @@ namespace ThreatSource.Guidance
/// - 初始化向量记录
/// - 清零转向速率
/// </remarks>
public InfraredCommandGuidanceSystem(string id, InfraredCommandGuidanceConfig guidanceConfig, double maxAcceleration, double guidanceCoefficient, ISimulationManager simulationManager)
: base(id, maxAcceleration, guidanceCoefficient, simulationManager)
public InfraredCommandGuidanceSystem(string id, string missileId, InfraredCommandGuidanceConfig guidanceConfig, double maxAcceleration, double guidanceCoefficient, ISimulationManager simulationManager)
: base(id, missileId, maxAcceleration, guidanceCoefficient, simulationManager)
{
turnRate = 0;
InitializeJamming(guidanceConfig.JammingResistanceThreshold, SupportedJammingTypes, SupportedBlockingJammingTypes);
@ -108,16 +109,14 @@ namespace ThreatSource.Guidance
/// 更新制导系统的状态和计算结果
/// </summary>
/// <param name="deltaTime">自上次更新以来的时间间隔，单位：秒</param>
/// <param name="missilePosition">导弹当前位置，单位：米</param>
/// <param name="missileVelocity">导弹当前速度，单位：米/秒</param>
/// <remarks>
/// 更新过程：
/// - 更新基类状态
/// - 计算制导加速度
/// </remarks>
public override void Update(double deltaTime, Vector3D missilePosition, Vector3D missileVelocity)
public override void Update(double deltaTime)
{
base.Update(deltaTime, missilePosition, missileVelocity);
base.Update(deltaTime);
if (!IsHardJammed)
{
if (HasGuidance)

39
ThreatSource/src/Guidance/InfraredImagingGuidanceSystem.cs
View File

@ -112,6 +112,7 @@ namespace ThreatSource.Guidance
/// 初始化红外成像制导系统的新实例
/// </summary>
/// <param name="id">系统标识</param>
/// <param name="missileId">导弹ID</param>
/// <param name="guidanceConfig">红外成像制导系统配置</param>
/// <param name="targetType">要攻击的目标类型</param>
/// <param name="maxAcceleration">最大加速度，单位：米/平方秒</param>
@ -126,13 +127,14 @@ namespace ThreatSource.Guidance
/// </remarks>
public InfraredImagingGuidanceSystem(
string id,
string missileId,
InfraredImagingGuidanceConfig guidanceConfig,
EquipmentType targetType,
double maxAcceleration,
double proportionalNavigationCoefficient,
ISimulationManager simulationManager
)
: base(id, maxAcceleration, proportionalNavigationCoefficient, simulationManager)
: base(id, missileId, maxAcceleration, proportionalNavigationCoefficient, simulationManager)
{
this.targetType = targetType;
config = guidanceConfig;
@ -174,25 +176,24 @@ namespace ThreatSource.Guidance
{
if (SimulationManager.GetEntityById(parameters.JammerId) is SmokeGrenade smokeGrenade)
{
// TODO：这里需要根据目标位置计算烟幕衰减，没有发现目标时，要根据当前方向，用一个假定目标位置来计算烟幕衰减
if (lastTargetPosition != null)
{
// 计算烟幕衰减 (这里存储衰减系数，1.0表示无衰减)
SmokeAttenuation = smokeGrenade.GetSmokeTransmittanceOnLine(Position, lastTargetPosition, config.Wavelength);
Console.WriteLine($"[烟幕干扰应用 IR] 视线透过率/衰减系数: {SmokeAttenuation:F3}");
Console.WriteLine($"[烟幕干扰IR] 视线透过率: {SmokeAttenuation:F3}");
}
else
{
// 目标尚未有效跟踪，无法计算特定视线衰减，假定一个默认值
SmokeAttenuation = 0.4;
Console.WriteLine("[烟幕干扰应用 IR] 没有发现目标位置，暂不计算烟幕衰减。");
// 目标尚未有效跟踪，计算视线方向衰减
var intersection = MotionAlgorithm.CalculateIntersectionWithGround(Position, Orientation.ToVector(), 0);
Console.WriteLine($"[###烟幕干扰IR] 计算视线方向衰减，交点: {intersection}");
if (intersection != null)
{
SmokeAttenuation = smokeGrenade.GetSmokeTransmittanceOnLine(Position, intersection, config.Wavelength);
Console.WriteLine($"[烟幕干扰IR] 没有发现目标位置，只计算视线透过率: {SmokeAttenuation:F3}");
}
}
}
else
{
// 未找到烟幕弹，假定无衰减
SmokeAttenuation = 1.0;
}
}
}
@ -211,8 +212,8 @@ namespace ThreatSource.Guidance
}
else if (parameters.Type == JammingType.SmokeGrenade)
{
SmokeAttenuation = 1.0; // Reset smoke attenuation
Debug.WriteLine("[烟幕干扰清除 IR]");
SmokeAttenuation = 1.0;
Debug.WriteLine("[烟幕干扰清除 IR]");
}
}
@ -243,8 +244,6 @@ namespace ThreatSource.Guidance
/// 更新引导系统的状态和计算结果
/// </summary>
/// <param name="deltaTime">自上次更新以来的时间间隔，单位：秒</param>
/// <param name="missilePosition">导弹当前位置，单位：米</param>
/// <param name="missileVelocity">导弹当前速度，单位：米/秒</param>
/// <remarks>
/// 更新过程：
/// - 探测目标位置
@ -252,12 +251,12 @@ namespace ThreatSource.Guidance
/// - 生成制导指令
/// - 限制最大加速度
/// </remarks>
public override void Update(double deltaTime, Vector3D missilePosition, Vector3D missileVelocity)
public override void Update(double deltaTime)
{
base.Update(deltaTime, missilePosition, missileVelocity);
base.Update(deltaTime);
if (!IsHardJammed)
{
if (TryDetectAndIdentifyTarget(missilePosition, missileVelocity, deltaTime, out Vector3D currentTargetPosition))
if (TryDetectAndIdentifyTarget(Position, Velocity, deltaTime, out Vector3D currentTargetPosition))
{
targetLostTimer = 0; // 重置丢失计时器
Vector3D? currentTargetVelocity = null; // Initialize as nullable
@ -274,8 +273,8 @@ namespace ThreatSource.Guidance
// Use proportional navigation, provide default if velocity is null
GuidanceAcceleration = MotionAlgorithm.CalculateProportionalNavigation(
ProportionalNavigationCoefficient,
missilePosition,
missileVelocity,
Position,
Velocity,
currentTargetPosition, // Non-nullable from out parameter
currentTargetVelocity ?? Vector3D.Zero // Provide default if null
);

12
ThreatSource/src/Guidance/LaserBeamRiderGuidanceSystem.cs
View File

@ -134,6 +134,7 @@ namespace ThreatSource.Guidance
/// 初始化激光驾束制导系统的新实例
/// </summary>
/// <param name="id">制导系统ID</param>
/// <param name="missileId">导弹ID</param>
/// <param name="maxAcceleration">最大加速度，单位：米/平方秒</param>
/// <param name="guidanceCoefficient">制导系数</param>
/// <param name="laserCodeConfig">激光编码配置，可选</param>
@ -147,12 +148,13 @@ namespace ThreatSource.Guidance
/// </remarks>
public LaserBeamRiderGuidanceSystem(
string id,
string missileId,
double maxAcceleration,
double guidanceCoefficient,
LaserCodeConfig? laserCodeConfig,
LaserBeamRiderGuidanceSystemConfig guidanceConfig,
ISimulationManager simulationManager)
: base(id, maxAcceleration, guidanceCoefficient, simulationManager)
: base(id, missileId, maxAcceleration, guidanceCoefficient, simulationManager)
{
config = guidanceConfig;
LaserPower = 0;
@ -284,7 +286,7 @@ namespace ThreatSource.Guidance
{
var mismatchEvent = new LaserCodeMismatchEvent
{
MissileId = ParentId,
MissileId = MissileId,
DesignatorId = designatorId,
ExpectedCodeConfig = InternalLaserCodeConfig,
ReceivedCodeConfig = receivedCodeConfig
@ -337,8 +339,6 @@ namespace ThreatSource.Guidance
/// 更新制导系统的状态和计算结果
/// </summary>
/// <param name="deltaTime">时间步长，单位：秒</param>
/// <param name="missilePosition">导弹位置，单位：米</param>
/// <param name="missileVelocity">导弹速度，单位：米/秒</param>
/// <remarks>
/// 更新过程：
/// - 检查激光照射状态
@ -346,9 +346,9 @@ namespace ThreatSource.Guidance
/// - 计算制导指令
/// - 更新输出参数
/// </remarks>
public override void Update(double deltaTime, Vector3D missilePosition, Vector3D missileVelocity)
public override void Update(double deltaTime)
{
base.Update(deltaTime, missilePosition, missileVelocity);
base.Update(deltaTime);
if (!IsJammed)
{
if (LaserIlluminationOn)

12
ThreatSource/src/Guidance/LaserSemiActiveGuidanceSystem.cs
View File

@ -137,6 +137,7 @@ namespace ThreatSource.Guidance
/// 初始化激光半主动制导系统的新实例
/// </summary>
/// <param name="id">制导系统ID</param>
/// <param name="missileId">导弹ID</param>
/// <param name="maxAcceleration">最大加速度，单位：米/平方秒</param>
/// <param name="guidanceCoefficient">制导系数</param>
/// <param name="laserCodeConfig">激光编码配置</param>
@ -152,12 +153,13 @@ namespace ThreatSource.Guidance
/// </remarks>
public LaserSemiActiveGuidanceSystem(
string id,
string missileId,
double maxAcceleration,
double guidanceCoefficient,
LaserCodeConfig laserCodeConfig,
LaserSemiActiveGuidanceConfig guidanceConfig,
ISimulationManager simulationManager)
: base(id, maxAcceleration, guidanceCoefficient, simulationManager)
: base(id, missileId, maxAcceleration, guidanceCoefficient, simulationManager)
{
config = guidanceConfig;
@ -386,11 +388,9 @@ namespace ThreatSource.Guidance
/// 更新制导系统的状态和计算结果
/// </summary>
/// <param name="deltaTime">时间步长，单位：秒</param>
/// <param name="missilePosition">导弹位置，单位：米</param>
/// <param name="missileVelocity">导弹速度，单位：米/秒</param>
public override void Update(double deltaTime, Vector3D missilePosition, Vector3D missileVelocity)
public override void Update(double deltaTime)
{
base.Update(deltaTime, missilePosition, missileVelocity);
base.Update(deltaTime);
// 处理接收到的所有激光信号
ProcessLaserTargets();
@ -842,7 +842,7 @@ namespace ThreatSource.Guidance
{
var mismatchEvent = new LaserCodeMismatchEvent
{
MissileId = ParentId,
MissileId = MissileId,
DesignatorId = designatorId,
ExpectedCodeConfig = InternalLaserCodeConfig,
ReceivedCodeConfig = receivedCodeConfig

16
ThreatSource/src/Guidance/MillimeterWaveGuidanceSystem.cs
View File

@ -135,6 +135,7 @@ namespace ThreatSource.Guidance
/// 初始化毫米波制导系统的新实例
/// </summary>
/// <param name="id">制导系统ID</param>
/// <param name="missileId">导弹ID</param>
/// <param name="maxAcceleration">最大加速度，单位：米/平方秒</param>
/// <param name="guidanceCoefficient">制导系数</param>
/// <param name="simulationManager">仿真管理器实例</param>
@ -149,11 +150,12 @@ namespace ThreatSource.Guidance
/// </remarks>
public MillimeterWaveGuidanceSystem(
string id,
string missileId,
double maxAcceleration,
double guidanceCoefficient,
MillimeterWaveGuidanceConfig config,
ISimulationManager simulationManager)
: base(id, maxAcceleration, guidanceCoefficient, simulationManager)
: base(id, missileId, maxAcceleration, guidanceCoefficient, simulationManager)
{
this.config = config;
InitializeJamming(config.JammingResistanceThreshold, SupportedJammingTypes, SupportedBlockingJammingTypes);
@ -448,8 +450,6 @@ namespace ThreatSource.Guidance
/// 更新制导系统的状态
/// </summary>
/// <param name="deltaTime">自上次更新以来的时间间隔，单位：秒</param>
/// <param name="missilePosition">导弹当前位置，单位：米</param>
/// <param name="missileVelocity">导弹当前速度，单位：米/秒</param>
/// <remarks>
/// 更新过程：
/// - 探测目标位置
@ -457,9 +457,9 @@ namespace ThreatSource.Guidance
/// - 生成制导指令
/// - 限制最大加速度
/// </remarks>
public override void Update(double deltaTime, Vector3D missilePosition, Vector3D missileVelocity)
public override void Update(double deltaTime)
{
base.Update(deltaTime, missilePosition, missileVelocity); // 更新基类状态和干扰状态
base.Update(deltaTime); // 更新基类状态和干扰状态
// 在执行核心逻辑前检查干扰状态
if (IsJammed) // 使用基类的 IsJammed 状态
@ -478,7 +478,7 @@ namespace ThreatSource.Guidance
// 更新扫描参数
UpdateConicalScan(deltaTime);
if (TryDetectAndTrackTarget(missilePosition, missileVelocity, deltaTime, out Vector3D currentTargetPosition))
if (TryDetectAndTrackTarget(Position, Velocity, deltaTime, out Vector3D currentTargetPosition))
{
targetLostTimer = 0;
Vector3D? currentTargetVelocity = null;
@ -492,8 +492,8 @@ namespace ThreatSource.Guidance
GuidanceAcceleration = MotionAlgorithm.CalculateProportionalNavigation(
ProportionalNavigationCoefficient,
missilePosition,
missileVelocity,
Position,
Velocity,
currentTargetPosition,
currentTargetVelocity ?? Vector3D.Zero
);

5
ThreatSource/src/Indicator/InfraredTracker.cs
View File

@ -27,11 +27,12 @@ namespace ThreatSource.Indicator
/// <remarks>
/// 红外测角仪支持的干扰类型：
/// - 红外干扰
/// - 烟雾干扰
/// </remarks>
public override IEnumerable<JammingType> SupportedJammingTypes => [JammingType.Infrared, JammingType.SmokeGrenade];
/// <summary>
/// 获取设备支持的阻塞干扰类型
/// 定义设备支持的阻塞干扰类型
/// </summary>
public override IEnumerable<JammingType> SupportedBlockingJammingTypes => [JammingType.Infrared];
@ -365,7 +366,7 @@ namespace ThreatSource.Indicator
// 添加子类特定响应：如果是红外干扰，停止跟踪
if (parameters.Type == JammingType.Infrared)
{
Debug.WriteLine($"[InfraredTracker] {Id} 受到红外干扰，停止跟踪。", "Jamming");
Debug.WriteLine($"[InfraredTracker] {Id} 受到红外干扰，停止跟踪。", "Jamming");
StopTracking();
}
}

3
ThreatSource/src/Indicator/LaserBeamRider.cs
View File

@ -24,11 +24,12 @@ namespace ThreatSource.Indicator
/// <remarks>
/// 激光驾束仪支持的干扰类型：
/// - 激光干扰
/// - 烟雾干扰
/// </remarks>
public override IEnumerable<JammingType> SupportedJammingTypes => [JammingType.Laser, JammingType.SmokeGrenade];
/// <summary>
/// 获取设备支持的阻塞干扰类型
/// 定义设备支持的阻塞干扰类型
/// </summary>
public override IEnumerable<JammingType> SupportedBlockingJammingTypes => [JammingType.Laser];

3
ThreatSource/src/Indicator/LaserDesignator.cs
View File

@ -24,11 +24,12 @@ namespace ThreatSource.Indicator
/// <remarks>
/// 激光目标指示器支持的干扰类型：
/// - 激光干扰
/// - 烟雾干扰
/// </remarks>
public override IEnumerable<JammingType> SupportedJammingTypes => [JammingType.Laser, JammingType.SmokeGrenade];
/// <summary>
/// 获取设备支持的阻塞干扰类型
/// 定义设备支持的阻塞干扰类型
/// </summary>
public override IEnumerable<JammingType> SupportedBlockingJammingTypes => [JammingType.Laser];

4
ThreatSource/src/MIssile/InfraredCommandGuidedMissile.cs
View File

@ -99,6 +99,7 @@ namespace ThreatSource.Missile
guidanceSystem = new InfraredCommandGuidanceSystem(
missileId + "_guidance",
missileId,
guidanceConfig,
properties.MaxAcceleration,
properties.ProportionalNavigationCoefficient,
@ -166,7 +167,7 @@ namespace ThreatSource.Missile
/// </remarks>
private void UpdateCruiseStage(double deltaTime)
{
guidanceSystem.Update(deltaTime, Position, Velocity);
guidanceSystem.Update(deltaTime);
GuidanceAcceleration = guidanceSystem.GetGuidanceAcceleration();
IsGuidance = guidanceSystem.HasGuidance;
}
@ -279,6 +280,7 @@ namespace ThreatSource.Missile
/// <remarks>
/// 返回信息包括：
/// - 基本状态信息
/// </remarks>
public override ElementStatusInfo GetStatusInfo()
{
var statusInfo = base.GetStatusInfo();

7
ThreatSource/src/MIssile/InfraredImagingTerminalGuidedMissile.cs
View File

@ -100,6 +100,7 @@ namespace ThreatSource.Missile
{
guidanceSystem = new InfraredImagingGuidanceSystem(
missileId + "_guidance",
missileId,
guidanceConfig,
targetType,
properties.MaxAcceleration,
@ -196,7 +197,7 @@ namespace ThreatSource.Missile
/// </remarks>
private void UpdateTerminalSearchStage(double deltaTime)
{
guidanceSystem.Update(deltaTime, Position, Velocity);
guidanceSystem.Update(deltaTime);
GuidanceAcceleration = guidanceSystem.GetGuidanceAcceleration();
IsGuidance = guidanceSystem.HasGuidance;
@ -220,7 +221,7 @@ namespace ThreatSource.Missile
/// </remarks>
private void UpdateTerminalTrackStage(double deltaTime)
{
guidanceSystem.Update(deltaTime, Position, Velocity);
guidanceSystem.Update(deltaTime);
GuidanceAcceleration = guidanceSystem.GetGuidanceAcceleration();
IsGuidance = guidanceSystem.HasGuidance;
@ -248,7 +249,7 @@ namespace ThreatSource.Missile
/// </remarks>
private void UpdateTerminalLockStage(double deltaTime)
{
guidanceSystem.Update(deltaTime, Position, Velocity);
guidanceSystem.Update(deltaTime);
GuidanceAcceleration = guidanceSystem.GetGuidanceAcceleration();
IsGuidance = guidanceSystem.HasGuidance;
if (!guidanceSystem.HasTarget)

3
ThreatSource/src/MIssile/LaserBeamRiderMissile.cs
View File

@ -79,6 +79,7 @@ namespace ThreatSource.Missile
{
guidanceSystem = new LaserBeamRiderGuidanceSystem(
missileId + "_guidance",
missileId,
properties.MaxAcceleration,
properties.ProportionalNavigationCoefficient,
laserCodeConfig,
@ -182,7 +183,7 @@ namespace ThreatSource.Missile
private void UpdateCruiseStage(double deltaTime)
{
// 巡航阶段
guidanceSystem.Update(deltaTime, Position, Velocity);
guidanceSystem.Update(deltaTime);
GuidanceAcceleration = guidanceSystem.GetGuidanceAcceleration();
IsGuidance = guidanceSystem.HasGuidance;
}

5
ThreatSource/src/MIssile/LaserSemiActiveGuidedMissile.cs
View File

@ -97,14 +97,13 @@ namespace ThreatSource.Missile
{
guidanceSystem = new LaserSemiActiveGuidanceSystem(
missileId + "_guidance",
missileId,
properties.MaxAcceleration,
properties.ProportionalNavigationCoefficient,
laserCodeConfig,
guidanceConfig,
manager);
// 设置制导系统的ParentId属性
guidanceSystem.ParentId = missileId;
LaserCodeConfig = laserCodeConfig;
}
@ -212,7 +211,7 @@ namespace ThreatSource.Missile
private void UpdateCruiseStage(double deltaTime)
{
// 更新制导系统
guidanceSystem.Update(deltaTime, Position, Velocity);
guidanceSystem.Update(deltaTime);
// 获取制导加速度
GuidanceAcceleration = guidanceSystem.GetGuidanceAcceleration();
// 设置制导状态

3
ThreatSource/src/MIssile/MillimeterWaveTerminalGuidedMissile.cs
View File

@ -93,6 +93,7 @@ namespace ThreatSource.Missile
{
guidanceSystem = new MillimeterWaveGuidanceSystem(
missileId + "_guidance",
missileId,
properties.MaxAcceleration,
properties.ProportionalNavigationCoefficient,
guidanceConfig,
@ -179,7 +180,7 @@ namespace ThreatSource.Missile
/// </remarks>
private void UpdateTerminalStage(double deltaTime)
{
guidanceSystem.Update(deltaTime, Position, Velocity);
guidanceSystem.Update(deltaTime);
GuidanceAcceleration = guidanceSystem.GetGuidanceAcceleration();
IsGuidance = guidanceSystem.HasGuidance;
}

42
ThreatSource/src/Sensor/InfraredDetector.cs
View File

@ -30,11 +30,12 @@ namespace ThreatSource.Sensor
/// <remarks>
/// 红外探测器支持的干扰类型：
/// - 红外干扰
/// - 烟雾干扰
/// </remarks>
public override IEnumerable<JammingType> SupportedJammingTypes => [JammingType.Infrared];
public override IEnumerable<JammingType> SupportedJammingTypes => [JammingType.Infrared, JammingType.SmokeGrenade];
/// <summary>
/// 获取设备支持的阻塞干扰类型
/// 定义设备支持的阻塞干扰类型
/// </summary>
public override IEnumerable<JammingType> SupportedBlockingJammingTypes => [JammingType.Infrared];
@ -64,7 +65,12 @@ namespace ThreatSource.Sensor
/// 存储探测器的测量结果
/// 包含温度和目标探测状态
/// </remarks>
private InfraredSensorData sensorData;
private readonly InfraredSensorData sensorData;
/// <summary>
/// 烟幕衰减系数
/// </summary>
private double SmokeAttenuation = 1.0;
/// <summary>
/// 初始化红外探测器的新实例
@ -140,7 +146,7 @@ namespace ThreatSource.Sensor
if (result.Angle != null && result.Target != null)
{
sensorData.TargetAngle = result.Angle;
return result.Target.Properties.InfraredRadiationIntensity;
return SmokeAttenuation * result.Target.Properties.InfraredRadiationIntensity;
}
sensorData.TargetAngle = null;
return 0;
@ -211,14 +217,25 @@ namespace ThreatSource.Sensor
protected override void HandleJammingApplied(JammingParameters parameters)
{
base.HandleJammingApplied(parameters);
// 基类 JammableComponent 和 Sensor 已经处理了 IsJammed 状态
// 这里只处理探测器特定的响应
if (parameters.Type == JammingType.Infrared)
if (parameters.Type == JammingType.Infrared)
{
// 不需要再次检查波长，因为 ShouldHandleJamming 已经做过
Debug.WriteLine($"[InfraredDetector] 红外探测器受到有效干扰，功率：{parameters.Power}瓦特", "Jamming");
sensorData.IsValid = false;
// IsTargetDetected 会在下一次 UpdateSensor 时根据干扰状态决定，这里不直接修改
sensorData.IsTargetDetected = false;
}
else if (parameters.Type == JammingType.SmokeGrenade)
{
if (SimulationManager.GetEntityById(parameters.JammerId) is SmokeGrenade smokeGrenade)
{
var intersection = MotionAlgorithm.CalculateIntersectionWithGround(Position, Orientation.ToVector(), 0);
if (intersection != null)
{
// 计算烟幕衰减 (这里存储衰减系数，1.0表示无衰减)
var wavelength = config.Band == InfraredBand.Long ? 10 : 4;
SmokeAttenuation = smokeGrenade.GetSmokeTransmittanceOnLine(Position, intersection, wavelength);
Console.WriteLine($"[InfraredDetector] 烟幕影响，视线透过率: {SmokeAttenuation:F3}");
}
}
}
}
@ -228,8 +245,6 @@ namespace ThreatSource.Sensor
protected override void HandleJammingCleared(JammingParameters parameters)
{
base.HandleJammingCleared(parameters);
// 基类 JammableComponent 和 Sensor 已经处理了 IsJammed 状态
// 这里只处理探测器特定的响应
if (parameters.Type == JammingType.Infrared)
{
Debug.WriteLine("[InfraredDetector] 红外探测器干扰已清除", "Jamming");
@ -243,6 +258,11 @@ namespace ThreatSource.Sensor
sensorData.IsValid = false; // 如果仍被干扰，保持无效
}
}
else if (parameters.Type == JammingType.SmokeGrenade)
{
SmokeAttenuation = 1.0;
Debug.WriteLine("[InfraredDetector] 烟幕干扰清除");
}
}
}
}

5
ThreatSource/src/Sensor/LaserRangefinder.cs
View File

@ -170,11 +170,8 @@ namespace ThreatSource.Sensor
protected override void HandleJammingApplied(JammingParameters parameters)
{
base.HandleJammingApplied(parameters);
// 基类 JammableComponent 和 Sensor 已经处理了 IsJammed 状态
// 这里只处理测距仪特定的响应
if (parameters.Type == JammingType.Laser)
{
// 不需要再次检查波长，因为 ShouldHandleJamming 已经做过
Debug.WriteLine($"[LaserRangefinder] 激光测距仪受到有效干扰，功率：{parameters.Power}瓦特", "Jamming");
sensorData.IsValid = false;
sensorData.Distance = 0; // 在干扰状态下将距离设置为0
@ -187,8 +184,6 @@ namespace ThreatSource.Sensor
protected override void HandleJammingCleared(JammingParameters parameters)
{
base.HandleJammingCleared(parameters);
// 基类 JammableComponent 和 Sensor 已经处理了 IsJammed 状态
// 这里只处理测距仪特定的响应
if (parameters.Type == JammingType.Laser)
{
Debug.WriteLine("[LaserRangefinder] 激光测距仪干扰已清除", "Jamming");

8
ThreatSource/src/Sensor/MillimeterWaveAltimeter.cs
View File

@ -34,7 +34,7 @@ namespace ThreatSource.Sensor
public override IEnumerable<JammingType> SupportedJammingTypes => [JammingType.MillimeterWave];
/// <summary>
/// 获取设备支持的阻塞干扰类型
/// 定义设备支持的阻塞干扰类型
/// </summary>
public override IEnumerable<JammingType> SupportedBlockingJammingTypes => [JammingType.MillimeterWave];
@ -181,11 +181,8 @@ namespace ThreatSource.Sensor
protected override void HandleJammingApplied(JammingParameters parameters)
{
base.HandleJammingApplied(parameters);
// 基类 JammableComponent 和 Sensor 已经处理了 IsJammed 状态
// 这里只处理测高雷达特定的响应
if (parameters.Type == JammingType.MillimeterWave)
{
// 不需要再次检查波长，因为 ShouldHandleJamming 已经做过
Debug.WriteLine($"[MillimeterWaveAltimeter] 毫米波测高雷达受到有效干扰，功率：{parameters.Power}瓦特", "Jamming");
sensorData.IsValid = false;
sensorData.Altitude = 0; // 被干扰时将高度值设为0
@ -198,8 +195,6 @@ namespace ThreatSource.Sensor
protected override void HandleJammingCleared(JammingParameters parameters)
{
base.HandleJammingCleared(parameters);
// 基类 JammableComponent 和 Sensor 已经处理了 IsJammed 状态
// 这里只处理测高雷达特定的响应
if (parameters.Type == JammingType.MillimeterWave)
{
Debug.WriteLine("[MillimeterWaveAltimeter] 毫米波测高雷达干扰已清除", "Jamming");
@ -211,7 +206,6 @@ namespace ThreatSource.Sensor
}
else
{
// 如果仍有其他干扰（理论上不可能，因为只支持MMW），保持无效
sensorData.IsValid = false;
}
}

10
ThreatSource/src/Sensor/MillimeterWaveRadiometer.cs
View File

@ -34,7 +34,7 @@ namespace ThreatSource.Sensor
public override IEnumerable<JammingType> SupportedJammingTypes => [JammingType.MillimeterWave];
/// <summary>
/// 获取设备支持的阻塞干扰类型
/// 定义设备支持的阻塞干扰类型
/// </summary>
public override IEnumerable<JammingType> SupportedBlockingJammingTypes => [JammingType.MillimeterWave];
@ -246,11 +246,8 @@ namespace ThreatSource.Sensor
protected override void HandleJammingApplied(JammingParameters parameters)
{
base.HandleJammingApplied(parameters);
// 基类 JammableComponent 和 Sensor 已经处理了 IsJammed 状态
// 这里只处理辐射计特定的响应
if (parameters.Type == JammingType.MillimeterWave)
{
// 不需要再次检查波长，因为 ShouldHandleJamming 已经做过
Debug.WriteLine($"[MillimeterWaveRadiometer] 毫米波辐射计受到有效干扰，功率：{parameters.Power}瓦特", "Jamming");
sensorData.IsValid = false;
sensorData.IsTargetDetected = false; // 干扰时无法探测目标
@ -263,16 +260,13 @@ namespace ThreatSource.Sensor
protected override void HandleJammingCleared(JammingParameters parameters)
{
base.HandleJammingCleared(parameters);
// 基类 JammableComponent 和 Sensor 已经处理了 IsJammed 状态
// 这里只处理辐射计特定的响应
if (parameters.Type == JammingType.MillimeterWave)
if (parameters.Type == JammingType.MillimeterWave)
{
Debug.WriteLine("[MillimeterWaveRadiometer] 毫米波辐射计干扰已清除", "Jamming");
// 只有在整体未被干扰时才恢复有效状态
if (!IsJammed)
{
sensorData.IsValid = true;
// 不需要重置 IsTargetDetected，UpdateSensor 会处理
}
else
{

2
ThreatSource/src/Utils/Common.cs
View File

@ -491,7 +491,7 @@ namespace ThreatSource.Utils
public enum InfraredBand
{
/// <summary>
/// 远红外波段，6-15um
/// 远红外波段，8-12um
/// </summary>
Long,
/// <summary>

32
ThreatSource/src/Utils/MotionAlgorithm.cs
View File

@ -308,5 +308,37 @@ namespace ThreatSource.Utils
return new Vector3D(windX, 0, windZ);
}
/// <summary>
/// 计算空中的观察者向下视线方向与地面相交点
/// </summary>
/// <param name="observerPosition">观察者位置</param>
/// <param name="targetDirection">目标方向</param>
/// <param name="groundLevel">地面高度</param>
/// <returns>观察者视线方向与地面相交点，如果视线不与地面相交则返回null</returns>
public static Vector3D? CalculateIntersectionWithGround(Vector3D observerPosition, Vector3D targetDirection, double groundLevel)
{
// 检查观察者是否在空中
if (observerPosition.Y <= groundLevel)
{
return null; // 观察者不在空中，无法计算交点
}
// 视线方向单位向量
Vector3D direction = targetDirection.Normalize();
// 检查视线是否向下
if (direction.Y >= 0)
{
return null; // 视线不向下，不会与地面相交
}
// 计算视线方向与地面相交点的参数t
double t = (groundLevel - observerPosition.Y) / direction.Y;
// 由于direction.Y < 0且observerPosition.Y > groundLevel，t应该为正值
// 计算并返回相交点坐标
return observerPosition + direction * t;
}
}
}

2
VERSION
View File

@ -1 +1 @@
0.2.13
0.2.14

8
tools/ComprehensiveMissileSimulator.cs
View File

@ -189,9 +189,9 @@ namespace ThreatSource.Tools.MissileSimulation
{
var motionParameters = new MotionParameters
{
Position = new Vector3D(0, 1.2, 20),
Position = new Vector3D(0, 1.2, 0),
Orientation = new Orientation(Math.PI/2, 0.0, 0.0),
InitialSpeed = 1.0
InitialSpeed = 0.0
};
string targetId = "Tank_1";
var target = _threatSourceFactory.CreateTarget(targetId, "mbt_001", motionParameters);
@ -348,8 +348,8 @@ namespace ThreatSource.Tools.MissileSimulation
{
var motionParameters = new MotionParameters
{
Position = new Vector3D(2000, 1, 30),
Orientation = new Orientation(Math.PI, 0.02, 0),
Position = new Vector3D(2000, 10, 0),
Orientation = new Orientation(Math.PI, -0.001, 0),
InitialSpeed = 300
};
string missileId = "ITGM_1";