火力规则：装备类型规则、目标规则实现、阵位规则、航迹规则

auto-solution-rule/src/main/java/com/solution/rule/domain/simplerulepojo/Task.java

@@ -34,9 +34,9 @@ public class Task {
     //任务目标id
     private String targetId;
 
-    //作战区经纬度
-    private Coordinate warZoneLocation;
+    //作战区经纬高
+    private List<Coordinate> warZoneLocation;
 
-    //防区经纬度
-    private Coordinate defZoneLocation;
+    //防区经纬高
+    private List<Coordinate> defZoneLocation;
 }

auto-solution-rule/src/main/resources/rules/README.md

@@ -0,0 +1,315 @@
+# fire-rule.drl 维护说明（业务+开发）
+
+本文档对应 `auto-solution-rule/src/main/resources/rules/fire-rule.drl` 当前版本，重点说明：
+- 业务人员改哪里
+- 每个参数改了会产生什么效果
+- 如何快速判断规则是否“命中/不命中”
+
+## 1. 先看这一个入口：业务可改区
+
+只改 `//TODO` 下的 `buildBusinessConfig()`，其他函数不要改。
+
+`buildBusinessConfig()` 里每个参数的效果如下。
+
+## 2. 参数-效果对照（给业务人员）
+
+### 2.1 武器名称映射（改名字，不改逻辑）
+- `redStrikeDroneName`：空中反制组中的无人机名称。
+- `redArmedHelicopterName`：空中反制组中的武装直升机名称。
+- `redHowitzerName`：地面反制组中的迫榴炮名称。
+- `redVehicleMortarName`：地面反制组中的车载迫击炮名称。
+- `redAaWeaponName`：空中反制组中的防空导弹武器名称。
+- `redAtRocketName`：装甲反制组中的反坦克火箭名称。
+- `redAtMissileSystemName`：装甲反制组中的反坦克导弹系统名称。
+- `redMissileVehicleName`：导弹补充组中的导弹发射车名称。
+
+### 2.2 白名单开关（决定“是否匹配”）
+- `enableAirRule`：`true` 时，蓝方空中目标会触发红方空中反制组；`false` 时该组永不触发。
+- `enableGroundRule`：`true` 时，蓝方地面目标会触发红方炮类反制组；`false` 时不触发。
+- `enableArmorRule`：`true` 时，蓝方装甲目标会触发红方反坦克组；`false` 时不触发。
+- `enableMissileVehicleRule`：`true` 时，蓝方有导弹能力可追加导弹发射车；`false` 时不追加。
+- `enableMissileLinkage`：`true` 时开启导弹数量/范围联动；`false` 时不做导弹联动增强。
+- `allowMultiGroup`：
+  - `true`：同一批输入可命中多组策略并叠加武器；
+  - `false`：只命中第一组，后续组不再生效（更“死规则”）。
+- `enableArmedHelicopterOnAir`：空中组中是否包含武装直升机。
+
+### 2.3 蓝方类型到红方方案映射（核心，可多选）
+
+先解释你提到的 “k”：
+- 这里的 `k` 就是 **key（键名）**，例如 `map_armor_targets`。
+- `v` 是 **value（值）**，例如 `反坦克火箭,反坦克导弹系统`。
+- 规则实际含义就是：`key` 决定“哪类蓝方目标”，`value` 决定“红方上哪些武器”。
+
+映射键名中文对照：
+- `map_air_targets`：蓝方是空中目标时，红方使用哪些武器。
+- `map_ground_targets`：蓝方是地面目标时，红方使用哪些武器。
+- `map_armor_targets`：蓝方是装甲目标（坦克/装甲车）时，红方使用哪些武器。
+- `map_artillery_targets`：蓝方是炮类目标时，红方使用哪些武器。
+- `map_missile_targets`：蓝方有导弹能力时，红方使用哪些武器。
+
+映射规则说明：
+- 值必须是红方武器库内合法名称，否则该项会被忽略。
+- 为空时视为该组不配置，允许不命中。
+- 示例：`map_armor_targets=反坦克火箭,反坦克导弹系统` 表示坦克可同时触发两种红方反制武器。
+
+### 2.4 数量和阈值（决定“匹配后给多少”）
+- `defaultAirNum`：空中组默认数量。
+- `defaultGroundNum`：地面/装甲组默认数量。
+- `defaultMissileVehicleNum`：导弹发射车默认数量。
+- `shellRangeDefault`：炮类组件参数值，单位固定 `范围米`。
+- `missileCountOffset`：红方导弹数量 = 蓝方导弹数量 + 偏移量。
+- `missileRangeOffset`：红方导弹范围 = 蓝方导弹范围 + 偏移量（单位 `破坏范围米`）。
+- `blueMissileRangeDefault`：蓝方导弹范围缺失时采用的默认值。
+- `minBlueMissileCountForLinkage`：蓝方导弹数量达到该值才触发联动增强。
+
+### 2.5 targetId 自动绑定参数（新增）
+- `enableTargetAutoBind`：是否自动给红方武器写入 `targetId`。
+- `minTargetBindRatio`：最低绑定比例（例如 `0.7` 表示至少 70% 红方武器有目标）。
+- `allowReserveWithoutTarget`：
+  - `true`：允许少量红方武器 `targetId` 为空（火力冗余）。
+  - `false`：尽量给每个红方武器分配目标。
+
+绑定规则说明（固定，不需要业务改代码）：
+- 绑定来源是蓝方武器 `equipmentId`。
+- 匹配优先级按武器类型：
+  - 防空类红方武器优先绑定蓝方空中目标
+  - 反装甲类红方武器优先绑定蓝方装甲目标
+  - 炮类红方武器优先绑定蓝方炮类/地面目标
+  - 导弹发射车优先绑定蓝方导弹能力目标
+- 当优先池不足时自动回退到地面池/全目标池，保证大部分武器有目标。
+
+### 2.6 阵位规则参数（新增）
+- `enablePositionRules`：阵位规则总开关。
+- 阵位输入来源：`blueTask.warZoneLocation` 与 `blueTask.defZoneLocation`（各 4 个经纬点）。
+- `fireUnitSpacingMeters`：防区/作战区点位间距（米），例如 `100` 代表约每 100 米一个火力单元。
+- `airDeployZonePreference`：飞机优先部署区域（`combat` 或 `defense`）。
+- `defensePriorityWeapons`：优先部署在防区的武器名单（逗号分隔）。
+- `groundDeployHeight` / `airDeployHeight`：地面/空中武器部署高度。
+
+阵位规则效果：
+- 新增两条规则：
+  - `阵位规则-区域解析与点位生成`
+  - `阵位规则-武器部署赋位`
+- 飞机可在任意区（按偏好区优先）；反坦克等重火力优先防区。
+- 在多边形区域内按间距生成候选点，并给红方武器写入 `weapon.coordinate`。
+
+阵位输入示例（仅经纬度，4点）：
+
+```json
+{
+  "warZoneLocation": [
+    { "longitude": 116.3801, "latitude": 39.9001 },
+    { "longitude": 116.3901, "latitude": 39.9001 },
+    { "longitude": 116.3901, "latitude": 39.9101 },
+    { "longitude": 116.3801, "latitude": 39.9101 }
+  ],
+  "defZoneLocation": [
+    { "longitude": 116.3825, "latitude": 39.9025 },
+    { "longitude": 116.3875, "latitude": 39.9025 },
+    { "longitude": 116.3875, "latitude": 39.9075 },
+    { "longitude": 116.3825, "latitude": 39.9075 }
+  ]
+}
+```
+
+### 2.7 航迹规则参数（新增）
+- `enableTrajectoryRules`：航迹规则总开关。
+- `strategyMode`：`auto/shortest/flank/interfere`。
+  - `auto`：智能选择策略。
+  - 其他值：强制使用指定策略（若该策略被禁用会自动回退）。
+- `enableShortest` / `enableFlank` / `enableInterfere`：各策略开关。
+- `nearDefDistanceMeters`：蓝方末端点到防区的“近距离阈值”。
+- `farDefDistanceMeters`：蓝方末端点到防区的“远距离阈值”。
+- `fastSpeedThreshold`：蓝方平均速度达到该值视为“高速”。
+- `flankOffsetMeters`：绕后追击偏移幅度（越大绕后越明显）。
+- `interfereOffsetMeters`：干扰轨迹基础偏移。
+- `interfereZigzagAmplitude`：干扰轨迹锯齿振幅（越大摆动越明显）。
+- `keepBlueHeight`：是否沿用蓝方高度。
+- `redTrackHeightOverride`：不沿用时红方统一高度。
+
+航迹智能选择逻辑：
+- `near + fast` -> `shortest`（最短距离追击）
+- `far + fast` -> `interfere`（干扰/诱偏）
+- 其他 -> `flank`（绕后追击）
+
+不生成保护：
+- 蓝方 `trackPoints` 为空，或 `defZoneLocation` 点数不足（<3），则不生成红方航迹。
+
+## 3. 当前规则行为（简版）
+
+- `装备组件匹配`、`组件参数匹配`：已作为 `legacy` 占位，不承担当前业务决策。
+- 主决策在 `红方武器自适应装配规则`：调用 `configureRedWeaponsByBlue(...)`，按“映射配置”添加武器。
+- 导弹增强在 `导弹联动增强规则`：调用 `applyMissileLinkage(...)`，受开关和阈值控制。
+- 任务命名在 `任务自动匹配规则`：调用 `assignTaskNameByRedWeapons(...)`，按红方最终武器自动生成任务名和 `dataType`。
+- 炮类约束：命中炮类条件时，炮类武器只保留 `炮弹` 组件，单位 `范围米`。
+- `targetId` 绑定：在装配后自动执行，尽量为红方武器绑定蓝方 `equipmentId`，允许少量空值冗余。
+- 阵位部署：按多边形区域和武器类型自动赋位，保证防区火力覆盖。
+- 航迹生成：根据蓝方 `trackPoints` 生成红方 `trackPoints`，点数与蓝方一致，支持三套策略和智能选择。
+
+## 3.1 任务名称自动匹配（新增）
+
+任务命名依据：**红方最终武器**（不是蓝方任务名关键字）。
+
+当前分类优先级：
+- 导弹突击（导弹发射车）
+- 防空压制（防空导弹武器/火力打击无人机/武装直升机）
+- 反装甲打击（反坦克火箭/反坦克导弹系统）
+- 炮火压制（迫榴炮/车载迫击炮）
+- 通用打击（兜底）
+
+业务可调模板（在 `buildBusinessConfig()`）：
+- `taskName_missile_strike` / `taskDataType_missile_strike`
+- `taskName_air_defence` / `taskDataType_air_defence`
+- `taskName_anti_armor` / `taskDataType_anti_armor`
+- `taskName_artillery` / `taskDataType_artillery`
+- `taskName_general` / `taskDataType_general`
+
+效果说明：
+- 只改这些模板文字，不改函数，也能改变最终任务展示名。
+- 若分类与武器不一致，会自动回落到 `通用打击任务`，避免“任务名和武器不符”。
+
+## 4. 快速修改示例（业务常用）
+
+- 想让规则更“死”：
+  - 把 `allowMultiGroup` 改成 `false`。
+- 想让“坦克只上反坦克火箭，不上导弹系统”：
+  - 把 `map_armor_targets` 改成 `反坦克火箭`。
+- 想让“坦克同时上火箭和导弹系统”：
+  - 把 `map_armor_targets` 改成 `反坦克火箭,反坦克导弹系统`。
+- 想允许更多不命中：
+  - 关闭部分开关，例如 `enableGroundRule=false`、`enableArmorRule=false`。
+- 想让导弹联动更难触发：
+  - 提高 `minBlueMissileCountForLinkage`，例如从 `1` 调到 `3`。
+- 想提升炮类打击范围：
+  - 调大 `shellRangeDefault`，例如 `1500 -> 1800`。
+
+## 5. 测试 JSON（按你项目常用的 Task 入参格式）
+
+说明：下面 JSON 是 **单个 Task** 格式，不是 `FactTask` 包装格式。
+如果你的执行入口最终需要 `FactTask`，则由开发在服务层把“蓝方 Task + 红方 Task”组装后再 `insert` 规则引擎。
+
+### 5.1 不命中样例（蓝方 Task）
+说明：该样例仅用于蓝方任务输入结构校验；若业务把对应映射留空或关闭开关，则允许不命中。
+
+```json
+{
+  "id": "blue-miss-001",
+  "side": "蓝方",
+  "dataType": "打击",
+  "threatLevel": "2",
+  "taskWeapons": [
+    {
+      "name": "攻击直升机",
+      "supportType": "overhead",
+      "number": 1,
+      "components": []
+    }
+  ]
+}
+```
+
+### 5.2 命中样例（蓝方 Task）
+说明：该蓝方输入同时包含空中和装甲特征，且有导弹组件，满足命中与联动测试条件。
+
+```json
+{
+  "id": "blue-hit-001",
+  "side": "蓝方",
+  "dataType": "打击",
+  "threatLevel": "3",
+  "taskWeapons": [
+    {
+      "name": "攻击直升机",
+      "supportType": "overhead",
+      "number": 2,
+      "components": [
+        {
+          "deviceName": "机载导弹",
+          "componentParams": [
+            {
+              "attDefaultValue": "260",
+              "attExplain": "破坏范围米",
+              "number": 2
+            }
+          ]
+        }
+      ]
+    },
+    {
+      "name": "主战坦克",
+      "supportType": "ground",
+      "number": 2,
+      "components": []
+    }
+  ]
+}
+```
+
+### 5.3 红方初始 Task 样例（通常为空列表）
+说明：用于和蓝方 Task 组装成规则输入对象。
+
+```json
+{
+  "id": "red-init-001",
+  "side": "红方",
+  "dataType": "打击",
+  "threatLevel": "1",
+  "taskWeapons": []
+}
+```
+
+### 5.4 航迹规则不生成样例（缺防区）
+```json
+{
+  "id": "blue-track-miss-001",
+  "side": "蓝方",
+  "dataType": "打击",
+  "threatLevel": "2",
+  "defZoneLocation": [],
+  "trackPoints": [
+    { "index": 0, "longitude": 116.3801, "latitude": 39.9001, "height": 100, "speed": 210 },
+    { "index": 1, "longitude": 116.3810, "latitude": 39.9010, "height": 100, "speed": 220 }
+  ],
+  "taskWeapons": []
+}
+```
+
+### 5.5 航迹规则命中样例（可生成）
+```json
+{
+  "id": "blue-track-hit-001",
+  "side": "蓝方",
+  "dataType": "打击",
+  "threatLevel": "3",
+  "defZoneLocation": [
+    { "longitude": 116.4001, "latitude": 39.9201 },
+    { "longitude": 116.4051, "latitude": 39.9201 },
+    { "longitude": 116.4051, "latitude": 39.9251 },
+    { "longitude": 116.4001, "latitude": 39.9251 }
+  ],
+  "trackPoints": [
+    { "index": 0, "longitude": 116.3801, "latitude": 39.9001, "height": 120, "speed": 240 },
+    { "index": 1, "longitude": 116.3840, "latitude": 39.9040, "height": 120, "speed": 245 },
+    { "index": 2, "longitude": 116.3880, "latitude": 39.9080, "height": 120, "speed": 250 },
+    { "index": 3, "longitude": 116.3920, "latitude": 39.9120, "height": 120, "speed": 248 }
+  ],
+  "taskWeapons": []
+}
+```
+
+## 6. 开发人员说明（放在末尾）
+
+- **入口约定**：业务仅改 `buildBusinessConfig()`，开发改函数实现时不要破坏该入口。
+- **类型约定**：配置读取统一走 `readIntCfg(...)` / `readBooleanCfg(...)`，避免 `Map` 强转异常。
+- **策略收敛**：`configureRedWeaponsByBlue(...)` 使用 `matchedAny + allowMultiGroup` 控制“单组命中/多组叠加”。
+- **映射解析**：通过 `parseMappedWeaponNames(...)` 将逗号分隔配置解析为武器列表，非法名称会被 `isValidRedWeaponNameByConfig(...)` 过滤。
+- **联动门控**：`applyMissileLinkage(...)` 必须同时满足：
+  - `enableMissileLinkage=true`
+  - 蓝方导弹数量 `>= minBlueMissileCountForLinkage`
+- **目标绑定**：`bindTargetIdsForRedWeapons(...)` 基于蓝方 `equipmentId` 分配 `targetId`，支持“优先匹配 + 绑定率阈值 + 冗余空目标”。
+- **阵位部署**：`prepareDeploymentPools(...)` + `applyWeaponDeployment(...)` 负责区域解析、点位生成与部署赋位。
+- **航迹生成**：`applyTrajectoryGeneration(...)` + `chooseTrajectoryStrategy(...)` + `generateRedTrackPoints(...)` 负责红方航迹策略生成。
+- **任务命名**：`assignTaskNameByRedWeapons(...)` 仅基于红方最终武器，避免旧版按蓝方 `drawName` 关键字造成误判。
+- **legacy 区域**：`装备组件匹配`、`组件参数匹配` 及 legacy 函数区只保留回滚，不建议继续扩展。
+- **新增武器建议**：优先补 `isAirWeapon/isGroundWeapon/isArmorWeapon/isArtilleryWeapon` 分类，再补 `ensureBasicRedComponents(...)` 模板。

