def __init__(self, ball: 'Ball'):
self.ball = ball
self.debug_interface = DebugInterface()
cfg = ConfigService()
if cfg.config_dict["GAME"]["our_side"] == "positive":
self.our_side = FieldSide.POSITIVE
self.constant = positive_side_constant
else:
self.our_side = FieldSide.NEGATIVE
self.constant = negative_side_constant
def __init__(self):
"""
Initialise le coach de l'IA.
:param mode_debug_active: (bool) indique si les commandes de debug sont actives
:param pathfinder: (str) indique le nom du pathfinder par défault
:param is_simulation: (bool) indique si en simulation (true) ou en vrai vie (false)
"""
cfg = ConfigService()
self.mode_debug_active = cfg.config_dict["DEBUG"][
"using_debug"] == "true"
self.is_simulation = cfg.config_dict["GAME"]["type"] == "sim"
# init the states
self.world_state = WorldState()
# init the executors
self.debug_executor = DebugExecutor(self.world_state)
self.play_executor = PlayExecutor(self.world_state)
self.module_executor = ModuleExecutor(self.world_state)
self.motion_executor = MotionExecutor(self.world_state)
self.robot_command_executor = CommandExecutor(self.world_state)
# logging
DebugInterface().add_log(
1, "\nCoach initialized with \nmode_debug_active = " +
str(self.mode_debug_active) + "\nis_simulation = " +
str(self.is_simulation))
def __init__(self):
""" Constructeur de la classe, établis les propriétés de bases et
construit les objets qui sont toujours necéssaire à son fonctionnement
correct.
"""
# config
self.cfg = ConfigService()
# time
self.last_frame_number = 0
self.time_stamp = None # time.time()
self.last_camera_time = time.time()
self.time_of_last_loop = time.time()
self.ai_timestamp = float(self.cfg.config_dict["GAME"]["ai_timestamp"])
# thread
self.ia_running_thread = None
self.thread_terminate = threading.Event()
# Communication
self.robot_command_sender = None
self.vision = None
self.referee_command_receiver = None
self.uidebug_command_sender = None
self.uidebug_command_receiver = None
self.uidebug_vision_sender = None
self.uidebug_robot_monitor = None
# because this thing below is a callable! can be used without being set
self.vision_redirection_routine = lambda *args: None
self.vision_routine = self._sim_vision # self._normal_vision # self._test_vision self._redirected_vision
self._choose_vision_routines()
# Debug
self.incoming_debug = []
self.debug = DebugInterface()
self.outgoing_debug = self.debug.debug_state
self._init_communication()
# Game elements
self.reference_transfer_object = None
self.game = None
self.ai_coach = None
self.referee = None
self.team_color_service = None
self._create_game_world()
# VISION
self.image_transformer = ImageTransformerFactory.get_image_transformer(
)
# ia couplage
self.ia_coach_mainloop = None
self.ia_coach_initializer = None
# for testing purposes
self.frame_number = 0
def __init__(self, world_state):
"""
Reçoit une référence vers InfoManager. Cette référence est renomée
comme étant *state*.
:param world_state: (WorldState) Référence vers le worldstate.
"""
self.ws = world_state
self.debug_interface = DebugInterface()
def __init__(self,
game_state: GameState,
player: OurPlayer,
target: Pose = Pose(),
args=None):
Tactic.__init__(self, game_state, player, target, args)
self.current_state = self.get_behind_ball
self.next_state = self.get_behind_ball
self.debug_interface = DebugInterface()
self.target = target
def __init__(self, mode_debug_active: bool = True):
"""
initialisation du worldstate
:param mode_debug_active: (bool) indique si le mode debug est activé
"""
self.module_state = ModuleState()
self.play_state = PlayState()
self.game_state = GameState()
# pour passer une interface de debug deja recuperer
self.debug_interface = DebugInterface()
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
class Field:
def __init__(self, ball: 'Ball'):
self.ball = ball
self.debug_interface = DebugInterface()
cfg = ConfigService()
if cfg.config_dict["GAME"]["our_side"] == "positive":
self.our_side = FieldSide.POSITIVE
self.constant = positive_side_constant
else:
self.our_side = FieldSide.NEGATIVE
self.constant = negative_side_constant
def set_collision_body(self):
x_their_goal = self.constant["FIELD_THEIR_GOAL_X_EXTERNAL"]
x_our_goal = self.constant["FIELD_OUR_GOAL_X_EXTERNAL"]
radius = self.constant["FIELD_GOAL_RADIUS"]
self.field_collision_body = [CollisionBody(Position(x_their_goal, 0), Position(0, 0), radius, CollisionType.ZONE),
CollisionBody(Position(x_our_goal, 0), Position(0, 0), radius, CollisionType.ZONE)]
self.debug_interface.add_circle((x_their_goal, 0), radius=radius, timeout=0, color=(255, 0, 0))
self.debug_interface.add_circle((x_our_goal, 0), radius=radius, timeout=0, color=(255, 0, 0))
def move_ball(self, position, delta):
self.ball.set_position(position, delta)
def is_inside_goal_area(self, position, dist_from_goal_area=0, our_goal=True):
assert (isinstance(position, Position))
assert (isinstance(our_goal, bool))
x1 = self.constant["FIELD_OUR_GOAL_X_EXTERNAL"] if our_goal else self.constant["FIELD_THEIR_GOAL_X_EXTERNAL"]
x2 = self.constant["FIELD_OUR_GOAL_X_INTERNAL"] if our_goal else self.constant["FIELD_THEIR_GOAL_X_INTERNAL"]
x_right = max(x1, x2) + dist_from_goal_area
x_left = min(x1, x2) - dist_from_goal_area
top_circle = self.constant["FIELD_OUR_GOAL_TOP_CIRCLE"] if our_goal\
else self.constant["FIELD_THEIR_GOAL_TOP_CIRCLE"]
bot_circle = self.constant["FIELD_OUR_GOAL_BOTTOM_CIRCLE"] if our_goal\
else self.constant["FIELD_THEIR_GOAL_BOTTOM_CIRCLE"]
if isInsideSquare(position, self.constant["FIELD_GOAL_Y_TOP"], self.constant["FIELD_GOAL_Y_BOTTOM"],
x_left, x_right):
if is_inside_circle(position, top_circle, self.constant["FIELD_GOAL_RADIUS"] + dist_from_goal_area):
return True
elif is_inside_circle(position, bot_circle, self.constant["FIELD_GOAL_RADIUS"] + dist_from_goal_area):
return True
return True
else:
return False
def is_outside_goal_area(self, position, dist_from_goal_area=0, our_goal=True):
return not self.is_inside_goal_area(position, dist_from_goal_area, our_goal)
def stay_inside_goal_area(self, position, our_goal=True):
# TODO Not tested: stayInsideGoalArea
if self.is_inside_goal_area(position, our_goal):
return Position(position.x, position.y)
else:
x1 = self.constant["FIELD_OUR_GOAL_X_EXTERNAL"] if our_goal else self.constant["FIELD_THEIR_GOAL_X_EXTERNAL"]
x2 = self.constant["FIELD_OUR_GOAL_X_INTERNAL"] if our_goal else self.constant["FIELD_THEIR_GOAL_X_INTERNAL"]
x_right = max(x1, x2)
x_left = min(x1, x2)
position = stayInsideSquare(position, self.constant["FIELD_GOAL_Y_TOP"],
self.constant["FIELD_GOAL_Y_BOTTOM"], x_left, x_right)
if isInsideSquare(position, self.constant["FIELD_GOAL_Y_TOP"], self.constant["FIELD_GOAL_Y_BOTTOM"],
x_left, x_right):
return position
else:
circle_top = self.constant["FIELD_OUR_GOAL_TOP_CIRCLE"] if our_goal\
else self.constant["FIELD_THEIR_GOAL_TOP_CIRCLE"]
circle_bot = self.constant["FIELD_OUR_GOAL_BOTTOM_CIRCLE"] if our_goal\
else self.constant["FIELD_THEIR_GOAL_BOTTOM_CIRCLE"]
dst_top = get_distance(circle_top, position)
dst_bot = get_distance(circle_bot, position)
if dst_top >= dst_bot:
return stayInsideCircle(position, circle_top, self.constant["FIELD_GOAL_RADIUS"])
else:
return stayInsideCircle(position, circle_bot, self.constant["FIELD_GOAL_RADIUS"])
def stay_outside_goal_area(self, position, dist_from_goal_area=200, our_goal=True):
# TODO Not tested: stayOutsideGoalArea
if self.is_outside_goal_area(position, dist_from_goal_area, our_goal):
return Position(position.x, position.y)
else:
x1 = self.constant["FIELD_OUR_GOAL_X_EXTERNAL"] if our_goal else self.constant["FIELD_THEIR_GOAL_X_EXTERNAL"]
x2 = self.constant["FIELD_OUR_GOAL_X_INTERNAL"] if our_goal else self.constant["FIELD_THEIR_GOAL_X_INTERNAL"]
x1 = 2*x1-x2
x_right = max(x1, x2) + dist_from_goal_area
x_left = min(x1, x2) - dist_from_goal_area
y_top = self.constant["FIELD_GOAL_SEGMENT"] / 2
y_bottom = (self.constant["FIELD_GOAL_SEGMENT"] / 2) * -1
circle_top = self.constant["FIELD_OUR_GOAL_TOP_CIRCLE"] if our_goal\
else self.constant["FIELD_THEIR_GOAL_TOP_CIRCLE"]
circle_bot = self.constant["FIELD_OUR_GOAL_BOTTOM_CIRCLE"] if our_goal\
else self.constant["FIELD_THEIR_GOAL_BOTTOM_CIRCLE"]
position = stayOutsideSquare(position, y_top, y_bottom, x_left, x_right)
position = stayOutsideCircle(position, circle_top, self.constant["FIELD_GOAL_RADIUS"] + dist_from_goal_area)
position = stayOutsideCircle(position, circle_bot, self.constant["FIELD_GOAL_RADIUS"] + dist_from_goal_area)
return Position(position.x, position.y)
def stay_inside_play_field(self, position):
return stayInsideSquare(position, Y_TOP=self.constant["FIELD_Y_TOP"],
Y_BOTTOM=self.constant["FIELD_Y_BOTTOM"],
X_LEFT=self.constant["FIELD_X_LEFT"],
X_RIGHT=self.constant["FIELD_X_RIGHT"])
def stay_inside_full_field(self, position):
return stayInsideSquare(position, Y_TOP=self.constant["FIELD_Y_TOP"] + self.constant["FIELD_BOUNDARY_WIDTH"],
Y_BOTTOM=self.constant["FIELD_Y_BOTTOM"] - self.constant["FIELD_BOUNDARY_WIDTH"],
X_LEFT=self.constant["FIELD_X_LEFT"] - self.constant["FIELD_BOUNDARY_WIDTH"],
X_RIGHT=self.constant["FIELD_X_RIGHT"] + self.constant["FIELD_BOUNDARY_WIDTH"])
def respect_field_rules(self, position):
new_position = self.stay_outside_goal_area(position, our_goal=False)
return self.stay_inside_play_field(new_position)
def update_field_dimensions(self, packets):
for packet in packets:
if not packet.HasField("geometry"):
continue
field = packet.geometry.field
if len(field.field_lines) == 0:
raise RuntimeError("Receiving legacy geometry message instead of the new geometry message. Update your grsim or check your vision port.")
self.field_lines = self._convert_field_line_segments(field.field_lines)
self.field_arcs = self._convert_field_circular_arc(field.field_arcs)
if "RightFieldLeftPenaltyArc" not in self.field_arcs:
# This is a new type of field for Robocup 2018, it does not have a circular goal zone
self._defense_radius = self.field_lines["LeftFieldLeftPenaltyStretch"].length
else:
self._defense_radius = self.field_arcs['RightFieldLeftPenaltyArc'].radius
self._field_length = field.field_length
self._field_width = field.field_width
self._boundary_width = field.boundary_width
self._goal_width = field.goal_width
self._goal_depth = field.goal_depth
self._center_circle_radius = self.field_arcs['CenterCircle'].radius
self._defense_stretch = 100 # hard coded parce que cette valeur d'est plus valide et que plusieurs modules en ont de besoin
#la valeur qu'on avait apres le fix a Babin était de 9295 mm, ce qui est 90 fois la grandeur d'avant.
self.constant["FIELD_Y_TOP"] = self._field_width / 2
self.constant["FIELD_Y_BOTTOM"] = -self._field_width / 2
self.constant["FIELD_X_LEFT"] = -self._field_length / 2
self.constant["FIELD_X_RIGHT"] = self._field_length / 2
self.constant["CENTER_CENTER_RADIUS"] = self._center_circle_radius
self.constant["FIELD_Y_POSITIVE"] = self._field_width / 2
self.constant["FIELD_Y_NEGATIVE"] = -self._field_width / 2
self.constant["FIELD_X_NEGATIVE"] = -self._field_length / 2
self.constant["FIELD_X_POSITIVE"] = self._field_length / 2
self.constant["FIELD_BOUNDARY_WIDTH"] = self._boundary_width
self.constant["FIELD_GOAL_RADIUS"] = self._defense_radius
self.constant["FIELD_GOAL_SEGMENT"] = self._defense_stretch
self.constant["FIELD_GOAL_WIDTH"] = self._goal_width
self.constant["FIELD_GOAL_Y_TOP"] = self._defense_radius + (self._defense_stretch / 2)
self.constant["FIELD_GOAL_Y_BOTTOM"] = -self.constant["FIELD_GOAL_Y_TOP"]
if self.our_side == FieldSide.POSITIVE:
self.constant["FIELD_THEIR_GOAL_X_EXTERNAL"] = self.constant["FIELD_X_NEGATIVE"]
self.constant["FIELD_THEIR_GOAL_X_INTERNAL"] = self.constant["FIELD_X_NEGATIVE"] + self.constant["FIELD_GOAL_RADIUS"]
self.constant["FIELD_OUR_GOAL_X_INTERNAL"] = self.constant["FIELD_X_POSITIVE"] - self.constant["FIELD_GOAL_RADIUS"]
self.constant["FIELD_OUR_GOAL_X_EXTERNAL"] = self.constant["FIELD_X_POSITIVE"]
self.constant["FIELD_THEIR_GOAL_TOP_CIRCLE"] = Position(self.constant["FIELD_X_NEGATIVE"], self.constant["FIELD_GOAL_SEGMENT"] / 2)
self.constant["FIELD_THEIR_GOAL_BOTTOM_CIRCLE"] = Position(self.constant["FIELD_X_NEGATIVE"], -self.constant["FIELD_GOAL_SEGMENT"] / 2)
self.constant["FIELD_THEIR_GOAL_MID_GOAL"] = Position(self.constant["FIELD_X_NEGATIVE"], 0)
self.constant["FIELD_OUR_GOAL_TOP_CIRCLE"] = Position(self.constant["FIELD_X_POSITIVE"], self.constant["FIELD_GOAL_SEGMENT"] / 2)
self.constant["FIELD_OUR_GOAL_BOTTOM_CIRCLE"] = Position(self.constant["FIELD_X_POSITIVE"], -self.constant["FIELD_GOAL_SEGMENT"] / 2)
self.constant["FIELD_OUR_GOAL_MID_GOAL"] = Position(self.constant["FIELD_X_POSITIVE"], 0)
else:
self.constant["FIELD_OUR_GOAL_X_EXTERNAL"] = self.constant["FIELD_X_NEGATIVE"]
self.constant["FIELD_OUR_GOAL_X_INTERNAL"] = self.constant["FIELD_X_NEGATIVE"] + self.constant["FIELD_GOAL_RADIUS"]
self.constant["FIELD_THEIR_GOAL_X_INTERNAL"] = self.constant["FIELD_X_POSITIVE"] - self.constant["FIELD_GOAL_RADIUS"]
self.constant["FIELD_THEIR_GOAL_X_EXTERNAL"] = self.constant["FIELD_X_POSITIVE"]
self.constant["FIELD_OUR_GOAL_TOP_CIRCLE"] = Position(self.constant["FIELD_X_NEGATIVE"], self.constant["FIELD_GOAL_SEGMENT"] / 2)
self.constant["FIELD_OUR_GOAL_BOTTOM_CIRCLE"] = Position(self.constant["FIELD_X_NEGATIVE"], -self.constant["FIELD_GOAL_SEGMENT"] / 2)
self.constant["FIELD_OUR_GOAL_MID_GOAL"] = Position(self.constant["FIELD_X_NEGATIVE"], 0)
self.constant["FIELD_THEIR_GOAL_TOP_CIRCLE"] = Position(self.constant["FIELD_X_POSITIVE"], self.constant["FIELD_GOAL_SEGMENT"] / 2)
self.constant["FIELD_THEIR_GOAL_BOTTOM_CIRCLE"] = Position(self.constant["FIELD_X_POSITIVE"], -self.constant["FIELD_GOAL_SEGMENT"] / 2)
self.constant["FIELD_THEIR_GOAL_MID_GOAL"] = Position(self.constant["FIELD_X_POSITIVE"], 0)
self.set_collision_body()
return True
return False
def _convert_field_circular_arc(self, field_arcs):
result = {}
for arc in field_arcs:
result[arc.name] = FieldCircularArc(arc)
return result
def _convert_field_line_segments(self, field_lines):
result = {}
for line in field_lines:
result[line.name] = FieldLineSegment(line)
return result
def __init__(self, p_world_state):
super().__init__(p_world_state)
self.debug_interface = DebugInterface()
self._sanity_check_of_speed_command()