zouju/auto-solution
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge branch 'refs/heads/develop'

Browse Source 
# Conflicts:
#	auto-solution-rule/src/main/java/com/solution/rule/service/FireRuleService.java
#	modeler/src/style.less
This commit is contained in:
MHW
2026-03-27 17:56:55 +08:00
parent 76022cf09a d8719c30c6
commit 3b3370c440
54 changed files with 24294 additions and 213 deletions
Download Patch File Download Diff File Expand all files Collapse all files

47
auto-solution-rule/pom.xml
View File

@@ -16,8 +16,55 @@
rule模块
</description>
<properties>
<!-- Drools 版本，建议使用稳定版，如 7.74.1.Final 或 8.x 系列 -->
<drools.version>7.74.1.Final</drools.version>
</properties>
<dependencies>
<!-- 1. Drools 核心引擎 -->
<dependency>
<groupId>org.drools</groupId>
<artifactId>drools-core</artifactId>
<version>${drools.version}</version>
</dependency>
<dependency>
<groupId>org.drools</groupId>
<artifactId>drools-templates</artifactId>
<version>${drools.version}</version>
</dependency>
<!-- 2. KIE API（Drools 属于 KIE 项目的一部分，此依赖提供核心 API） -->
<dependency>
<groupId>org.kie</groupId>
<artifactId>kie-api</artifactId>
<version>${drools.version}</version>
</dependency>
<!-- 3. 规则编译器（用于编译 .drl 等规则文件） -->
<dependency>
<groupId>org.drools</groupId>
<artifactId>drools-compiler</artifactId>
<version>${drools.version}</version>
</dependency>
<!-- 4. Spring 整合（如果需要和 Spring/Spring Boot 深度整合） -->
<dependency>
<groupId>org.kie</groupId>
<artifactId>kie-spring</artifactId>
<version>${drools.version}</version>
</dependency>
<!-- 流式解析工具-->
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-databind</artifactId>
<version>2.15.2</version>
</dependency>
<!-- 通用工具-->
<dependency>
<groupId>com.solution</groupId>

91
auto-solution-rule/src/main/java/com/solution/rule/config/DroolsConfig.java Normal file
View File

@@ -0,0 +1,91 @@
package com.solution.rule.config;
import org.kie.api.KieBase;
import org.kie.api.KieServices;
import org.kie.api.builder.KieBuilder;
import org.kie.api.builder.KieFileSystem;
import org.kie.api.builder.KieRepository;
import org.kie.api.builder.Message;
import org.kie.api.runtime.KieContainer;
import org.kie.api.runtime.KieSession;
import org.kie.internal.io.ResourceFactory;
import org.kie.spring.KModuleBeanFactoryPostProcessor;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.io.Resource;
import org.springframework.core.io.support.PathMatchingResourcePatternResolver;
import org.springframework.core.io.support.ResourcePatternResolver;
import java.io.IOException;
@Configuration
public class DroolsConfig {
private static final String RULE_PATH = "classpath*:rules/**/*.drl";
private final KieServices kieServices = KieServices.Factory.get();
/**
* 加载规则文件
*/
@Bean
public KieFileSystem kieFileSystem() throws IOException {
KieFileSystem kieFileSystem = kieServices.newKieFileSystem();
ResourcePatternResolver resolver = new PathMatchingResourcePatternResolver();
Resource[] resources = resolver.getResources(RULE_PATH);
for (Resource resource : resources) {
kieFileSystem.write(
ResourceFactory.newInputStreamResource(resource.getInputStream())
.setSourcePath("rules/" + resource.getFilename())
);
}
return kieFileSystem;
}
/**
* 构建 KieContainer
*/
@Bean
public KieContainer kieContainer(KieFileSystem kieFileSystem) {
KieBuilder kieBuilder = kieServices.newKieBuilder(kieFileSystem);
kieBuilder.buildAll();
// 检查错误
if (kieBuilder.getResults().hasMessages(Message.Level.ERROR)) {
throw new RuntimeException("Drools规则编译错误：\n" +
kieBuilder.getResults().toString());
}
KieRepository repository = kieServices.getRepository();
return kieServices.newKieContainer(repository.getDefaultReleaseId());
}
/**
* KieBase
*/
@Bean
public KieBase kieBase(KieContainer kieContainer) {
return kieContainer.getKieBase();
}
/**
* KieSession（推荐加）
*/
@Bean
public KieSession kieSession(KieContainer kieContainer) {
return kieContainer.newKieSession();
}
/**
* 必须是 static
*/
@Bean
public static KModuleBeanFactoryPostProcessor kiePostProcessor() {
return new KModuleBeanFactoryPostProcessor();
}
}

5
auto-solution-rule/src/main/java/com/solution/rule/domain/PlatformComponent.java
View File