auto-solution-rule/src/main/resources/rules/fire-rule.drl

@@ -5,6 +5,8 @@ import com.solution.rule.domain.simplerulepojo.Task;
 import com.solution.rule.domain.simplerulepojo.Weapon;
 import com.solution.rule.domain.simplerulepojo.SubComponents;
 import com.solution.rule.domain.simplerulepojo.ComponentParam;
+import com.solution.rule.domain.simplerulepojo.Coordinate;
+import com.solution.rule.domain.simplerulepojo.TrackPoints;
 
 import java.util.List;
 import java.util.Map;
@@ -160,6 +162,35 @@ function Map buildBusinessConfig() {
     cfg.put("taskDataType_artillery", "artillery");
     cfg.put("taskDataType_general", "strike");
 
+    // ---------- targetId 自动绑定（可改） ----------
+    cfg.put("enableTargetAutoBind", Boolean.TRUE);       // 是否自动给红方武器绑定蓝方目标
+    cfg.put("minTargetBindRatio", "0.7");                // 最低绑定比例（大部分有目标）
+    cfg.put("allowReserveWithoutTarget", Boolean.TRUE);  // 允许少量武器 targetId 为空（火力冗余）
+
+    // ---------- 阵位规则参数（可改） ----------
+    cfg.put("enablePositionRules", Boolean.TRUE);             // 阵位规则总开关
+    // 区域来源已切换到 Task 实体字段：warZoneLocation / defZoneLocation（4点经纬度）
+    cfg.put("fireUnitSpacingMeters", 100);                    // 火力单元间距（米）
+    cfg.put("airDeployZonePreference", "combat");            // 飞机优先部署区：combat/defense
+    cfg.put("defensePriorityWeapons", "反坦克导弹系统,反坦克火箭,车载迫击炮,迫榴炮"); // 优先部署防区武器
+    cfg.put("groundDeployHeight", 20);                        // 地面武器部署高度
+    cfg.put("airDeployHeight", 300);                          // 空中武器部署高度
+
+    // ---------- 航迹规则参数（可改） ----------
+    cfg.put("enableTrajectoryRules", Boolean.TRUE);           // 航迹规则总开关
+    cfg.put("strategyMode", "auto");                         // auto/shortest/flank/interfere
+    cfg.put("enableShortest", Boolean.TRUE);
+    cfg.put("enableFlank", Boolean.TRUE);
+    cfg.put("enableInterfere", Boolean.TRUE);
+    cfg.put("nearDefDistanceMeters", 800);                    // 近防区阈值
+    cfg.put("farDefDistanceMeters", 2500);                    // 远防区阈值
+    cfg.put("fastSpeedThreshold", 180);                       // 快速阈值
+    cfg.put("flankOffsetMeters", 150);                        // 绕后偏移
+    cfg.put("interfereOffsetMeters", 120);                    // 干扰基础偏移
+    cfg.put("interfereZigzagAmplitude", 90);                  // 干扰锯齿幅度
+    cfg.put("keepBlueHeight", Boolean.TRUE);                  // true=沿用蓝方高度
+    cfg.put("redTrackHeightOverride", 200);                   // keepBlueHeight=false 时生效
+
     return cfg;
 }
 
