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 best_passing_option(passing_player, passer_can_kick_in_goal=True):
# Retourne l'ID du player ou le but le mieux placé pour une passe, NONE si but est la meilleure possibilité
score_min = float("inf")
goal = GameState().field.their_goal
receiver = None
for p in GameState().our_team.available_players.values():
try:
is_goaler = p == GameState().get_player_by_role(Role.GOALKEEPER)
except KeyError:
is_goaler = False
if p != passing_player and not is_goaler:
# Calcul du score pour passeur vers receveur
score = line_of_sight_clearance(passing_player, p.pose.position)
# Calcul du score pour receveur vers but
score += line_of_sight_clearance(p, goal)
if score_min > score:
score_min = score
receiver = p
if passer_can_kick_in_goal and not is_ball_our_side():
score = (line_of_sight_clearance(passing_player, goal))
if score_min > score:
receiver = None
return receiver
def best_passing_option(passing_player, consider_goal=True):
# Retourne l'ID du player ou le but le mieux placé pour une passe, NONE si but est la meilleure possibilité
score_min = float("inf")
goal = Position(GameState().field.constant["FIELD_THEIR_GOAL_X_EXTERNAL"], 0)
receiver_id = None
for i in GameState().my_team.available_players.values():
if i.id != passing_player.id:
# Calcul du score pour passeur vers receveur
score = line_of_sight_clearance(passing_player, np.array(i.pose.position))
# Calcul du score pour receveur vers but
score += line_of_sight_clearance(i, goal)
if (score_min > score).any():
score_min = score
receiver_id = i.id
if consider_goal and not is_ball_our_side():
score = (line_of_sight_clearance(passing_player, np.array(goal)))
if score_min > score:
receiver_id = None
return receiver_id
def _change_tactic(self, cmd: STAChangeCommand):
try:
this_player = GameState().our_team.available_players[cmd.data['id']]
except KeyError:
self.logger.info('A tactic was assign to a player which is not on the field (id={}).'.format(cmd.data['id']))
this_player = GameState().our_team.players[cmd.data['id']]
player_id = this_player.id
tactic_name = cmd.data['tactic']
target = Position.from_list(cmd.data['target'])
if config['GAME']['on_negative_side']:
target = target.flip_x()
target = Pose(target, this_player.orientation)
args = cmd.data.get('args', '')
try:
tactic = self.play_state.get_new_tactic(tactic_name)(self.game_state, this_player, target, args)
except:
self.logger.exception('An error occurred.')
self.logger.debug('The tactic was call with wrong arguments')
raise
if not isinstance(self.play_state.current_strategy, HumanControl):
self.play_state.current_strategy = 'HumanControl'
self.play_state.current_strategy.assign_tactic(tactic, player_id)
def __init__(self, game_state: GameState, number_of_players: int = 4):
super().__init__(game_state)
self.number_of_players = number_of_players
self.robots = []
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
]
goalkeeper = self.game_state.get_player_by_role(Role.GOALKEEPER)
self.add_tactic(Role.GOALKEEPER,
GoalKeeper(self.game_state, goalkeeper, ourgoal))
role_by_robots = [(i, self.game_state.get_player_by_role(i))
for i in roles_to_consider]
self.robots = [
player for _, player in role_by_robots if player is not None
]
for role, player in role_by_robots:
if player:
self.add_tactic(
role,
AlignToDefenseWall(self.game_state, player, self.robots))
def _create_mock_teams(self, allies, opponents):
team1 = create_autospec(Team)
team1.available_players = allies
GameState().my_team = team1
team2 = create_autospec(Team)
team2.available_players = opponents
GameState().other_team = team2
def best_goal_score_option(passing_player):
# Retourne la meilleure position dans le but pour kick
goalA = Position(GameState().field.constant["FIELD_THEIR_GOAL_X_EXTERNAL"],
GameState().field.constant["FIELD_GOAL_WIDTH"]/2)
goalB = Position(GameState().field.constant["FIELD_THEIR_GOAL_X_EXTERNAL"],
-GameState().field.constant["FIELD_GOAL_WIDTH"] / 2)
best_position = best_position_option(passing_player, goalA, goalB)
return best_position
def create_mock_teams(allies, opponents):
team1 = create_autospec(Team)
team1.available_players = allies
GameState()._our_team = team1
print(GameState().our_team.available_players.values())
team2 = create_autospec(Team)
team2.available_players = opponents
GameState()._enemy_team = team2
def _exec_state(self):
# We use the ball's mobility for detecting a kick and change state
if self.current_state in self.NORMAL_STATE and GameState().ball.is_immobile():
return self._decide_between_normal_play()
elif self.current_state in self.FREE_KICK_STATE and GameState().ball.is_mobile():
return self._decide_between_normal_play()
elif self.current_state in self.KICKOFF_STATE and GameState().ball.is_mobile():
return self._decide_between_normal_play()
return self.current_state
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 player_covered_from_goal(player: Player):
shooting_angle = angle_between_three_points(GameState().field.their_goal_line.p1,
player.position, GameState().field.their_goal_line.p2)
vec_player_to_goal = GameState().field.their_goal - player.position
our_team = [other_player for other_player in GameState().our_team.available_players.values() if other_player is not player]
enemy_team = [other_player for other_player in GameState().enemy_team.available_players.values()]
pertinent_collisions = []
for other_player in our_team + enemy_team:
if object_pointing_toward_point(player.position,
vec_player_to_goal.angle,
other_player.position,
wrap_to_pi(shooting_angle + 5 * np.pi / 180)):
pertinent_collisions.append(Obstacle(other_player.position.array, avoid_distance=90))
if not any(pertinent_collisions):
return GameState().field.their_goal
pertinent_collisions_positions = np.array([obs.position for obs in pertinent_collisions])
pertinent_collisions_avoid_radius = np.array([obs.avoid_distance for obs in pertinent_collisions])
results = []
for i in range(0, 15 + 1): # discretisation de la ligne de but
goal_point = GameState().field.their_goal_line.p1 + GameState().field.their_goal_line.direction * \
(GameState().field.their_goal_line.length * i / 15)
is_colliding = is_path_colliding(pertinent_collisions, pertinent_collisions_positions,
pertinent_collisions_avoid_radius, player.position.array, goal_point.array)
results.append((is_colliding, goal_point))
max_len_seg, indexend = find_max_consecutive_bool(results)
if max_len_seg == 0 and indexend == 0:
return None
return results[int(indexend-1 - np.math.ceil(max_len_seg / 2))][1]
def setUp(self):
self.game = Game()
self.referee = Referee
self.game.set_referee(self.referee)
self.tcsvc = TeamColorService(TeamColor.BLUE)
self.game_world_OK = ReferenceTransferObject(self.game)
self.game_world_OK.set_team_color_svc(self.tcsvc)
self.GameStateManager1 = GameState()
self.GameStateManager2 = GameState()
self.GameStateManager1.set_reference(self.game_world_OK)
def _find_best_passing_option(self):
assignation_delay = (time.time() - self.target_assignation_last_time)
if assignation_delay > TARGET_ASSIGNATION_DELAY:
tentative_target_id = best_passing_option(self.player)
if tentative_target_id is None:
self.target = Pose.from_values(GameState().field.their_goal_x, 0, 0)
else:
self.target = Pose(GameState().get_player_position(tentative_target_id))
self.target_assignation_last_time = time.time()
def line_of_sight_clearance(player, target):
# Retourne un score en fonction du dégagement de la trajectoire (plus c'est dégagé plus le score est petit)
score = (player.pose.position - target).norm
for p in GameState().our_team.available_players.values():
# Obstacle : les players friends
if not (p.id == player.id):
if target is not p.pose.position:
score *= trajectory_score(player.pose.position, target, p.pose.position)
for p in GameState().enemy_team.available_players.values():
# Obstacle : les players ennemis
score *= trajectory_score(player.pose.position, target, p.pose.position)
return score
def is_closest_not_goalkeeper(self, player):
if self.game_state.ball.is_mobile():
self.has_ball_move = True
role = GameState().get_role_by_player_id(player.id)
if not self.has_ball_move:
return role == self.closest_role
closest_players = closest_players_to_point(GameState().ball_position,
our_team=True)
if player == closest_players[0].player:
return True
return closest_players[0].player == self.game_state.get_player_by_role(Role.GOALKEEPER) \
and player == closest_players[1].player
def setUp(self):
config_service = ConfigService().load_file("config/sim_standard.cfg")
self.game = Game()
self.referee = Referee
self.game.set_referee(self.referee)
self.tcsvc = TeamColorService(TeamColor.BLUE_TEAM)
self.game.set_our_team_color(self.tcsvc.OUR_TEAM_COLOR)
self.game_world_OK = ReferenceTransferObject(self.game)
self.game_world_OK.set_team_color_svc(self.tcsvc)
self.GameStateManager1 = GameState()
self.GameStateManager2 = GameState()
self.GameStateManager1.set_reference(self.game_world_OK)
def line_of_sight_clearance_ball_legacy(player, target: Position):
# Retourne un score en fonction du dégagement de la trajectoire de la target vers la ball excluant le robot actuel
# (plus c'est dégagé plus le score est petit)
score = np.linalg.norm(GameState().get_ball_position() - target)
# for j in GameState().my_team.available_players.values():
# # Obstacle : les players friends
# if not (j.id == player.id or j.pose.position == target):
# score *= trajectory_score(GameState().get_ball_position(), target, j.pose.position)
for j in GameState().other_team.available_players.values():
# Obstacle : les players ennemis
score *= trajectory_score(GameState().get_ball_position(), target, j.pose.position)
return score
def _find_best_passing_option(self):
assignation_delay = (time.time() - self.target_assignation_last_time)
if assignation_delay > TARGET_ASSIGNATION_DELAY:
tentative_target_id = best_passing_option(self.player)
if tentative_target_id is None:
self.target = Pose(
GameState().const["FIELD_THEIR_GOAL_X_EXTERNAL"], 0, 0)
else:
self.target = Pose(
GameState().get_player_position(tentative_target_id))
self.target_assignation_last_time = time.time()
def line_of_sight_clearance(player, targets):
# Retourne un score en fonction du dégagement de la trajectoire (plus c'est dégagé plus le score est petit)
score = np.linalg.norm(player.pose.position - targets)
for j in GameState().my_team.available_players.values():
# Obstacle : les players friends
condition = []
if not (j.id == player.id):
condition += [target is not j.pose.position for target in targets]
if any(condition):
score *= trajectory_score(player.pose.position, targets[condition], j.pose.position)
for j in GameState().other_team.available_players.values():
# Obstacle : les players ennemis
score *= trajectory_score(player.pose.position, targets, j.pose.position)
return score
def __init__(self, p_game_state):
super().__init__(p_game_state, keep_roles=False)
# TODO: HARDCODED ID FOR QUALIFICATION, REMOVE LATER
self.roles_graph = {r: Graph() for r in Role}
role_mapping = {
Role.GOALKEEPER: 2,
Role.MIDDLE: 4,
Role.FIRST_ATTACK: 6
}
self.game_state.map_players_to_roles_by_player_id(role_mapping)
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.MIDDLE, Role.FIRST_ATTACK, Role.GOALKEEPER]
role_by_robots = [(i, self.game_state.get_player_by_role(i))
for i in roles_to_consider]
self.robots = [
player for _, player in role_by_robots if player is not None
]
goalkeeper = self.game_state.get_player_by_role(Role.GOALKEEPER)
self.add_tactic(
Role.GOALKEEPER,
GoalKeeper(self.game_state, goalkeeper, ourgoal,
penalty_kick=True))
for index, player in role_by_robots:
if player:
self.add_tactic(
index,
PositionForPass(self.game_state,
player,
auto_position=True,
robots_in_formation=self.robots))
self.add_tactic(
index,
GoKick(self.game_state, player, target=self.theirgoal))
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 player_with_ball(min_dist_from_ball=1.2*ROBOT_RADIUS, our_team=None):
# Retourne le joueur qui possède la balle, NONE si balle libre
closest_player = closest_player_to_point(GameState().get_ball_position(), our_team)
if closest_player.distance < min_dist_from_ball:
return closest_player.player
else:
return None
def closest_players_to_point(point: Position, our_team=None):
# Retourne une liste de tuples (player, distance) en ordre croissant de distance,
# our_team pour obtenir une liste contenant une équipe en particulier
list_player = []
if our_team or our_team is None:
for i in GameState().our_team.available_players.values():
# les players friends
player_distance = (i.pose.position - point).norm
list_player.append(PlayerPosition(i, player_distance))
if not our_team:
for i in GameState().enemy_team.available_players.values():
# les players ennemis
player_distance = (i.pose.position - point).norm
list_player.append(PlayerPosition(i, player_distance))
list_player = sorted(list_player, key=lambda x: x.distance)
return list_player
def has_received(self, player):
role = GameState().get_role_by_player_id(player.id)
if self.roles_graph[role].current_tactic_name == 'ReceivePass':
return self.roles_graph[
role].current_tactic.status_flag == Flags.SUCCESS
else:
return False
def __init__(self, game_state: GameState,
player: Player,
args: Optional[List[str]]=None,
robots_in_formation: Optional[List[Player]]=None,
object_to_block=None,
stay_away_from_ball=False,
cruise_speed=3):
super().__init__(game_state, player, args=args)
if object_to_block is None:
object_to_block = GameState().ball
self.object_to_block = object_to_block
if robots_in_formation is None:
self.robots_in_formation = [player]
else:
self.robots_in_formation = robots_in_formation
assert isinstance(self.robots_in_formation[0], Player)
self.cruise_speed = cruise_speed
self.stay_away_from_ball = stay_away_from_ball
self.go_kick_tactic = None
self.player_number_in_formation = None
self.wall_segment = None
# Used for debug_cmd() visualization
self.bisect_inter = None
self.center_formation = None
self.init_players_in_formation()
self.current_state = self.main_state
self.next_state = self.main_state
def has_kicked(self, player):
role = GameState().get_role_by_player_id(player.id)
if self.roles_graph[role].get_current_tactic_name() == 'GoKick':
return self.roles_graph[role].get_current_tactic(
).status_flag == Flags.SUCCESS
else:
return False
def __init__(self):
self.paths = defaultdict(lambda: None)
self.sub_paths = defaultdict(lambda: [None])
self.logger = logging.getLogger(self.__class__.__name__)
self.pathfinder = PathPartitionner()
self.obstacles = []
self.strategy_obstacles = []
self.game_state = GameState()
def __init__(self, game_state: GameState, number_of_players: int = 3):
super().__init__(game_state)
role_mapping = {
Role.GOALKEEPER: 4,
Role.FIRST_ATTACK: 3,
Role.SECOND_ATTACK: 2
}
self.game_state.map_players_to_roles_by_player_id(role_mapping)
self.number_of_players = number_of_players
self.robots = []
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]
goalkeeper = self.game_state.get_player_by_role(Role.GOALKEEPER)
self.add_tactic(
Role.GOALKEEPER,
GoalKeeper(self.game_state, goalkeeper, target=ourgoal))
role_by_robots = [(i, self.game_state.get_player_by_role(i))
for i in roles_to_consider]
self.robots = [
player for _, player in role_by_robots if player is not None
]
for role, player in role_by_robots:
if player:
self.add_tactic(
role,
AlignToDefenseWall(self.game_state, player, self.robots))
self.add_tactic(
role, GoKick(self.game_state,
player,
target=self.theirgoal))
self.add_condition(role, 0, 1, partial(self.is_closest,
player))
self.add_condition(role, 1, 1, partial(self.is_closest,
player))
self.add_condition(role, 1, 0,
partial(self.is_not_closest, player))
def setUp(self):
# ToDo : Use mock instead of actual objects
self.game_state = GameState()
self.game = Game()
self.game.set_referee(Referee())
game_world = ReferenceTransferObject(self.game)
game_world.set_team_color_svc(TeamColorService(TeamColor.YELLOW))
self.game_state.set_reference(game_world)
self.a_player = OurPlayer(TeamColor.YELLOW, A_PLAYER_ID)
def is_ready_to_kick(self, player):
if self.has_ball_move:
return True # FIXME: Test irl, might Cause a lot of problem
role = GameState().get_role_by_player_id(player.id)
if self.roles_graph[role].current_tactic_name == 'RotateAroundBall':
return self.roles_graph[
role].current_tactic.status_flag == Flags.SUCCESS
else:
return False
def setUp(self):
self.game_state = GameState()
self.game_state._update_player(0, Pose(Position(-4450, 0), 0))
self.tactic1 = GoalKeeper(self.game_state, 0)
self.tactic2 = Stop(self.game_state, 1)
self.node1 = Node(self.tactic1)
self.node2 = Node(self.tactic2)
self.vertex1 = Vertex(0, foo)
self.vertex2 = Vertex(1, foo2)