예제 #1
0
 def copyAndChangeMap(self,ants):
     map=ants.map
     for (r,c) in ants.my_ants():
         map[r][c]=SELF_PLAYER
     for ((r,c),nr) in ants.enemy_ants():
         map[r][c]=ENEMS_PLAYER
     return map
예제 #2
0
파일: utils.py 프로젝트: jsom/nothingboring
def pprintlm(ants):
	hillrow, hillcol = ants.my_hills()[0]
	lbound = max(0, hillrow - 10)
	rbound = min(ants.rows - 1, hillrow + 10)
	bbound = max(0, hillcol - 10)
	tbound = min(ants.cols - 1, hillcol + 10)
	for rownum, row in enumerate(xrange(ants.rows)):
		if rownum < lbound or rownum > rbound:
			continue
		new_row = []
		for colnum, col in enumerate(xrange(ants.cols)):
			if colnum < bbound or colnum > tbound:
				continue
			if not ants.passable((row, col)):
				new_elem = '  x  '
			elif (row, col) in ants.my_ants():
				new_elem = '  a  '
			else:
				new_elem = '  -  ' 
			new_row.append(new_elem)			
		sys.stderr.write('m  ' + ' '.join(new_row) + '\n')
예제 #3
0
파일: MyBot.py 프로젝트: veloce/antwar
    def do_turn(self, ants):
        logging.info('MAP: \n' + ants.render_text_map())
        # track all moves, prevent collisions
        orders = {}
        def do_move_direction(loc, direction):
            new_loc = ants.destination(loc, direction)
            if (ants.unoccupied(new_loc) and new_loc not in orders):
                ants.issue_order((loc, direction))
                orders[new_loc] = loc
                return new_loc
            else:
                return False

        target_dests = {}
        def do_move_location(loc, dest, path=None):
            # if path given use it
            if path:
                direction = path.popleft()
                # ant who has an aim will be in new_loc next turn
                new_loc = do_move_direction(loc, direction)
                if new_loc and ants.passable(new_loc):
                    self.aims[new_loc] = dest, path
                    target_dests[dest] = loc
                    return True
            # or use direction from manhattan distance
            else:
                directions = ants.manhattan_direction(loc, dest)
                for direction in directions:
                    if do_move_direction(loc, direction):
                        target_dests[dest] = loc
                        return True
            return False

        # prevent stepping on own hill
        for hill_loc in ants.my_hills():
            orders[hill_loc] = None

        # ants who have an aim shall continue first
        for ant_loc in self.aims.keys():
            # be sure that ant is not dead nor assigned
            if (ant_loc not in ants.my_ants()) or (ant_loc in orders.values()):
                del(self.aims[ant_loc])
                continue
            dest, path = self.aims[ant_loc]
            # are we at the end of the road?
            if path:
                # got stuck somewhere? repath
                if not do_move_location(ant_loc, dest, path):
                    new_path = ants.bfs_shortest_path(ant_loc, dest)
                    if do_move_location(ant_loc, dest, new_path):
                        logging.info('REPATH: ' + str(ant_loc) + ' ' + str(dest) + ' ' + str(new_path))
                else:
                    logging.info('CONTINUE PATH: ' + str(ant_loc) + ' ' + str(dest) + ' ' + str(path))
            # in all cases delete current loc from aims
            del(self.aims[ant_loc])

        for food_loc in ants.food():
            ant_loc, path = ants.find_closest_ant(food_loc)
            if ant_loc and (food_loc not in target_dests) and (ant_loc not in target_dests.values()):
                path = ants.reverse_path(path)
                if do_move_location(ant_loc, food_loc, path):
                    logging.info('FEEDER (2): ' + str(ant_loc) + ' ' + str(food_loc) + ' ' + str(path))

        # attack hills
        for hill_loc, hill_owner in ants.enemy_hills():
            if hill_loc not in self.hills:
                self.hills.append(hill_loc)
        ant_dist = []
        for hill_loc in self.hills:
            for ant_loc in iter(ants.my_ants()):
                if ant_loc not in orders.values():
                    dist = ants.manhattan_distance(ant_loc, hill_loc)
                    ant_dist.append((dist, ant_loc))
        ant_dist.sort()
        for dist, ant_loc in ant_dist:
            do_move_location(ant_loc, hill_loc)

        # explore unseen areas
        for loc in self.unseen[:]:
            if ants.visible(loc):
                self.unseen.remove(loc)
        for ant_loc in iter(ants.my_ants()):
            if ant_loc not in orders.values():
                unseen_dist = []
                for unseen_loc in self.unseen:
                    dist = ants.manhattan_distance(ant_loc, unseen_loc)
                    unseen_dist.append((dist, unseen_loc))
                unseen_dist.sort()
                for dist, unseen_loc in unseen_dist:
                    if do_move_location(ant_loc, unseen_loc):
                        logging.info('SCOUT: ' + str(ant_loc) + ' ' + str(unseen_loc))
                        break

        # unblock own hill
        for hill_loc in ants.my_hills():
            if hill_loc in ants.my_ants() and hill_loc not in orders.values():
                for direction in ('s','e','w','n'):
                    if do_move_direction(hill_loc, direction):
                        break

        # track idle ants
        for ant in iter(ants.my_ants()):
            if ant not in orders.values():
                logging.info('IDLE: ' + str(ant))