@@ -199,6 +230,40 @@ then
     assignTaskNameByRedWeapons($fact, cfg);
 end
 
+//-------------------------------------------------------------------------------
+rule "阵位规则-区域解析与点位生成"
+agenda-group "打击任务"
+salience 49
+when
+    $fact : FactTask(blueTask.side == "蓝方", redTask.side == "红方")
+then
+    Map cfg = buildBusinessConfig();
+    prepareDeploymentPools($fact, cfg, globalParams);
+end
+
+//-------------------------------------------------------------------------------
+rule "阵位规则-武器部署赋位"
+agenda-group "打击任务"
+salience 48
+when
+    $fact : FactTask(blueTask.side == "蓝方", redTask.side == "红方")
+then
+    Map cfg = buildBusinessConfig();
+    applyWeaponDeployment($fact, cfg, globalParams);
+end
+
+//-------------------------------------------------------------------------------
+rule "航迹规则-生成红方航迹"
+agenda-group "打击任务"
+salience 47
+when
+    // 根据蓝方 trackPoints 生成红方 trackPoints，点数保持一致
+    $fact : FactTask(blueTask.side == "蓝方", redTask.side == "红方")
+then
+    Map cfg = buildBusinessConfig();
+    applyTrajectoryGeneration($fact, cfg);
+end
+
 //-------------------------------------------------------------------------------
 // 说明：以下函数全部是 DRL function（不是 Java 类方法）
 // 目标：让不懂代码的业务同事只改“可调整常量区”即可完成策略调整
