构建AI智能体：反应式智能体：基于感知-行动，AI世界的条件反射

规则集 = [
    "如果(前方有障碍物) 那么(向左转)",
    "如果(电量低于20%) 那么(返回充电)",
    "如果(检测到目标) 那么(向前移动)",
    "如果(无特殊情况) 那么(随机探索)"
]

行为层 = {
    # 最高优先级：安全相关
    "紧急制动": {"条件": "碰撞 imminent", "动作": "全力刹车"},
    
    # 高优先级：避障
    "主动避障": {"条件": "前方有障碍", "动作": "转向避让"},
    
    # 中优先级：导航
    "车道保持": {"条件": "偏离车道", "动作": "微调方向"},
    
    # 低优先级：舒适性
    "平稳驾驶": {"条件": "道路弯曲", "动作": "平滑转向"}
}

def get_sensor_readings(self, obstacles):
    readings = []
    for sensor_angle in self.sensor_angles:
        sensor_dir = np.array([
            np.cos(self.angle + sensor_angle),  # 传感器方向向量x分量
            np.sin(self.angle + sensor_angle)   # 传感器方向向量y分量
        ])
        
        min_distance = self.sensor_range  # 初始化为最大探测距离
        
        for obstacle in obstacles:
            # 计算机器人到障碍物的向量
            obstacle_pos = np.array([obstacle[0], obstacle[1]])
            robot_pos = np.array([self.x, self.y])
            to_obstacle = obstacle_pos - robot_pos
            
            # 向量投影：判断障碍物是否在传感器前方
            projection = np.dot(to_obstacle, sensor_dir)
            
            if projection > 0:  # 障碍物在传感器前方
                # 计算障碍物到传感器射线的垂直距离
                distance_to_ray = np.linalg.norm(to_obstacle - projection * sensor_dir)
                
                if distance_to_ray < obstacle[2]:  # 如果距离小于障碍物半径
                    # 计算实际的碰撞距离
                    hit_distance = projection - np.sqrt(obstacle[2]**2 - distance_to_ray**2)
                    if 0 < hit_distance < min_distance:
                        min_distance = hit_distance
            
            readings.append(min_distance)
    return readings

def reactive_control(self, sensor_readings):
    # 传感器分组：左2个、前1个、右2个
    left_readings = sensor_readings[:2]    # 左侧传感器
    front_readings = sensor_readings[2]    # 前方传感器  
    right_readings = sensor_readings[3:]   # 右侧传感器
    
    # 计算各方向的最小距离
    min_front = min(front_readings, self.sensor_range)
    min_left = min(left_readings)
    min_right = min(right_readings)
    
    # 行为1: 紧急避障 (最高优先级)
    if min_front < 0.8:  # 前方很近有障碍
        self.speed = 0.3  # 减速
        # 选择更空旷的一侧转向
        if min_left > min_right:
            self.angle -= np.pi/4  # 向右转45度
        else:
            self.angle += np.pi/4  # 向左转45度
        self.current_behavior = "紧急避障"
        return self.current_behavior
    
    # 行为2: 预防性避障 (中优先级)
    elif min_front < 1.5:  # 前方较近有障碍
        self.speed = 0.4
        if min_left > min_right:
            self.angle -= np.pi/8  # 向右转22.5度
        else:
            self.angle += np.pi/8  # 向左转22.5度
        self.current_behavior = "预防避障"
        return self.current_behavior
    
    # 行为3: 沿墙跟随 (低优先级)
    elif min_left < 1.2 or min_right < 1.2:  # 侧面有墙
        self.speed = 0.6
        if min_left < min_right:  # 左侧有墙
            self.angle -= 0.1  # 向右微调
        else:  # 右侧有墙  
            self.angle += 0.1  # 向左微调
        self.current_behavior = "沿墙跟随"
        return self.current_behavior
    
    # 行为4: 随机探索 (默认行为)
    else:
        self.speed = 0.8  # 正常速度
        # 加入随机扰动，避免陷入局部循环
        self.angle += random.uniform(-0.2, 0.2)
        self.current_behavior = "随机探索"
        return self.current_behavior

