def get_interception_point(steps_o, InitPosX, InitPosY, agentO: Agent): ip_x = -1 ip_y = -1 steps_counter = 0 g = get_graph_from_board(agentO.gameBoard) start = Slot(InitPosX, InitPosY) path_to = [] for step in steps_o: steps_counter += 1 # computing the distance should be done using dijkstra, since now we allow obstacles # create graph from Board (with obstacles) dijkstra(g, g.get_vertex(start), g.get_vertex(step)) target = g.get_vertex(step) path = [target.get_id()] shortest(target, path) # print('The shortest path : %s' % (path[::-1])) distance_from_i_r = len(path[::-1]) if steps_counter > distance_from_i_r: ip_x, ip_y = step.row, step.col path_to = path[::-1] break assert (ip_x != -1 and ip_y != -1) return Slot(ip_x, ip_y), len(path_to), path_to
def get_steps(self, agent_r, board_size=50, agent_o=None): """ This function returns the coverage self.steps,when covering knowing io, and start covering vertically from the farthest corner. :param self: :param board_size: :param agent_o: :return: the coverage self.steps. """ assert agent_o is not None # go to the farthest corner self.steps.extend( Strategy.go_from_a_to_b(a=Slot(agent_r.InitPosX, agent_r.InitPosY), b=Strategy.get_farthest_corner( a=Slot(agent_o.InitPosX, agent_o.InitPosY), board_size=board_size))) # from there, cover vertically current_slot = self.steps[-1] v_dir = 'u' if current_slot.row == board_size - 1 else 'd' h_dir = 'l' if current_slot.col == board_size - 1 else 'r' counter = 1 while counter <= board_size * board_size: if v_dir == 'u': while current_slot.row > 0: current_slot = current_slot.go_north() self.steps.append(current_slot) counter += 1 if counter == board_size * board_size: break current_slot = current_slot.go_west( ) if h_dir == 'l' else current_slot.go_east() v_dir = 'd' self.steps.append(current_slot) counter += 1 continue else: while current_slot.row < board_size - 1: current_slot = current_slot.go_south() self.steps.append(current_slot) counter += 1 if counter == board_size * board_size: break current_slot = current_slot.go_west( ) if h_dir == 'l' else current_slot.go_east() v_dir = 'u' self.steps.append(current_slot) counter += 1 continue return self.steps
def get_steps(self, agent_r, board_size=50, agent_o=None): """ This function returns the coverage steps, choosing to start from the initial position of the opponent, io, and from there cover the world circling out. This function perform spiraling out simply: doesn't take steps in alternate sizes, and limiting the available slots to be in range :param self: the agent :param board_size: :param agent_o: :return: """ fixed_io = Slot(agent_o.InitPosX, agent_o.InitPosY) self.steps.extend( Strategy.go_from_a_to_b(Slot(agent_r.InitPosX, agent_r.InitPosY), fixed_io)) # cover the world, circling from this position out. current_slot = self.steps[-1] step_size = 1 counter = 1 b = [[0 for i in xrange(board_size)] for j in xrange(board_size)] b[current_slot.row][current_slot.col] = 1 while sum(map(sum, b)) < board_size * board_size: # go horizontally right then vertically up for dir in ['r', 'u']: for _ in xrange(step_size): current_slot = current_slot.go(dir) counter += 1 if 0 <= current_slot.row < board_size and 0 <= current_slot.col < board_size: self.steps.append(current_slot) b[current_slot.row][current_slot.col] = 1 step_size += 1 # go horizontally left then vertically down for dir in ['l', 'd']: for _ in xrange(step_size): current_slot = current_slot.go(dir) counter += 1 if 0 <= current_slot.row < board_size and 0 <= current_slot.col < board_size: self.steps.append(current_slot) b[current_slot.row][current_slot.col] = 1 step_size += 1 return self.steps
def get_steps(self, agent_r: Agent, board_size=50, agent_o: Agent = None): covered_cells = [] current_slot = Slot(agent_r.InitPosX, agent_r.InitPosY) covered_cells.append(current_slot) all_slots = [ Slot(i, j) for i in range(board_size) for j in range(board_size) ] while not sublist(all_slots, covered_cells): # randomly select move new_slot = current_slot while not (0 <= new_slot.row < board_size and 0 <= new_slot.col < board_size) or new_slot == current_slot: new_slot = current_slot.go(random.choice(['r', 'l', 'u', 'd'])) # update accordingly covered_cells.append(new_slot) current_slot = new_slot print(len(set(covered_cells)) / (board_size * board_size * 1.0)) print(covered_cells) print(len(covered_cells)) exit(2) return covered_cells
def cover_current_level(level, current: Slot, board: Board, leveled_slots): slots = [current] current_slot = current level_amount = len([i for i in leveled_slots.values() if i == level]) # print("covering level %d" % leveled_slots.get(current_slot)) leveled_neighbors = lambda slot: [ i for i in current_slot.get_inbound_neighbors(board) if leveled_slots.get(i) == level ] nonpresent_leveled_neighbors = lambda slot, l: [ i for i in leveled_neighbors(slot) if i not in l ] # go toward a neighbor of the same level, covering until having a single neighbor with level value uncovered_inbound_neighbors = nonpresent_leveled_neighbors( current_slot, slots) while uncovered_inbound_neighbors: current_slot = uncovered_inbound_neighbors.pop() slots.append(current_slot) uncovered_inbound_neighbors = nonpresent_leveled_neighbors( current_slot, slots) # if not covered all of this level, go the the opposite direction and cover until all level is covered doubly_covered_slots = [] # if reached to this point, go until there is a cell with uncovered neighbor, and from there cover until done. # if len(set(slots)) < level_amount: # go until at a cell with uncovered neighbor previous_slot = Slot(-1, -1) while len(set(slots)) < level_amount: uncovered_leveled_slots = nonpresent_leveled_neighbors( current_slot, doubly_covered_slots) if not uncovered_leveled_slots: break temp = current_slot l = [ i for i in uncovered_leveled_slots if i != previous_slot and not is_slot_shallow_obstacle(i, board.Obstacles) ] if not l: return slots[1::] current_slot = l[0] previous_slot = temp doubly_covered_slots.append(current_slot) slots.append(current_slot) return slots[1:]
def test_positions(positions): ir=Slot(positions[0][0], positions[0][1]) io=Slot(positions[1][0], positions[1][1]) run_game(ir, io)
def get_steps(self, agent_r, board_size=50, agent_o=None): """ This function return the agent_r steps, when deciding to cover the world, spiraling from inside to outside. Note: this coverage method is not optimal! :param agent_r: the agent covering the world :param board_size: self explanatory :return: list of steps """ self.steps.extend( self.go_from_a_to_b(Slot(agent_r.InitPosX, agent_r.InitPosY), Slot(board_size / 2, board_size / 2))) next_slot = self.steps[-1] # next_slot = Slot(36,6) # start by going toward the center if next_slot.row < board_size / 2: while next_slot.row < board_size / 2: next_slot = next_slot.go_south() self.steps.append(next_slot) continue else: while next_slot.row > board_size / 2: next_slot = next_slot.go_north() self.steps.append(next_slot) continue if next_slot.col < board_size / 2: while next_slot.col < board_size / 2: next_slot = next_slot.go_east() self.steps.append(next_slot) continue else: while next_slot.col > board_size / 2: next_slot = next_slot.go_west() self.steps.append(next_slot) continue # after reaching the center, start covering, counter clockwise circ = 0 counter = 1 while circ < board_size: circ += 1 if circ < board_size: for _ in range(circ): next_slot = next_slot.go_west() self.steps.append(next_slot) counter += 1 if circ < board_size: for _ in range(circ): next_slot = next_slot.go_north() self.steps.append(next_slot) counter += 1 circ += 1 if circ < board_size: for _ in range(circ): next_slot = next_slot.go_east() self.steps.append(next_slot) counter += 1 if circ < board_size: for _ in range(circ): next_slot = next_slot.go_south() self.steps.append(next_slot) counter += 1 for step in self.steps: if step.row > board_size - 1 or step.col > board_size - 1 or step.row < 0 or step.col < 0: print( "Error while circling outside from board center: reached unavailable position" ) break return self.steps
def get_steps(self, agent_r, board_size=50, agent_o=None): """ This function returns the coverage self.steps, when covering knowing io, starting from the a corner adjacent to io, and covering semi-cyclic - covering the closer layers first. :param self: :param board_size: :param agent_o: :return: the coverage self.steps. """ assert agent_o is not None # go to the adjacent corner steps_to_start = Strategy.go_from_a_to_b( a=Slot(agent_r.InitPosX, agent_r.InitPosY), b=Strategy.get_adjacent_corner(a=Slot(agent_o.InitPosX, agent_o.InitPosY), board_size=board_size, first_option=self.first_option)) for i in steps_to_start: self.add_step(i) # from there, cover semi-cyclic current_slot = self.steps[-1] v_dir = 'u' if current_slot.row == board_size - 1 else 'd' h_dir = 'r' if current_slot.col == board_size - 1 else 'l' start_vertical = True distance = 1 counter = 1 # initial horizontal step current_slot = current_slot.go_west( ) if h_dir == 'r' else current_slot.go_east() self.add_step(current_slot) counter += 1 while counter <= board_size * board_size and distance < board_size: if start_vertical: # going vertically for _ in range(distance): current_slot = current_slot.go_north( ) if v_dir == 'u' else current_slot.go_south() self.add_step(current_slot) counter += 1 # going horizontally for _ in range(distance): current_slot = current_slot.go_west( ) if h_dir == 'l' else current_slot.go_east() self.add_step(current_slot) counter += 1 # final vertical step if counter < board_size * board_size: current_slot = current_slot.go_north( ) if v_dir == 'u' else current_slot.go_south() self.add_step(current_slot) counter += 1 else: # going horizontally for _ in range(distance): current_slot = current_slot.go_west( ) if h_dir == 'l' else current_slot.go_east() self.add_step(current_slot) counter += 1 # going vertically for _ in range(distance): current_slot = current_slot.go_north( ) if v_dir == 'u' else current_slot.go_south() self.add_step(current_slot) counter += 1 # final horizontal step if counter < board_size * board_size: current_slot = current_slot.go_west( ) if h_dir == 'l' else current_slot.go_east() self.add_step(current_slot) counter += 1 start_vertical = not start_vertical h_dir = 'r' if h_dir == 'l' else 'l' v_dir = 'u' if v_dir == 'd' else 'd' distance += 1 return self.steps
def get_steps(self, agent_r, board_size = 50, agent_o = None): """ This function return the agent steps, when deciding to cover the world, spiraling from outside to inside. Note: this coverage method is not optimal! :param agent: the agent covering the world :param board_size: self explanatory :return: list of steps """ next_slot = Slot(agent_r.InitPosX, agent_r.InitPosY) # todo: impreve performance by using extending of lists # start by going toward the closest corner if next_slot.row < board_size / 2: while next_slot.row > 0: self.steps.append(next_slot) next_slot = next_slot.go_north() continue else: while next_slot.row < board_size - 1: self.steps.append(next_slot) next_slot = next_slot.go_south() continue if next_slot.col < board_size / 2: while next_slot.col > 0: self.steps.append(next_slot) next_slot = next_slot.go_west() continue else: while next_slot.col < board_size - 1: self.steps.append(next_slot) next_slot = next_slot.go_east() continue self.steps.append(next_slot) # after reaching the closest-to-start corner, start covering the world, counter clockwise shallow_slots = [[0 for x in range(board_size)] for y in range(board_size)] shallow_slots[next_slot.row][next_slot.col] = 1 dist_from_edge = 0 while dist_from_edge < board_size / 2: if next_slot.row + dist_from_edge < board_size - 1 and next_slot.col == dist_from_edge: direction = 's' elif next_slot.row + dist_from_edge == board_size - 1 and next_slot.col + dist_from_edge < board_size - 1: direction = 'e' elif next_slot.row > dist_from_edge and next_slot.col + dist_from_edge == board_size - 1: direction = 'n' elif next_slot.row == dist_from_edge and next_slot.col + dist_from_edge >= board_size - 1: direction = 'w' if direction == 's': new_slot = next_slot.go_south() elif direction == 'e': new_slot = next_slot.go_east() elif direction == 'n': new_slot = next_slot.go_north() elif direction == 'w': new_slot = next_slot.go_west() if shallow_slots[new_slot.row][new_slot.col] == 1: dist_from_edge += 1 continue else: next_slot = new_slot self.steps.append(next_slot) shallow_slots[next_slot.row][next_slot.col] = 1 return self.steps
def get_steps(self, agent_r: Agent, board_size=50, agent_o: Agent = None): assert agent_o is not None # 1. perform bfs and set LEVEL values # 2. go to cell with highest LEVEL value # 3. while not all cells covered: # 3.1. cover current LEVEL # 3.2. if next level adjacent, go there # 3.3 if not all cells are covered, go to next level (search) covered_slots = [] # get the 'farthest' cell from R's initial location initial_level_assignment = assign_level_to_slots( board=agent_o.gameBoard, init=Slot(agent_o.InitPosX, agent_o.InitPosY), levelType=4) farthest_slot = max(initial_level_assignment.items(), key=operator.itemgetter(1))[0] # 1. perform bfs board = agent_o.gameBoard leveled_slots = assign_level_to_slots(board, farthest_slot) # define lambda def there_are_cells_to_cover(): return len(set(self.steps)) + len( board.get_shallow_obstacles()) < board.Rows * board.Cols def distance(a, b): return fabs(a.row - b.row) + fabs(a.col - b.col) def edges_and_distance_score(slot: Slot): return len(slot.get_inbound_neighbors(board)) * 10 + distance( slot, Slot(agent_r.InitPosX, agent_r.InitPosY)) max_level = min(leveled_slots.values()) max_leveled_slots = [ i for i in leveled_slots if leveled_slots[i] == max_level ] ordered_max_leveled_slots = sorted(max_leveled_slots, key=edges_and_distance_score) # 2. go to cell with highest LEVEL value # max_level_slot = max(leveled_slots.items(), key=operator.itemgetter(1)) best_max_level_slot = ordered_max_leveled_slots[0] path_to_max_slot = Strategy.go_from_a_to_b_dijkstra( a=Slot(agent_r.InitPosX, agent_r.InitPosY), b=best_max_level_slot, board=board) self.steps.extend(path_to_max_slot) current_slot = best_max_level_slot covered_slots.append(current_slot) # covered_slots.extend(path_to_max_slot) # 3. while not all cells covered: while there_are_cells_to_cover(): # 3.1. cover current LEVEL level_steps = cover_current_level( level=leveled_slots[current_slot], current=current_slot, board=board, leveled_slots=leveled_slots) self.steps.extend(level_steps) covered_slots.extend(level_steps) if level_steps: current_slot = level_steps[-1] # 3.2. if next level adjacent, go there preferred_n = Slot(-1, -1) current_slot_neighbors = [ n for n in current_slot.get_inbound_neighbors(board) if not is_slot_shallow_obstacle(n, board.Obstacles) ] if any([ (leveled_slots.get(i) == leveled_slots.get(current_slot) + 1) for i in current_slot_neighbors if i not in covered_slots ]): for n in current_slot_neighbors: if leveled_slots[n] == leveled_slots[current_slot] + 1: if preferred_n == Slot(-1, -1) or len( n.get_inbound_neighbors(board)) < len( preferred_n.get_inbound_neighbors(board)): preferred_n = n if preferred_n != Slot(-1, -1): if preferred_n.row == -1: pass current_slot = preferred_n covered_slots.append(current_slot) self.steps.append(current_slot) # break else: raise Exception("Unhandled Code! Slot: %s" % current_slot) else: # reaching this case means all current slot's neighbors are already covered. either coverage is done, # or we have reached a dead end, and should look for the closest uncovered cell. if not there_are_cells_to_cover(): break # 3.3 if next level not adjacent, and process not finished, search for next level # (higher than 0) and go there # 3.4 from there, cover with decreasing level values until no more slots are to cover # find_closest_uncovered_slot cus = min( [i for i in leveled_slots.keys() if i not in self.steps], key=lambda a: distance(a, current_slot)) current_slot = cus self.steps.append(current_slot) covered_slots.append(current_slot) continue # print("closest ucs is: %s" %cus) return self.steps
def get_steps(self, agent_r, board_size=50, agent_o=None): next_slot = Slot(agent_r.InitPosX, agent_r.InitPosY) flag = (agent_r.InitPosY == board_size - 1 and not (agent_r.InitPosX == 0)) steps = [] counter = 0 while True: counter += 1 if counter > 1000000000000: break steps.append(next_slot) # in the middle of moving from bottom row to top row if flag: next_slot = next_slot.go_north() if next_slot.row == 0: flag = False if next_slot == Slot(agent_r.InitPosX, agent_r.InitPosY): break continue # check if in last position, and start moving from last row to top row elif next_slot.row == board_size - 1 and next_slot.col == board_size - 1 - 1: flag = True next_slot = next_slot.go_east() if next_slot == Slot(agent_r.InitPosX, agent_r.InitPosY): break continue # update next slot elif next_slot.row % 2 != 0: if next_slot.col == board_size - 1 - 1: next_slot = next_slot.go_south() else: next_slot = next_slot.go_east() else: if next_slot.col == 0: next_slot = next_slot.go_south() else: next_slot = next_slot.go_west() if next_slot == Slot(agent_r.InitPosX, agent_r.InitPosY): break return steps
def get_steps(self, agent_r, board_size = 50, agent_o = None): next_slot = Slot(agent_r.InitPosX, agent_r.InitPosY) flag = (agent_r.InitPosX == board_size - 1) counter = 0 # print "init pos {},{}: ".format(agent_r.InitPosX, agent_r.InitPosY) while True: counter += 1 if counter > board_size * board_size: break self.steps.append(next_slot) # in the middle of moving from bottom rpw to top row if flag: if next_slot.col == board_size - 1: flag = False next_slot = next_slot.go_north() else: next_slot = next_slot.go_east() if next_slot == Slot(agent_r.InitPosX, agent_r.InitPosY): break continue # check if in last position, and start moving from last row to top row elif next_slot.row == board_size - 1 - 1 and next_slot.col == 0: flag = True next_slot = next_slot.go_south() if next_slot == Slot(agent_r.InitPosX, agent_r.InitPosY): break continue # update next slot elif next_slot.col % 2 != 0: if next_slot.row == 0: next_slot = next_slot.go_west() else: next_slot = next_slot.go_north() else: if next_slot.row == board_size - 1 - 1: next_slot = next_slot.go_west() else: next_slot = next_slot.go_south() if next_slot.row > board_size - 1: print("+1") if next_slot == Slot(agent_r.InitPosX, agent_r.InitPosY): break return self.steps
def take_snapshots(): import seaborn as sb num_samples = 100 random_results = [] steps_times_o = {} steps_times_r = {} for i in range(1024): steps_times_o[i] = [] for i in range(1056): steps_times_r[i] = [] for _ in tqdm(range(num_samples)): b = Board(32, 32) agentO = Agent("O", StrategyEnum.RandomSTC, 31, 31, board=b) agentR = Agent("R", StrategyEnum.LONGEST_TO_REACH, 0, 0, board=b, agent_o=agentO) game = Game(agentR, agentO) game.run_game(enforce_paths_length=False) for os in range(len(agentO.steps)): step = agentO.steps[os] steps_times_o[os].append(step) random_results.append(game.get_r_gain()) b = Board(32, 32) agentO = Agent("O", StrategyEnum.RandomSTC, 31, 31, board=b) agentR = Agent("R", StrategyEnum.LONGEST_TO_REACH, 0, 0, board=b, agent_o=agentO) for os in range(len(agentR.steps)): step = agentR.steps[os] steps_times_r[os].append(step) from collections import Counter iterations = float(num_samples) to_t = [] # for cell c, how much strategies cover it by time t\ for t in tqdm(range(1024)): to_t.extend(steps_times_o[t]) c = Counter(to_t) probes = [[c[Slot(i, j)] / iterations for j in range(32)] for i in range(32)] probes.reverse() sb.heatmap(probes, yticklabels=False, xticklabels=False, vmin=0, vmax=1) plt.savefig('data_O/time_%s' % t) plt.close() for t in tqdm(range(1056)): to_t.extend(steps_times_r[t]) c = Counter(to_t) probes = [[c[Slot(i, j)] / iterations for j in range(32)] for i in range(32)] probes.reverse() sb.heatmap(probes, yticklabels=False, xticklabels=False, vmin=1) plt.savefig('data_R/time_%s' % t) plt.close()
def get_steps(self, agent_r: Agent, board_size=50, agent_o: Agent = None): assert agent_o is not None # go to the farthest corner self.steps.extend( Strategy.go_from_a_to_b(a=Slot(agent_r.InitPosX, agent_r.InitPosY), b=Slot(agent_o.InitPosX, agent_o.InitPosY))) # from there, cover semi-cyclic current_slot = self.steps[-1] v_dir = 'u' if current_slot.row == board_size - 1 else 'd' h_dir = 'r' if current_slot.col == board_size - 1 else 'l' start_vertical = True distance = 1 counter = 1 # initial horizontal step current_slot = current_slot.go_west( ) if h_dir == 'r' else current_slot.go_east() self.steps.append(current_slot) counter += 1 while counter <= board_size * board_size and distance < board_size: if start_vertical: # going vertically for _ in range(distance): current_slot = current_slot.go_north( ) if v_dir == 'u' else current_slot.go_south() self.steps.append(current_slot) counter += 1 # going horizontally for _ in range(distance): current_slot = current_slot.go_west( ) if h_dir == 'l' else current_slot.go_east() self.steps.append(current_slot) counter += 1 # final vertical step if counter < board_size * board_size: current_slot = current_slot.go_north( ) if v_dir == 'u' else current_slot.go_south() self.steps.append(current_slot) counter += 1 else: # going horizontally for _ in range(distance): current_slot = current_slot.go_west( ) if h_dir == 'l' else current_slot.go_east() self.steps.append(current_slot) counter += 1 # going vertically for _ in range(distance): current_slot = current_slot.go_north( ) if v_dir == 'u' else current_slot.go_south() self.steps.append(current_slot) counter += 1 # final horizontal step if counter < board_size * board_size: current_slot = current_slot.go_west( ) if h_dir == 'l' else current_slot.go_east() self.steps.append(current_slot) counter += 1 start_vertical = not start_vertical h_dir = 'r' if h_dir == 'l' else 'l' v_dir = 'u' if v_dir == 'd' else 'd' distance += 1 return self.steps
def get_steps(self, agent_r, board_size=50, agent_o=None): # This coverage strategy covers first the top left, then top right, then bottom left, then bottom right quarters of # the area. # While building this function, we assumed 100X100 dimensions next_slot = Slot(agent_r.InitPosX, agent_r.InitPosY) # flag = (agent_r.InitPosY == boardSizeY - 1 and not (agent_r.InitPosX == 0)) steps = [] counter = 0 while True: counter += 1 if counter > 100000: print("Something is wrong, counter is too big!") print(steps) break if counter > 1 and (next_slot.row, next_slot.col) == (agent_r.InitPosX, agent_r.InitPosY): break steps.append(next_slot) # TL Quarter if 0 <= next_slot.row < board_size / 2 and 0 <= next_slot.col < board_size / 2: if (next_slot.row, next_slot.col) == (board_size / 2 - 1, board_size / 2 - 1): next_slot = next_slot.go_east() continue if next_slot.col == 0: next_slot = next_slot.go_north( ) if next_slot.row > 0 else next_slot.go_east() continue if next_slot.row % 2 == 0 and next_slot.row < board_size / 2 - 2: # An even line, not the last one next_slot = next_slot.go_east( ) if not next_slot.col == board_size / 2 - 1 else next_slot.go_south( ) continue elif next_slot.row % 2 != 0 and not next_slot.row == board_size / 2 - 1: # An odd line, not before last next_slot = next_slot.go_west( ) if not next_slot.col == 1 else next_slot.go_south() continue elif next_slot.row % 2 == 0 and next_slot.row == board_size / 2 - 2: # An even line, the last one next_slot = next_slot.go_south( ) if next_slot.col % 2 != 0 else next_slot.go_east() elif next_slot.row % 2 != 0 and next_slot.row == board_size / 2 - 1: # An odd line, last line next_slot = next_slot.go_east( ) if next_slot.col % 2 != 0 else next_slot.go_north() else: print("TL: Error occurred! Should not reach here!") continue # TR Quarter elif 0 <= next_slot.row < board_size / 2 and board_size / 2 <= next_slot.col < board_size: if (next_slot.row, next_slot.col) == (board_size / 2 - 1, board_size - 1): next_slot = next_slot.go_south() continue elif next_slot.col % 2 == 0: next_slot = next_slot.go_north( ) if next_slot.row > 0 else next_slot.go_east() continue elif next_slot.col % 2 != 0: next_slot = next_slot.go_south( ) if next_slot.row < board_size / 2 - 1 else next_slot.go_east( ) continue else: print("TR: Error occurred! Should not reach here!") continue # BL Quarter elif board_size / 2 <= next_slot.row < board_size and 0 <= next_slot.col < board_size / 2: if (next_slot.row, next_slot.col) == (board_size / 2, 0): # last cell of quarter next_slot = next_slot.go_north() continue elif next_slot.col % 2 == 0: # an even column next_slot = next_slot.go_north( ) if next_slot.row > board_size / 2 else next_slot.go_west( ) continue elif next_slot.col % 2 != 0: # An odd line next_slot = next_slot.go_south( ) if next_slot.row < board_size - 1 else next_slot.go_west( ) continue else: print("BL: Error occurred! Should not reach here!") continue # BR Quarter else: if (next_slot.row, next_slot.col) == (board_size / 2, board_size / 2): # last cell of quarter next_slot = next_slot.go_west() continue elif next_slot.col == board_size - 1: next_slot = next_slot.go_south( ) if not next_slot.row == board_size - 1 else next_slot.go_west( ) continue elif next_slot.row % 2 != 0 and not next_slot.row == board_size / 2 + 1: # and odd line, not before last next_slot = next_slot.go_west( ) if next_slot.col > board_size / 2 else next_slot.go_north( ) continue elif next_slot.row % 2 != 0 and next_slot.row == board_size / 2 + 1: # and odd line, DO before last next_slot = next_slot.go_north( ) if next_slot.col % 2 == 0 else next_slot.go_west() continue elif next_slot.row % 2 == 0 and not next_slot.row == board_size / 2: # an even line, not last one next_slot = next_slot.go_east( ) if next_slot.col < board_size - 2 else next_slot.go_north( ) continue elif next_slot.row % 2 == 0 and next_slot.row == board_size / 2: # an even line, INDEED last one next_slot = next_slot.go_west( ) if next_slot.col % 2 == 0 else next_slot.go_south() continue else: print("BR: Error occurred! Should not reach here!") continue return steps
def get_steps(self, agent_r, board_size = 50, agent_o = None): """ Returns a non-circular vertical coverage, starting from agent_r's initial position to top-right position, then cover all cells from top-right to bottom-left, without repeating cells (there are some assumption regarding the initial position :param agent_r: the given agent_r :param board_size: board's width :param board_size: board's height :return: a set of steps covering the whole board """ steps = [] next_slot = Slot(agent_r.InitPosX, agent_r.InitPosY) turning_slot = Slot(agent_r.InitPosX, agent_r.InitPosY) reaching_to_farthest_corner = True up_or_down = 'd' # assert call assert agent_r.InitPosX % 2 == 0 while True: steps.append(next_slot) if len(steps) >= board_size * board_size: break # Check if we agent_r reached the farthest corner of the board if next_slot == Slot(board_size - 1, board_size - 1): reaching_to_farthest_corner = False if reaching_to_farthest_corner: if next_slot.row < board_size - 1: next_slot = next_slot.go_south() continue elif next_slot.col < board_size - 1: next_slot = next_slot.go_east() continue else: if next_slot.col > agent_r.InitPosY: if next_slot.col % 2 != 0: next_slot = next_slot.go_north() if next_slot.row > 0 else next_slot.go_west() else: next_slot = next_slot.go_south() if next_slot.row < board_size - 2 else next_slot.go_west() continue else: if up_or_down == 'd': if next_slot.go_south() != turning_slot: if next_slot.row < board_size - 1: next_slot = next_slot.go_south() else: next_slot = next_slot.go_west() up_or_down = 'u' continue else: turning_slot = turning_slot.go_west().go_west().go_north().go_north() steps.append(next_slot.go_west()) steps.append(next_slot.go_west().go_south()) next_slot = next_slot.go_west().go_south().go_south() continue else: if next_slot != turning_slot: if next_slot.row > 0: next_slot = next_slot.go_north() else: next_slot = next_slot.go_west() up_or_down = 'd' continue else: steps.append(next_slot.go_east()) steps.append(next_slot.go_east().go_north()) next_slot = next_slot.go_east().go_north().go_north() continue return steps[:board_size * board_size]
def get_steps(self, agent_r, board_size = 50, agent_o = None,): return SpanningTreeCoverage.get_random_coverage_strategy(size=board_size, i_r=Slot(agent_r.InitPosX, agent_r.InitPosY), print_mst=True, obstacles=agent_r.gameBoard.Obstacles)
def edges_and_distance_score(slot: Slot): return len(slot.get_inbound_neighbors(board)) * 10 + distance( slot, Slot(agent_r.InitPosX, agent_r.InitPosY))