def test_wrap_to_pi(self):
self.assertEqual(Pose.wrap_to_pi(0), 0)
self.assertEqual(Pose.wrap_to_pi(-1), -1)
self.assertEqual(Pose.wrap_to_pi(1), 1)
self.assertEqual(Pose.wrap_to_pi(m.pi), -m.pi)
self.assertEqual(Pose.wrap_to_pi(-m.pi), -m.pi)
self.assertEqual(Pose.wrap_to_pi(2 * m.pi), 0)
def __init__(self, p_game_state):
super().__init__(p_game_state)
self.add_tactic(0, Stop(self.game_state, 0))
self.add_tactic(
0, GoStraightTo(self.game_state, 0, Pose(Position(-500, -500))))
self.add_tactic(
0, GoStraightTo(self.game_state, 0, Pose(Position(-1500, -1500))))
self.add_condition(0, 0, 1, self.condition2)
self.add_condition(0, 1, 2, self.condition)
self.add_condition(0, 2, 0, self.condition)
self.add_tactic(1,
GoStraightTo(self.game_state, 1, Pose(Position(0, 0))))
self.add_tactic(
1, GoStraightTo(self.game_state, 1, Pose(Position(1000, 0))))
self.add_tactic(
1, GoStraightTo(self.game_state, 1, Pose(Position(1000, 1000))))
self.add_tactic(
1, GoStraightTo(self.game_state, 1, Pose(Position(0, 1000))))
self.add_condition(1, 0, 1, self.condition1)
self.add_condition(1, 1, 2, self.condition1)
self.add_condition(1, 2, 3, self.condition1)
self.add_condition(1, 3, 0, self.condition1)
for i in range(2, 6):
self.add_tactic(i, Stop(self.game_state, i))
def update(self, cmd: AICommand) -> Pose():
#print(cmd.path_speeds)
self.update_states(cmd)
# Rotation control
rotation_cmd = self.angle_controller.update(
self.pose_error.orientation, dt=self.dt)
rotation_cmd = self.apply_rotation_constraints(rotation_cmd)
if abs(self.pose_error.orientation) < 0.2:
self.rotation_flag = True
# Translation control
self.position_flag = False
if self.position_error.norm(
) < MIN_DISTANCE_TO_REACH_TARGET_SPEED * max(1.0, self.cruise_speed):
if self.target_speed < 0.01:
self.position_flag = True
if self.position_flag:
translation_cmd = Position(
self.x_controller.update(self.pose_error.position.x,
dt=self.dt),
self.y_controller.update(self.pose_error.position.y,
dt=self.dt))
else:
translation_cmd = self.get_next_velocity()
# Adjust command to robot's orientation
# self.ws.debug_interface.add_line(start_point=(self.current_pose.position[0] * 1000, self.current_pose.position[1] * 1000),
# end_point=(self.current_pose.position[0] * 1000 + translation_cmd[0] * 600, self.current_pose.position[1] * 1000 + translation_cmd[1] * 600),
# timeout=0.01, color=debug_interface.CYAN.repr())
compasation_ref_world = translation_cmd.rotate(self.dt * rotation_cmd)
translation_cmd = translation_cmd.rotate(
-(self.current_pose.orientation))
if not self.rotation_flag and cmd.path[-1] is not cmd.path[0]:
translation_cmd *= translation_cmd * 0.0
self.next_speed = 0.0
self.x_controller.reset()
self.y_controller.reset()
if self.position_error.norm() > 0.1 and self.rotation_flag:
self.angle_controller.reset()
rotation_cmd = 0
# self.ws.debug_interface.add_line(
# start_point=(self.current_pose.position[0] * 1000, self.current_pose.position[1] * 1000),
# end_point=(self.current_pose.position[0] * 1000 + compasation_ref_world[0] * 600,
# self.current_pose.position[1] * 1000 + compasation_ref_world[1] * 600),
# timeout=0.01, color=debug_interface.ORANGE.repr())
translation_cmd = self.apply_translation_constraints(translation_cmd)
#if not translation_cmd.norm() < 0.01:
# print(translation_cmd, "self.target_reached()", self.target_reached(), "self.next_speed", self.next_speed,"self.target_speed", self.target_speed )
# self.debug(translation_cmd, rotation_cmd)
return SpeedPose(translation_cmd, rotation_cmd)
def test_to_tuple(self):
uut = Pose()
#sanity check
self.assertNotEqual(type(uut.to_tuple()), type(Pose()))
self.assertEqual(type(uut.to_tuple()), type(tuple()))
self.assertEqual(uut.to_tuple(), tuple((0, 0)))
uut = Pose(Position(557, -778.5), 0)
self.assertEqual(uut.to_tuple(), tuple((557, -778.5)))
self.assertNotEqual(uut.to_tuple(), tuple((-42, 3897)))
def protect_goal(self):
ball_position = self.game_state.get_ball_position()
if not self.game_state.game.field.is_inside_goal_area(
ball_position, self.is_yellow):
self.next_state = self.protect_goal
else:
self.next_state = self.go_behind_ball
self.target = Pose(self.game_state.get_ball_position())
return ProtectGoal(self.game_state,
self.player,
self.is_yellow,
minimum_distance=self.game_state.game.field.
constant["FIELD_GOAL_RADIUS"])
def __init__(self, game_state: GameState, player: OurPlayer, target: Pose=Pose(), args: List[str]=None):
super().__init__(game_state, player, target, args)
self.current_state = self.get_behind_ball
self.next_state = self.get_behind_ball
self.debug_interface = DebugInterface()
self.move_action = self._generate_move_to()
self.move_action.status_flag = Flags.SUCCESS
self.last_ball_position = self.game_state.get_ball_position()
self.charge_time = 0
self.last_time = time.time()
self.orientation_target = 0
self.target = target
def __init__(self, game_state, p_player_id, target=Pose(),
time_to_live=DEFAULT_TIME_TO_LIVE):
Tactic.__init__(self, game_state, p_player_id, target)
assert isinstance(p_player_id, int)
assert PLAYER_PER_TEAM >= p_player_id >= 0
self.player_id = p_player_id
self.current_state = self.protect_goal
self.next_state = self.protect_goal
self.status_flag = Flags.INIT
self.side = None
self.zone = None
self._check_side_and_zone()
def exec(self):
"""
Exécute le déplacement en tenant compte de la possession de la balle. Le robot se déplace vers la destination,
mais s'oriente de façon à garder la balle sur le dribleur. C'est la responsabilité de la Tactique de faire les
corrections de trajectoire nécessaire.
:return:
"""
# TODO: Améliorer le comportement en ajoutant l'intervalle d'anle correspondant à la largeur du dribbleur
destination_orientation = get_angle(
self.player.pose.position, self.game_state.get_ball_position())
destination_pose = Pose(self.destination, destination_orientation)
return AICommand(self.player, AICommandType.MOVE,
**{"pose_goal": destination_pose})
def setUp(self):
self.game_state = GameState()
self.empty_graph = Graph()
self.graph1 = Graph()
self.tactic1 = Stop(self.game_state, 1)
self.tactic2 = GoToPosition(self.game_state, 0,
Pose(Position(500, 0), 0))
self.node1 = Node(self.tactic1)
self.node2 = Node(self.tactic2)
self.vertex1 = Vertex(1, foo)
self.graph1.add_node(self.node1)
self.graph1.add_node(self.node2)
self.graph1.add_vertex(0, 1, foo)
def go_between_ball_and_target(self):
self.status_flag = Flags.WIP
ball = self.game_state.get_ball_position()
ball_velocity = self.game_state.get_ball_velocity().conv_2_np()
if np.linalg.norm(ball_velocity) > 50:
self.target = Pose(
Position.from_np(ball.conv_2_np() - ball_velocity), 0)
dist_behind = np.linalg.norm(ball_velocity) + 1 / np.sqrt(
np.linalg.norm(ball_velocity))
else:
self.target = None
dist_behind = 250
if self.target is None:
self.target = Pose(
self.game_state.const["FIELD_THEIR_GOAL_MID_GOAL"], 0)
if self._is_player_towards_ball_and_target():
self.next_state = self.grab_ball
else:
self.next_state = self.go_between_ball_and_target
return GoBehind(self.game_state, self.player, ball,
self.target.position, dist_behind)
def exec(self):
if self.check_success():
self.status_flag = Flags.SUCCESS
else:
self.status_flag = Flags.WIP
ball = self.game_state.get_ball_position().conv_2_np()
target = self.target.position.conv_2_np()
ball_to_target = target - ball
orientation = np.arctan2(ball_to_target[1], ball_to_target[0])
next_action = RotateAround(self.game_state, self.player,
Pose(Position.from_np(ball), orientation),
90)
return next_action.exec()
def __init__(self, p_game_state, player_id, target=Pose()):
Tactic.__init__(self, p_game_state, player_id, target)
assert isinstance(player_id, int)
assert PLAYER_PER_TEAM >= player_id >= 0
self.player_id = player_id
self.current_state = self.get_behind_ball
self.next_state = self.get_behind_ball
self.move_action = GoToPosition(self.game_state, self.player_id,
self.game_state.get_player_pose(self.player_id))
self.move_action.status_flag = Flags.SUCCESS
self.last_ball_position = self.game_state.get_ball_position()
def protect_goal(self):
# FIXME : enlever ce hack de merde
ball_position = self.game_state.get_ball_position()
if not isInsideGoalArea(ball_position):
self.next_state = self.protect_goal
else:
if canGetBall(self.game_state, self.player_id, ball_position):
self.next_state = self.grab_ball
else:
self.next_state = self.go_behind_ball
self.target = Pose(self.game_state.get_ball_position())
return GoToPositionNoPathfinder(self.game_state, self.player_id)
def test_exec(self):
self.node1.add_vertex(self.vertex1)
self.node1.add_vertex(self.vertex2)
next_ai_command, next_node = self.node1.exec()
self.assertEqual(next_node, 0)
expected_aicmd = AICommand(Pose(Position(-4000, 0), 0), 0)
self.assertEqual(next_ai_command, expected_aicmd)
self.node2.add_vertex(self.vertex2)
expected_aicmd = AICommand(None, 0)
next_ai_command, next_node = self.node2.exec()
self.assertEqual(next_ai_command, expected_aicmd)
self.assertEqual(next_node, -1)
def __init__(self, p_game_state):
super().__init__(p_game_state)
self.add_tactic(0, GoalKeeper(self.game_state, 0))
self.add_tactic(
1, GoStraightTo(self.game_state, 1, Pose(Position(), 3 * pi / 2)))
self.add_tactic(
1, GoStraightTo(self.game_state, 1, Pose(Position(1000, 0), 0)))
self.add_tactic(
1,
GoStraightTo(self.game_state, 1, Pose(Position(1000, 1000),
pi / 2)))
self.add_tactic(
1, GoStraightTo(self.game_state, 1, Pose(Position(0, 1000), pi)))
self.add_condition(1, 0, 1, self.condition)
self.add_condition(1, 1, 2, self.condition)
self.add_condition(1, 2, 3, self.condition)
self.add_condition(1, 3, 0, self.condition)
for i in range(2, PLAYER_PER_TEAM):
self.add_tactic(i, Stop(self.game_state, i))
def generate_destination(self):
player = self.player.pose.position.conv_2_np()
target = self.target.position.conv_2_np()
player_to_target_orientation = np.arctan2(target[1] - player[1], target[0] - player[0])
target_orientation = self.target.orientation
delta_theta = player_to_target_orientation - target_orientation
delta_theta = min(abs(delta_theta), np.pi/6) * np.sign(delta_theta)
rotation_matrix = np.array([[np.cos(delta_theta), np.sin(delta_theta)], [-np.sin(delta_theta), np.cos(delta_theta)]])
player_to_ball_rot = np.dot(rotation_matrix, player - target)
translation = player_to_ball_rot / np.linalg.norm(player_to_ball_rot) * self.rayon
destination = translation + target
orientation = target_orientation
return Pose(Position.from_np(destination), orientation)
def exec(self):
"""
Place le robot afin qu'il prenne le contrôle de la balle
:return: Un tuple (Pose, kick) où Pose est la destination du joueur et kick est nul (on ne botte pas)
"""
ball_position = self.game_state.get_ball_position()
destination_orientation = (ball_position -
self.player.pose.position).angle()
return AICommand(self.player,
AICommandType.MOVE,
pose_goal=Pose(ball_position,
destination_orientation))
def get_path(self,
player: OurPlayer,
pose_target: Pose = Pose(),
cruise_speed: [int, float] = 1,
old_path=None,
old_raw_path=Path(Position(99999, 99999),
Position(99999, -99999))):
self.cruise_speed = cruise_speed
self.player = player
i = 0
self.pose_obstacle = np.zeros(
(len(self.game_state.my_team.available_players) +
len(self.game_state.other_team.available_players) - 1, 2))
for player in self.game_state.my_team.available_players.values():
if player.id != self.player.id:
self.pose_obstacle[i, :] = player.pose.position.conv_2_np()
self.players_obstacles.append(player)
i += 1
for player in self.game_state.other_team.available_players.values():
self.pose_obstacle[i, :] = player.pose.position.conv_2_np()
self.players_obstacles.append(player)
i += 1
# tentative de code pour ne pas recalculer le path a toutes les ittérations (marche un peu mais pas parfait)
if (old_path
is not None) and (not self.is_path_collide(old_raw_path)
) and self.path.goal == old_raw_path.goal:
old_raw_path.quick_update_path(self.player)
old_path.quick_update_path(self.player)
self.path = old_path
self.path = self.remove_redundant_points()
self.raw_path = old_raw_path
else:
self.path = Path(self.player.pose.position, pose_target.position)
self.closest_obs_speed = self.find_closest_obstacle(
self.player.pose.position, self.path)
self.path = self.fastpathplanner(self.path)
self.path = self.remove_redundant_points()
self.raw_path = self.path
self.path = self.reshaper.reshape_path(self.path, self.player,
self.cruise_speed)
if self.is_path_collide(self.raw_path):
self.path.speeds[1] = 0
#print("points", self.path.points)
#print("speeds", self.path.speeds)
return self.path, self.raw_path
def handle_joystick(self):
if self.status_flag is not Flags.FAILURE:
self.status_flag = Flags.WIP
pygame.event.pump()
x, y = self.joy.get_left_axis_vector()
_, t = self.joy.get_right_axis_vector()
if self.joy.get_btn_value("X"):
charge_kick = True
else:
charge_kick = False
if self.joy.get_btn_value("A"):
kick = 4
else:
kick = 0
if self.joy.get_btn_value("B"):
dribbler = 2
else:
dribbler = 0
if self.joy.get_btn_value("Y"):
self.next_state = self.halt
x_speed = -y * self.inv_y
y_speed = x * self.inv_x
speed_pose = Pose(Position(x_speed, y_speed), t * 5)
if kick == 0:
next_action = AllStar(
self.game_state, self.player, **{
"ai_command_type": AICommandType.MOVE,
"pose_goal": speed_pose,
"control_loop_type": AIControlLoopType.SPEED,
"charge_kick": charge_kick,
"kick_strength": kick,
"dribbler_on": dribbler
})
else:
next_action = AllStar(
self.game_state, self.player, **{
"ai_command_type": AICommandType.KICK,
"kick_strength": kick
})
else:
next_action = Idle(self.game_state, self.player)
return next_action
def __init__(self, p_game_state):
super().__init__(p_game_state)
# ID Robot Indiana Jones : 0
# ID Robot obstacles mouvants : 1 et 2
indiana = self.game_state.my_team.available_players[4]
obs_right = self.game_state.my_team.available_players[5]
obs_left = self.game_state.my_team.available_players[3]
# Positions objectifs d'Indiana Jones
goal_left = (Pose(
Position(self.game_state.const["FIELD_GOAL_YELLOW_X_LEFT"], 0), 0))
goal_right = (Pose(
Position(self.game_state.const["FIELD_GOAL_BLUE_X_RIGHT"], 0), 0))
# Positions objectifs des obstacles
y_down = self.game_state.const["FIELD_Y_BOTTOM"] + 500
y_top = self.game_state.const["FIELD_Y_TOP"] - 500
x_left = self.game_state.const["FIELD_X_LEFT"] + 500
x_right = self.game_state.const["FIELD_X_RIGHT"] - 500
self.add_tactic(
indiana.id,
GoToPositionPathfinder(self.game_state, indiana, goal_left))
self.add_tactic(
indiana.id,
GoToPositionPathfinder(self.game_state, indiana, goal_right))
self.add_condition(indiana.id, 0, 1, partial(self.condition, indiana))
self.add_condition(indiana.id, 1, 0, partial(self.condition, indiana))
self.add_tactic(
obs_left.id,
GoToPositionPathfinder(self.game_state, obs_left,
Pose(Position(x_left / 2, y_top))))
self.add_tactic(
obs_left.id,
GoToPositionPathfinder(self.game_state, obs_left,
Pose(Position(x_left / 2, y_down))))
self.add_condition(obs_left.id, 0, 1, partial(self.condition,
obs_left))
self.add_condition(obs_left.id, 1, 0, partial(self.condition,
obs_left))
self.add_tactic(
obs_right.id,
GoToPositionPathfinder(self.game_state, obs_right,
Pose(Position(x_right / 2, y_top))))
self.add_tactic(
obs_right.id,
GoToPositionPathfinder(self.game_state, obs_right,
Pose(Position(x_right / 2, y_down))))
self.add_condition(obs_right.id, 0, 1,
partial(self.condition, obs_right))
self.add_condition(obs_right.id, 1, 0,
partial(self.condition, obs_right))
for i in range(PLAYER_PER_TEAM):
if not (i == obs_right.id or i == obs_left.id or i == indiana.id):
self.add_tactic(i, Stop(self.game_state, i))
def _bouger(self, joueur):
#TODO: ajuster la deadzone en fonction du type du goal
position = self._convertirPosition(self.robot_goals[joueur])
player = self.team.players[joueur]
dist = geometry.get_distance(player.pose.position, position)
deadzone = self._getDeadZone(self.robot_goals[joueur])
if dist < deadzone: # si la distance est exactement 0, la position n'est pas bonne
self._succeed(joueur)
else:
orientation = player.pose.orientation
command = Command.MoveToAndRotate(player, self.team,
Pose(position, orientation))
self._send_command(command)
def grab_ball(self):
if self._get_distance_from_ball(
) < 120 and self._is_player_towards_ball_and_target():
self.next_state = self.halt
self.status_flag = Flags.SUCCESS
else:
self.next_state = self.grab_ball
ball_x = self.game_state.get_ball_position().x
ball_y = self.game_state.get_ball_position().y
angle_ball_2_target = np.arctan2(self.target.position.y - ball_y,
self.target.position.x - ball_x)
return MoveToPosition(
self.game_state, self.player,
Pose(Position(ball_x, ball_y), angle_ball_2_target))
def exec(self):
"""
Exécute le déplacement en tenant compte de la possession de la balle. Le robot se déplace vers la destination,
mais s'oriente de façon à garder la balle sur le dribleur. C'est la responsabilité de la Tactique de faire les
corrections de trajectoire nécessaire.
:return: Un tuple (Pose, kick) où Pose est la destination du joueur kick est faux (on ne botte pas)
"""
# TODO: Améliorer le comportement en ajoutant l'intervalle d'anle correspondant à la largeur du dribleur
destination_orientation = get_angle(
self.game_state.get_player_pose(self.player_id).position,
self.game_state.get_ball_position())
destination_pose = Pose(self.destination, destination_orientation)
kick_strength = 0
return AICommand(destination_pose, kick_strength)
def test_exec(self):
next_ai_command = self.graph1.exec()
expected_ai_command = AICommand(1, AICommandType.STOP)
self.assertEqual(self.graph1.current_node, 1)
self.assertEqual(next_ai_command, expected_ai_command)
self.assertRaises(EmptyGraphException, self.empty_graph.exec)
self.empty_graph.add_node(self.node2)
self.empty_graph.add_node(self.node1)
self.empty_graph.add_vertex(0, 1, foo2)
next_ai_command = self.empty_graph.exec()
expected_ai_command = AICommand(
0, AICommandType.MOVE, **{"pose_goal": Pose(Position(500, 0))})
self.assertEqual(self.empty_graph.current_node, 0)
self.assertEqual(next_ai_command, expected_ai_command)
next_ai_command = self.empty_graph.exec()
expected_ai_command = AICommand(
0, AICommandType.MOVE, **{"pose_goal": Pose(Position(500, 0))})
self.assertEqual(self.empty_graph.current_node, 0)
self.assertEqual(next_ai_command, expected_ai_command)
def update_states(self, cmd: AICommand):
self.dt = self.ws.game_state.game.delta_t
# Dynamics constraints
self.setting.translation.max_acc = self.ws.game_state.get_player(
self.id).max_acc
self.setting.translation.max_speed = self.ws.game_state.get_player(
self.id).max_speed
self.setting.translation.max_angular_acc = self.ws.game_state.get_player(
self.id).max_angular_acc
self.setting.rotation.max_speed = self.ws.game_state.get_player(
self.id).max_angular_speed
# Current state of the robot
self.current_pose = self.ws.game_state.game.friends.players[
self.id].pose.scale(1 / 1000)
self.current_velocity = self.ws.game_state.game.friends.players[
self.id].velocity.scale(1 / 1000)
self.current_speed = self.current_velocity.position.norm()
self.current_angular_speed = self.current_velocity.orientation
self.current_orientation = self.current_pose.orientation
# Desired parameters
if cmd.path != []:
current_path_position = Position(cmd.path[0] / 1000)
if not self.last_position.is_close(
current_path_position, 0.1) and self.target_speed < 0.2:
self.reset()
self.last_position = current_path_position
self.target_pose = Pose(cmd.path[0],
cmd.pose_goal.orientation).scale(1 / 1000)
self.target_turn = cmd.path_turn[1] / 1000
self.target_speed = cmd.path_speeds[1] / 1000
else: # No pathfinder case
self.target_pose = cmd.pose_goal.scale(1 / 1000)
self.target_turn = self.target_pose.position
self.target_speed = 0.0
self.target_angle = self.target_pose.orientation
self.pose_error = self.target_pose - self.current_pose # Pose are always wrap to pi
self.position_error = self.pose_error.position
self.angle_error = self.pose_error.orientation
if self.position_error.norm() != 0.0:
self.target_direction = (self.target_turn -
self.current_pose.position).normalized()
self.cruise_speed = cmd.cruise_speed
def test_eq(self):
pos1 = Pose()
pos2 = Pose()
pos3 = Pose(Position(500, 400), 0)
pos4 = Pose(Position(500, 400), 1.5)
pos5 = Pose(Position(500, 400), -1.5)
pos6 = Pose(Position(400, 500), 0)
pos7 = Pose(Position(), 1.54679)
pos8 = Pose(Position(), 1.54671)
pos9 = Pose(Position(), 1.5466)
pos10 = Pose(Position(), 1.5468)
self.assertEqual(pos1, pos2)
self.assertEqual(pos2, pos1)
self.assertFalse(pos3 == pos4)
self.assertFalse(pos3 == pos5)
self.assertFalse(pos3 == pos6)
self.assertTrue(pos7 == pos8)
self.assertFalse(pos7 == pos9)
self.assertFalse(pos7 == pos10)
def exec(self):
if self.check_success():
self.current_position_index_to_go = random.randint(
0,
len(self.grid_of_positions) - 1)
self.current_position_to_go = self.grid_of_positions[
self.current_position_index_to_go]
#self.current_angle_to_go = random.randint(-1, 1) * np.pi / 100.
self.next_pose = Pose(self.current_position_to_go,
self.current_angle_to_go)
self.next_state = self.exec
return GoToPositionPathfinder(self.game_state, self.player,
self.next_pose).exec()
def _bouger(self, joueur):
#TODO: ajuster la deadzone en fonction du type du goal
position = self._convertirPosition(self.robot_goals[joueur])
player = self.team.players[joueur]
dist = geometry.get_distance(player.pose.position, position)
print(dist)
deadzone = 225 #225 est la deadzone nécessaire pour que le robot ne fonce pas dans la balle
if 0 < dist < deadzone: # si la distance est exactement 0, la position n'est pas bonne
self._succeed(joueur)
else:
orientation = player.pose.orientation
command = Command.MoveToAndRotate(player, self.team,
Pose(position, orientation))
self._send_command(command)
def exec(self):
for player in self.ws.game_state.my_team.available_players.values():
if player.ai_command is None:
continue
cmd = player.ai_command
r_id = player.id
if cmd.command is AICommandType.MOVE:
if cmd.control_loop_type is AIControlLoopType.POSITION:
cmd.speed = self.robot_motion[r_id].update(cmd)
elif cmd.control_loop_type is AIControlLoopType.SPEED:
speed = fixed2robot(cmd.pose_goal.conv_2_np(),
player.pose.orientation)
cmd.speed = Pose(Position(speed[Pos.X], speed[Pos.Y]),
speed[Pos.THETA])
elif cmd.control_loop_type is AIControlLoopType.OPEN:
cmd.speed = cmd.pose_goal
elif cmd.command is AICommandType.STOP:
cmd.speed = Pose(Position(0, 0), 0)
self.robot_motion[r_id].stop()
def __init__(self, p_game_state):
super().__init__(p_game_state)
ourgoal = Pose(
Position(GameState().const["FIELD_OUR_GOAL_X_EXTERNAL"], 0), 0)
self.theirgoal = Pose(
Position(GameState().const["FIELD_THEIR_GOAL_X_EXTERNAL"], 0), 0)
roles_to_consider = [
Role.FIRST_ATTACK, Role.SECOND_ATTACK, Role.MIDDLE,
Role.FIRST_DEFENCE, Role.SECOND_DEFENCE
]
role_by_robots = [(i, self.game_state.get_player_by_role(i))
for i in roles_to_consider]
goalkeeper = self.game_state.get_player_by_role(Role.GOALKEEPER)
self.add_tactic(Role.GOALKEEPER,
GoalKeeper(self.game_state, goalkeeper, ourgoal))
for index, player in role_by_robots:
if player:
self.add_tactic(
index,
PositionForPass(self.game_state,
player,
auto_position=True))
self.add_tactic(
index,
GoKick(self.game_state, player, auto_update_target=True))
self.add_condition(index, 0, 1,
partial(self.is_closest, player))
self.add_condition(index, 1, 0,
partial(self.is_not_closest, player))
self.add_condition(index, 1, 1,
partial(self.has_kicked, player))
def test_exec(self):
next_ai_command = self.graph1.exec()
expected_ai_command = Idle(self.game_state, self.a_player).exec()
self.assertEqual(self.graph1.current_node, 1)
self.assertEqual(next_ai_command, expected_ai_command)
self.assertRaises(EmptyGraphException, self.empty_graph.exec)
self.empty_graph.add_node(self.node2)
self.empty_graph.add_node(self.node1)
self.empty_graph.add_vertex(0, 1, foo2)
next_ai_command = self.empty_graph.exec()
expected_ai_command = GoToPositionNoPathfinder(
self.game_state, self.a_player, Pose(Position(500, 0), 0)).exec()
self.assertEqual(self.empty_graph.current_node, 0)
self.assertEqual(next_ai_command, expected_ai_command)
next_ai_command = self.empty_graph.exec()
expected_ai_command = GoToPositionNoPathfinder(
self.game_state, self.a_player, Pose(Position(500, 0), 0)).exec()
self.assertEqual(self.empty_graph.current_node, 0)
self.assertEqual(next_ai_command, expected_ai_command)