@@ -304,6 +369,9 @@ function void configureRedWeaponsByBlue(
     if (matchedAny && hasBlueArtillery) {
         limitRedArtilleryToShellOnly(redWeapons, (String) cfg.get("shellRangeDefault"));
     }
+
+    // 自动绑定红方武器 targetId（来源：蓝方 equipmentId）
+    bindTargetIdsForRedWeapons(redWeapons, blueWeapons, cfg);
 }
 
 function void applyMappedWeapons(List redWeapons, Map cfg, String mapKey, int defaultNum, boolean allowArmedHelicopter) {
@@ -352,6 +420,25 @@ function List parseMappedWeaponNames(Map cfg, String mapKey) {
     return result;
 }
 
+function List parseCsvList(String text) {
+    List result = new ArrayList();
+    if (text == null || text.trim().equals("")) {
+        return result;
+    }
+    String[] parts = text.split(",");
+    for (int i = 0; i < parts.length; i++) {
+        String one = parts[i];
+        if (one == null) {
+            continue;
+        }
+        String item = one.trim();
+        if (!item.equals("") && !result.contains(item)) {
+            result.add(item);
+        }
+    }
+    return result;
+}
+
 function boolean isValidRedWeaponNameByConfig(Map cfg, String weaponName) {
     if (cfg == null || weaponName == null || weaponName.equals("")) {
         return false;
@@ -425,6 +512,622 @@ function void applyMissileLinkage(
     }
 }
 
+function void bindTargetIdsForRedWeapons(List redWeapons, List blueWeapons, Map cfg) {
+    if (!readBooleanCfg(cfg, "enableTargetAutoBind", true)) {
+        return;
+    }
+    if (redWeapons == null || redWeapons.isEmpty() || blueWeapons == null || blueWeapons.isEmpty()) {
+        return;
+    }
+
+    Map pools = extractBlueTargetPools(blueWeapons);
+    Map cursor = new java.util.HashMap();
+    int total = redWeapons.size();
+    int bound = 0;
+
+    // 第一轮：按武器类别优先匹配
+    for (Object obj : redWeapons) {
+        Weapon redWeapon = (Weapon) obj;
+        if (redWeapon == null) {
+            continue;
+        }
+        if (!isBlank(redWeapon.getTargetId())) {
+            bound++;
+            continue;
+        }
+        String poolKey = inferBluePoolKeyForRedWeapon(redWeapon);
+        String targetId = pickTargetIdFromPools(pools, cursor, poolKey);
+        if (!isBlank(targetId)) {
+            redWeapon.setTargetId(targetId);
+            bound++;
+        }
+    }
+
+    double minRatio = readDoubleCfg(cfg, "minTargetBindRatio", 0.7d);
+    boolean allowReserveWithoutTarget = readBooleanCfg(cfg, "allowReserveWithoutTarget", true);
+    double currentRatio = total <= 0 ? 1.0d : ((double) bound / (double) total);
+    if (currentRatio >= minRatio && allowReserveWithoutTarget) {
+        return;
+    }
+
+    // 第二轮：若绑定率不足，回退到全目标池尽量补齐（仍允许复用目标）
+    for (Object obj : redWeapons) {
+        if (total > 0 && ((double) bound / (double) total) >= minRatio) {
+            break;
+        }
+        Weapon redWeapon = (Weapon) obj;
+        if (redWeapon == null || !isBlank(redWeapon.getTargetId())) {
+            continue;
+        }
+        String targetId = pickTargetIdFromPools(pools, cursor, "all");
+        if (!isBlank(targetId)) {
+            redWeapon.setTargetId(targetId);
+            bound++;
+        }
+    }
+
+    // 第三轮：若不允许空 targetId，最后强制从 all 池补齐（尽力而为）
+    if (!allowReserveWithoutTarget) {
+        for (Object obj : redWeapons) {
+            Weapon redWeapon = (Weapon) obj;
+            if (redWeapon == null || !isBlank(redWeapon.getTargetId())) {
+                continue;
+            }
+            String targetId = pickTargetIdFromPools(pools, cursor, "all");
+            if (!isBlank(targetId)) {
+                redWeapon.setTargetId(targetId);
+            }
+        }
+    }
+}
+
+function void prepareDeploymentPools(FactTask fact, Map cfg, Map runtime) {
+    if (!readBooleanCfg(cfg, "enablePositionRules", true)) {
+        return;
+    }
+    if (fact == null || runtime == null) {
+        return;
+    }
+    List combatPolygon = extractZonePolygonFromTask(fact, true);
+    List defensePolygon = extractZonePolygonFromTask(fact, false);
+    int spacing = readIntCfg(cfg, "fireUnitSpacingMeters", 100);
+    List combatPoints = buildGridPointsInPolygon(combatPolygon, spacing, readIntCfg(cfg, "groundDeployHeight", 20));
+    List defensePoints = buildGridPointsInPolygon(defensePolygon, spacing, readIntCfg(cfg, "groundDeployHeight", 20));
+    runtime.put("deploymentCombatPoints", combatPoints);
+    runtime.put("deploymentDefensePoints", defensePoints);
+}
+
+function void applyWeaponDeployment(FactTask fact, Map cfg, Map runtime) {
+    if (!readBooleanCfg(cfg, "enablePositionRules", true)) {
+        return;
+    }
+    if (fact == null || fact.getRedTask() == null || fact.getRedTask().getTaskWeapons() == null || runtime == null) {
+        return;
+    }
+    List combatPoints = (List) runtime.get("deploymentCombatPoints");
+    List defensePoints = (List) runtime.get("deploymentDefensePoints");
+    if ((combatPoints == null || combatPoints.isEmpty()) && (defensePoints == null || defensePoints.isEmpty())) {
+        return;
+    }
+    Map cursor = new java.util.HashMap();
+    List defensePriorityWeapons = parseCsvList((String) cfg.get("defensePriorityWeapons"));
+    String airPref = String.valueOf(cfg.get("airDeployZonePreference"));
+    int groundH = readIntCfg(cfg, "groundDeployHeight", 20);
+    int airH = readIntCfg(cfg, "airDeployHeight", 300);
+
+    for (Object obj : fact.getRedTask().getTaskWeapons()) {
+        Weapon redWeapon = (Weapon) obj;
+        if (redWeapon == null) {
+            continue;
+        }
+        Coordinate selected = null;
+        if (isRedAirWeapon(redWeapon)) {
+            selected = pickCoordinateByPreference(combatPoints, defensePoints, cursor, airPref);
+            if (selected != null) {
+                selected = cloneCoordinateWithHeight(selected, airH);
+            }
+        } else if (defensePriorityWeapons.contains(redWeapon.getName())) {
+            selected = pickCoordinateByPreference(defensePoints, combatPoints, cursor, "defense");
+            if (selected != null) {
+                selected = cloneCoordinateWithHeight(selected, groundH);
+            }
+        } else {
+            selected = pickCoordinateByPreference(combatPoints, defensePoints, cursor, "combat");
+            if (selected != null) {
+                selected = cloneCoordinateWithHeight(selected, groundH);
+            }
+        }
+        if (selected != null) {
+            redWeapon.setCoordinate(selected);
+        }
+    }
+}
+
+function void applyTrajectoryGeneration(FactTask fact, Map cfg) {
+    if (!readBooleanCfg(cfg, "enableTrajectoryRules", true)) {
+        return;
+    }
+    if (fact == null || fact.getBlueTask() == null || fact.getRedTask() == null) {
+        return;
+    }
+    Task blueTask = fact.getBlueTask();
+    Task redTask = fact.getRedTask();
+    List blueTrack = blueTask.getTrackPoints();
+    if (blueTrack == null || blueTrack.isEmpty()) {
+        return;
+    }
+    List defZone = blueTask.getDefZoneLocation();
+    if (defZone == null || defZone.size() < 3) {
+        return;
+    }
+    String strategy = chooseTrajectoryStrategy(blueTask, cfg);
+    Coordinate endPoint = findNearestDefPointToBlueTail(blueTask);
+    List redTrack = generateRedTrackPoints(blueTrack, strategy, cfg, endPoint);
+    if (redTrack != null && !redTrack.isEmpty()) {
+        redTask.setTrackPoints(redTrack);
+    }
+}
+
+function String chooseTrajectoryStrategy(Task blueTask, Map cfg) {
+    String mode = String.valueOf(cfg.get("strategyMode"));
+    if (mode == null || mode.trim().equals("")) {
+        mode = "auto";
+    }
+    mode = mode.trim().toLowerCase();
+    if (!mode.equals("auto")) {
+        return fallbackToEnabledStrategy(mode, cfg);
+    }
+    double defMinDistance = computeDefMinDistanceMeters(blueTask);
+    int avgSpeed = computeAverageSpeed(blueTask.getTrackPoints());
+    int near = readIntCfg(cfg, "nearDefDistanceMeters", 800);
+    int far = readIntCfg(cfg, "farDefDistanceMeters", 2500);
+    int fast = readIntCfg(cfg, "fastSpeedThreshold", 180);
+    String selected = "flank";
+    if (avgSpeed >= fast && defMinDistance <= near) {
+        selected = "shortest";
+    } else if (avgSpeed >= fast && defMinDistance >= far) {
+        selected = "interfere";
+    }
+    return fallbackToEnabledStrategy(selected, cfg);
+}
+
+function String fallbackToEnabledStrategy(String preferred, Map cfg) {
+    if (isStrategyEnabled(preferred, cfg)) {
+        return preferred;
+    }
+    if (isStrategyEnabled("shortest", cfg)) {
+        return "shortest";
+    }
+    if (isStrategyEnabled("flank", cfg)) {
+        return "flank";
+    }
+    if (isStrategyEnabled("interfere", cfg)) {
+        return "interfere";
+    }
+    return "shortest";
+}
+
+function boolean isStrategyEnabled(String strategy, Map cfg) {
+    if (strategy == null) {
+        return false;
+    }
+    if (strategy.equals("shortest")) {
+        return readBooleanCfg(cfg, "enableShortest", true);
+    }
+    if (strategy.equals("flank")) {
+        return readBooleanCfg(cfg, "enableFlank", true);
+    }
+    if (strategy.equals("interfere")) {
+        return readBooleanCfg(cfg, "enableInterfere", true);
+    }
+    return false;
+}
+
+function Coordinate findNearestDefPointToBlueTail(Task blueTask) {
+    if (blueTask == null || blueTask.getTrackPoints() == null || blueTask.getTrackPoints().isEmpty() || blueTask.getDefZoneLocation() == null || blueTask.getDefZoneLocation().isEmpty()) {
+        return null;
+    }
+    TrackPoints tail = (TrackPoints) blueTask.getTrackPoints().get(blueTask.getTrackPoints().size() - 1);
+    if (tail == null || tail.getLongitude() == null || tail.getLatitude() == null) {
+        return null;
+    }
+    Coordinate nearest = null;
+    double best = Double.MAX_VALUE;
+    for (Object obj : blueTask.getDefZoneLocation()) {
+        Coordinate c = (Coordinate) obj;
+        if (c == null || c.getLongitude() == null || c.getLatitude() == null) {
+            continue;
+        }
+        double d = approxDistanceMeters(tail.getLongitude().doubleValue(), tail.getLatitude().doubleValue(), c.getLongitude().doubleValue(), c.getLatitude().doubleValue());
+        if (d < best) {
+            best = d;
+            nearest = c;
+        }
+    }
+    return nearest;
+}
+
+function double computeDefMinDistanceMeters(Task blueTask) {
+    Coordinate nearest = findNearestDefPointToBlueTail(blueTask);
+    if (nearest == null || blueTask == null || blueTask.getTrackPoints() == null || blueTask.getTrackPoints().isEmpty()) {
+        return Double.MAX_VALUE;
+    }
+    TrackPoints tail = (TrackPoints) blueTask.getTrackPoints().get(blueTask.getTrackPoints().size() - 1);
+    return approxDistanceMeters(
+        tail.getLongitude().doubleValue(),
+        tail.getLatitude().doubleValue(),
+        nearest.getLongitude().doubleValue(),
+        nearest.getLatitude().doubleValue()
+    );
+}
+
+function int computeAverageSpeed(List trackPoints) {
+    if (trackPoints == null || trackPoints.isEmpty()) {
+        return 0;
+    }
+    int total = 0;
+    int count = 0;
+    for (Object obj : trackPoints) {
+        TrackPoints p = (TrackPoints) obj;
+        if (p == null || p.getSpeed() == null) {
+            continue;
+        }
+        total += p.getSpeed();
+        count++;
+    }
+    if (count <= 0) {
+        return 0;
+    }
+    return total / count;
+}
+
+function List generateRedTrackPoints(List blueTrackPoints, String strategy, Map cfg, Coordinate endPoint) {
+    List result = new ArrayList();
+    if (blueTrackPoints == null || blueTrackPoints.isEmpty()) {
+        return result;
+    }
+    TrackPoints start = (TrackPoints) blueTrackPoints.get(0);
+    TrackPoints tail = (TrackPoints) blueTrackPoints.get(blueTrackPoints.size() - 1);
+    if (start == null || start.getLongitude() == null || start.getLatitude() == null) {
+        return result;
+    }
+    double sLon = start.getLongitude().doubleValue();
+    double sLat = start.getLatitude().doubleValue();
+    double eLon = (endPoint != null && endPoint.getLongitude() != null) ? endPoint.getLongitude().doubleValue() : (tail == null || tail.getLongitude() == null ? sLon : tail.getLongitude().doubleValue());
+    double eLat = (endPoint != null && endPoint.getLatitude() != null) ? endPoint.getLatitude().doubleValue() : (tail == null || tail.getLatitude() == null ? sLat : tail.getLatitude().doubleValue());
+    double dx = eLon - sLon;
+    double dy = eLat - sLat;
+    int n = blueTrackPoints.size();
+    int flankOffset = readIntCfg(cfg, "flankOffsetMeters", 150);
+    int intBase = readIntCfg(cfg, "interfereOffsetMeters", 120);
+    int intAmp = readIntCfg(cfg, "interfereZigzagAmplitude", 90);
+    boolean keepBlueHeight = readBooleanCfg(cfg, "keepBlueHeight", true);
+    int redH = readIntCfg(cfg, "redTrackHeightOverride", 200);
+
+    for (int i = 0; i < n; i++) {
+        double t = (n <= 1) ? 1.0d : ((double) i / (double) (n - 1));
+        double baseLon = sLon + dx * t;
+        double baseLat = sLat + dy * t;
+        double offMeters = 0.0d;
+        if ("flank".equals(strategy)) {
+            offMeters = flankOffset * Math.sin(Math.PI * t);
+        } else if ("interfere".equals(strategy)) {
+            double zig = (i % 2 == 0 ? 1.0d : -1.0d) * intAmp;
+            offMeters = intBase * Math.sin(2.0d * Math.PI * t) + zig;
+        }
+        double latDeg = metersToLatDeg(offMeters);
+        double lonDeg = metersToLonDeg(offMeters, baseLat);
+        double norm = Math.sqrt(dx * dx + dy * dy);
+        if (norm < 1e-10) {
+            norm = 1e-10;
+        }
+        double nx = -dy / norm;
+        double ny = dx / norm;
+        double finalLon = baseLon + nx * lonDeg;
+        double finalLat = baseLat + ny * latDeg;
+
+        TrackPoints blueP = (TrackPoints) blueTrackPoints.get(i);
+        TrackPoints redP = new TrackPoints();
+        redP.setIndex(i);
+        redP.setLongitude(new java.math.BigDecimal(String.valueOf(finalLon)));
+        redP.setLatitude(new java.math.BigDecimal(String.valueOf(finalLat)));
+        redP.setSpeed(blueP == null || blueP.getSpeed() == null ? 0 : blueP.getSpeed());
+        if (keepBlueHeight) {
+            redP.setHeight(blueP == null || blueP.getHeight() == null ? redH : blueP.getHeight());
+        } else {
+            redP.setHeight(redH);
+        }
+        result.add(redP);
+    }
+    return result;
+}
+
+function double metersToLatDeg(double meters) {
+    return meters / 111000.0d;
+}
+
+function double metersToLonDeg(double meters, double latitudeDeg) {
+    double cos = Math.cos(Math.toRadians(latitudeDeg));
+    if (Math.abs(cos) < 1e-6) {
+        cos = 1e-6;
+    }
+    return meters / (111000.0d * cos);
+}
+
+function double approxDistanceMeters(double lon1, double lat1, double lon2, double lat2) {
+    double dx = (lon2 - lon1) * 111000.0d * Math.cos(Math.toRadians((lat1 + lat2) / 2.0d));
+    double dy = (lat2 - lat1) * 111000.0d;
+    return Math.sqrt(dx * dx + dy * dy);
+}
+
+function List extractZonePolygonFromTask(FactTask fact, boolean isCombat) {
+    // 输入约定：Task.warZoneLocation / defZoneLocation 传入 4 个经纬点（高度可空）
+    List result = new ArrayList();
+    Task blueTask = fact == null ? null : fact.getBlueTask();
+    if (blueTask == null) {
+        return result;
+    }
+    List source = isCombat ? blueTask.getWarZoneLocation() : blueTask.getDefZoneLocation();
+    if (source == null || source.isEmpty()) {
+        return result;
+    }
+    for (Object oneObj : source) {
+        Coordinate one = (Coordinate) oneObj;
+        if (one == null || one.getLongitude() == null || one.getLatitude() == null) {
+            continue;
+        }
+        Coordinate c = new Coordinate();
+        c.setLongitude(one.getLongitude());
+        c.setLatitude(one.getLatitude());
+        c.setHeight(one.getHeight());
+        result.add(c);
+    }
+    return result;
+}
+
+function List normalizeToCoordinateList(Object raw) {
+    List result = new ArrayList();
+    if (raw == null) {
+        return result;
+    }
+    if (!(raw instanceof List)) {
+        return result;
+    }
+    List values = (List) raw;
+    for (Object obj : values) {
+        Coordinate c = toCoordinate(obj);
+        if (c != null) {
+            result.add(c);
+        }
+    }
+    return result;
+}
+
+function Coordinate toCoordinate(Object obj) {
+    if (obj == null) {
+        return null;
+    }
+    if (obj instanceof Coordinate) {
+        return (Coordinate) obj;
+    }
+    if (obj instanceof Map) {
+        Map m = (Map) obj;
+        Object lon = m.get("longitude");
+        Object lat = m.get("latitude");
+        Object h = m.get("height");
+        if (lon == null || lat == null) {
+            return null;
+        }
+        Coordinate c = new Coordinate();
+        try {
+            c.setLongitude(new java.math.BigDecimal(String.valueOf(lon)));
+            c.setLatitude(new java.math.BigDecimal(String.valueOf(lat)));
+            c.setHeight(h == null ? 0 : parseIntSafe(String.valueOf(h), 0));
+            return c;
+        } catch (Exception ex) {
+            return null;
+        }
+    }
+    return null;
+}
+
+function List buildGridPointsInPolygon(List polygon, int spacingMeters, int defaultHeight) {
+    List points = new ArrayList();
+    if (polygon == null || polygon.size() < 3) {
+        return points;
+    }
+    double step = ((double) spacingMeters) / 111000.0d;
+    if (step <= 0) {
+        step = 0.0009d;
+    }
+    double minLon = 180.0d;
+    double maxLon = -180.0d;
+    double minLat = 90.0d;
+    double maxLat = -90.0d;
+    for (Object cObj : polygon) {
+        Coordinate c = (Coordinate) cObj;
+        if (c == null || c.getLongitude() == null || c.getLatitude() == null) {
+            continue;
+        }
+        double lon = c.getLongitude().doubleValue();
+        double lat = c.getLatitude().doubleValue();
+        if (lon < minLon) minLon = lon;
+        if (lon > maxLon) maxLon = lon;
+        if (lat < minLat) minLat = lat;
+        if (lat > maxLat) maxLat = lat;
+    }
+    for (double lon = minLon; lon <= maxLon; lon += step) {
+        for (double lat = minLat; lat <= maxLat; lat += step) {
+            if (isPointInsidePolygon(lon, lat, polygon)) {
+                Coordinate c = new Coordinate();
+                c.setLongitude(new java.math.BigDecimal(String.valueOf(lon)));
+                c.setLatitude(new java.math.BigDecimal(String.valueOf(lat)));
+                c.setHeight(defaultHeight);
+                points.add(c);
+            }
+        }
+    }
+    return points;
+}
+
+function boolean isPointInsidePolygon(double x, double y, List polygon) {
+    if (polygon == null || polygon.size() < 3) {
+        return false;
+    }
+    boolean inside = false;
+    int n = polygon.size();
+    int j = n - 1;
+    for (int i = 0; i < n; i++) {
+        Coordinate pi = (Coordinate) polygon.get(i);
+        Coordinate pj = (Coordinate) polygon.get(j);
+        if (pi == null || pj == null || pi.getLongitude() == null || pi.getLatitude() == null || pj.getLongitude() == null || pj.getLatitude() == null) {
+            j = i;
+            continue;
+        }
+        double xi = pi.getLongitude().doubleValue();
+        double yi = pi.getLatitude().doubleValue();
+        double xj = pj.getLongitude().doubleValue();
+        double yj = pj.getLatitude().doubleValue();
+        boolean intersect = ((yi > y) != (yj > y))
+            && (x < (xj - xi) * (y - yi) / ((yj - yi) == 0 ? 1e-12 : (yj - yi)) + xi);
+        if (intersect) {
+            inside = !inside;
+        }
+        j = i;
+    }
+    return inside;
+}
+
+function Coordinate pickCoordinateByPreference(List first, List second, Map cursor, String key) {
+    Coordinate c1 = pickCoordinateRoundRobin(first, cursor, "first_" + key);
+    if (c1 != null) {
+        return c1;
+    }
+    return pickCoordinateRoundRobin(second, cursor, "second_" + key);
+}
+
+function Coordinate pickCoordinateRoundRobin(List values, Map cursor, String key) {
+    if (values == null || values.isEmpty()) {
+        return null;
+    }
+    Integer idxObj = (Integer) cursor.get(key);
+    int idx = idxObj == null ? 0 : idxObj.intValue();
+    Coordinate value = (Coordinate) values.get(idx % values.size());
+    cursor.put(key, idx + 1);
+    return value;
+}
+
+function Coordinate cloneCoordinateWithHeight(Coordinate source, int height) {
+    if (source == null) {
+        return null;
+    }
+    Coordinate c = new Coordinate();
+    c.setLongitude(source.getLongitude());
+    c.setLatitude(source.getLatitude());
+    c.setHeight(height);
+    return c;
+}
+
+function Map extractBlueTargetPools(List blueWeapons) {
+    Map pools = new java.util.HashMap();
+    pools.put("air", new ArrayList());
+    pools.put("armor", new ArrayList());
+    pools.put("artillery", new ArrayList());
+    pools.put("ground", new ArrayList());
+    pools.put("missile", new ArrayList());
+    pools.put("all", new ArrayList());
+
+    for (Object obj : blueWeapons) {
+        Weapon blueWeapon = (Weapon) obj;
+        if (blueWeapon == null) {
+            continue;
+        }
+        String id = blueWeapon.getEquipmentId();
+        if (isBlank(id)) {
+            continue;
+        }
+        addUnique((List) pools.get("all"), id);
+        if (isAirWeapon(blueWeapon)) {
+            addUnique((List) pools.get("air"), id);
+        }
+        if (isArmorWeapon(blueWeapon)) {
+            addUnique((List) pools.get("armor"), id);
+        }
+        if (isArtilleryWeapon(blueWeapon)) {
+            addUnique((List) pools.get("artillery"), id);
+        }
+        if (isGroundWeapon(blueWeapon)) {
+            addUnique((List) pools.get("ground"), id);
+        }
+        if (hasMissileComponent(blueWeapon)) {
+            addUnique((List) pools.get("missile"), id);
+        }
+    }
+    return pools;
+}
+
+function String inferBluePoolKeyForRedWeapon(Weapon redWeapon) {
+    if (redWeapon == null || redWeapon.getName() == null) {
+        return "ground";
+    }
+    String name = redWeapon.getName();
+    if (name.contains("反坦克")) {
+        return "armor";
+    }
+    if (name.contains("防空导弹") || name.contains("无人机") || name.contains("直升机")) {
+        return "air";
+    }
+    if (name.contains("迫榴炮") || name.contains("迫击炮")) {
+        return "artillery";
+    }
+    if (name.contains("导弹发射车")) {
+        return "missile";
+    }
+    return "ground";
+}
+
+function String pickTargetIdFromPools(Map pools, Map cursor, String preferredKey) {
+    String fromPreferred = pickFromSinglePool(pools, cursor, preferredKey);
+    if (!isBlank(fromPreferred)) {
+        return fromPreferred;
+    }
+    if (!"ground".equals(preferredKey)) {
+        String fromGround = pickFromSinglePool(pools, cursor, "ground");
+        if (!isBlank(fromGround)) {
+            return fromGround;
+        }
+    }
+    return pickFromSinglePool(pools, cursor, "all");
+}
+
+function String pickFromSinglePool(Map pools, Map cursor, String poolKey) {
+    if (pools == null || cursor == null || poolKey == null) {
+        return null;
+    }
+    List ids = (List) pools.get(poolKey);
+    if (ids == null || ids.isEmpty()) {
+        return null;
+    }
+    Integer idxObj = (Integer) cursor.get(poolKey);
+    int idx = idxObj == null ? 0 : idxObj.intValue();
+    String id = (String) ids.get(idx % ids.size());
+    cursor.put(poolKey, idx + 1);
+    return id;
+}
+
+function void addUnique(List values, String value) {
+    if (values == null || isBlank(value)) {
+        return;
+    }
+    if (!containsString(values, value)) {
+        values.add(value);
+    }
+}
+
+function boolean isBlank(String text) {
+    return text == null || text.trim().equals("");
+}
+
 function void assignTaskNameByRedWeapons(FactTask fact, Map cfg) {
     if (fact == null || fact.getRedTask() == null) {
         return;
@@ -809,6 +1512,21 @@ function boolean readBooleanCfg(Map cfg, String key, boolean fallback) {
     return "true".equalsIgnoreCase(text.trim());
 }
 
+function double readDoubleCfg(Map cfg, String key, double fallback) {
+    if (cfg == null || key == null) {
+        return fallback;
+    }
+    Object value = cfg.get(key);
+    if (value == null) {
+        return fallback;
+    }
+    try {
+        return Double.parseDouble(String.valueOf(value).trim());
+    } catch (Exception ex) {
+        return fallback;
+    }
+}
+
 function boolean isRedAirWeapon(Weapon weapon) {
     if (weapon == null) {
         return false;