写一个初始位置为[-10, -10]，[0, -10]，[10, -10]的三个智能体追踪和合围一个动态目标的python程序，其中三个智能体的x.y方向速度不超过5m/s,角速度不超过30rad/s,目标是沿着y轴匀速直线运动，速度为2m/s,要求采取合适的控制策略先追上目标，当智能体与目标的距离等于5m时，开始采取势场法来形成正三角形队形来包围住目标，并保持围捕半径为5m。显示出每个智能体的走过的路径。写一个比较完整的程序

下面是一个基于Python的程序，可以实现三个智能体追踪和合围一个动态目标的任务：

import numpy as np
import matplotlib.pyplot as plt

# 目标的初始位置和速度
target_pos = np.array([0, -10])
target_vel = np.array([0, 2])

# 智能体的初始位置
agent1_pos = np.array([-10, -10])
agent2_pos = np.array([0, -10])
agent3_pos = np.array([10, -10])

# 智能体的速度和角速度上限
v_max = 5.0
omega_max = np.pi / 6

# 目标与智能体的距离阈值
d_goal = 5.0

# 智能体之间的距离阈值
d_swarm = 5.0

# 势场法中的常数
k_att = 0.5
k_rep = 10.0

# 记录智能体的路径
agent1_path = [agent1_pos]
agent2_path = [agent2_pos]
agent3_path = [agent3_pos]

# 运行时间和时间步长
t = 0
dt = 0.01

# 循环运行直到目标被成功包围
while True:
    # 计算每个智能体对目标的距离和方向
    d1 = np.linalg.norm(agent1_pos - target_pos)
    d2 = np.linalg.norm(agent2_pos - target_pos)
    d3 = np.linalg.norm(agent3_pos - target_pos)
    dir1 = (target_pos - agent1_pos) / (d1 + 1e-6)
    dir2 = (target_pos - agent2_pos) / (d2 + 1e-6)
    dir3 = (target_pos - agent3_pos) / (d3 + 1e-6)

    # 如果智能体与目标的距离小于阈值，则停止追逐
    if d1 < d_goal and d2 < d_goal and d3 < d_goal:
        break

    # 计算每个智能体的速度和角速度
    v1 = k_att * dir1
    v2 = k_att * dir2
    v3 = k_att * dir3
    for pos, v in [(agent1_pos, v1), (agent2_pos, v2), (agent3_pos, v3)]:
        d = np.linalg.norm(pos - target_pos)
        if d < d_swarm:
            v += k_rep * (pos - target_pos) / (d + 1e-6)
        v_norm = np.linalg.norm(v)
        if v_norm > v_max:
            v = v_max * v / v_norm
        omega = np.clip(np.arctan2(v[1], v[0]) - np.arctan2(pos[1] - target_pos[1], pos[0] - target_pos[0]), -omega_max, omega_max)
        v = v + np.array([-v[1], v[0]]) * omega
        pos += v * dt
        pos[0] = np.clip(pos[0], -10, 10)
        pos[1] = np.clip(pos[1], -10, 10)
        if pos[0] == -10 or pos[0] == 10 or pos[1] == -10:
            v *= -1
            omega *= -1
    agent1_path.append(agent1_pos)
    agent2_path.append(agent2_pos)
    agent3_path.append(agent3_pos)
    t += dt

# 计算智能体的平均位置
center = (agent1_pos + agent2_pos + agent3_pos) / 3

# 计算每个智能体到平均位置的向量
dir1 = center - agent1_pos
dir2 = center - agent2_pos
dir3 = center - agent3_pos

# 计算每个智能体的目标方向
target_dir1 = np.array([-dir1[1], dir1[0]])
target_dir2 = np.array([-dir2[1], dir2[0]])
target_dir3 = np.array([-dir3[1], dir3[0]])

# 计算每个智能体的速度和角速度
v1 = k_att * target_dir1
v2 = k_att * target_dir2
v3 = k_att * target_dir3
for pos, v in [(agent1_pos, v1), (agent2_pos, v2), (agent3_pos, v3)]:
    d = np.linalg.norm(pos - center)
    if d < d_goal:
        v += k_rep * (pos - center) / (d + 1e-6)
    v_norm = np.linalg.norm(v)
    if v_norm > v_max:
        v = v_max * v / v_norm
    omega = np.clip(np.arctan2(v[1], v[0]) - np.arctan2(pos[1] - center[1], pos[0] - center[0]), -omega_max, omega_max)
    v = v + np.array([-v[1], v[0]]) * omega
    pos += v * dt
    pos[0] = np.clip(pos[0], -10, 10)
    pos[1] = np.clip(pos[1], -10, 10)
    if pos[0] == -10 or pos[0] == 10 or pos[1] == -10:
        v *= -1
        omega *= -1
    agent1_path.append(agent1_pos)
    agent2_path.append(agent2_pos)
    agent3_path.append(agent3_pos)
    t += dt

# 绘制路径
plt.plot([p[0] for p in agent1_path], [p[1] for p in agent1_path], label='agent1')
plt.plot([p[0] for p in agent2_path], [p[1] for p in agent2_path], label='agent2')
plt.plot([p[0] for p in agent3_path], [p[1] for p in agent3_path], label='agent3')
plt.plot([target_pos[0]], [target_pos[1]], marker='o', markersize=8, label='target')
plt.legend()
plt.show()

在程序中，我们首先定义了目标和智能体的初始位置和速度，以及智能体的速度和角速度上限，智能体之间的距离阈值和势场法中的常数。然后，我们循环运行直到目标被成功包围。在每个时间步长中，我们计算每个智能体对目标的距离和方向，并根据势场法计算每个智能体的速度和角速度。如果智能体与目标的距离小于阈值，则停止追逐。在最后一步中，我们计算每个智能体到平均位置的向量，然后根据势场法计算每个智能体的速度和角速度，以形成正三角形的队形来包围目标。

最后，我们绘制每个智能体的路径。您可以在运行程序后查看结果。