def load(self, deliverable: Deliverable, warehouse: Warehouse, n=1):
self._at_turn += 1+ceil(distance_to(self.pos, warehouse.pos))
self.pos = warehouse.pos
def deliverables_in_order(order_id):
return filter(lambda d: d._order_id == order_id, deliverables)
def deliverables_in_order_of_type(order_id, product_id):
return list(filter(lambda d: d._product_id == product_id, deliverables_in_order(order_id)))
deliverables_to_pickup = deliverables_in_order_of_type(deliverable._order_id, deliverable._product_id)
if len(deliverables_to_pickup) < 1:
raise Exception
available_n = len(deliverables_to_pickup)
l = []
while sum(map(lambda d: d.weight, l)) <= self.capacity and len(deliverables_to_pickup) > 0:
d = deliverables_to_pickup.pop()
deliverables.remove(d)
l.append(d)
n = len(l)
#if n > 1:
# print("asd: ", n)
warehouse.take_from_stock(deliverable._product_id, n)
self.n = n
print("{} L {} {} {}".format(self.id, warehouse.id, deliverable._product_id, n))
return n
def get_optimal_drone(destination):
cost = [
drone.turn + distance_to(drone.pos, destination)
for drone in drones
]
i = cost.index(min(cost))
return drones[i]
def create_problem(environment, start_positions, goal_positions):
robots = []
current_environment = environment.copy()
random.shuffle(robot_sizes)
for i, size in enumerate(robot_sizes):
np.random.shuffle(start_positions)
np.random.shuffle(goal_positions)
# Create set of allowed cells.
start_cells = []
for start in start_positions:
c = util.Cell(start[0], start[1])
if c.allowed(current_environment, size):
start_cells.append(c)
goal_cells = []
for goal in goal_positions:
c = util.Cell(goal[0], goal[1])
if c.allowed(environment, size):
goal_cells.append(c)
if len(goal_cells) >= _MAX_TRIES:
break
# Pick random starts.
found = False
for g in goal_cells:
dist = util.distance_to(environment, g, size)
for s in start_cells:
d = dist[s.x, s.y]
if not np.isinf(d):
robots.append((size, (s.x, s.y), (g.x, g.y)))
current_environment[s.x:s.x + size, s.y:s.y + size] = 1
found = True
break
if found:
break
if not found:
raise ValueError('Unable to find valid start and goal positions.')
print('Robot #{} done.'.format(i))
return robots
def availability(product_id, destination):
av = 0
for warehouse in warehouses:
# TODO: Bench **1 vs **2 on dist
av += warehouse.stock[product_id] / distance_to(destination, warehouse.pos)**2
return av
def unload(self, warehouse: Warehouse):
self._at_turn += ceil(distance_to(self.pos, warehouse.pos))
# Special
pass
def deliver(self, deliverable):
self._at_turn += 1+ceil(distance_to(self.pos, deliverable._destination_pos))
self.pos = deliverable._destination_pos
print("{} D {} {} {}".format(self.id, deliverable._order_id, deliverable._product_id, self.n))
pass
def get_warehouses_sorted_by_distance(pos):
return sorted(classes.warehouses, key=lambda o: distance_to(o.pos, pos))
def get_closest_deliverable(pos):
return sorted(classes.deliverables, key=lambda o: distance_to(o.destination_pos, pos))
def get_optimal_drone(destination):
cost = [drone.turn + distance_to(drone.pos, destination) for drone in drones]
i = cost.index(min(cost))
return drones[i]
def get_closest_order(pos):
return sorted(orders, key=lambda o: distance_to(o.pos, pos))
def _distance_to(self, environment, destination, size=None):
if size is None:
size = self.size
return util.distance_to(environment, destination, size)
def get_warehouses_sorted_by_distance(pos):
return sorted(classes.warehouses,
key=lambda o: distance_to(o.pos, pos))
def get_closest_deliverable(pos):
return sorted(classes.deliverables,
key=lambda o: distance_to(o.destination_pos, pos))
