def __init__(self, p_game_state):
super().__init__(p_game_state)
our_goal = self.game_state.field.our_goal_pose
role_to_positions = {
Role.FIRST_ATTACK:
Pose.from_values(our_goal.position.x / 8,
GameState().field.top * 2 / 3),
Role.SECOND_ATTACK:
Pose.from_values(our_goal.position.x / 8,
GameState().field.top / 3),
Role.MIDDLE:
Pose.from_values(our_goal.position.x / 8, 0),
Role.FIRST_DEFENCE:
Pose.from_values(our_goal.position.x / 8,
GameState().field.bottom / 3),
Role.SECOND_DEFENCE:
Pose.from_values(our_goal.position.x / 8,
GameState().field.bottom * 2 / 3)
}
goalkeeper = self.game_state.get_player_by_role(Role.GOALKEEPER)
self.create_node(
Role.GOALKEEPER,
GoalKeeper(self.game_state, goalkeeper, penalty_kick=True))
self.assign_tactics(role_to_positions)
def __init__(self, game_state):
super().__init__(game_state)
their_goal = game_state.field.their_goal
role_to_positions = {
Role.FIRST_ATTACK:
Pose.from_values(their_goal.x / 8,
self.game_state.field.top * 2 / 3),
Role.SECOND_ATTACK:
Pose.from_values(their_goal.x / 8, self.game_state.field.top / 3),
Role.MIDDLE:
Pose.from_values(their_goal.x / 8, 0),
Role.FIRST_DEFENCE:
Pose.from_values(their_goal.x / 8,
self.game_state.field.bottom / 3),
Role.SECOND_DEFENCE:
Pose.from_values(their_goal.x / 8,
self.game_state.field.bottom * 2 / 3)
}
goalkeeper = self.assigned_roles[Role.GOALKEEPER]
self.create_node(Role.GOALKEEPER,
GoalKeeper(game_state, goalkeeper, penalty_kick=True))
self.assign_tactics(role_to_positions)
def __init__(self, p_game_state):
super().__init__(p_game_state)
# Positions objectifs des joueurs
attack_top_position = Pose.from_values(
self.game_state.field.our_goal_x / 15,
self.game_state.field.bottom * 3 / 5, 0)
attack_bottom_position = Pose.from_values(
self.game_state.field.our_goal_x / 15,
self.game_state.field.top * 3 / 5, 0)
middle_position = Pose.from_values(
self.game_state.field.our_goal_x / 15, 0, 0)
defense_top_position = Pose.from_values(
self.game_state.field.our_goal_x / 2,
self.game_state.field.top / 3, 0)
defense_bottom_position = Pose.from_values(
self.game_state.field.our_goal_x / 2,
self.game_state.field.bottom / 3, 0)
goalkeeper = self.assigned_roles[Role.GOALKEEPER]
self.create_node(Role.GOALKEEPER,
GoalKeeper(self.game_state, goalkeeper))
role_to_positions = {
Role.FIRST_ATTACK: attack_top_position,
Role.SECOND_ATTACK: attack_bottom_position,
Role.MIDDLE: middle_position,
Role.FIRST_DEFENCE: defense_top_position,
Role.SECOND_DEFENCE: defense_bottom_position
}
self.assign_tactics(role_to_positions)
def __init__(self, game_state):
super().__init__(game_state)
# Attribution des joueurs
center_offset = game_state.field.center_circle_radius
# Positions objectifs des joueurs
# FIXME: This is bad, the orientation of the player will always be the same,
# independently of if we are in a positive or negative x
attack_top_position = Pose.from_values(GameState().field.our_goal_x / 10,
GameState().field.bottom * 3 / 5, 0)
attack_bottom_position = Pose.from_values(GameState().field.our_goal_x / 10,
GameState().field.top * 3 / 5, 0)
middle_position = Pose.from_values(center_offset + GameState().field.our_goal_x / 10, 0, 0)
defense_top_position = Pose.from_values(GameState().field.our_goal_x / 2,
GameState().field.top / 10, 0)
defense_bottom_position = Pose.from_values(GameState().field.our_goal_x / 2,
GameState().field.bottom / 10, 0)
goalkeeper = self.assigned_roles[Role.GOALKEEPER]
self.create_node(Role.GOALKEEPER, GoalKeeper(game_state, goalkeeper))
role_to_positions = {Role.FIRST_ATTACK: attack_top_position,
Role.SECOND_ATTACK: attack_bottom_position,
Role.MIDDLE: middle_position,
Role.FIRST_DEFENCE: defense_top_position,
Role.SECOND_DEFENCE: defense_bottom_position}
self.assign_tactics(role_to_positions)
def __init__(self, number_id: int, team):
assert isinstance(number_id, int)
assert number_id in range(0, Config()['ENGINE']['max_robot_id'])
self._id = number_id
self._team = team
self._pose = Pose()
self._velocity = Pose()
def __init__(self, game_state):
super().__init__(game_state)
their_goal = game_state.field.their_goal
role_to_positions = {Role.FIRST_ATTACK: Pose.from_values(their_goal.x / 8, self.game_state.field.top * 2 / 3),
Role.SECOND_ATTACK: Pose.from_values(their_goal.x / 8, self.game_state.field.top / 3),
Role.MIDDLE: Pose.from_values(their_goal.x / 8, 0),
Role.FIRST_DEFENCE: Pose.from_values(their_goal.x / 8, self.game_state.field.bottom / 3),
Role.SECOND_DEFENCE: Pose.from_values(their_goal.x / 8, self.game_state.field.bottom * 2 / 3)}
goalkeeper = self.assigned_roles[Role.GOALKEEPER]
self.create_node(Role.GOALKEEPER, GoalKeeper(game_state, goalkeeper, penalty_kick=True))
self.assign_tactics(role_to_positions)
def __init__(self, p_game_state):
super().__init__(p_game_state)
their_goal = self.game_state.field.their_goal_pose
role_to_positions = {Role.FIRST_ATTACK: Pose.from_values(their_goal.position.x / 8, GameState().field.top * 2 / 3),
Role.SECOND_ATTACK: Pose.from_values(their_goal.position.x / 8, GameState().field.top / 3),
Role.MIDDLE: Pose.from_values(their_goal.position.x / 8, 0),
Role.FIRST_DEFENCE: Pose.from_values(their_goal.position.x / 8, GameState().field.bottom / 3),
Role.SECOND_DEFENCE: Pose.from_values(their_goal.position.x / 8, GameState().field.bottom * 2 / 3)}
goalkeeper = self.game_state.get_player_by_role(Role.GOALKEEPER)
self.create_node(Role.GOALKEEPER, GoalKeeper(self.game_state, goalkeeper, penalty_kick=True))
self.assign_tactics(role_to_positions)
def __init__(self, game_state):
super().__init__(game_state)
our_goal = game_state.field.our_goal_pose
their_goal = game_state.field.their_goal_pose
role_to_positions = {Role.SECOND_ATTACK: Pose.from_values(our_goal.position.x / 8, GameState().field.top * 2 / 3),
Role.MIDDLE: Pose.from_values(our_goal.position.x / 8, GameState().field.top / 3),
Role.FIRST_DEFENCE: Pose.from_values(our_goal.position.x / 8, GameState().field.bottom / 3),
Role.SECOND_DEFENCE: Pose.from_values(our_goal.position.x / 8, GameState().field.bottom * 2 / 3)}
kicker = self.assigned_roles[Role.FIRST_ATTACK]
self.create_node(Role.FIRST_ATTACK, GoKick(game_state, kicker, their_goal, kick_force=KickForce.HIGH))
goalkeeper = self.assigned_roles[Role.GOALKEEPER]
self.create_node(Role.GOALKEEPER, GoalKeeper(game_state, goalkeeper, penalty_kick=True))
self.assign_tactics(role_to_positions)
def GoBetween(position1: Position,
position2: Position,
target: Position,
minimum_distance: float = 0):
delta = minimum_distance * normalize(position2 - position1)
position1 = position1 + delta
position2 = position2 - delta
destination = closest_point_on_segment(target, position1, position2)
dest_to_target = target - destination
return CmdBuilder().addMoveTo(Pose(destination,
dest_to_target.angle)).build()
def __init__(self, p_game_state):
super().__init__(p_game_state)
# Positions objectifs des joueurs
attack_top_position = Pose.from_values(self.game_state.field.our_goal_x / 15,
self.game_state.field.bottom * 3 / 5, 0)
attack_bottom_position = Pose.from_values(self.game_state.field.our_goal_x / 15,
self.game_state.field.top * 3 / 5, 0)
middle_position = Pose.from_values(self.game_state.field.our_goal_x / 15, 0, 0)
defense_top_position = Pose.from_values(self.game_state.field.our_goal_x / 2,
self.game_state.field.top / 3, 0)
defense_bottom_position = Pose.from_values(self.game_state.field.our_goal_x / 2,
self.game_state.field.bottom / 3, 0)
goalkeeper = self.assigned_roles[Role.GOALKEEPER]
self.create_node(Role.GOALKEEPER, GoalKeeper(self.game_state, goalkeeper))
role_to_positions = {Role.FIRST_ATTACK: attack_top_position,
Role.SECOND_ATTACK: attack_bottom_position,
Role.MIDDLE: middle_position,
Role.FIRST_DEFENCE: defense_top_position,
Role.SECOND_DEFENCE: defense_bottom_position}
self.assign_tactics(role_to_positions)
def addMoveTo(self,
target: Union[Pose, Position],
cruise_speed: float = 1,
end_speed: float = 0,
ball_collision=True,
way_points=None,
enable_pathfinder=True):
assert isinstance(target, (Pose, Position))
self._target = Pose(target) if isinstance(target, Position) else target
self._cruise_speed = cruise_speed
self._end_speed = end_speed
self._ball_collision = ball_collision
self._enable_pathfinder = enable_pathfinder
if way_points is not None: self._way_points = way_points
return self
def __init__(self, p_game_state):
super().__init__(p_game_state)
robot1 = Role.FIRST_ATTACK
robot2 = Role.SECOND_ATTACK
robot3 = Role.MIDDLE
dist_inter_robot = 300
positions_on_xaxis = [Pose(Position(-dist_inter_robot*3, 0), 1.57),
Pose(Position(-dist_inter_robot*2, 0), 1.57),
Pose(Position(-dist_inter_robot, 0), 1.57),
Pose(Position(dist_inter_robot, 0), 1.57),
Pose(Position(2*dist_inter_robot, 0), 1.57),
Pose(Position(3*dist_inter_robot, 0), 1.57)]
shuffle(positions_on_xaxis)
positions_on_yaxis = [Pose(Position(0, -dist_inter_robot * 3), 0),
Pose(Position(0, -dist_inter_robot * 2), 0),
Pose(Position(0, -dist_inter_robot), 0),
Pose(Position(0, dist_inter_robot), 0),
Pose(Position(0, 2 * dist_inter_robot), 0),
Pose(Position(0, 3 * dist_inter_robot), 0)]
shuffle(positions_on_yaxis)
node_robot1_go_to_x = self.create_node(robot1, GoToPosition(self.game_state, self.assigned_roles[robot1], positions_on_xaxis[1], cruise_speed=2))
node_robot1_go_to_y = self.create_node(robot1, GoToPosition(self.game_state, self.assigned_roles[robot1], positions_on_yaxis[2], cruise_speed=2))
robot_1_succeeded = partial(self.current_tactic_succeed, robot1)
node_robot1_go_to_x.connect_to(node_robot1_go_to_y, when=robot_1_succeeded)
node_robot1_go_to_y.connect_to(node_robot1_go_to_x, when=robot_1_succeeded)
node_robot_2_go_to_x = self.create_node(robot2, GoToPosition(self.game_state, self.assigned_roles[robot2], positions_on_xaxis[3], cruise_speed=2))
node_robot_2_go_to_y = self.create_node(robot2, GoToPosition(self.game_state, self.assigned_roles[robot2], positions_on_yaxis[4], cruise_speed=2))
robot2_succeeded = partial(self.current_tactic_succeed, robot2)
node_robot_2_go_to_x.connect_to(node_robot_2_go_to_y, when=robot2_succeeded)
node_robot_2_go_to_y.connect_to(node_robot_2_go_to_x, when=robot2_succeeded)
node_robot3_go_to_x = self.create_node(robot3, GoToPosition(self.game_state, self.assigned_roles[robot3], positions_on_xaxis[5], cruise_speed=2))
node_robot3_go_to_y = self.create_node(robot3, GoToPosition(self.game_state, self.assigned_roles[robot3], positions_on_yaxis[0], cruise_speed=2))
robot3_succeeded = partial(self.current_tactic_succeed, robot3)
node_robot3_go_to_x.connect_to(node_robot3_go_to_y, when=robot3_succeeded)
node_robot3_go_to_y.connect_to(node_robot3_go_to_x, when=robot3_succeeded)
def __init__(self, game_state):
super().__init__(game_state)
indiana = self.assigned_roles[Role.MIDDLE]
indiana_role = Role.MIDDLE
obs_right = self.assigned_roles[Role.FIRST_DEFENCE]
obs_right_role = Role.FIRST_DEFENCE
obs_left = self.assigned_roles[Role.SECOND_DEFENCE]
obs_left_role = Role.SECOND_DEFENCE
# Positions objectifs d'Indiana Jones
FIELD_GOAL_INTERNAL_X = self.game_state.field.our_goal_area.left - ROBOT_DIAMETER
goal_left = (Pose(Position(+FIELD_GOAL_INTERNAL_X, 0),
indiana.pose.orientation))
goal_right = (Pose(Position(-FIELD_GOAL_INTERNAL_X, 0),
indiana.pose.orientation))
# Positions objectifs des obstacles
y_bottom = self.game_state.field.bottom + 500
y_top = self.game_state.field.top - 500
x_left = self.game_state.field.left + 500
x_right = self.game_state.field.right - 500
node_go_to_goal_left = self.create_node(
indiana_role,
GoToPosition(self.game_state, indiana, goal_left, cruise_speed=2))
node_go_to_goal_right = self.create_node(
indiana_role,
GoToPosition(self.game_state, indiana, goal_right, cruise_speed=2))
indiana_succeeded = partial(self.current_tactic_succeed, indiana_role)
node_go_to_goal_left.connect_to(node_go_to_goal_right,
when=indiana_succeeded)
node_go_to_goal_right.connect_to(node_go_to_goal_left,
when=indiana_succeeded)
node_go_to_top_left = self.create_node(
obs_left_role,
GoToPosition(self.game_state,
obs_left,
Pose(Position(x_left / 2, y_top),
obs_left.pose.orientation),
cruise_speed=2))
node_go_to_bottom_left = self.create_node(
obs_left_role,
GoToPosition(
self.game_state, obs_left,
Pose(Position(x_left / 2, y_bottom),
obs_left.pose.orientation)))
obs_left_role_succeeded = partial(self.current_tactic_succeed,
obs_left_role)
node_go_to_top_left.connect_to(node_go_to_bottom_left,
when=obs_left_role_succeeded)
node_go_to_bottom_left.connect_to(node_go_to_top_left,
when=obs_left_role_succeeded)
node_go_to_top_right = self.create_node(
obs_right_role,
GoToPosition(self.game_state,
obs_right,
Pose(Position(x_right / 2, y_top),
obs_right.pose.orientation),
cruise_speed=2))
node_go_to_bottom_right = self.create_node(
obs_right_role,
GoToPosition(self.game_state,
obs_right,
Pose(Position(x_right / 2, y_bottom),
obs_right.pose.orientation),
cruise_speed=2))
obs_right_role_succeeded = partial(self.current_tactic_succeed,
obs_right_role)
node_go_to_top_right.connect_to(node_go_to_bottom_right,
when=obs_right_role_succeeded)
node_go_to_bottom_right.connect_to(node_go_to_top_right,
when=obs_right_role_succeeded)