@@ -4,6 +4,8 @@ import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import java.util.List;
/**
* 平台挂载的组件实体类
* 对应表 platform_component
@@ -29,4 +31,7 @@ public class PlatformComponent {
@ApiModelProperty(value = "组件数量")
private Long num;
@ApiModelProperty(value = "平台参数（List<String>）")
private List<String> platformParams;
}

18
auto-solution-rule/src/main/java/com/solution/rule/domain/dto/ComponentJsonDTO.java Normal file
View File

@@ -0,0 +1,18 @@
package com.solution.rule.domain.dto;
import lombok.Data;
import java.util.List;
@Data
public class ComponentJsonDTO {
//组件类型
private String type;
//组件名称
private String name;
//组件参数列表
private List<PlatformJsonDTO> parameters;
}

18
auto-solution-rule/src/main/java/com/solution/rule/domain/dto/ComponentParamJsonDTO.java Normal file
View File

@@ -0,0 +1,18 @@
package com.solution.rule.domain.dto;
import lombok.Data;
@Data
public class ComponentParamJsonDTO {
// 参数名称
private String name;
private String def;
// 参数值
private String value;
// 参数单位
private String unit;
}

21
auto-solution-rule/src/main/java/com/solution/rule/domain/dto/PlatformJsonDTO.java Normal file
View File

@@ -0,0 +1,21 @@
package com.solution.rule.domain.dto;
import lombok.Data;
import java.util.List;
@Data
public class PlatformJsonDTO {
// 装备ID
private String id;
// 装备名称
private String name;
// 平台类型 (Platform_type)
private String type;
// 子组件列表（武器、传感器、通信等）
private List<ComponentJsonDTO> components;
}

22
auto-solution-rule/src/main/java/com/solution/rule/domain/dto/RequestDTO.java
View File

@@ -1,22 +0,0 @@
package com.solution.rule.domain.dto;
import lombok.Data;
/**
* 规则请求参数
*/
@Data
public class RequestDTO {
//编队数量
private Long formationNum;
//武装直升机数量
private Long gunshipNum;
//无人机数量
private Long droneNum;
//单兵武器数量
private Long singleWeaponNum;
}

25
auto-solution-rule/src/main/java/com/solution/rule/domain/dto/TaskJsonDTO.java Normal file
View File

@@ -0,0 +1,25 @@
package com.solution.rule.domain.dto;
import lombok.Data;
import javax.sound.midi.Track;
import java.util.List;
@Data
public class TaskJsonDTO {
//任务id
private Long attackId;
//任务名称
private String name;
//任务类型
private String dataType;
//任务下的平台
private List<PlatformJsonDTO> platforms;
//任务轨迹
private List<Track> tracks;
}

18
auto-solution-rule/src/main/java/com/solution/rule/domain/dto/TrackJsonDTO.java Normal file
View File

@@ -0,0 +1,18 @@
package com.solution.rule.domain.dto;
import lombok.Data;
import java.util.List;
@Data
public class TrackJsonDTO {
// 轨迹ID
private String id;
// 轨迹名称
private String name;
// 轨迹点列表
private List<TrackPointJsonDTO> points;
}

25
auto-solution-rule/src/main/java/com/solution/rule/domain/dto/TrackPointJsonDTO.java Normal file
View File

@@ -0,0 +1,25 @@
package com.solution.rule.domain.dto;
public class TrackPointJsonDTO {
// 轨迹点索引
private int index;
// 经度
private double longitude;
// 纬度
private double latitude;
// 高度（米）
private double height;
// 速度（米/秒）
private double speed;
// 航向角（度）
private double heading;
// 时间点（秒）
private double time;
}

3
auto-solution-rule/src/main/java/com/solution/rule/domain/dto/WeaponModelDTO.java
View File

@@ -20,4 +20,7 @@ public class WeaponModelDTO {
@ApiModelProperty("平台组件")
private List<PlatformComponent> components;
@ApiModelProperty("平台参数（List<String>）")
private List<String> platformParams;
}

52
auto-solution-rule/src/main/java/com/solution/rule/domain/request/Attribute.java Normal file
View File

@@ -0,0 +1,52 @@
package com.solution.rule.domain.request;
import com.fasterxml.jackson.annotation.JsonProperty;
import com.solution.common.utils.sign.Md5Utils;
import lombok.Data;
import java.util.List;
/**
* 单个属性的定义
*/
@Data
public class Attribute {
//uuid
@JsonProperty("_uuid")
private String uuid;
/** 属性数据类型（如：float、int、string、bool、enum） */
private String attDataType;
/** 属性定义（英文标识） */
private String attDef;
/** 属性默认值 */
private String attDefaultValue;
/** 属性详细信息 */
private Object attDetail;
/** 属性说明（中文描述） */
private String attExplain;
/** 属性ID */
private String attId;
/** 属性名称（中文） */
private String attName;
/** 属性取值范围（格式：最小值|最大值） */
private String attRange;
/** 属性单位 */
private String attUnit;
/** 是否为内置属性 */
private boolean builtIn;
/** 枚举信息 */
private String enumInfo;
/** 是否为关键属性 */
private boolean isKey;
/** 是否为公共属性 */
private boolean isPublic;
/** 是否可搜索 */
private boolean isSearch;
/** 是否为文本域 */
private boolean isTextarea;
/** 模型信息（可以是对象或数组，此处定义为具体对象） */
private List<ModelInfo> mdlInfo;
/** 是否只读（0-可编辑，1-只读） */
private int readOnly;
}

18
auto-solution-rule/src/main/java/com/solution/rule/domain/request/DictItem.java Normal file
View File

@@ -0,0 +1,18 @@
package com.solution.rule.domain.request;
import lombok.Data;
/**
* 字典项实体
*/
@Data
public class DictItem {
/** 编码 */
private String code;
/** 说明 */
private String explain;
/** 名称 */
private String name;
/** 唯一标识符 */
private String uuid;
}

10
auto-solution-rule/src/main/java/com/solution/rule/domain/request/Equipments.java Normal file
View File

@@ -0,0 +1,10 @@
package com.solution.rule.domain.request;
import lombok.Data;
@Data
public class Equipments {
}

16
auto-solution-rule/src/main/java/com/solution/rule/domain/request/Force.java Normal file
View File

@@ -0,0 +1,16 @@
package com.solution.rule.domain.request;
import lombok.Data;
@Data
public class Force {
//对象句柄
private String ObjectHandle;
//类型
private Integer type;
}

26
auto-solution-rule/src/main/java/com/solution/rule/domain/request/ForceSides.java Normal file
View File

@@ -0,0 +1,26 @@
package com.solution.rule.domain.request;
import lombok.Data;
import java.util.List;
/**
* 阵营实体
*/
@Data
public class ForceSides {
//分组类型
private String groupType;
private List<Force> postures;
//对象句柄
private String ObjectHandle;
//阵营名称
private String ForceSideName;
//作战目标
private String warGoal;
}

