def initialize_packet(self, packet):
packet.direction = DIRECTION_BACKWARDS
packet.angle = 2.56
packet.points.append(position.Pose(1.5, 2.3))
packet.points.append(position.Pose(0.6, 1.7))
packet.points.append(position.Pose(2.0, 0.2))
packet.points.append(position.Pose(1.2, 2.7))
def test_strait_route(self):
route = self.map.route(position.Pose(YELLOW_START_X, YELLOW_START_Y),
position.Pose(YELLOW_START_X, 1.5))
self.assertEquals(len(route), 1)
self.assertTrue(len(route[0]) > 0)
p = route[0][0]
self.assertEquals(p.x, YELLOW_START_X)
self.assertEquals(p.y, 1.5)
def on_enter(self):
dest = self.path[-1]
self.robot.destination = position.Pose(dest.x, dest.y, 0.0)
if self.direction == DIRECTION_AUTO:
first_point = self.path[0]
self.direction = tools.get_direction(self.robot.pose,
first_point.virt.x,
first_point.virt.y)
for pose in self.path:
assert isinstance(pose, position.Pose)
if self.direction == DIRECTION_FORWARD:
if not self.robot.is_looking_at(pose):
move = yield LookAt(pose.virt.x, pose.virt.y,
DIRECTION_FORWARD)
else:
if not self.robot.is_looking_at_opposite(pose):
move = yield LookAtOpposite(pose.virt.x, pose.virt.y,
DIRECTION_FORWARD)
move = self.create_move_line(pose, self.direction)
yield move
if move.exit_reason != TRAJECTORY_DESTINATION_REACHED:
break
self.robot.destination = None
self.exit_reason = move.exit_reason
yield None
def get_pose(self):
y = self.item.pos().x() / 1000.0
x = self.item.pos().y() / 1000.0
angle = self.item.rotation() / 180.0 * math.pi
# Map from Qt reference to field reference
angle = self.convert_angle(angle)
return position.Pose(x, y, angle)
def __init__(self,
x,
y,
direction=DIRECTION_AUTO,
virtual=True,
opponent_handling_config=OPPONENT_HANDLING_STOP):
super().__init__([position.Pose(x, y, None, virtual)], direction,
virtual, opponent_handling_config)
def __init__(self, x=None, y=None, angle=None):
statemachine.State.__init__(self)
self.has_x = x is not None
self.has_y = y is not None
px = x if self.has_x else 0.0
py = y if self.has_y else 0.0
pangle = angle if angle is not None else 0.0
self.pose = position.Pose(px, py, pangle, True)
def __init__(self,
angle,
min_curve_radius,
points,
direction=DIRECTION_AUTO,
virtual=True,
opponent_handling_config=OPPONENT_HANDLING_STOP):
super().__init__(opponent_handling_config)
apose = position.Pose(0.0, 0.0, angle, virtual)
poses = []
for pt in points:
if isinstance(pt, tuple):
poses.append(position.Pose(pt[0], pt[1], None, virtual))
else:
poses.append(pt)
self.packet = packets.MoveCurve(direction, apose.angle,
min_curve_radius, poses)
def __init__(self,
angle,
direction=DIRECTION_AUTO,
virtual=True,
opponent_handling_config=OPPONENT_HANDLING_NONE):
super().__init__(opponent_handling_config)
pose = position.Pose(0.0, 0.0, angle, virtual)
self.packet = packets.Rotate(direction=direction, angle=pose.angle)
def __init__(self,
angle,
direction=DIRECTION_FORWARD,
chained=None,
virtual=True):
super().__init__(chained, NO_OPPONENT_HANDLING)
pose = position.Pose(0.0, 0.0, angle, virtual)
self.packet = packets.Rotate(direction=direction, angle=pose.angle)
def initialize_packet(self, packet):
packet.direction = DIRECTION_BACKWARDS
packet.center = position.Pose(2.34, 1.78)
packet.radius = 2.56
packet.points.append(1.5)
packet.points.append(1.7)
packet.points.append(2.0)
packet.points.append(2.7)
def __init__(self,
center_x,
center_y,
radius,
points,
direction=DIRECTION_AUTO,
virtual=True,
opponent_handling_config=OPPONENT_HANDLING_STOP):
super().__init__(opponent_handling_config)
cpose = position.Pose(center_x, center_y, None, virtual)
angles = []
for a in points:
apose = position.Pose(0.0, 0.0, a, virtual)
angles.append(apose.angle)
self.packet = packets.MoveArc(direction=direction,
center=cpose,
radius=radius,
points=angles)
def __init__(self,
x,
y,
direction=DIRECTION_AUTO,
virtual=True,
opponent_handling_config=OPPONENT_HANDLING_NONE):
super().__init__(opponent_handling_config)
self.pose = position.Pose(x, y, None, virtual)
self.direction = direction
def __init__(self, event_loop):
self.pose = position.Pose(0.0, 0.0, 0.0)
self._team = TEAM_UNKNOWN
self.event_loop = event_loop
self.destination = None
self.main_opponent_direction = None
self.secondary_opponent_direction = None
self.goal_manager = goalmanager.GoalManager(event_loop)
self.mammoth_sparrow_loaded = True
def __init__(self,
angle,
points,
direction=DIRECTION_FORWARD,
chained=None,
virtual=True,
opponent_handling_config=OPPONENT_HANDLING):
super().__init__(chained, opponent_handling_config)
apose = position.Pose(0.0, 0.0, angle, virtual)
poses = []
for pt in points:
if isinstance(pt, tuple):
poses.append(position.Pose(pt[0], pt[1], None, virtual))
else:
poses.append(pt)
self.packet = packets.MoveCurve(direction=direction,
angle=apose.angle,
points=poses)
def __init__(self,
x,
y,
direction=DIRECTION_FORWARD,
chained=None,
virtual=True,
opponent_handling_config=OPPONENT_HANDLING):
super().__init__([position.Pose(x, y, None, virtual)], direction,
chained, virtual, opponent_handling_config)
def __init__(self,
x,
y,
direction=DIRECTION_FORWARD,
chained=None,
virtual=True):
super().__init__(chained, NO_OPPONENT_HANDLING)
self.pose = position.Pose(x, y, None, virtual)
self.direction = direction
def __init__(self,
center_x,
center_y,
radius,
points,
direction=DIRECTION_FORWARD,
chained=None,
virtual=True,
opponent_handling_config=OPPONENT_HANDLING):
AbstractMove.__init__(self, chained, opponent_handling_config)
cpose = position.Pose(center_x, center_y, None, virtual)
angles = []
for a in points:
apose = position.Pose(0.0, 0.0, a, virtual)
angles.append(apose.angle)
self.packet = packets.MoveArc(direction=direction,
center=cpose,
radius=radius,
points=angles)
def on_enter(self):
if self.packet.direction == DIRECTION_AUTO:
first_angle = self.packet.points[0].virt.angle
first_point = position.Pose(
center_x + math.cos(first_angle) * self.packet.radius,
center_y + math.sin(first_angle) * self.packet.radius, None,
True)
self.packet.direction = self.get_direction(first_point.virt.x,
first_point.virt.y)
yield from super().on_enter()
def __init__(self,
points,
direction=DIRECTION_AUTO,
virtual=True,
opponent_handling_config=OPPONENT_HANDLING_STOP):
checks.check_type(direction, int)
super().__init__(opponent_handling_config)
poses = []
for pt in points:
if type(pt) == tuple:
poses.append(position.Pose(pt[0], pt[1], None, virtual))
else:
poses.append(pt)
self.packet = packets.MoveLine(direction=direction, points=poses)
def __init__(self, event_loop):
self.pose = position.Pose(0.0, 0.0, 0.0)
self._team = TEAM_UNKNOWN
self.event_loop = event_loop
self.destination = None
self.main_opponent_direction = None
self.secondary_opponent_direction = None
self.goal_manager = goalmanager.GoalManager(event_loop)
self.goal_decider = goaldecider.GoalDecider(event_loop,
self.goal_manager)
self.locks = set()
self.used_storage_spaces = []
self.score = 0
self.is_holding_module = True
def __init__(self,
points,
direction=DIRECTION_FORWARD,
chained=None,
virtual=True,
opponent_handling_config=OPPONENT_HANDLING):
super().__init__(chained, opponent_handling_config)
poses = []
for pt in points:
if type(pt) == tuple:
poses.append(position.Pose(pt[0], pt[1], None, virtual))
else:
poses.append(pt)
self.packet = packets.MoveLine(direction=direction, points=poses)
def route(self, start, end):
logger.log("Compute route from ({}, {}) to ({}, {})".format(start.x, start.y, end.x, end.y))
start_date = datetime.datetime.now()
(cost, path) = self.pathfinder.find_path(start.x, start.y, end.x, end.y)
delta = datetime.datetime.now() - start_date
if len(path) == 0:
logger.log("No route found. Cost: {}. computation time: {}".format(cost, delta.total_seconds()))
return None, []
else:
logger.log("Route computed. Cost: {}. computation time: {}".format(cost, delta.total_seconds()))
pose_path = []
# remove start node and convert to poses
for (x, y) in path[1:]:
pose_path.append(position.Pose(x, y))
self.send_to_simulator(pose_path)
return cost, pose_path
def on_enter(self):
move = self.chained
dest = self.path[-1]
self.robot.destination = position.Pose(dest.x, dest.y, 0.0)
for pose in self.path:
if self.direction == DIRECTION_FORWARD:
if not self.robot.is_looking_at(pose):
move = yield LookAt(pose.virt.x, pose.virt.y,
DIRECTION_FORWARD, move)
else:
if not self.robot.is_looking_at_opposite(pose):
move = yield LookAtOpposite(pose.virt.x, pose.virt.y,
DIRECTION_FORWARD, move)
move = yield MoveLine([pose], self.direction, move)
self.robot.destination = None
self.exit_reason = move.exit_reason
yield None
def get_next_goal(self):
candidates = self.get_candidate_goals()
for goal in candidates:
goal.before_evaluation()
for goal in candidates:
pose = position.Pose(goal.x, goal.y, virtual=True)
logger.log("Evaluate goal {}".format(goal.uid))
if GOAL_EVALUATION_USES_PATHFINDING:
goal.navigation_cost = self.event_loop.map.evaluate(
self.event_loop.robot.pose, pose)
else:
goal.navigation_cost = tools.distance(
self.event_loop.robot.pose.x, self.event_loop.robot.pose.y,
pose.x, pose.y)
# Remove unreachable goals
candidates = [
goal for goal in candidates if goal.navigation_cost is not None
]
if len(candidates) == 0:
return None
if len(candidates) == 1:
return candidates[0]
candidates.sort(key=lambda goal: goal.navigation_cost)
nearest_cost = candidates[0].navigation_cost
farest_cost = candidates[-1].navigation_cost
total_range = farest_cost - nearest_cost
logger.log("Nearest cost: {} Farest cost: {} Range: {}".format(
nearest_cost, farest_cost, total_range))
for goal in candidates:
current = goal.navigation_cost - nearest_cost
k = (total_range - current) / total_range
goal.score = goal.weight * (1.0 / 3.0 + k * 2.0 / 3.0)
logger.log("Goal '{}' Navigation cost: {} Score: {}".format(
goal.identifier, goal.navigation_cost, goal.score))
return max(candidates, key=lambda goal: goal.score)
if not funny_action_goals:
return best_goal
def get_simple_next_goal(self):
candidates = self.get_candidate_goals()
if len(candidates) == 0:
return None
for goal in candidates:
goal.before_evaluation()
candidates.sort(key=lambda goal: goal.weight)
logger.log('Candidate goals : {}'.format(
["{}({})".format(goal.uid, goal.weight) for goal in candidates]))
best_weight = candidates[0].weight
best_candidates = []
for goal in candidates:
if goal.weight == best_weight:
best_candidates.append(goal)
else:
break
if len(best_candidates) == 1:
return best_candidates[0]
else:
best_goal = None
for goal in best_candidates:
pose = position.Pose(goal.x, goal.y, virtual=True)
logger.log("Evaluate goal {}".format(goal.uid))
if GoalManager.GOAL_EVALUATION_USES_PATHFINDING:
goal.navigation_cost = self.event_loop.map.evaluate(
self.event_loop.robot.pose, pose)
else:
goal.navigation_cost = tools.distance(
self.event_loop.robot.pose.x,
self.event_loop.robot.pose.y, pose.x, pose.y)
if goal.navigation_cost and (
best_goal is None
or best_goal.navigation_cost > goal.navigation_cost):
best_goal = goal
return best_goal
def __init__(self, goals, map_, remaining_time):
"""
:type goals: list(brewery.goalmanager.Goal)
:type remaining_time: float
"""
import logger
self.score = 0
self.right_builder_count = 0
self.left_builder_count = 0
self.remaining_goals = goals
self.executed_goals = []
":type executed_goals: list(brewery.goalmanager.Goal)"
self.depth = 0
self.remaining_time = remaining_time
self.map_ = map_
self.robot_pose = position.Pose(0, 0, 0)
self.logger = logger
self.traveled_distance = 0
self.has_right_bulb = False
self.has_left_bulb = False
self._remaining_deposit_goals = None
def on_enter(self):
logger.log('WaitForOpponentLeave : time={}, retries={}'.format(
self.miliseconds, self.retries))
Timer.on_enter(self)
self.goto_finished = False
self.opponent_disappeared = False
self.timer_expired = False
self.exit_reason = None
if self.move_direction == DIRECTION_FORWARD:
direction = DIRECTION_BACKWARDS
distance = -0.150
else:
direction = DIRECTION_FORWARD
distance = 0.150
current_pose = self.robot.pose
x = current_pose.virt.x + math.cos(current_pose.virt.angle) * distance
y = current_pose.virt.y + math.sin(current_pose.virt.angle) * distance
packet = packets.MoveLine()
packet.direction = direction
packet.points = [position.Pose(x, y, None, True)]
self.send_packet(packet)
def test_escape_from_forbidden_zone(self):
route = self.map.route(
position.Pose(YELLOW_START_X + MAP_WALLS_DISTANCE, YELLOW_START_Y),
position.Pose(1.6, 2.0))
self.assertNotEquals(len(route), 0)
def test_unroutable(self):
route = self.map.route(position.Pose(YELLOW_START_X, YELLOW_START_Y),
position.Pose(1.99, 2.99))
self.assertEquals(len(route), 0)
def setUp(self):
position.Pose.match_team = TEAM_RED
self.pose = position.Pose(1.0, 1.0, math.pi)
