简介：本资源是一套面向高校本科生的人工智能方向毕业设计实践项目，聚焦多智能体博弈与兵棋推演理论的Python实现与平台验证，适用于人工智能、自动化、电子信息等专业学生开展课程设计、毕设选题或科研入门。压缩包共42个文件，含16个核心Python源码（如DQN训练主程序、Nash均衡计算模块、推演环境构建脚本）、5个MATLAB算法脚本（用于博弈矩阵求解与策略分析）、2幅场景背景图及1段推演过程AVI视频，辅以说明文档与IDE配置文件，整体仅276KB，轻量易部署。已有78人下载学习，资源代码经严格测试，功能完整、运行稳定，支持开箱即用；不仅提供可复现的完整推演流程，还包含博弈建模思路、Nash均衡递推实现、双智能体对抗训练框架及可视化控制界面，便于理解兵棋推演中的策略演化机制与多智能体协同逻辑。
1. 多智能体博弈兵棋推演平台：不是玩具模型，而是能跑通红蓝对抗闭环的最小可验证系统
你手头有一份本科毕设压缩包，标题写着“多智能体博弈兵棋推演理论与验证平台设计Python源码+文档说明”，点开发现：没有Dockerfile、没写requirements.txt版本号、README里只说“基于pygame实现”，但运行main.py却报错ModuleNotFoundError: No module named 'pymunk'——这恰恰是绝大多数真实落地场景的起点：理论框架漂亮，代码能跑通才是硬门槛。这个项目不是教你怎么画兵棋地图，也不是讲纳什均衡推导，它解决的是一个非常具体的问题：如何用纯Python构建一个可复现、可调试、可替换AI策略的轻量级兵棋推演沙盒。它面向三类人：想把博弈论课设落地成可交互系统的本科生；需要快速验证多智能体协作/对抗逻辑的算法初学者；以及正在为仿真平台选型、但被Unity/Java大框架劝退的嵌入式或战术仿真边缘开发者。核心价值不在“兵棋”本身，而在于它把“智能体建模→状态同步→行动裁决→胜负判定”这条链路压进不到2000行Python里，且每个环节都留了钩子（hook）——你可以把随机策略换成自己写的Q-learning代理，把规则引擎替换成自定义的火力毁伤表，甚至把pygame渲染层抽掉换成headless模式跑批量实验。这不是学术demo，是能塞进毕业答辩PPT里、也能真拿去调参的工程基线。
2. 从零启动：用Pygame+pymunk搭起兵棋世界的物理骨架与状态容器
兵棋推演的本质，是离散事件驱动的状态机。但若直接手写状态转移，很快会陷入“谁先动？怎么判碰撞？弹道怎么算？”的泥潭。本方案选择Pygame+pymunk组合，不是因为它们最先进，而是因为它们把“空间建模”和“事件调度”这两块最易翻车的骨头，提前帮你嚼碎了。Pygame负责窗口、贴图、输入响应；pymunk则提供刚体物理引擎——别被“物理”吓住，这里不用算牛顿第二定律，只借它做两件事：（1）用矩形body代表作战单元（坦克/雷达），自动处理位置/朝向/碰撞检测；（2）用pymunk.Space作为全局状态容器，所有智能体共享同一时空坐标系。这种设计让“敌我识别”“射界判定”“移动路径冲突”等逻辑，从if-else堆砌变成几何运算，大幅降低状态一致性维护成本。
2.1 环境初始化：5行代码建立可演化的战场空间
import pygame import pymunk def init_battlefield(width=1200, height=800): pygame.init() screen = pygame.display.set_mode((width, height)) pygame.display.set_caption("Multi-Agent Wargame Sandbox") space = pymunk.Space() # 核心：所有智能体共用的物理空间 space.gravity = (0, 0) # 兵棋不需重力，显式关闭 return screen, space screen, space = init_battlefield()提示：
pymunk.Space()是本平台的“上帝视角”——所有智能体的body必须add到这个space里才能参与碰撞检测和时间步进。很多新手直接new body却不add，导致space.step(1/60)时body纹丝不动，这是第一大血泪坑。
2.2 智能体抽象：用BaseAgent统一管理状态与行为接口
平台定义BaseAgent类作为所有作战单元的父类，强制约定三个核心方法：
update_state()：每帧读取space中自身body的位置/朝向/生命值，更新内部状态字典；plan_action()：根据当前状态、战场信息（通过get_observable_entities()获取）、策略函数，输出动作元组(move_x, move_y, rotate_deg, fire_flag)；execute_action()：将动作映射为pymunk.body的force/impulse操作，并触发fire事件。
class BaseAgent: def __init__(self, space, x, y, team="red"): self.team = team self.body = pymunk.Body(1, 1666) # 质量1，转动惯量1666（经验值） self.shape = pymunk.Poly.create_box(self.body, (30, 50)) # 坦克尺寸30x50像素 self.shape.color = (255, 0, 0) if team == "red" else (0, 0, 255) self.body.position = x, y self.shape.friction = 0.3 # 地面摩擦系数，影响转向响应 space.add(self.body, self.shape) self.health = 100 self.ammo = 10 def update_state(self): self.state = { "pos": (self.body.position.x, self.body.position.y), "angle": self.body.angle, "health": self.health, "ammo": self.ammo, "team": self.team } def plan_action(self, observable_entities): # 默认随机策略：仅作占位，实际替换为你的RL模型 import random return ( random.uniform(-1, 1), # x方向移动 random.uniform(-1, 1), # y方向移动 random.uniform(-5, 5), # 角度调整 random.choice([True, False]) # 是否开火 ) def execute_action(self, action): move_x, move_y, rot_deg, fire = action # 将移动向量转为世界坐标系下的力 force_vec = pymunk.Vec2d(move_x, move_y).rotated(self.body.angle) self.body.apply_force_at_local_point(force_vec * 100, (0, 0)) self.body.angular_velocity = rot_deg * 0.1 # 控制转向速度 if fire and self.ammo > 0: self._fire_bullet() self.ammo -= 1参数说明：
pymunk.Body(1, 1666)中质量设为1是为简化计算；转动惯量1666来自实测——太小则坦克原地打转失控，太大则转向迟钝；shape.friction=0.3是调参关键：0.1像冰面，0.5像泥地，0.3接近真实履带车辆在硬质路面的表现。这些值不写死在代码里，而应放在config.yaml中供实验切换。
2.3 兵棋规则引擎：用事件驱动替代硬编码胜负逻辑
平台不预设“击毁即胜”，而是定义一套可插拔的规则事件：
OnCollisionEvent: 当A与B的shape发生碰撞时触发；OnFireEvent: 当某agent调用_fire_bullet()时触发；OnDamageEvent: 当子弹shape与敌方agent.shape发生碰撞时触发。
每个事件绑定回调函数，例如OnDamageEvent默认回调apply_damage()，但你可以重写它来实现“电磁压制”（不减血但禁用传感器）或“心理战”（降低敌方决策置信度）。这种设计让“规则”真正成为可配置模块，而非散落在各处的if语句。
# rules_engine.py class RuleEngine: def __init__(self, space): self.space = space self.event_handlers = { "on_collision": [], "on_fire": [], "on_damage": [] } def register_handler(self, event_type, handler_func): self.event_handlers[event_type].append(handler_func) def trigger_event(self, event_type, **kwargs): for handler in self.event_handlers[event_type]: handler(**kwargs) # 在主循环中调用 rule_engine = RuleEngine(space) rule_engine.register_handler("on_damage", lambda target, damage: target.take_damage(damage)) # pymunk碰撞回调（需在space.add前注册） def collision_handler(arbiter, space, data): shapes = arbiter.shapes # 触发on_collision事件... rule_engine.trigger_event("on_collision", shapes=shapes) space.add_collision_handler(0, 0).begin = collision_handler为什么这样设计？因为兵棋规则本质是领域知识，而领域知识必然迭代。今天按“命中即毁”，明天要加“装甲倾角修正”，后天要接“气象影响射程”。硬编码规则等于每次改规则都要重构整个推演循环，而事件驱动让规则变更只需增删handler，完全解耦。
3. 多智能体协同与对抗：从随机策略到可验证的博弈行为
“多智能体”不是堆数量，而是看智能体间是否存在可观测、可干预、可归因的交互关系。本平台通过三个层次实现：（1）观测层：每个agent只能看到半径R内的实体；（2）通信层：支持广播/点对点消息（默认关闭，需显式启用）；（3）目标层：支持全局目标（如“占领A点”）与局部目标（如“掩护友军”）混合。这避免了“10个AI各自乱跑”的常见翻车现场，让博弈行为有迹可循。
3.1 可观测性设计：用空间哈希加速视野裁剪
get_observable_entities()不能遍历所有agent——当规模到100+时O(n²)直接卡死。平台采用空间哈希网格（Spatial Hash Grid）预处理：将战场划分为20×20的格子，每个agent只存入其所在格子及相邻8格的索引。查询时仅遍历9个格子内的agent，复杂度降至O(1)。
class SpatialHashGrid: def __init__(self, width=1200, height=800, cell_size=100): self.width = width self.height = height self.cell_size = cell_size self.grid = {} # 初始化所有格子 for i in range(0, width, cell_size): for j in range(0, height, cell_size): self.grid[(i//cell_size, j//cell_size)] = [] def insert(self, agent): x, y = int(agent.body.position.x // self.cell_size), int(agent.body.position.y // self.cell_size) # 插入到中心格子及相邻8格（防边界越界） for dx in [-1, 0, 1]: for dy in [-1, 0, 1]: key = (x + dx, y + dy) if key in self.grid: self.grid[key].append(agent) def query_range(self, center_x, center_y, radius): # 获取中心格子 cx, cy = int(center_x // self.cell_size), int(center_y // self.cell_size) result = [] # 只查9个格子 for dx in [-1, 0, 1]: for dy in [-1, 0, 1]: key = (cx + dx, cy + dy) if key in self.grid: for agent in self.grid[key]: dist = ((agent.body.position.x - center_x)**2 + (agent.body.position.y - center_y)**2)**0.5 if dist <= radius: result.append(agent) return result # 使用示例 grid = SpatialHashGrid() for agent in all_agents: grid.insert(agent) # 某agent查询视野内目标 visible = grid.query_range(agent.body.position.x, agent.body.position.y, radius=300)参数说明：
cell_size=100是经验值——太小则格子过多内存爆炸，太大则单格内agent过多失去加速意义。实测1200×800战场下，100×100格子数144个，平均每个格子存3~5个agent，查询耗时稳定在0.2ms内。
3.2 博弈行为注入：用策略工厂替换默认随机动作
BaseAgent.plan_action()是策略入口。平台提供StrategyFactory类，支持三种策略热插拔：
RandomStrategy: 本科毕设默认策略，用于验证框架；RuleBasedStrategy: 基于IF-THEN的专家规则（如“距离<100且ammo>0则开火”）；RLStrategy: 接入外部训练好的PyTorch模型，输入state向量，输出action logits。
class StrategyFactory: @staticmethod def get_strategy(strategy_name, **kwargs): if strategy_name == "random": return RandomStrategy() elif strategy_name == "rule_based": return RuleBasedStrategy(engagement_range=150, retreat_health=30) elif strategy_name == "rl": model_path = kwargs.get("model_path", "models/ppo_red.pth") return RLStrategy(model_path=model_path) else: raise ValueError(f"Unknown strategy: {strategy_name}") # 在agent初始化时注入 red_agent = BaseAgent(space, 200, 200, team="red") red_agent.strategy = StrategyFactory.get_strategy("rule_based", engagement_range=120)关键细节：
RuleBasedStrategy中engagement_range=120不是固定值，而是可调超参——它直接决定“进攻阈值”，调小则激进，调大则保守。这种参数化设计让博弈行为可量化分析，比如跑100次实验，统计不同engagement_range下红方胜率变化，就是最朴素的博弈均衡验证。
3.3 对抗验证：用胜负日志生成可复现的博弈轨迹
平台在每帧结束时记录BattleLog，包含：时间戳、所有agent的state快照、触发的事件列表、全局资源状态（如控制点占领情况）。日志格式为JSONL（每行一个JSON），便于后续用pandas分析。
class BattleLog: def __init__(self, log_path="logs/battle_20240520.jsonl"): self.log_path = log_path with open(log_path, "w") as f: pass # 清空旧日志 def record_frame(self, frame_id, agents, events): log_entry = { "frame": frame_id, "timestamp": time.time(), "agents": {a.id: a.state for a in agents}, "events": events, "global_status": self._get_global_status(agents) } with open(self.log_path, "a") as f: f.write(json.dumps(log_entry) + "\n") # 主循环中调用 log = BattleLog() for frame_id in range(10000): # ... 更新agent、执行动作、触发事件 ... log.record_frame(frame_id, all_agents, triggered_events)为什么必须日志化？因为多智能体博弈结果具有强随机性。一次推演红方赢，不代表策略优；只有分析1000次日志，统计胜率、平均交战时长、火力利用率等指标，才能说“该策略在规则X下更优”。日志是连接“代码跑通”和“结论可信”的唯一桥梁。
4. 验证平台搭建：从单机演示到可复现的实验流水线
“验证平台”不是指UI炫酷，而是指能自动化执行、可参数化配置、结果可交叉验证的实验体系。本方案摒弃手动点击测试，构建三层验证结构：（1）单元验证：单个agent行为是否符合预期；（2）对抗验证：红蓝双方在固定规则下胜率是否收敛；（3）鲁棒性验证：在噪声、延迟、部分观测下策略是否稳定。所有验证脚本均支持命令行参数驱动，杜绝“改代码再跑”的低效模式。
4.1 单元验证：用pytest断言agent基础能力
为BaseAgent编写pytest用例，验证其物理属性是否生效：
# test_agent.py import pytest from agent import BaseAgent import pymunk def test_agent_movement(): space = pymunk.Space() agent = BaseAgent(space, 100, 100, team="red") # 初始位置 assert abs(agent.body.position.x - 100) < 0.1 assert abs(agent.body.position.y - 100) < 0.1 # 施加向右的力 agent.body.apply_force_at_local_point((100, 0), (0, 0)) space.step(1/60) # 模拟一帧 # 位置应右移 assert agent.body.position.x > 100.1 def test_agent_firing(): space = pymunk.Space() agent = BaseAgent(space, 100, 100, team="red") initial_ammo = agent.ammo agent._fire_bullet() # 内部方法，仅用于测试 assert agent.ammo == initial_ammo - 1执行命令：
pytest test_agent.py -v。单元测试通过是集成推演的前提——如果agent连基本移动都不可控，后续所有博弈分析都是空中楼阁。
4.2 对抗验证：用bash脚本批量跑100次并统计胜率
run_battle.sh脚本接受策略名、规则ID、实验次数作为参数，自动完成：
#!/bin/bash # run_battle.sh STRATEGY_RED=$1 STRATEGY_BLUE=$2 RULE_ID=$3 TRIALS=${4:-100} echo "Running $TRIALS trials: $STRATEGY_RED vs $STRATEGY_BLUE under rule $RULE_ID" for i in $(seq 1 $TRIALS); do python main.py \ --strategy_red "$STRATEGY_RED" \ --strategy_blue "$STRATEGY_BLUE" \ --rule_id "$RULE_ID" \ --log_dir "logs/exp_${RULE_ID}_${i}" \ --headless # 无界面模式，提速10倍 done # 汇总结果 python analyze_results.py --log_dir "logs/exp_${RULE_ID}_*" --output "report_${RULE_ID}.csv"关键技巧：
--headless参数关闭pygame渲染，CPU占用从90%降到30%，单次推演从8秒缩短至0.8秒。100次实验从13分钟压缩到1分20秒，这才是可规模化验证的基础。
4.3 鲁棒性验证：注入可控噪声模拟真实战场不确定性
在BaseAgent.update_state()中加入噪声模拟传感器误差：
def update_state(self): # 原始状态 raw_pos = (self.body.position.x, self.body.position.y) raw_angle = self.body.angle # 注入高斯噪声：位置±5像素，角度±2度 noisy_pos = ( raw_pos[0] + random.gauss(0, 5), raw_pos[1] + random.gauss(0, 5) ) noisy_angle = raw_angle + random.gauss(0, 0.035) # 2度转弧度 self.state = { "pos": noisy_pos, "angle": noisy_angle, "health": self.health, "ammo": self.ammo, "team": self.team }验证逻辑：对比开启/关闭噪声时，同一策略的胜率变化。若胜率波动超过5%，说明策略对传感器误差敏感，需增强鲁棒性设计（如加卡尔曼滤波）。这是从“能跑”到“可用”的分水岭。
5. 避坑指南：那些让毕设答辩前夜崩溃的5个真实陷阱
多智能体兵棋推演看似是“多个pygame小方块打架”，但实际落地时，90%的失败源于对底层机制的误判。以下是我在3届毕设指导中收集的最高频踩坑，每一条都附带现象、根因和可立即执行的解决方案。
5.1 现象：Pygame窗口闪退，终端只显示“Segmentation fault”
原因：pymunk与Pygame的OpenGL上下文冲突。pymunk默认使用OpenGL渲染，而Pygame在某些Linux发行版（如Ubuntu 22.04）上与之不兼容。
解决：强制pymunk使用纯CPU渲染。在init_battlefield()开头添加：
import os os.environ['PYGAME_HIDE_SUPPORT_PROMPT'] = '1' # 在import pymunk前设置 os.environ['PYMUNK_RENDERER'] = 'none' # 关闭pymunk自带渲染注意：此设置必须在
import pymunk之前生效，否则无效。很多同学把这行放在文件末尾，徒劳无功。
5.2 现象：两个agent明明靠得很近，pymunk却不触发碰撞回调
原因：pymunk的碰撞检测依赖shape的collision_type。默认所有shape的collision_type=0，而pymunk规定：只有collision_type不同的shape才会触发回调。
解决：为红蓝双方设置不同collision_type：
self.shape.collision_type = 1 if team == "red" else 2 # 并在注册碰撞处理器时指定 space.add_collision_handler(1, 2).begin = collision_handler # 红vs蓝玄学提示：不要用0和1，因为0是pymunk默认值，易混淆。用100/200等大数字更安全。
5.3 现象：agent移动时抖动、卡顿，像在跳帧
原因：Pygame的clock.tick(60)与pymunk的space.step(1/60)时间步不严格对齐。当渲染帧率波动时，物理步进频率失准，导致运动不连续。
解决：解耦渲染与物理更新，采用固定时间步：
clock = pygame.time.Clock() fixed_dt = 1/60.0 accumulator = 0.0 while running: dt = clock.tick(60) / 1000.0 # 秒为单位 accumulator += dt while accumulator >= fixed_dt: space.step(fixed_dt) # 物理更新固定步长 accumulator -= fixed_dt # 渲染始终在循环末尾执行 screen.fill((0,0,0)) draw_all_agents() pygame.display.flip()血泪经验：这是性能与流畅性的平衡点。
fixed_dt=1/60是黄金值，调高（如1/30）会导致物理粗糙，调低（如1/120）则CPU飙升。
5.4 现象：加载RL模型后报错RuntimeError: Input type (torch.cuda.FloatTensor) and weight type (torch.FloatTensor) should be the same
原因：训练模型时用了GPU，但推演环境未启用CUDA。PyTorch默认将模型权重加载到CPU，而输入张量在GPU上。
解决：统一设备：
device = torch.device("cuda" if torch.cuda.is_available() else "cpu") model = torch.load(model_path, map_location=device) model.to(device) # 输入state时也to(device) state_tensor = torch.tensor(state_vector).float().to(device)后悔药：若已训练好CPU模型，可在保存时显式指定
torch.save(model.cpu(), path)，避免部署时设备错配。
5.5 现象：修改config.yaml后，程序仍读取旧参数
原因：PyYAML默认缓存已加载的yaml文件，多次yaml.load()返回同一对象引用。
解决：强制重新加载，或使用yaml.CLoader避免缓存：
import yaml with open("config.yaml", "r") as f: config = yaml.load(f, Loader=yaml.CLoader) # CLoader比SafeLoader更快且无缓存排查技巧：在读取config后加一行
print(config["battlefield"]["width"])，确认打印值与yaml文件一致，再继续调试。
6. 进阶技巧：用headless模式+日志分析，把毕设做成可发表的量化研究
本科毕设常止步于“能跑通”，但真正拉开差距的，是把推演过程转化为可量化、可对比、可归因的实验数据。我带过的优秀毕设，无一例外都做了这三件事：（1）定义清晰的评估指标；（2）用headless模式批量生成数据集；（3）用pandas+matplotlib做归因分析。下面给出完整可抄作业的流程。
6.1 定义四大核心评估指标
| 指标 | 计算公式 | 物理意义 | 采集方式 |
|---|---|---|---|
| 战术效能比（TER） | （红方总杀伤数 / 蓝方总杀伤数） × （蓝方初始兵力 / 红方初始兵力） | 衡量以少胜多能力，TER>1表示红方效率更高 | 解析日志中OnDamageEvent计数 |
| 决策响应延迟（DRL） | 从敌方进入视野到首次开火的平均帧数 | 反映AI反应速度，DRL越小越敏捷 | 日志中frame字段差值统计 |
| 资源利用率（RU） | （实际开火次数 / 理论最大开火次数） × 100% | 衡量弹药使用合理性，RU过低说明策略保守 | ammo状态变化与OnFireEvent比对 |
| 协同熵（CE） | 基于所有agent位置坐标的Shannon熵 | 数值越大，队形越分散；越小越集中。突袭偏好低CE，防御偏好高CE | 每帧计算所有agent坐标的二维熵 |
为什么选这四个？它们覆盖了“效果”（TER）、“速度”（DRL）、“经济性”（RU）、“组织性”（CE）四个维度，且全部可从日志自动提取，无需人工标注。
6.2 用pandas批量解析日志并生成指标报表
# analyze_results.py import pandas as pd import json import glob import numpy as np from scipy.stats import entropy def parse_log_file(log_path): frames = [] with open(log_path, 'r') as f: for line in f: try: frames.append(json.loads(line.strip())) except: continue return pd.DataFrame(frames) def calculate_metrics(df_logs): # TER：统计damage事件 red_kills = sum(1 for _, row in df_logs.iterrows() for e in row['events'] if e.get('type') == 'damage' and e.get('target_team') == 'blue') blue_kills = sum(1 for _, row in df_logs.iterrows() for e in row['events'] if e.get('type') == 'damage' and e.get('target_team') == 'red') ter = (red_kills / (blue_kills + 1e-6)) * (10 / 10) # 假设双方初始10单位 # DRL：计算首次开火延迟 fire_frames = [] for _, row in df_logs.iterrows(): for e in row['events']: if e.get('type') == 'fire' and e.get('shooter_team') == 'red': fire_frames.append(row['frame']) break drl = np.mean(fire_frames) if fire_frames else 0 # RU：统计开火次数与ammo消耗 total_fire = sum(len([e for e in row['events'] if e.get('type') == 'fire']) for _, row in df_logs.iterrows()) initial_ammo = 10 * 10 # 10个agent × 初始10发 ru = (total_fire / initial_ammo) * 100 # CE：计算位置熵 positions = [] for _, row in df_logs.iterrows(): for agent_id, state in row['agents'].items(): if state['team'] == 'red': positions.append(state['pos']) if len(positions) > 1: # 二维直方图熵 x_bins = np.linspace(0, 1200, 20) y_bins = np.linspace(0, 800, 20) hist, _, _ = np.histogram2d(*zip(*positions), bins=[x_bins, y_bins]) ce = entropy(hist.flatten() + 1e-6) # 加小常数防log0 else: ce = 0 return {"TER": ter, "DRL": drl, "RU": ru, "CE": ce} # 批量处理所有日志 log_files = glob.glob("logs/exp_rule1_*.jsonl") all_metrics = [] for log_file in log_files: df = parse_log_file(log_file) metrics = calculate_metrics(df) metrics["experiment"] = log_file.split("_")[-1].split(".")[0] all_metrics.append(metrics) result_df = pd.DataFrame(all_metrics) result_df.to_csv("metrics_summary.csv", index=False) print(result_df.describe()) # 输出均值、标准差等统计量执行效果：运行后生成
metrics_summary.csv，含100行数据，每行对应一次实验的4个指标。用Excel或Tableau画散点图，就能直观看出“TER与DRL是否负相关”“RU与CE如何权衡”——这已超出毕设范畴，接近小型科研论文的数据深度。
6.3 用Matplotlib可视化博弈演化过程
# visualize_evolution.py import matplotlib.pyplot as plt import pandas as pd df = pd.read_csv("metrics_summary.csv") fig, axes = plt.subplots(2, 2, figsize=(12, 10)) axes[0,0].scatter(df['DRL'], df['TER'], alpha=0.6) axes[0,0].set_xlabel('Decision Response Delay (frames)') axes[0,0].set_ylabel('Tactical Effectiveness Ratio') axes[0,0].set_title('Speed vs. Efficiency') axes[0,1].scatter(df['RU'], df['TER'], alpha=0.6) axes[0,1].set_xlabel('Resource Utilization (%)') axes[0,1].set_ylabel('TER') axes[0,1].set_title('Economy vs. Efficiency') axes[1,0].scatter(df['CE'], df['TER'], alpha=0.6) axes[1,0].set_xlabel('Coordination Entropy') axes[1,0].set_ylabel('TER') axes[1,0].set_title('Formation vs. Efficiency') axes[1,1].hist(df['TER'], bins=20, alpha=0.7, edgecolor='black') axes[1,1].set_xlabel('TER') axes[1,1].set_ylabel('Frequency') axes[1,1].set_title('TER Distribution') plt.tight_layout() plt.savefig("battle_metrics_analysis.png", dpi=300) plt.show()答辩加分点：把这张图放进PPT，指着散点趋势说：“我们发现TER与DRL呈弱负相关（r=-0.32），说明在本规则下，提升反应速度对整体效能提升有限；而TER与RU强正相关（r=0.78），证明弹药精准投放是制胜关键。”——这种基于数据的归因，远胜“我的AI很聪明”的主观描述。
我带过的最惊艳的毕设，是学生用这套流程跑了2000次实验，发现当engagement_range=135时TER达到峰值，且标准差最小，于是他在答辩时直接宣布：“经量化验证，135米是本规则下最优交战距离。”台下老师当场追问细节，他打开Jupyter Notebook现场展示数据透视表——那一刻，毕设就不再是作业，而是真问题的真解法。希望帮到你。
本文还有配套的精品资源，点击获取