35
auto-solution-rule/src/main/java/com/solution/rule/domain/request/ModelInfo.java Normal file
View File

@@ -0,0 +1,35 @@
package com.solution.rule.domain.request;
import com.fasterxml.jackson.annotation.JsonProperty;
import lombok.Data;
import java.util.List;
/**
* 模型信息实体
*/
@Data
public class ModelInfo {
/** 模型ID */
@JsonProperty("_id")
private String id;
/** 类别 */
private String category;
/** 分类ID */
private String classifyId;
/** 分类名称 */
private String classifyName;
/** 创建时间（时间戳） */
private long createTime;
/** 字典项列表 */
private List<DictItem> dict;
/** 模型系统ID */
private int mxSysId;
/** 名称 */
private String name;
/** 角色ID */
private int roleId;
/** 空间ID */
private int spaceId;
/** 更新时间（时间戳） */
private long updateTime;
}

20
auto-solution-rule/src/main/java/com/solution/rule/domain/request/RefAttributeObject.java Normal file
View File

@@ -0,0 +1,20 @@
package com.solution.rule.domain.request;
import lombok.Data;
import java.util.List;
import java.util.Map;
/**
* 引用属性对象
*/
@Data
public class RefAttributeObject {
//属性列表
private Map<String, List<Attribute>> attributes;
private TrackParam trackParam;
}

23
auto-solution-rule/src/main/java/com/solution/rule/domain/request/RequestDTO.java Normal file
View File

@@ -0,0 +1,23 @@
package com.solution.rule.domain.request;
import lombok.Data;
import java.util.List;
/**
* 接收智唐接口实体
*/
@Data
public class RequestDTO {
//引用属性对象（设备属性定义）
private RefAttributeObject refAttributeObject;
//阵营列表
private List<ForceSides> forceSides;
//装备列表
private List<Equipments> equipments;
//private List<Tasks> tasks;
}

26
auto-solution-rule/src/main/java/com/solution/rule/domain/request/Track.java Normal file
View File

@@ -0,0 +1,26 @@
package com.solution.rule.domain.request;
import lombok.Data;
import java.util.List;
@Data
public class Track {
//航迹名称
private String name;
//航迹开始时间
private int StartTime;
//航迹结束时间
private int EndTime;
//航迹类型
private String TrackType;
//航迹高度类型
private String HeightType;
//航迹海面类型
private String seaType;
//航迹点集合
private List<TrackPoint> TrackPoints;
//航迹所属阵营
private String Color;
//航迹总点数
private int PointCount;
}

13
auto-solution-rule/src/main/java/com/solution/rule/domain/request/TrackParam.java Normal file
View File

@@ -0,0 +1,13 @@
package com.solution.rule.domain.request;
import javax.sound.midi.Track;
import java.util.List;
import java.util.Map;
/**
* 航迹参数
*/
public class TrackParam {
private Map<String, List<Track>> tracks;
}

26
auto-solution-rule/src/main/java/com/solution/rule/domain/request/TrackPoint.java Normal file
View File

@@ -0,0 +1,26 @@
package com.solution.rule.domain.request;
import lombok.Data;
/**
* 航迹节点实体
*/
@Data
public class TrackPoint {
//航迹索引
private String index;
//经度
private String longitude;
//纬度
private String latitude;
//高度
private String height;
//航速
private String speed;
//航向角
private String psia;
//时间
private String time;
//活动
private String active;
}

19
auto-solution-rule/src/main/java/com/solution/rule/domain/simplerulepojo/ComponentParam.java Normal file
View File

@@ -0,0 +1,19 @@
package com.solution.rule.domain.simplerulepojo;
import lombok.Data;
@Data
public class ComponentParam {
//唯一标识符
private String uuid;
//组件默认参数
private String attDefaultValue;
//参数单位
private String attExplain;
//组件数量
private Integer number;
}

18
auto-solution-rule/src/main/java/com/solution/rule/domain/simplerulepojo/Coordinate.java Normal file
View File

@@ -0,0 +1,18 @@
package com.solution.rule.domain.simplerulepojo;
import lombok.Data;
import java.math.BigDecimal;
@Data
public class Coordinate {
//经度
private BigDecimal longitude;
//纬度
private BigDecimal latitude;
//高度
private Integer height;
}

19
auto-solution-rule/src/main/java/com/solution/rule/domain/simplerulepojo/SubComponents.java Normal file
View File

@@ -0,0 +1,19 @@
package com.solution.rule.domain.simplerulepojo;
import lombok.Data;
import java.util.List;
@Data
public class SubComponents {
//设备id
private String deviceId;
//设备名称
private String deviceName;
//设备组件参数
private List<ComponentParam> componentParams;
}

42
auto-solution-rule/src/main/java/com/solution/rule/domain/simplerulepojo/Task.java Normal file
View File

@@ -0,0 +1,42 @@
package com.solution.rule.domain.simplerulepojo;
import lombok.Data;
import java.util.List;
/**
* 简单任务实体
*/
@Data
public class Task {
//任务id
private String id;
//任务名称
private String drawName;
//任务类型
private String dataType;
//任务所属阵营
private String side;
//任务威胁等级(1-3)
private String threatLevel;
//任务航迹
private List<TrackPoints> trackPoints;
//任务武器
private List<Weapon> taskWeapons;
//任务目标id
private String targetId;
//作战区经纬高
private List<Coordinate> warZoneLocation;
//防区经纬高
private List<Coordinate> defZoneLocation;
}

24
auto-solution-rule/src/main/java/com/solution/rule/domain/simplerulepojo/TrackPoints.java Normal file
View File