def update_position(self, obstacles, area_bounds):
    # 1. 感知：获取传感器数据
    sensor_readings = self.get_sensor_readings(obstacles)
    
    # 2. 决策：反应式控制
    behavior = self.reactive_control(sensor_readings)
    
    # 3. 行动：更新位置
    dx = self.speed * np.cos(self.angle) * 0.1  # x方向位移
    dy = self.speed * np.sin(self.angle) * 0.1  # y方向位移
    
    new_x = self.x + dx
    new_y = self.y + dy
    
    # 边界检查：防止跑出环境
    if (area_bounds[0] < new_x < area_bounds[2] and 
        area_bounds[1] < new_y < area_bounds[3]):
        self.x = new_x
        self.y = new_y
    
    # 记录轨迹（最多100个点）
    self.trajectory.append((self.x, self.y))
    if len(self.trajectory) > 100:
        self.trajectory.pop(0)  # 移除最旧的点
        
    return behavior, sensor_readings

def create_environment():
    # 障碍物格式：(x坐标, y坐标, 半径)
    obstacles = [
        (3, 2, 0.8),  # 中心区域的大障碍物
        (6, 4, 1.0),  # 右侧的大障碍物  
        (8, 2, 0.6),  # 右上角的小障碍物
        (4, 6, 0.7),  # 中部偏上的障碍物
        (7, 7, 0.9),  # 右上角的大障碍物
        (2, 8, 0.5),  # 左上角的小障碍物
        (9, 9, 0.6),  # 最右上角的障碍物
        (5, 3, 0.4)   # 中心区域的小障碍物
    ]
    
    # 环境边界：(x_min, y_min, x_max, y_max)
    area_bounds = (0, 0, 10, 10)
    
    return obstacles, area_bounds

def animate(frame):
    ax.clear()
    
    # 更新机器人位置（第一帧除外）
    if frame > 0:
        behavior, sensor_readings = robot.update_position(obstacles, area_bounds)
    
    # 绘制传感器（颜色编码）
    for i, (sensor_angle, reading) in enumerate(zip(robot.sensor_angles, sensor_readings)):
        sensor_dir = np.array([np.cos(robot.angle + sensor_angle), 
                              np.sin(robot.angle + sensor_angle)])
        sensor_length = min(reading, robot.sensor_range)
        
        end_x = robot.x + sensor_length * sensor_dir[0]
        end_y = robot.y + sensor_length * sensor_dir[1]
        
        # 颜色编码：绿色(安全) → 橙色(警告) → 红色(危险)
        if reading > 1.5:
            color = 'green'   # 安全距离
        elif reading > 0.8:
            color = 'orange'  # 警告距离  
        else:
            color = 'red'     # 危险距离
            
        ax.plot([robot.x, end_x], [robot.y, end_y], color=color, 
               linewidth=2, alpha=0.7)

# 机器人没有记忆环境地图，只依赖当前传感器数据
def reactive_control(self, sensor_readings):  # 只使用当前传感器读数
    # 不访问历史数据，不维护环境模型
    # 决策完全基于当前的sensor_readings

# 明确的优先级顺序
if min_front < 0.8:        # 1. 紧急避障 (最高)
elif min_front < 1.5:      # 2. 预防避障  
elif min_left < 1.2 or ... # 3. 沿墙跟随
else:                      # 4. 随机探索 (最低)

# 每帧都重新感知和决策
def update_position(self, obstacles, area_bounds):
    sensor_readings = self.get_sensor_readings(obstacles)  # 实时感知
    behavior = self.reactive_control(sensor_readings)      # 实时决策
    # 立即执行动作

# 简单规则组合产生复杂行为
# 单个规则很简单，但组合后能：
# - 自主避开所有障碍物
# - 沿着墙壁行走  
# - 探索未知区域
# - 不会陷入死循环