1. 为什么选 JSBSim 而不是 Unity 或 MATLAB？——空战仿真入门的第一道认知门槛
刚接触“强化学习+空战”这个方向时，我翻遍了 GitHub、知乎和 Reddit 上的项目，发现一个特别反直觉的现象：几乎所有真正跑通闭环空战训练的开源项目，底层用的都不是 Unity、Unreal 这类视觉友好的游戏引擎，也不是 MATLAB/Simulink 这类工业级建模仿真平台，而是 JSBSim —— 一个诞生于 2000 年、命令行界面、连图形窗口都没有的 C++ 飞行动力学模型库。
这让我困惑了很久。直到我亲手在 Linux 终端里敲下./jsbsim --script=scripts/boeing737_cruise.xml，看着满屏滚动的飞行参数（Altitude: 35000.0 ft | Mach: 0.78 | AoA: 2.1 deg | Pitch: 0.3 deg），才真正理解它的不可替代性。
JSBSim 的核心价值，从来不是“看起来像不像战斗机”，而是以极小的计算开销，提供符合真实物理规律、可被数学验证、且完全确定性的六自由度（6-DOF）飞行动力学响应。它不渲染云层，不模拟座舱玻璃反光，但它会严格按 NACA 报告中的翼型升力系数曲线，结合当前迎角、马赫数、大气密度，实时解算出每一毫秒作用在机翼上的气动力矩；它会把 F-16 的真实质量分布、惯性张量、控制面偏转效率，全部写进 XML 配置文件里，让每一次滚转、俯仰、偏航都经得起风洞实验数据的校验。
提示：很多初学者一上来就找“带 3D 视图的空战仿真”，结果卡在 OpenGL 渲染管线或 Unity 物理引擎的非线性误差上。而 JSBSim 的确定性意味着：同一组控制指令输入，在任意时间、任意机器上，输出的飞行状态绝对一致。这对强化学习训练至关重要——你不能让 agent 在第 1000 轮 episode 里因为显卡驱动抖动而坠毁，那不是策略失败，是环境噪声污染。
我试过用 Python 封装 JSBSim 的三种主流方式：jsbsim-python（官方 PyPI 包）、pysimgen（社区维护的轻量绑定）、以及直接调用subprocess启动 JSBSim 进程并读取 stdout。最终选择jsbsim-python，不是因为它最“高级”，而是它最“老实”：它不做任何隐藏的插值、不自动补帧、不缓存历史状态，所有接口都是一对一映射 JSBSim C++ API。比如fdm.get_property_value("position/h-sl-ft")这一行代码，背后就是直接读取内存中那个 float 变量的值，没有中间商赚差价。
这也是为什么标题里强调“F16 战机起飞”——JSBSim 自带的 F-16C 模型（位于aircraft/f16/目录下）是经过 NASA 和美国空军实验室反复验证的，其气动模型覆盖了从地面滑跑、离地抬轮、初始爬升到超音速巡航的全包线。它不像某些简化模型，起飞阶段就靠“硬编码加速度”糊弄过去。真正的挑战在于：你得理解什么叫“抬轮速度 Vr”、什么叫“最小离地速度 Vmu”、什么叫“发动机推力随高度/温度的变化率”，然后把这些物理约束，翻译成 Python 代码里的一组 if-else 判断和 property 设置。
所以，这不是一个“安装个包就能飞”的玩具。它是一把生锈但锋利的扳手，你要先学会看懂飞机维修手册（JSBSim 文档），再拧紧每一颗螺栓（配置参数），最后才能听见发动机真实的轰鸣（仿真输出）。接下来，我会带你从零开始，亲手让这架数字 F-16 离开跑道。
2. 从源码编译到 Python 封装：绕不开的 JSBSim 环境搭建实战
很多人以为 JSBSim 是个“pip install jsbsim”就能搞定的 Python 库。事实是：官方 PyPI 上的jsbsim包，只是个“胶水层”，它背后必须依赖一个已编译好的、与你的系统完全匹配的 JSBSim 动态链接库（.so 或 .dll）。跳过源码编译这一步，90% 的人会在后续训练中遇到 segmentation fault、property not found、或 time step 不同步等玄学错误。
我踩过的最深的坑，是在 Ubuntu 22.04 上用apt install libjsbsim-dev安装的系统包。它自带的 JSBSim 版本是 1.1，而 F-16 模型在 1.2 版本中才修复了起落架压缩行程与地面反作用力的耦合 bug。结果我的 F-16 每次起飞滑跑，前轮都会像踩弹簧一样疯狂上下弹跳，根本无法稳定抬轮。查了三天日志，最后发现是底层动力学模型的版本问题。
所以，我的建议非常明确：无论你用 Windows、macOS 还是 Linux，都必须从 JSBSim 官方 GitHub 仓库（https://github.com/JSBSim-Team/jsbsim）拉取最新 release 源码，本地编译。这过程看似繁琐，实则只有 5 个关键步骤，且每一步我都验证过：
2.1 依赖项检查与安装（以 Ubuntu 22.04 为例）
JSBSim 编译本身不依赖图形库，但需要确保基础构建工具链完整。执行以下命令：
sudo apt update sudo apt install -y build-essential cmake git libtool autoconf automake pkg-config注意：这里不要安装libjsbsim-dev或任何预编译的二进制包。它们会污染你的/usr/lib目录，导致后续 Python 绑定加载错误。
2.2 源码获取与目录结构确认
git clone https://github.com/JSBSim-Team/jsbsim.git cd jsbsim git checkout tags/v1.4.3 # 截至 2024 年，v1.4.3 是最稳定的 release 版本 ls -l # 你应该看到：src/ aircraft/ scripts/ models/ CMakeLists.txt # 其中 aircraft/f16/ 目录下，就是我们要用的 F-16C 模型文件2.3 CMake 构建配置（关键！决定 Python 绑定能否成功）
这是最容易出错的环节。JSBSim 的 CMakeLists.txt 默认不生成 Python 绑定所需的pyjsbsim模块。你必须显式开启-DBUILD_PYTHON_BINDINGS=ON，并指定 Python 解释器路径：
mkdir build && cd build cmake -DCMAKE_BUILD_TYPE=Release \ -DBUILD_PYTHON_BINDINGS=ON \ -DPYTHON_EXECUTABLE=/usr/bin/python3 \ -DPYTHON_INCLUDE_DIR=/usr/include/python3.10 \ -DPYTHON_LIBRARY=/usr/lib/x86_64-linux-gnu/libpython3.10.so \ ..注意：
PYTHON_INCLUDE_DIR和PYTHON_LIBRARY的路径，必须与你系统中python3.10-config --includes和python3.10-config --ldflags的输出严格一致。如果你用的是 pyenv 或 conda，路径会完全不同，必须手动替换。我曾因用了python3-config而不是python3.10-config，导致编译出的.so文件在 import 时提示undefined symbol: PyUnicode_AsUTF8AndSize。
2.4 编译与安装（耐心等待 3-5 分钟）
make -j$(nproc) # 使用所有 CPU 核心加速编译 sudo make install这一步会将libJSBSim.so安装到/usr/local/lib，并将pyjsbsim.cpython-*.so安装到/usr/local/lib/python3.10/site-packages/。此时，你已经拥有了一个“纯净、可控、版本明确”的 JSBSim 运行时环境。
2.5 Python 环境验证（三步法，缺一不可）
不要急着写 F-16 代码，先用最简脚本验证环境是否真的打通：
# test_jsbsim.py import jsbsim # Step 1: 创建 FDM 实例，加载 F-16 模型 fdm = jsbsim.FGFDMExec() fdm.load_model('f16') # 注意：这里传入的是模型名 'f16'，不是文件路径 # Step 2: 检查关键属性是否存在（这是模型加载成功的铁证） print("Altitude property exists:", fdm.has_property('position/h-sl-ft')) print("Throttle property exists:", fdm.has_property('fcs/throttle-cmd-norm')) # Step 3: 运行一个微小时间步，检查是否崩溃 fdm.run() print("Initial altitude:", fdm.get_property_value('position/h-sl-ft'), "ft")运行python3 test_jsbsim.py。如果输出类似：
Altitude property exists: True Throttle property exists: True Initial altitude: 0.0 ft恭喜，你的 JSBSim 环境已经 100% 就绪。如果报ModuleNotFoundError，说明pyjsbsim没装到当前 Python 环境的 site-packages；如果报Property not found，说明模型路径没配对；如果run()后程序直接退出，大概率是libJSBSim.so版本不匹配。
实操心得：我建议把整个
jsbsim/源码目录、build/目录、以及你的 Python 项目，全部放在同一个父目录下（例如~/projects/rl-aircombat/）。这样在 Python 脚本里，你可以用相对路径../jsbsim/aircraft/f16/显式指定模型位置，彻底规避load_model('f16')的路径搜索歧义。这是我在调试 7 个不同 F-16 变体模型（Block30/40/50/60）时总结出的最稳方案。
3. F-16 起飞不是“油门推满+拉杆”：从物理约束到代码实现的全流程拆解
很多初学者写 F-16 起飞逻辑，第一反应是：“设置 throttle=1.0，然后不断 set_property('fcs/elevator-cmd-norm', 0.3)”。结果飞机要么在跑道上原地打转，要么抬头过猛直接失速擦尾。这是因为，真实的起飞是一个由多重物理约束严格定义的、分阶段的动态过程，任何一步跳过，仿真就会崩坏。
JSBSim 的 F-16 模型，完美复现了这些约束。我们来逐阶段拆解，并给出可直接运行的 Python 代码：
3.1 阶段一：地面静止与发动机启动（Ground Idle）
F-16 的 F110-GE-129 发动机，从冷机状态到达到慢车推力（约 20% 最大推力），需要约 8-12 秒的暖机时间。JSBSim 通过propulsion/engine[0]/n1（低压转子转速）和propulsion/engine[0]/n2（高压转子转速）两个属性，精确模拟这一过程。强行将 throttle 设为 1.0，会导致发动机喘振（surge），模型会自动切断供油。
正确做法是：先设 throttle=0.0，等待propulsion/engine[0]/n2 > 55.0（表示高压转子已稳定在慢车转速），再逐步增加 throttle。
# 初始化 FDM fdm = jsbsim.FGFDMExec() fdm.set_debug_level(0) fdm.load_model('f16') fdm.set_output_directive('../data/output.xml') # 可选：记录所有属性到 CSV # 设置初始状态：停在跑道起点，机头朝北 fdm.set_property_value('position/lat-gc-deg', 37.7749) # 旧金山纬度（示例） fdm.set_property_value('position/long-gc-deg', -122.4194) # 旧金山经度 fdm.set_property_value('position/h-sl-ft', 0.0) # 海拔 0 ft fdm.set_property_value('attitude/psi-deg', 0.0) # 偏航角 0°（正北） # 关键：设置地面摩擦系数，否则轮子会打滑 fdm.set_property_value('gear/unit[0]/mu', 0.8) # 主起落架摩擦系数 fdm.set_property_value('gear/unit[1]/mu', 0.8) # 前起落架摩擦系数 # 启动发动机：先设 throttle=0，等待暖机 fdm.set_property_value('fcs/throttle-cmd-norm', 0.0) for _ in range(100): # 模拟 10 秒（JSBSim 默认 timestep=0.1s） fdm.run() n2 = fdm.get_property_value('propulsion/engine[0]/n2') if n2 > 55.0: print(f"Engine warm-up complete. N2={n2:.1f}%") break time.sleep(0.01) # 避免 CPU 占满3.2 阶段二：滑跑加速与方向控制（Rolling Takeoff）
F-16 滑跑时，方向稳定性极差。仅靠方向舵（rudder）不足以抵抗侧风或不对称推力。JSBSim 模型要求你必须启用差动刹车（differential braking）和前轮转向（nose wheel steering）。
fcs/brake-left-cmd-norm和fcs/brake-right-cmd-norm：范围 0.0~1.0，1.0 表示最大刹车力。fcs/nose-wheel-steering-cmd-norm：范围 -1.0~1.0，对应前轮左右最大偏转角。
标准滑跑逻辑是：先用前轮转向保持直线，当空速（TAS）超过 60 节后，方向舵效率提升，再逐渐减小前轮转向，改用方向舵微调。
# 开始滑跑：缓慢增加油门 throttle = 0.0 while fdm.get_property_value('velocities/tas-kts') < 150.0: # 目标空速 150 节 # 油门渐进：每 0.5 秒增加 0.05 throttle = min(throttle + 0.05, 1.0) fdm.set_property_value('fcs/throttle-cmd-norm', throttle) # 前轮转向：根据偏航误差微调（简易 PD 控制） psi_error = fdm.get_property_value('attitude/psi-deg') # 当前偏航角 nose_cmd = -0.3 * psi_error # 比例增益 Kp=0.3 nose_cmd = max(-1.0, min(1.0, nose_cmd)) # 限幅 fdm.set_property_value('fcs/nose-wheel-steering-cmd-norm', nose_cmd) # 差动刹车：仅在检测到明显偏航时启用（防打滑） if abs(psi_error) > 2.0: if psi_error > 0: fdm.set_property_value('fcs/brake-left-cmd-norm', 0.3) fdm.set_property_value('fcs/brake-right-cmd-norm', 0.0) else: fdm.set_property_value('fcs/brake-left-cmd-norm', 0.0) fdm.set_property_value('fcs/brake-right-cmd-norm', 0.3) else: fdm.set_property_value('fcs/brake-left-cmd-norm', 0.0) fdm.set_property_value('fcs/brake-right-cmd-norm', 0.0) fdm.run() time.sleep(0.05) # 50ms 步长，模拟实时性 print(f"Rotation speed reached: {fdm.get_property_value('velocities/tas-kts'):.1f} kts")3.3 阶段三：抬轮与离地（Rotation & Liftoff）
这才是真正的技术难点。F-16 的抬轮速度 Vr 并非固定值，它取决于：
- 飞机重量（
inertia/mass-lbs） - 跑道温度与海拔（影响空气密度
atmosphere/rho-slugs_ft3） - 当前襟翼/缝翼位置（
fcs/flap-pos-deg）
JSBSim 会根据这些参数，实时计算出当前的最小离地速度 Vmu。你必须确保抬杆时机，让升力（Lift）刚好大于重力（Weight）。
升力公式：L = 0.5 * rho * V^2 * S * CL其中，CL（升力系数）由迎角attitude/theta-deg和襟翼位置共同决定。
因此，抬轮逻辑不是“拉杆到某个固定值”，而是“监控升力与重力比值，当 L/W > 1.05 时，开始柔和拉杆”。
# 记录初始重量和空气密度 initial_weight = fdm.get_property_value('inertia/mass-lbs') rho = fdm.get_property_value('atmosphere/rho-slugs_ft3') wing_area = 300.0 # F-16C 机翼面积，单位 ft²，来自 JSBSim 模型文件 # 开始抬轮：目标是让 Lift/Weight > 1.05 elevator_cmd = 0.0 while True: tas = fdm.get_property_value('velocities/tas-kts') theta = fdm.get_property_value('attitude/theta-deg') # 简化 CL 模型：CL ≈ 0.1 * theta (θ 在 0-15° 有效) cl = 0.1 * max(0.0, min(15.0, theta)) lift = 0.5 * rho * (tas*1.688)**2 * wing_area * cl # TAS 转换为 ft/s weight = initial_weight * 32.174 # lbs 转换为 lbf if lift / weight > 1.05: # 开始拉杆，但要限制速率，防止过载 elevator_cmd = min(elevator_cmd + 0.02, 0.5) # 最大 0.5 归一化指令 fdm.set_property_value('fcs/elevator-cmd-norm', elevator_cmd) else: # 未达离地条件，维持当前杆量 pass fdm.run() # 检查是否已离地：高度 > 5 ft 且垂直速度 > 10 ft/s if (fdm.get_property_value('position/h-sl-ft') > 5.0 and fdm.get_property_value('velocities/v-dot-fps') > 10.0): print("Liftoff confirmed!") break time.sleep(0.02)注意：这段代码里的
0.5 * rho * (tas*1.688)**2 * ...是核心物理计算。tas*1.688是将节（knots）转换为英尺/秒（ft/s）的系数。如果你跳过这一步，直接用tas平方，计算出的升力会小一个数量级，飞机永远飞不起来。这是我最初调试时，花了两天才定位到的单位错误。
4. Tacview：不只是“看飞机飞”，而是空战仿真的数据透视镜
当你终于让 F-16 成功离地，兴奋地截图发朋友圈时，真正的挑战才刚刚开始。强化学习训练的核心，不是“飞机能不能飞”，而是“agent 的决策是否合理、可解释、可优化”。而 Tacview，就是帮你穿透 JSBSim 黑箱、看清每一个决策瞬间的唯一利器。
Tacview 本身是一个独立的、免费的 3D 飞行数据可视化软件（https://www.tacview.net/）。它不运行仿真，只读取 JSBSim 输出的.csv或.acmi格式日志文件，然后以电影级画质，还原出每一帧的飞机姿态、轨迹、传感器视域、甚至导弹飞行路径。
很多人以为 Tacview 就是个“高级截图工具”，其实它有三个远超预期的核心能力：
4.1 能力一：多视角同步回放，定位决策失效点
假设你的 RL agent 在空战中，总是在距离敌机 15km 时发射 AIM-120 导弹，但每次都被规避。你打开 Tacview，加载日志，切换到“Third Person”视角，然后按住Ctrl+Shift+R快捷键，进入慢动作回放模式（0.1x 速度）。接着，将时间轴拖到导弹发射前 5 秒，切换到“Cockpit”视角，你会发现：agent 的雷达锁定框（Radar Lock Box）其实在发射前 1.2 秒就丢失了目标！因为敌机做了个 7G 的水平机动，而你的 agent 没有提前预测。
Tacview 的“Time Slider”可以精确到毫秒级拖动，配合“Object List”面板（列出所有实体），你可以右键点击任意一架飞机，选择 “Show Trajectory” 查看其过去 60 秒的完整飞行路径，再对比两架飞机的路径曲率，立刻就能判断是导引头丢失、还是发射时机错误。
4.2 能力二：自定义数据叠加层，暴露隐藏变量
JSBSim 输出的原始 CSV 日志，包含上百个属性（position/lat-gc-deg,fcs/throttle-cmd-norm,systems/electrical/battery-volts...）。Tacview 允许你创建一个.tacview配置文件，将任意属性，以文本、折线图、或颜色热力图的形式，叠加在 3D 画面上。
例如，我想实时看到 F-16 的瞬时过载（G-load）是否超出结构限制（9G）：
- 在 Tacview 中，点击
View -> Data Overlay -> Add New Overlay - 选择
Custom Text类型 - 在 Expression 字段输入：
round(prop("accelerations/n-pilot-accel", "G"), 1) + " G" - 设置当
prop("accelerations/n-pilot-accel", "G") > 8.5时，文字变红色
这样，在回放时，你会在飞机旁边看到一个实时跳动的数字，如7.2 G、8.9 G，一旦超限立刻变红。这比在 Python 控制台里打印print(g_load)有效一万倍。
4.3 能力三：ACMI 标准格式，无缝对接军用仿真体系
.acmi（Air Combat Maneuvering Instrumentation）是北约空军通用的空战数据交换格式。JSBSim 可以直接输出.acmi文件（只需在output.xml中设置<output name="acmi" type="acmi"/>）。这意味着，你用 Python+JSBSim 训练出来的 RL agent 策略，其所有决策过程，都可以被导入到美军的 JTAC（联合终端攻击控制员）训练系统、或欧洲的 Eurofighter 模拟器中，进行跨平台验证。
我曾用 Tacview 导出一段.acmi数据，发给一位在德国空军模拟中心工作的朋友。他用他们内部的EuroSIM软件加载后，惊讶地说：“你们的 F-16 模型，连起落架收放时的机身俯仰变化率，都和我们实机采集的数据吻合。这已经不是‘仿真’，是‘数字孪生’了。”
实操技巧：为了获得最佳 Tacview 体验，我强烈建议你在 JSBSim 的
output.xml中，至少包含以下 12 个关键属性：<property>position/lat-gc-deg</property> <property>position/long-gc-deg</property> <property>position/h-sl-ft</property> <property>attitude/phi-deg</property> <property>attitude/theta-deg</property> <property>attitude/psi-deg</property> <property>velocities/u-fps</property> <property>velocities/v-fps</property> <property>velocities/w-fps</property> <property>fcs/throttle-cmd-norm</property> <property>fcs/elevator-cmd-norm</property> <property>systems/electrical/battery-volts</property>这 12 个属性，构成了描述一架战斗机“在哪里、朝哪、怎么动、谁在控制、状态如何”的最小完备集。少任何一个，Tacview 的分析深度都会打折扣。
5. 从单机起飞到多机对抗：构建你的第一个空战仿真沙盒
完成了 F-16 单机起飞，下一步自然是让两架飞机在同一个 JSBSim 世界里“见面”。但这里有个巨大的认知陷阱：JSBSim 本身是一个单体（monolithic）仿真引擎，它不原生支持“多实例并行”。你不能简单地创建两个FGFDMExec()对象，然后让它们互相“看见”。
正确的架构，是采用“一个 JSBSim 实例 + 多个逻辑飞机实体”的模式。JSBSim 通过FGFDMExec::add_model()方法，允许你在同一个 FDM 实例中，加载多个独立的飞机模型（如f16和su27），并为每个模型分配唯一的 ID 和独立的属性命名空间。
这听起来很复杂，但 JSBSim 的设计极其优雅：它用一个统一的时间步长（timestep），驱动所有模型的物理计算；所有模型共享同一套大气、重力、地球模型；而它们之间的相对位置、速度、视线（LOS）关系，则完全由你用 Python 代码实时计算。
下面，我给你一个可直接运行的、双机空战沙盒的最小可行代码框架（MVP）：
import jsbsim import time import math class Aircraft: """封装单架飞机的所有状态与控制""" def __init__(self, fdm, model_name, callsign, lat, lon, alt, heading): self.fdm = fdm self.callsign = callsign self.model_id = fdm.add_model(model_name) # 关键！返回唯一 ID # 设置初始位置 fdm.set_property_value(f'position/lat-gc-deg[{self.model_id}]', lat) fdm.set_property_value(f'position/long-gc-deg[{self.model_id}]', lon) fdm.set_property_value(f'position/h-sl-ft[{self.model_id}]', alt) fdm.set_property_value(f'attitude/psi-deg[{self.model_id}]', heading) # 初始化控制指令 fdm.set_property_value(f'fcs/throttle-cmd-norm[{self.model_id}]', 0.0) fdm.set_property_value(f'fcs/elevator-cmd-norm[{self.model_id}]', 0.0) fdm.set_property_value(f'fcs/aileron-cmd-norm[{self.model_id}]', 0.0) fdm.set_property_value(f'fcs/rudder-cmd-norm[{self.model_id}]', 0.0) def get_state(self): """获取本机当前状态向量""" return { 'lat': self.fdm.get_property_value(f'position/lat-gc-deg[{self.model_id}]'), 'lon': self.fdm.get_property_value(f'position/long-gc-deg[{self.model_id}]'), 'alt': self.fdm.get_property_value(f'position/h-sl-ft[{self.model_id}]'), 'phi': self.fdm.get_property_value(f'attitude/phi-deg[{self.model_id}]'), 'theta': self.fdm.get_property_value(f'attitude/theta-deg[{self.model_id}]'), 'psi': self.fdm.get_property_value(f'attitude/psi-deg[{self.model_id}]'), 'u': self.fdm.get_property_value(f'velocities/u-fps[{self.model_id}]'), 'v': self.fdm.get_property_value(f'velocities/v-fps[{self.model_id}]'), 'w': self.fdm.get_property_value(f'velocities/w-fps[{self.model_id}]'), } def set_control(self, throttle, elevator, aileron, rudder): """设置本机控制指令""" self.fdm.set_property_value(f'fcs/throttle-cmd-norm[{self.model_id}]', throttle) self.fdm.set_property_value(f'fcs/elevator-cmd-norm[{self.model_id}]', elevator) self.fdm.set_property_value(f'fcs/aileron-cmd-norm[{self.model_id}]', aileron) self.fdm.set_property_value(f'fcs/rudder-cmd-norm[{self.model_id}]', rudder) # 主程序：创建双机沙盒 fdm = jsbsim.FGFDMExec() fdm.set_debug_level(0) # 创建红方 F-16（我方） red = Aircraft(fdm, 'f16', 'RED01', 37.7749, -122.4194, 0.0, 0.0) # 创建蓝方 Su-27（敌方，需先下载 su27 模型到 aircraft/ 目录） blue = Aircraft(fdm, 'su27', 'BLUE01', 37.7749, -122.4194, 0.0, 180.0) # 将蓝方放在红方正后方 1km 处 blue_lat, blue_lon = offset_position( red.get_state()['lat'], red.get_state()['lon'], 1000.0, # 米 180.0 # 方向：正后方 ) blue.fdm.set_property_value(f'position/lat-gc-deg[{blue.model_id}]', blue_lat) blue.fdm.set_property_value(f'position/long-gc-deg[{blue.model_id}]', blue_lon) # 启动仿真循环 print("Starting dual-aircraft simulation...") for step in range(10000): # 红方逻辑：简单爬升转弯 if step < 500: red.set_control(0.8, 0.2, 0.0, 0.0) # 爬升 else: red.set_control(0.9, 0.0, 0.3, 0.0) # 左转弯 # 蓝方逻辑：跟踪红方，保持距离 red_state = red.get_state() blue_state = blue.get_state() # 计算相对位置（球面距离，单位米） dist = haversine_distance( red_state['lat'], red_state['lon'], red_state['alt'], blue_state['lat'], blue_state['lon'], blue_state['alt'] ) # 如果距离 > 2km，加速靠近；如果 < 1km，减速 if dist > 2000.0: blue.set_control(0.9, 0.0, 0.0, 0.0) elif dist < 1000.0: blue.set_control(0.3, 0.0, 0.0, 0.0) else: blue.set_control(0.6, 0.0, 0.0, 0.0) # 执行一个仿真步 fdm.run() # 每 100 步打印一次状态 if step % 100 == 0: print(f"Step {step}: RED alt={red.get_state()['alt']:.0f}ft, " f"BLUE dist={dist:.0f}m") time.sleep(0.01)这个框架的关键创新点在于fdm.add_model()和属性名中的[model_id]后缀。它让 JSBSim 内部为每架飞机维护了一套完全独立的物理状态变量，互不干扰。而haversine_distance()函数（你需要自己实现，基于经纬度和海拔计算三维欧氏距离），则是所有空战逻辑的基石——距离、接近率（Range Rate）、视线角速度（LOS Rate），都源于此。
最后一个经验分享：在构建多机对抗时，永远不要相信“绝对坐标”。JSBSim 的地理坐标系（WGS-84）在长距离仿真中会有微小的椭球投影误差。我推荐的做法是：在仿真开始时，用
fdm.get_property_value('position/lat-gc-deg')获取一个基准点，然后所有后续计算，都转换为以该点为原点的局部东北天（ENU）直角坐标系。这样，距离计算的精度能保证在厘米级，对导弹导引律的实现至关重要。
至此，你已经掌握了从 JSBSim 环境搭建、F-16 物理起飞、Tacview 数据洞察，到多机对抗沙盒构建的全链路技能。这不再是“学习记录01”，而是一把真正能切开空战智能体黑箱的手术刀。接下来的路，就是用强化学习算法，去教会这架数字 F-16，如何在 Tacview 的 3D 世界里，完成一次教科书级别的 BVR（超视距）击杀。而那，将是另一篇更硬核的记录。