@@ -0,0 +1,24 @@
package com.solution.rule.domain.simplerulepojo;
import lombok.Data;
import java.math.BigDecimal;
@Data
public class TrackPoints extends Coordinate{
// 轨迹索引
private Integer index;
// // 轨迹点经度
// private BigDecimal longitude;
//
// // 轨迹点纬度
// private BigDecimal latitude;
//
// // 轨迹点高度
// private Integer height;
//速度
private Integer speed;
}

30
auto-solution-rule/src/main/java/com/solution/rule/domain/simplerulepojo/Weapon.java Normal file
View File

@@ -0,0 +1,30 @@
package com.solution.rule.domain.simplerulepojo;
import lombok.Data;
import java.util.List;
@Data
public class Weapon {
//装备id
private String equipmentId;
//装备名称
private String name;
//装备类型
private String supportType;
//装备组件
private List<SubComponents> components;
//装备部署位置(经纬高)
private Coordinate coordinate;
//武器数量
private Integer number;
//目标id
private String targetId;
}

12
auto-solution-rule/src/main/java/com/solution/rule/domain/simplerulepojo/fact/FactTask.java Normal file
View File

@@ -0,0 +1,12 @@
package com.solution.rule.domain.simplerulepojo.fact;
import com.solution.rule.domain.simplerulepojo.Task;
import lombok.Data;
@Data
public class FactTask {
private Task blueTask;
private Task redTask;
}

13
auto-solution-rule/src/main/java/com/solution/rule/handler/WarplaneHandler.java
View File

@@ -7,10 +7,12 @@ import com.solution.common.constant.PlatformAndModuleConstants;
import com.solution.rule.domain.PlatformComponent;
import com.solution.rule.domain.RuleParam;
import com.solution.rule.domain.dto.WeaponModelDTO;
import com.solution.rule.handler.opponent.OpponentParamChain;
import com.solution.rule.domain.vo.ComponentCountVO;
import com.solution.rule.domain.vo.PlatformWeaponAggregateVO;
import org.springframework.stereotype.Component;
import javax.annotation.Resource;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
@@ -26,6 +28,9 @@ public class WarplaneHandler extends AbstractRuleChainHandler {
// 组件数量增量常量
private static final long COMPONENT_COUNT_INCREMENT = 1;
@Resource
private OpponentParamChain opponentParamChain;
@Override
public RuleParam doHandler(RuleParam ruleParam) {
// 1. 参数校验
@@ -38,8 +43,6 @@ public class WarplaneHandler extends AbstractRuleChainHandler {
List<PlatformWeaponAggregateVO> resultWeapons = new ArrayList<>();
//TODO获取所有组件以及count
Iterator<WeaponModelDTO> iterator = dtoList.iterator();
while (iterator.hasNext()) {
WeaponModelDTO dto = iterator.next();
@@ -54,12 +57,16 @@ public class WarplaneHandler extends AbstractRuleChainHandler {
if(component.getName().equals(databaseWeapon.getComponentName())){
PlatformComponent component1 = new PlatformComponent();
component1.setName(databaseWeapon.getComponentName());
// TODO
component1.setPlatformParams(CollUtil.isNotEmpty(component.getPlatformParams())
? component.getPlatformParams()
: dto.getPlatformParams());
opponentParamChain.apply(ruleParam, dto, componentList);
if(databaseWeapon.getCount() > component.getNum()){
component1.setNum(component.getNum() + COMPONENT_COUNT_INCREMENT);
}else {
component1.setNum(databaseWeapon.getCount());
}
//TODO 补充基本信息 暂未完成
componentList.add(component1);
}
}

18
auto-solution-rule/src/main/java/com/solution/rule/handler/opponent/AbstractOpponentParamHandler.java Normal file
View File

@@ -0,0 +1,18 @@
package com.solution.rule.handler.opponent;
public abstract class AbstractOpponentParamHandler {
private AbstractOpponentParamHandler next;
public abstract void handle(OpponentParamContext context);
protected void doNext(OpponentParamContext context) {
if (next == null) return;
next.handle(context);
}
public void setNext(AbstractOpponentParamHandler next) {
this.next = next;
}
}

24
auto-solution-rule/src/main/java/com/solution/rule/handler/opponent/Ammo20Handler.java Normal file
View File

@@ -0,0 +1,24 @@
package com.solution.rule.handler.opponent;
import com.solution.rule.domain.PlatformComponent;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;
@Component
@Order(2)
public class Ammo20Handler extends AbstractOpponentParamHandler {
@Override
public void handle(OpponentParamContext context) {
Long ammo = context.getParamLong("ammo");
if (ammo != null && ammo <= 20) {
PlatformComponent reaction = new PlatformComponent();
reaction.setType("weapon");
reaction.setName("reaction_ammo_le_20");
reaction.setNum(1L);
context.addReactionComponent(reaction);
}
doNext(context);
}
}

24
auto-solution-rule/src/main/java/com/solution/rule/handler/opponent/Distance50Handler.java Normal file
View File

@@ -0,0 +1,24 @@
package com.solution.rule.handler.opponent;
import com.solution.rule.domain.PlatformComponent;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;
@Component
@Order(3)
public class Distance50Handler extends AbstractOpponentParamHandler {
@Override
public void handle(OpponentParamContext context) {
Long distance = context.getParamLong("distance");
if (distance != null && distance <= 50) {
PlatformComponent reaction = new PlatformComponent();
reaction.setType("weapon");
reaction.setName("reaction_distance_le_50");
reaction.setNum(1L);
context.addReactionComponent(reaction);
}
doNext(context);
}
}

21
auto-solution-rule/src/main/java/com/solution/rule/handler/opponent/FallbackHandler.java Normal file
View File

@@ -0,0 +1,21 @@
package com.solution.rule.handler.opponent;
import com.solution.rule.domain.PlatformComponent;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;
@Component
@Order(4)
public class FallbackHandler extends AbstractOpponentParamHandler {
@Override
public void handle(OpponentParamContext context) {
PlatformComponent reaction = new PlatformComponent();
reaction.setType("weapon");
reaction.setName("reaction_default");
reaction.setNum(0L);
context.addReactionComponent(reaction);
doNext(context);
}
}

40
auto-solution-rule/src/main/java/com/solution/rule/handler/opponent/OpponentParamChain.java Normal file
View File

@@ -0,0 +1,40 @@
package com.solution.rule.handler.opponent;
import cn.hutool.core.collection.CollUtil;
import com.solution.rule.domain.PlatformComponent;
import com.solution.rule.domain.RuleParam;
import com.solution.rule.domain.dto.WeaponModelDTO;
import org.springframework.stereotype.Component;
import javax.annotation.PostConstruct;
import javax.annotation.Resource;
import java.util.List;
@Component
public class OpponentParamChain {
@Resource
private List<AbstractOpponentParamHandler> handlers;
private AbstractOpponentParamHandler first;
@PostConstruct
private void construct() {
if (CollUtil.isEmpty(handlers)) {
return;
}
this.first = handlers.get(0);
for (int i = 0; i < handlers.size(); i++) {
AbstractOpponentParamHandler current = handlers.get(i);
AbstractOpponentParamHandler next = (i == handlers.size() - 1) ? null : handlers.get(i + 1);
current.setNext(next);
}
}
public void apply(RuleParam ruleParam, WeaponModelDTO dto, List<PlatformComponent> resultComponents) {
if (first == null) return;
OpponentParamContext context = new OpponentParamContext(ruleParam, dto, resultComponents);
first.handle(context);
}
}

88
auto-solution-rule/src/main/java/com/solution/rule/handler/opponent/OpponentParamContext.java Normal file
View File

@@ -0,0 +1,88 @@
package com.solution.rule.handler.opponent;
import com.solution.rule.domain.PlatformComponent;
import com.solution.rule.domain.RuleParam;
import com.solution.rule.domain.dto.WeaponModelDTO;
import lombok.Getter;
import java.util.HashMap;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
@Getter
public class OpponentParamContext {
private static final Pattern NUMBER_PATTERN = Pattern.compile("(\\d+(?:\\.\\d+)?)");
private final RuleParam ruleParam;
private final WeaponModelDTO weaponModelDTO;
private final List<PlatformComponent> resultComponents;
private final Map<String, String> paramMap;
public OpponentParamContext(RuleParam ruleParam, WeaponModelDTO weaponModelDTO, List<PlatformComponent> resultComponents) {
this.ruleParam = ruleParam;
this.weaponModelDTO = weaponModelDTO;
this.resultComponents = resultComponents;
this.paramMap = parseParams(weaponModelDTO);
}
public String getParamRaw(String key) {
if (key == null) return null;
return paramMap.get(key.toLowerCase(Locale.ROOT));
}
public Long getParamLong(String key) {
String raw = getParamRaw(key);
if (raw == null) return null;
Matcher m = NUMBER_PATTERN.matcher(raw);
if (!m.find()) return null;
try {
return (long) Double.parseDouble(m.group(1));
} catch (Exception e) {
return null;
}
}
public void addReactionComponent(PlatformComponent component) {
if (component == null || component.getName() == null) return;
for (PlatformComponent existing : resultComponents) {
if (component.getName().equals(existing.getName())) {
return;
}
}
resultComponents.add(component);
}
private static Map<String, String> parseParams(WeaponModelDTO dto) {
Map<String, String> map = new HashMap<>();
if (dto == null || dto.getPlatformParams() == null) return map;
for (String item : dto.getPlatformParams()) {
if (item == null) continue;
String s = item.trim();
if (s.isEmpty()) continue;
String[] parts;
if (s.contains("=")) {
parts = s.split("=", 2);
} else if (s.contains(":")) {
parts = s.split(":", 2);
} else if (s.contains("：")) {
parts = s.split("：", 2);
} else {
continue;
}
if (parts.length != 2) continue;
String key = parts[0].trim().toLowerCase(Locale.ROOT);
String val = parts[1].trim();
if (!key.isEmpty() && !val.isEmpty()) {
map.put(key, val);
}
}
return map;
}
}

123
auto-solution-rule/src/main/java/com/solution/rule/handler/opponent/README.md Normal file
View File

@@ -0,0 +1,123 @@
## opponent（对方参数嵌套责任链）说明
本目录新增了一套**“嵌套责任链”**，用于在已有规则链（`AbstractRuleChainHandler` / `RuleChainHandler`）执行过程中，再额外对“对方传入的平台参数”做二次判断，并把**我方的反应**写入到 `RuleParam.resultWeapons` 对应平台的 `components` 中。
> 你原本已经在用“规则链”处理 `RuleParam`；这里是在 `WarplaneHandler` 内部再次调用一条新的链，因此属于 **责任链嵌套责任链**。
---
### 1. 改动点概览（这个目录配套的改动）
- **`WeaponModelDTO` 增加字段**
- `platformParams: List<String>`
- 用于接收平台维度的参数列表（例如对方速度、弹量、距离等）。
- **`PlatformComponent` 增加字段**
- `platformParams: List<String>`
- 用于在“组件维度”也能承载同样的参数（如果你希望参数挂在组件上）。
- **`WarplaneHandler`（第55行 `// TODO` 下方）接入嵌套链**
- 将平台参数透传到结果组件 `component1.platformParams`
- 优先取 `component.platformParams`
- 若组件没传，则取 `dto.platformParams`
- 调用 `OpponentParamChain.apply(ruleParam, dto, componentList)`：
- 读取 `dto.platformParams` 中的对方参数
- 按责任链规则生成“反应组件”
- 把反应组件加入当前平台的 `componentList`（最终进入 `RuleParam.resultWeapons`）
---
### 2. 对方参数的传参格式约定
目前解析逻辑位于 `OpponentParamContext`，支持以下分隔符：
- `key=value`
- `key:value`
- `key：value`（中文冒号）
并会从 `value` 中提取**第一个数字**作为判断依据（例如 `200km` 会提取为 `200`）。
建议前端/调用方传参示例：
```text
["speed=200km", "ammo=20", "distance=50km"]
```
目前内置识别的 key：
- `speed`：速度
- `ammo`：弹量
- `distance`：距离
---
### 3. 目录结构与职责（类说明）
- **`OpponentParamChain`**
- 责任链的“组装与入口”。
- Spring `@Component` + `@PostConstruct`：自动获取容器中的 `AbstractOpponentParamHandler` 实现列表并按顺序串起来。
- `apply(ruleParam, dto, resultComponents)`：对外入口，创建上下文并触发链路执行。
- **`AbstractOpponentParamHandler`**
- 对方参数链的抽象 Handler。
- 只负责：
- `handle(context)`：当前节点处理
- `doNext(context)`：传递到下一个节点
- **`OpponentParamContext`**
- 链路执行上下文（把链执行需要的对象集中起来）：
- `RuleParam ruleParam`：当前规则执行参数
- `WeaponModelDTO weaponModelDTO`：当前处理的平台 DTO（承载 `platformParams`）
- `List<PlatformComponent> resultComponents`：本平台最终要返回的组件列表（也就是要写入 `resultWeapons` 的列表）
- 关键能力：
- `getParamLong(key)`：从 `platformParams` 中按 key 取值并解析出数字
- `addReactionComponent(component)`：把“反应组件”加入 `resultComponents`（按 name 做简单去重，避免循环里重复加入）
---
### 4. 当前内置的 4 个链节点（最少四个）
这 4 个节点都实现了 `AbstractOpponentParamHandler`，并通过 `@Order` 控制执行顺序：
- **`Speed200Handler`（@Order(1)）**
- 条件：`speed >= 200`
- 反应：加入组件
- `name = reaction_speed_ge_200`
- `type = weapon`
- `num = 1`
- **`Ammo20Handler`（@Order(2)）**
- 条件：`ammo <= 20`
- 反应：加入组件
- `name = reaction_ammo_le_20`
- `type = weapon`
- `num = 1`
- **`Distance50Handler`（@Order(3)）**
- 条件：`distance <= 50`
- 反应：加入组件
- `name = reaction_distance_le_50`
- `type = weapon`
- `num = 1`
- **`FallbackHandler`（@Order(4)）**
- 兜底：无论是否命中其它规则，都加入一个默认反应（便于你观察链是否运行）
- 反应：加入组件
- `name = reaction_default`
- `type = weapon`
- `num = 0`
> 注意：这些“反应组件”目前只是用 `PlatformComponent` 承载并加入到返回的 `components` 列表中，保证**一定能落到 `RuleParam.resultWeapons`**。
---
### 5. 如何扩展新规则（你后续要加更多链节点时）
按照下面步骤即可：
1. 在本目录新增一个类，继承 `AbstractOpponentParamHandler`
2. 加上 `@Component` 与 `@Order(n)`（n 决定执行顺序）
3. 在 `handle` 中从 `context.getParamLong("xxx")` 取值判断
4. 组装一个 `PlatformComponent` 作为“反应”，调用 `context.addReactionComponent(...)`
5. 最后 `doNext(context)` 传递到下一节点

24
auto-solution-rule/src/main/java/com/solution/rule/handler/opponent/Speed200Handler.java Normal file
View File

@@ -0,0 +1,24 @@
package com.solution.rule.handler.opponent;
import com.solution.rule.domain.PlatformComponent;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;
@Component
@Order(1)
public class Speed200Handler extends AbstractOpponentParamHandler {
@Override
public void handle(OpponentParamContext context) {
Long speed = context.getParamLong("speed");
if (speed != null && speed >= 200) {
PlatformComponent reaction = new PlatformComponent();
reaction.setType("weapon");
reaction.setName("reaction_speed_ge_200");
reaction.setNum(1L);
context.addReactionComponent(reaction);
}
doNext(context);
}
}

120
auto-solution-rule/src/main/java/com/solution/rule/parser/JsonStreamParser.java Normal file
View File

@@ -0,0 +1,120 @@
//package com.solution.rule.parser;
//
//import com.fasterxml.jackson.core.JsonParser;
//import com.fasterxml.jackson.core.JsonToken;
//import com.fasterxml.jackson.databind.ObjectMapper;
//import javax.servlet.http.HttpServletRequest;
//import java.io.IOException;
//import java.util.*;
//
//public class JsonStreamParser {
//
// // 核心：解析所有集合 → 内存关联ID → 组装完整数据
// public List<AssembledWeapon> parseAndAssemble(HttpServletRequest request) throws IOException {
// ObjectMapper mapper = new ObjectMapper();
// try (JsonParser parser = mapper.getFactory().createParser(request.getInputStream())) {
//
// // ========== 步骤1：流式解析，把所有关联集合存到内存 ==========
// String version = null;
// // 存储所有集合：key=集合名(weaponList/weaponParams)，value=数据列表
// Map<String, List<Map<String, Object>>> allCollections = new HashMap<>();
//
// // 解析状态
// String currentCollection = null;
// Map<String, Object> currentItem = null;
//
// JsonToken token;
// while ((token = parser.nextToken()) != null) {
// switch (token) {
// case START_OBJECT:
// if (currentCollection != null) currentItem = new HashMap<>();
// break;
// case END_OBJECT:
// if (currentCollection != null && currentItem != null) {
// allCollections.get(currentCollection).add(currentItem);
// currentItem = null;
// }
// break;
// case START_ARRAY:
// currentCollection = parser.getCurrentName();
// allCollections.putIfAbsent(currentCollection, new ArrayList<>());
// break;
// case END_ARRAY:
// currentCollection = null;
// break;
// case FIELD_NAME:
// String field = parser.getCurrentName();
// // 解析版本号
// if ("version".equals(field) && isInMeta(parser)) {
// version = parser.nextTextValue();
// break;
// }
// // 解析普通字段
// if (currentItem != null) {
// parser.nextToken();
// currentItem.put(field, getValue(parser));
// }
// break;
// }
// }
//
// // ========== 步骤2：核心！通过ID关联匹配，组装完整数据 ==========
// return assembleFullWeaponData(allCollections);
// }
// }
//
// /**
// * 【核心逻辑】ID关联匹配：武器列表 + 参数列表 → 完整武器
// */
// private List<AssembledWeapon> assembleFullWeaponData(Map<String, List<Map<String, Object>>> allCollections) {
// List<AssembledWeapon> result = new ArrayList<>();
//
// // 1. 获取武器主列表
// List<Map<String, Object>> weaponList = allCollections.getOrDefault("weaponList", Collections.emptyList());
// // 2. 获取武器参数列表
// List<Map<String, Object>> paramList = allCollections.getOrDefault("weaponParams", Collections.emptyList());
//
// // 3. 构建【ID -> 参数】索引Map（O(1)快速匹配，效率最高）
// Map<Long, Map<String, Object>> paramIndex = new HashMap<>();
// for (Map<String, Object> param : paramList) {
// Long weaponId = Long.valueOf(param.get("weaponId").toString());
// paramIndex.put(weaponId, param);
// }
//
// // 4. 遍历武器，通过ID匹配参数，组装完整对象
// for (Map<String, Object> weapon : weaponList) {
// AssembledWeapon fullWeapon = new AssembledWeapon();
// Long weaponId = Long.valueOf(weapon.get("id").toString());
//
// // 填充基础信息
// fullWeapon.setId(weaponId);
// fullWeapon.setName((String) weapon.get("name"));
//
// // 匹配参数（通过ID）
// Map<String, Object> param = paramIndex.get(weaponId);
// if (param != null) {
// fullWeapon.setDamage(Integer.valueOf(param.get("damage").toString()));
// fullWeapon.setMagazine(Integer.valueOf(param.get("magazine").toString()));
// fullWeapon.setType((String) param.get("type"));
// }
//
// result.add(fullWeapon);
// }
//
// return result;
// }
//
// // ---------------- 工具方法 ----------------
// private boolean isInMeta(JsonParser parser) {
// return parser.getParsingContext().getParent() != null
// && "meta".equals(parser.getParsingContext().getParent().getCurrentName());
// }
//
// private Object getValue(JsonParser parser) throws IOException {
// if (parser.getCurrentToken().isNumeric()) return parser.getLongValue();
// if (parser.getCurrentToken() == JsonToken.VALUE_STRING) return parser.getText();
// if (parser.getCurrentToken() == JsonToken.VALUE_TRUE) return true;
// if (parser.getCurrentToken() == JsonToken.VALUE_FALSE) return false;
// return null;
// }
//}

8
auto-solution-rule/src/main/java/com/solution/rule/service/FireRuleService.java
View File

@@ -1,7 +1,6 @@
package com.solution.rule.service;
import com.solution.rule.domain.FireRuleExecuteDTO;
import com.solution.rule.domain.Platform;
import com.solution.rule.domain.PlatformComponent;
import com.solution.rule.domain.vo.PlatformComponentNamesVO;
import com.solution.rule.domain.vo.PlatformWeaponAggregateVO;
@@ -45,4 +44,11 @@ public interface FireRuleService {
* @return
*/
List<Platform> findPlatformComponents(Integer scenarioId);
/**
* 开始执行规则匹配
* @param task
* @return
*/
Task executeTask(Task task);
}

34
auto-solution-rule/src/main/java/com/solution/rule/service/impl/FireRuleServiceImpl.java
View File

@@ -8,14 +8,20 @@ import com.solution.rule.domain.Platform;
import com.solution.rule.domain.PlatformComponent;
import com.solution.rule.domain.RuleParam;
import com.solution.rule.domain.dto.WeaponModelDTO;
import com.solution.rule.domain.simplerulepojo.Task;
import com.solution.rule.domain.simplerulepojo.Weapon;
import com.solution.rule.domain.vo.ComponentCountVO;
import com.solution.rule.domain.vo.PlatformComponentNamesVO;
import com.solution.rule.domain.vo.PlatformWeaponAggregateVO;
import com.solution.rule.domain.vo.WeaponModelVO;
import com.solution.rule.mapper.FireRuleMapper;
import com.solution.rule.service.FireRuleService;
import com.solution.rule.simpstrategy.FireRUleType;
import com.solution.rule.simpstrategy.FireRuleStrategy;
import com.solution.rule.simpstrategy.FireRuleStrategyFactory;
import com.solution.rule.strategy.SceneStrategy;
import com.solution.rule.strategy.SceneStrategyFactory;
import org.kie.api.KieBase;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
@@ -33,9 +39,15 @@ public class FireRuleServiceImpl implements FireRuleService {
@Autowired
private SceneStrategyFactory strategyFactory;
@Autowired
private FireRuleStrategyFactory fireStrategyFactory;
@Autowired
private FireRuleMapper ruleMapper;
@Autowired
private KieBase kieBase;
/* @Override
public WeaponModelVO execute(Integer sceneType, WeaponModelDTO weaponModelDTO) {
if(ObjectUtil.isNull(sceneType) || ObjectUtil.isEmpty(weaponModelDTO)){
@@ -155,6 +167,28 @@ public class FireRuleServiceImpl implements FireRuleService {
return ruleMapper.getComponents(platformId);
}
/**
* 执行任务
* @param task
* @return
*/
@Override
public Task executeTask(Task task) {
if(ObjectUtil.isEmpty(task)){
throw new RuntimeException(ExceptionConstants.PARAMETER_EXCEPTION);
}
String dataType = task.getDataType();
if("打击".contains(dataType)){
FireRuleStrategy strategy = fireStrategyFactory.getStrategy(0);
task = strategy.mappingTask(task);
} else {
FireRuleStrategy strategy = fireStrategyFactory.getStrategy(1);
task = strategy.mappingTask(task);
}
return task;
}
/**
* 获取所有组件以及数量
* @return

40
auto-solution-rule/src/main/java/com/solution/rule/simpstrategy/FireRUleType.java Normal file
View File

@@ -0,0 +1,40 @@
package com.solution.rule.simpstrategy;
import com.solution.rule.enums.SceneType;
public enum FireRUleType {
HIT(0, "打击"),
DISTURB(2, "干扰");
private final int code;
private final String description;
FireRUleType(int code, String description) {
this.code = code;
this.description = description;
}
public int getCode() {
return code;
}
public String getDescription() {
return description;
}
/**
* 根据数字编码获取对应的枚举
* @param code 前端传递的数字
* @return 枚举实例
* @throws IllegalArgumentException 如果找不到对应枚举
*/
public static FireRUleType fromCode(int code) {
for (FireRUleType type : values()) {
if (type.code == code) {
return type;
}
}
throw new IllegalArgumentException("未知的任务类型编码: " + code);
}
}

13
auto-solution-rule/src/main/java/com/solution/rule/simpstrategy/FireRuleStrategy.java Normal file
View File

@@ -0,0 +1,13 @@
package com.solution.rule.simpstrategy;
import com.solution.rule.domain.FireRuleExecuteDTO;
import com.solution.rule.domain.simplerulepojo.Task;
import com.solution.rule.enums.SceneType;
public interface FireRuleStrategy {
Task mappingTask(Task task);
FireRUleType getFireRuleType();
}

45
auto-solution-rule/src/main/java/com/solution/rule/simpstrategy/FireRuleStrategyFactory.java Normal file
View File

@@ -0,0 +1,45 @@
package com.solution.rule.simpstrategy;
import com.solution.rule.enums.SceneType;
import com.solution.rule.strategy.SceneStrategy;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import javax.annotation.PostConstruct;
import java.util.EnumMap;
import java.util.List;
import java.util.Map;
@Component
public class FireRuleStrategyFactory {
@Autowired
private List<FireRuleStrategy> strategyList;
private final Map<FireRUleType, FireRuleStrategy> strategyMap = new EnumMap<>(FireRUleType.class);
@PostConstruct
public void init() {
for (FireRuleStrategy strategy : strategyList) {
FireRUleType type = strategy.getFireRuleType();
if (strategyMap.containsKey(type)) {
throw new IllegalStateException("重复的场景类型: " + type);
}
strategyMap.put(type, strategy);
}
}
/**
* 根据前端传递的数字编码获取对应的策略
* @param code 前端传递的数字
* @return 策略实现
* @throws IllegalArgumentException 如果编码无效或策略未注册
*/
public FireRuleStrategy getStrategy(int code) {
FireRUleType type = FireRUleType.fromCode(code);
FireRuleStrategy strategy = strategyMap.get(type);
if (strategy == null) {
throw new IllegalArgumentException("未找到任务 " + code + " 对应的策略实现");
}
return strategy;
}
}

50
auto-solution-rule/src/main/java/com/solution/rule/simpstrategy/impl/BlowStrategy.java Normal file
View File

@@ -0,0 +1,50 @@
package com.solution.rule.simpstrategy.impl;
import com.solution.rule.domain.simplerulepojo.Task;
import com.solution.rule.domain.simplerulepojo.fact.FactTask;
import com.solution.rule.simpstrategy.FireRUleType;
import com.solution.rule.simpstrategy.FireRuleStrategy;
import org.kie.api.KieBase;
import org.kie.api.runtime.KieSession;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import java.util.HashMap;
import java.util.Map;
@Component
public class BlowStrategy implements FireRuleStrategy {
private static final String TASK_TYPE = "打击任务";
@Autowired
private KieBase kieBase;
@Override
public Task mappingTask(Task task) {
KieSession kieSession = kieBase.newKieSession();
FactTask factTask = new FactTask();
Task redTask = new Task();
redTask.setTargetId(task.getId());
redTask.setSide("红方");
Map<String, Object> globalParams = new HashMap<>();
kieSession.setGlobal("globalParams", globalParams);
factTask.setRedTask(redTask);
factTask.setBlueTask(task);
kieSession.insert(factTask);
// 👇 核心：根据策略选择规则组
kieSession.getAgenda()
.getAgendaGroup(TASK_TYPE)
.setFocus();
kieSession.fireAllRules();
return redTask;
}
@Override
public FireRUleType getFireRuleType() {
return FireRUleType.HIT;
}
}

15
auto-solution-rule/src/main/resources/META-INF/kmoudle.xml Normal file
View File

@@ -0,0 +1,15 @@
<?xml version="1.0" encoding="UTF-8" ?>
<kmodule xmlns="http://www.drools.org/xsd/kmodule">
<!--
name:指定kbase的名称，可以任意，但是需要唯一
packages:指定规则文件的目录，需要根据实际情况填写，否则无法加载到规则文件
default:指定当前kbase是否为默认
-->
<kbase name="myKbase1" packages="rules" default="true">
<!--
name:指定ksession名称，可以任意，但是需要唯一
default:指定当前session是否为默认
-->
<ksession name="ksession-rule" default="true"/>
</kbase>
</kmodule>

315
auto-solution-rule/src/main/resources/rules/README.md Normal file
View File

@@ -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(...)` 模板。

1750
auto-solution-rule/src/main/resources/rules/fire-rule.drl Normal file
View File

File diff suppressed because it is too large Load Diff