def act(self, game):
     active_team = {}
     active_enemy = {}
     enemy_distance = {}
     active_bots = {}
     for loc, bot in game.get('robots').items():
         if bot.player_id != self.player_id:
             active_enemy[loc] = bot                
             enemy_distance[loc] = 0
         else:
             active_team[loc] = bot
     for loc, bot in game.get('robots').items():
         active_bots[loc] = bot
     for loc in active_enemy:
         for myloc in active_team:
             enemy_distance[loc] = enemy_distance[loc] + rg.dist(loc, myloc)
     if self.hp <= 20:
         return flee(self, active_enemy, active_team, game)
     if 'spawn' in rg.loc_types(self.location):
         if game['turn'] %10 == 0: #spawn about to happen, gtfo
             return ['move', rg.toward(self.location, rg.CENTER_POINT)]
     for loc, bot in game['robots'].iteritems():
         if bot.player_id != self.player_id:
             if rg.dist(loc, self.location) <= 1:
                 print("ATTACK")
                 return ['attack', loc]
             else:                    
                 return['move', rg.toward(self.location, bot.location)]
Exemple #2
0
    def act(self, game):
        my_team = self.player_id
        if 'spawn' in rg.loc_types(self.location):
            return ['move', rg.toward(self.location, rg.CENTER_POINT)]
        else:
            # Get the nearby locations
            near_locations = rg.locs_around(self.location)
            # For each location see if there is a robot there or not...
            for loc in near_locations:
                try:
                    robot_location = game.robots[loc]
                    # There is...
                    # If it is our own robot, just move to the center one step. Stop moving when we reach the center.
                    if game.robots[loc][
                            'player_id'] == my_team and self.location != rg.CENTER_POINT:
                        return [
                            'move',
                            rg.toward(self.location, rg.CENTER_POINT)
                        ]
                    elif game.robots[loc]['player_id'] != my_team:
                        return ['attack', loc]
                except KeyError:
                    # There are no robots there...
                    pass

        return ['guard']
Exemple #3
0
    def act(self, game):
        # TODO:
        # Swarm around the sub-leader bot
        # attack in group, increase radius of search to 2-3 tiles away
        
        #print " robot {} has moves ".format(self.robot_id), self.move_randomly(game)
        #print " robot {} has {} enemy around".format(self.robot_id, len(self.enemy_around(game)))
        if self.move_randomly(game):
            return self.move_randomly(game)
        else:
            enemies_1 = self.enemy_around(game, 1)
            enemies_2 = self.enemy_around(game)
            if len(enemies_1) > 0:
                if self.hp <= 15: 
                    return ['suicide']
                #attack the weakest enemy
                weakest_enemy = self.find_weakest(enemies_1)
                return ['attack', weakest_enemy.location]
            elif len(enemies_2) > 0:
                #no enemy around, extend to 2nd radius
                weakest_enemy = self.find_weakest(enemies_2)
                if rg.wdist(self.location, weakest_enemy.location) == 2:
                    return ['attack', rg.toward(self.location, weakest_enemy.location)]
                else:
                    return ['move', rg.toward(self.location, weakest_enemy.location)]
                
            return ['guard']
        #else:
        #next_move = rg.toward(self.location, rg.CENTER_POINT)
        #if next_move in game.robots
        #else:
        #    return ['move', next_move]

        return ['guard']
Exemple #4
0
    def act(self, game):
        
        myId = self.robot_id
        myAge = 0

        if myId in self.age:
            self.age[myId] += 1
            myAge = self.age[myId]
        else:
            self.age[myId] = 0
       
        # get off the spawn point fast
        if myAge <= 3:
            return ['move', rg.toward(self.location, rg.CENTER_POINT)]
        
        # if there are enemies around, attack them
        for loc, bot in game.robots.iteritems():
            if bot.player_id != self.player_id:
                if rg.dist(loc, self.location) <= 1:
                    return ['attack', loc]

                # if we're in the center, stay put
        if self.location == rg.CENTER_POINT:
            return ['guard']

        # move toward the center slowly
        if game.turn % 2:
            return ['move', rg.toward(self.location, rg.CENTER_POINT)]
        
        return['guard']
Exemple #5
0
    def act(self, game):
        my_team = self.player_id
        if 'spawn' in rg.loc_types(self.location):
            # Store the position of the spawning point
            self.spawn_loc = self.location
            # Just move one place toward the center
            return ['move', rg.toward(self.location, rg.CENTER_POINT)]
        else:
            # Get the nearby locations
            near_locations = rg.locs_around(self.location)
            # For each location see if there is a robot there or not...
            for loc in near_locations:
                try:
                    robot_location = game.robots[loc]
                    # There is...

                    # TODO AR: there is problem. When robots from our team are near to each other
                    # they start moving to the center. in late phases of game it will be more often.

                    # If it is our own robot, just move to the center one step. If we are more than 1 distance from the spawning location, stop moving.
                    # this is to avoid moving to the center.
                    #if game.robots[loc]['player_id'] == my_team and self.location != rg.CENTER_POINT: 
                    if game.robots[loc]['player_id'] == my_team and rg.wdist(self.location,self.spawn_loc) == 1:
                        return ['move', rg.toward(self.location, rg.CENTER_POINT)]
                    # Just to take advantage of the situation, if there is an enemy near, attack it.
                    elif game.robots[loc]['player_id'] != my_team:
                        return ['attack', loc ]
                except KeyError:
                    # There are no robots there...
                    pass 

        return ['guard']
Exemple #6
0
    def act(self, game):
        ennemies_around = []
        toward_center_location = rg.toward(self.location, rg.CENTER_POINT)
        
        for location, bot in game.robots.iteritems():
            if bot.player_id != self.player_id:
                if rg.dist(location, self.location) <= 1:
                    ennemies_around.append(location)

            if location == toward_center_location:
                if bot.player_id == self.player_id:
                    return ['guard']
                    

        if len(ennemies_around) > 2:
            return ['suicide']
        if len(ennemies_around) > 0:
            return ['attack', ennemies_around[0]]

        for location, bot in game.robots.iteritems():
            if bot.player_id == self.player_id:
                if self.give_way(location, toward_center_location):
                    print location, toward_center_location, self.location
                    return ['guard']

        return ['move', rg.toward(self.location, rg.CENTER_POINT)]
Exemple #7
0
 def act(self, game):
     # first run: make the 'updated' attribute
     if not hasattr(self, 'groups_updated'):
         self.groups_updated = -1
         self.ally_groups = []
         self.enemy_groups = []
         self.taget_group = None
         self.target_location = rg.CENTER_POINT
         self.bfs_grid = []
     # 'self' is an entity shared by all bots. each frame, only one bot needs to make decisions, then they are shared
     if self.groups_updated < game['turn']:
         self.groups_updated = game['turn']
         self.ally_groups, self.enemy_groups = self.compute_groups(game, True)
         # sort groups by strength (sum of health)
         self.enemy_groups = sorted(self.enemy_groups, key=(lambda grp: sum([game['robots'][loc].hp for loc in grp])))
         # attack weakest group
         # TODO multiple targets
         self.target_group = self.enemy_groups[0]
         target_location_x = sum([loc[0] for loc in self.target_group])
         target_location_y = sum([loc[1] for loc in self.target_group])
         self.target_location = (target_location_x, target_location_y)
         self.bfs_grid = bfs_tree(game['robots'], self.target_location, self.player_id)
     # bot-specifics: move towards target or attack if there
     next = self.bfs_grid[self.location[0]][self.location[1]]
     # print self.location, "to", self.target_location, "via", next
     if next is not None:
         if next in game['robots']:
             return self.guard_or_attack(game)
         else:
             return ['move', next]
     elif rg.toward(self.location, self.target_location) in game['robots']:
         return ['attack', rg.toward(self.location, self.target_location)]
     else:
         return self.guard_or_attack(game)
Exemple #8
0
 def act(self, game):
     self.game = game
     enemy_location = self.closest_adjacent_enemy()
     if 'spawn' in rg.loc_types(self.location):
         destinations = rg.locs_around(self.location, filter_out=('invalid','obstacle','spawn'))
         if destinations:
             # print("Robot {0}: In a spawn. Moving to {1}".format(str(self.location), str(destination)))
             return self.move(destinations[0])
         else:
             return self.guard()
     elif enemy_location:
         # print("Robot {0}:Trying to attack. Location:{1}".format(str(self.location), str(enemy_location)))
         return self.attack(enemy_location)
     else:
         enemies = []
         for loc, robot in game.robots.items():
             if robot.player_id != self.player_id:
                 enemies.append(loc)
         enemies.sort()
         if rg.toward(self.location, enemies[0]) == self.location:
             # print("Robot {0}:Don't want to collide; guarding.".format(self.location))
             return self.guard()
         else:
             destination = rg.toward(self.location, enemies[0])
             # print("Robot {0}: Not in position; moving to {1}.".format(self.location, destination))
             if 'spawn' not in rg.loc_types(destination):
                 return self.move(rg.toward(self.location, enemies[0]))
             else:
                 return self.move(rg.toward(self.location, rg.CENTER_POINT))
Exemple #9
0
    def act(self, game):

        wszystkie = {(x, y) for x in xrange(19) for y in xrange(19)}
        wejscia = {poz for poz in wszystkie if 'spawn' in rg.loc_types(poz)}
        zablokowane = {poz for poz in wszystkie if 'obstacle' in rg.loc_types(poz)}
        druzyna = {poz for poz in game.robots if game.robots[poz].player_id == self.player_id}
        wrogowie = set(game.robots) - druzyna
        sasiednie = set(rg.locs_around(self.location)) - zablokowane
        sasiednie_wrogowie = sasiednie & wrogowie
        sasiednie_wrogowie2 = {poz for poz in sasiednie if (set(rg.locs_around(poz)) & wrogowie)} - druzyna

        # działanie domyślne:
        ruch = ['move', rg.toward(self.location, rg.CENTER_POINT)]

        if self.location in wejscia:
            ruch = ['move',  rg.toward(self.location, rg.CENTER_POINT)]

        if self.location == rg.CENTER_POINT:
            ruch = ['guard']

        if sasiednie_wrogowie:
            if 9*len(sasiednie_wrogowie) >= self.hp:
                pass
            else:
                ruch = ['attack', sasiednie_wrogowie.pop()]

        if sasiednie_wrogowie2:
            ruch = ['attack', sasiednie_wrogowie2.pop()]

        return ruch
Exemple #10
0
    def act(self, game):
        if self.hp < 14:
            return ['suicide']

        # Calculate nearby bots
        nearby_bots = 0
        for loc, bot in game.robots.iteritems():
            if bot.player_id != self.player_id:
                if rg.dist(loc, self.location) <= 2:
                    nearby_bots += 1
                    enemy_loc = loc

        # Attack or suicide if bots nearby
        if nearby_bots == 1:
            if rg.dist(enemy_loc, self.location) == 1:
                return ['attack', enemy_loc]
            else:
                return ['attack', rg.toward(self.location, enemy_loc)]
        elif nearby_bots > 2:
            return ['suicide']

        # If already at center, guard the center
        if self.location == rg.CENTER_POINT:
            return ['guard']

        # Move to center
        next_move_to_center = rg.toward(self.location, rg.CENTER_POINT)

        #import pdb; pdb.set_trace()
        if next_move_to_center in game['robots']:
            return ['guard']

        return ['move', next_move_to_center]
Exemple #11
0
 def act(self, game):
     
     print
     print "Turn: " +str( game.turn) + "\tBot: " + str(self.robot_id)
     # find closest friend & enemy
     closestFriend = (1000, 1000)
     closestEnemy = (1000, 1000)
     for loc, bot in game.get('robots').items():
         if bot.player_id != self.player_id:
             if rg.wdist(loc, self.location) <= rg.wdist(closestEnemy, self.location):
                 closestEnemy = loc
         else:
             if rg.wdist(loc, self.location) <= rg.wdist(closestFriend, self.location) and self.robot_id != bot.robot_id:
                 closestFriend = loc
     
     for loc, bot in game['robots'].iteritems():
         # if there are enemies around, attack them
         if bot.player_id != self.player_id:
             if rg.dist(loc, self.location) <= 1:
                 return ['attack', loc]
         else:
             # if there are friends around, move to them
             if rg.dist(loc, self.location) > 2:
                 return ['move', rg.toward(self.location, closestFriend)]
                 
     # move towards enemy
     return ['move', rg.toward(self.location, closestEnemy)]
Exemple #12
0
 def compute_command(self, turn, bot, enemy_bots):
     if bot.location in self.SPAWN_LOCATIONS:
         self.move(
             turn, bot,
             choice(bot.movements) if bot.movements else rg.toward(
                 bot.location, rg.CENTER_POINT))
         return
     # if there are enemies around, attack them
     if bot.enemies:
         enemies = [enemy_bots[loc] for loc in bot.enemies]
         weak_enemies = [
             b for b in enemies if self.health(b) <= self.MIN_ATTACK_DAMAGE
         ]
         if weak_enemies:
             self.attack(turn, bot, choice(weak_enemies).location)
             return
         if self.health(bot) < len(enemies) * self.MIN_ATTACK_DAMAGE:
             self.suicide(turn, bot)
             return
         target = min(enemies, key=self.health)
         self.attack(turn, bot, target.location)
         return
     # if we're in the center, stay put
     if bot.location == rg.CENTER_POINT:
         self.guard(turn, bot)
         return
     # move toward the center
     self.move(turn, bot, rg.toward(bot.location, rg.CENTER_POINT))
Exemple #13
0
    def act(self, game):
        if self.robot_id in self.mayday:
            del self.mayday[self.robot_id]
        
        if self.hp < 10:
            return self.kill_self(game)

        enemies = []
        friends = []

        for robot in game.robots.itervalues():
            if hasattr(robot, "robot_id"):
                friends.append(robot)
            else:
                enemies.append(robot)

        targets = []
        for enemy in enemies:
            targets.append((enemy, rg.wdist(self.location, enemy.location)))

        target, distance = min(targets, key=lambda (a, b): b)

        if distance == 1:
            self.mayday[self.robot_id] = target.location
            return ["attack", target.location]
        if self.mayday:
            targets = [(t, rg.wdist(self.location, t)) for t in self.mayday.values()]
            target, _ = min(targets, key=lambda (a, b): b)
            if rg.wdist(self.location, target) == 1:
                return ["attack", target]
            return ["move", rg.toward(self.location, target)]
        return ["move", rg.toward(self.location, target.location)]
Exemple #14
0
    def act(self, game):

        # wyznaczamy zbiory różnych pól na planszy
        wszystkie = {(x, y) for x in xrange(19) for y in xrange(19)}
        wejscia = {loc for loc in wszystkie if 'spawn' in rg.loc_types(loc)}
        zablokowane = {loc for loc in wszystkie if 'obstacle' in rg.loc_types(loc)}
        druzyna = {loc for loc in game.robots if game.robots[loc].player_id == self.player_id}
        wrogowie = set(game.robots) - druzyna
        sasiednie = set(rg.locs_around(self.location)) - zablokowane
        sasiednie_wrogowie = sasiednie & wrogowie
        sasiednie_wrogowie2 = {loc for loc in sasiednie if (set(rg.locs_around(loc)) & wrogowie)} - druzyna

        ruch = ['move', rg.toward(self.location, rg.CENTER_POINT)]

        if self.location in wejscia:
            ruch = ['move',  rg.toward(self.location, rg.CENTER_POINT)]

        if self.location == rg.CENTER_POINT:
            ruch = ['guard']

        if sasiednie_wrogowie:
            if 9*len(sasiednie_wrogowie) < self.hp:
                ruch = ['attack', sasiednie_wrogowie.pop()]

        if sasiednie_wrogowie2:
            ruch = ['attack', sasiednie_wrogowie2.pop()]

        return ruch
Exemple #15
0
    def act(self, game):
        # Borrowed sets of sets from github.com/ramk13
        all_locs = {(x, y) for x in xrange(19) for y in xrange(19)}
        spawn = {loc for loc in all_locs if 'spawn' in rg.loc_types(loc)}
        obstacle = {loc for loc in all_locs if 'obstacle' in rg.loc_types(loc)}
        team = {loc for loc in game.robots if game.robots[loc].player_id == self.player_id}
        enemy = set(game.robots) - team
        adjacent = set(rg.locs_around(self.location)) - obstacle
        adjacent_enemy = adjacent & enemy
        safe = adjacent - adjacent_enemy - spawn - team

        north = {loc for loc in team if loc[1] > 9 and loc[0] > 9}
        east = {loc for loc in team if loc[1] <= 9 < loc[0]}
        west = {loc for loc in team if loc[1] <= 9 and loc[0] <= 9}
        south = team - north - east - west

        x, y = int(sum(x for x, y in north if self)/len(north)), int(sum(y for x, y in north)/len(north))
        sx, sy = int(sum(x for x, y in south)/len(south)), int(sum(y for x, y in south)/len(south))
        if self.location in ((nx, ny), (sx, sy)) or rg.locs_around(self.location) in ((nx, ny), (sx, sy)):
            if self.location not in spawn:
                return ['guard']
        if len(adjacent_enemy) >= 3:
            return ['suicide']
        if self.hp < 9 and adjacent_enemy:
            return ['suicide']
        if adjacent_enemy:
            return ['attack', min(adjacent_enemy, key=lambda x: rg.dist(x, self.location))]
        if safe:
            if self.location in north:
                return ['move', rg.toward(self.location, (nx, ny))]
            else:
                return ['move', rg.toward(self.location, (sx, sy))]
        return ['guard']
Exemple #16
0
    def act(self, game):
        if 'spawn' in rg.loc_types(self.location):
            return ['move', rg.toward(self.location, rg.CENTER_POINT)]

        my_friendly_neighbours = self.get_neighbours(game)
        if my_friendly_neighbours:
            return ['move', rg.toward(self.location, rg.CENTER_POINT)]

        bad_neighbours = self.get_neighbours(game,
                                             friendly=False,
                                             onlyspawn=False)
        # CAMP THE SPAWN! SHOOT NOW!
        shoot = 'attack'
        if bad_neighbours:
            if random.randint(0, 10) > 7:
                print('HAHAHA! DIE DIE DIE!')
            return [shoot, bad_neighbours[0]['location']]

        friends = [
            bot for bot in game.robots.values()
            if bot['player_id'] == self.player_id
        ]

        def check_friend(current_close_friend, new_friend):
            if not current_close_friend:
                return new_friend
            if rg.wdist(self.location, new_friend.location) < rg.wdist(
                    self.location, current_close_friend.location):
                return new_friend
            return current_close_friend

        closest_friend = reduce(check_friend, friends, None)

        return ['guard']
Exemple #17
0
    def act(self, game):

        def czy_wejscie(poz):
            if 'spawn' in rg.loc_types(poz):
                return True
            return False

        def czy_wrog(poz):
            if game.robots.get(poz) != None:
                if game.robots[poz].player_id != self.player_id:
                    return True
            return False
        
        # lista wrogów obok
        wrogowie_obok = []
        for poz in rg.locs_around(self.location):
            if czy_wrog(poz):
                wrogowie_obok.append(poz)

        # jeżeli jesteś w punkcie wejścia, opuść go
        if czy_wejscie(self.location):
            return ['move', rg.toward(self.location, rg.CENTER_POINT)]

        # jeżeli obok są przeciwnicy, atakuj
        if len(wrogowie_obok):
            return ['attack', wrogowie_obok.pop()]

        # jeżeli jesteś w środku, broń się
        if self.location == rg.CENTER_POINT:
            return ['guard']

        # idź do środka planszy
        return ['move', rg.toward(self.location, rg.CENTER_POINT)]
	def act(self, game):
		x,y = self.location
		bot = None
		active_team = {}
		active_enemy = {}
		enemy_distance  = {}
		for loc, bot in game.get('robots').items():
			if bot.get('player_id') != self.player_id:
				active_enemy[loc] = bot
				enemy_distance[loc] = 0
			else:
				active_team[loc] = bot
		for loc in active_enemy:
			for myloc in active_team:
				enemy_distance[loc] = enemy_distance[loc] + rg.dist(loc, myloc)
		prio_loc, attack_loc = self.findPriority(active_team, active_enemy,enemy_distance)
		distance_to_prio = rg.dist(self.location,prio_loc)
		distance_to_attack = BIG_DIST
		if attack_loc:
			distance_to_attack = rg.dist(self.location,attack_loc)
			if distance_to_attack<=1:
				return ['attack', attack_loc]
			else:
				return ['move', rg.toward(self.location, prio_loc)]
		else:
			if prio_loc == self.location:
				if self.hp < SELF_CRITICAL:
					return ['suicide']
				return ['guard']
			return ['move',rg.toward(self.location,prio_loc)]
		return ['guard']
Exemple #19
0
    def act(self, game):
        self.game = game
        max_angry = 10
        angry = 8
        is_angry = random.choice([True]*angry+[False]*(max_angry-angry))


        local_enemies = self.local_enemies(game)
        empty_spaces = [e for e in self.local_spaces()
                        if e not in local_enemies.keys()]

        if local_enemies:
            if self.hp < 10 and len(local_enemies) > 1:
                return ['suicide']

            if is_angry:
                return ['attack', random.choice(local_enemies.keys())]
            if empty_spaces:
                return ['move', random.choice(empty_spaces)]
            return['guard']

        enemies = self.enemies(game)

        for enemy in enemies:
            displacement = (self.location, enemy.location)
            if rg.wdist(*displacement) == 2:
                attack_loc = rg.toward(*displacement)
                if is_angry:
                    return ['move', attack_loc]
                if self.in_square(attack_loc) != 'friend':
                    return ['attack', attack_loc]

        return ['move', rg.toward(self.location,
                                  random.choice(self.enemies(game)).location)]
Exemple #20
0
    def act(self, game):
        
        # wszystkie pola
        wszystkie = {(x, y) for x in xrange(19) for y in xrange(19)}
        # punkty wejścia
        wejscia = {poz for poz in wszystkie if 'spawn' in rg.loc_types(poz)}
        # pola zablokowane
        zablokowane = {poz for poz in wszystkie if 'obstacle' in rg.loc_types(poz)}
        # pola zajęte przez nasze roboty
        przyjaciele = {poz for poz in game.robots if game.robots[poz].player_id == self.player_id}
        # pola zajęte przez wrogów
        wrogowie = set(game.robots) - przyjaciele
        # pola sąsiednie
        sasiednie = set(rg.locs_around(self.location)) - zablokowane
        # pola sąsiednie zajęte przez wrogów
        wrogowie_obok = sasiednie & wrogowie

        # działanie domyślne:
        ruch = ['move', rg.toward(self.location, rg.CENTER_POINT)]

        # jeżeli jesteś w punkcie wejścia, opuść go
        if self.location in wejscia:
            ruch = ['move', rg.toward(self.location, rg.CENTER_POINT)]

        # jeżeli jesteś w środku, broń się
        if self.location == rg.CENTER_POINT:
            ruch = ['guard']

        # jeżeli obok są przeciwnicy, atakuj
        if wrogowie_obok:
            ruch = ['attack', wrogowie_obok.pop()]

        return ruch
Exemple #21
0
  def act(self, game):
    blob_locs = set(self.location)
   
    #if one nearby enemy, attack
    #if surrounded by enemies, suicide
    #in between, run towards center.
    adj_enemies = []
    for l in set(rg.locs_around(self.location, ['spawn', 'invalid'])).difference(blob_locs):
      if l in game.get('robots').keys():
        if game['robots'][l].get('player_id') != self.player_id:
          adj_enemies.append(game['robots'][l])
    if len(adj_enemies) >= 4:
      return ['suicide']
    elif len(adj_enemies) > 1:
      #if in center, stand and fight lowest hp enemy 
      if self.location == rg.CENTER_POINT:
        target = min(adj_enemies, key=lambda k: k['hp']) 
        return['attack', target['location']]
      else:
        return ['move', rg.toward(self.location, rg.CENTER_POINT)]
    elif len(adj_enemies) == 1:
      return ['attack', adj_enemies[0]['location']]

    #hold the center
    if self.location == rg.CENTER_POINT:
      return ['guard']
    elif self.in_blob(self.location, blob_locs, game) and rg.CENTER_POINT in blob_locs:
      return ['guard']

    #don't hang around spawn points
    if 'spawn' in rg.loc_types(self.location):
      return ['move', rg.toward(self.location, rg.CENTER_POINT)]

    #if nothing better to do, move toward center.
    return ['move', rg.toward(self.location, rg.CENTER_POINT)]
Exemple #22
0
    def act(self, game):

        # wszystkie pola
        wszystkie = {(x, y) for x in xrange(19) for y in xrange(19)}
        # punkty wejścia
        wejscia = {poz for poz in wszystkie if 'spawn' in rg.loc_types(poz)}
        # pola zablokowane
        zablokowane = {
            poz
            for poz in wszystkie if 'obstacle' in rg.loc_types(poz)
        }
        # pola zajęte przez nasze roboty
        przyjaciele = {
            poz
            for poz in game.robots
            if game.robots[poz].player_id == self.player_id
        }
        # pola zajęte przez wrogów
        wrogowie = set(game.robots) - przyjaciele
        # pola sąsiednie
        sasiednie = set(rg.locs_around(self.location)) - zablokowane
        # pola sąsiednie zajęte przez wrogów
        wrogowie_obok = sasiednie & wrogowie
        wrogowie_obok2 = {
            poz
            for poz in sasiednie if (set(rg.locs_around(poz)) & wrogowie)
        } - przyjaciele
        # pola bezpieczne
        bezpieczne = sasiednie - wrogowie_obok - wejscia - przyjaciele

        # funkcja znajdująca najsłabszego wroga obok z podanego zbioru (bots)
        def minhp(bots):
            return min(bots, key=lambda x: game.robots[x].hp)

        # działanie domyślne:
        ruch = ['move', rg.toward(self.location, rg.CENTER_POINT)]

        # jeżeli jesteś w punkcie wejścia, opuść go
        if self.location in wejscia:
            ruch = ['move', rg.toward(self.location, rg.CENTER_POINT)]

        # jeżeli jesteś w środku, broń się
        if self.location == rg.CENTER_POINT:
            ruch = ['guard']

        # jeżeli obok są przeciwnicy, atakuj, o ile to bezpieczne,
        # najsłabszego wroga
        if wrogowie_obok:
            if 9 * len(wrogowie_obok) >= self.hp:
                if bezpieczne:
                    ruch = ['move', bezpieczne.pop()]
            else:
                ruch = ['attack', minhp(wrogowie_obok)]

        if wrogowie_obok2:
            ruch = ['attack', wrogowie_obok2.pop()]

        return ruch
Exemple #23
0
    def act(self, game):
        if "spawn" in rg.loc_types(self.location):
            s = sanitize(['move', rg.toward(self.location, rg.CENTER_POINT)])
            return s

        adjacent_enemies = []
        for loc, bot in game.get('robots').items():
            if bot.get('player_id') != self.player_id:
                if rg.dist(loc, self.location) <= 1:
                    allies = 0
                    #Find out how many allies are around this enemy
                    for nloc, nbot in game.get('robots').items():
                        if bot.get("player_id") == self.player_id and rg.dist(loc, nloc) <=1:
                            allies = allies + 1
                    adjacent_enemies.append([loc, bot, allies])
            else:
                if "spawn" in rg.loc_types(bot.get("location")): #The friendly wants to get out of spawn, make way for it
                    r = Robot.move(self, game)
                    if r and rg.toward(bot.get("location"), rg.CENTER_POINT) == r[1]:
                            return sanitize(['move', rg.toward(self.location, rg.CENTER_POINT)])
        if adjacent_enemies and self.hp >= CRITICAL_HP:
            if len(adjacent_enemies) * ATTACK_DAMAGE > self.hp: # They can kill me! lets flee!
                return sanitize(self.flee(game))
            adjacent_enemies.sort(key= lambda x: (x[2], x[1].get("hp")))
            return sanitize(['attack', adjacent_enemies[0][0]])
        elif adjacent_enemies and self.hp < CRITICAL_HP:
            return sanitize(self.flee(game))
        else:
            r = Robot.move(self, game)

            if not r:
                return ["guard"]
            
            #Check if allied damaged bots will move to our destination, and if so, let them
            move = True
            for loc, bot in game.get('robots').items():
                if bot.get("player_id") == self.player_id and not bot.location == self.location:
                    if rg.dist(loc, r[1]) <= 1:
                        if Robot.get_destination(bot, game) == r[1]: #our destination matches, let them come
                            if bot.get("hp") < CRITICAL_HP:
                                return ["guard"]
                            else: # Figure out who should be given highest movement priority (based on which one is furthest from middle, or who has lowest hp in tiebreaker)
                                prio = rg.dist(self.location, rg.CENTER_POINT)
                                prio_o = rg.dist(bot.location, rg.CENTER_POINT)

                                if prio == prio_o: #Tie
                                    if self.hp >= bot.hp:
                                        move = True
                                    else:
                                        move = False
                                elif prio > prio_o:
                                    move = True
                                else:
                                    move = False
            if not move:
                return ["guard"]
            else:
                return sanitize(r) or ["guard"]
    def act(self, game):
        # Update the class variables if this is a new turn. 
        if game.turn != self.currentTurn:
            # If this is the very first turn, print out some info.
            if game.turn == 1:
                print "The rally point is: {0}".format(self.rallyPoint);

            self.updateVariables(game);
            self.currentTurn = game.turn;
            print "New Turn! " + str(self.currentTurn) + " Friends: " + str(self.numberOfFriends) + " Foes: " + str(self.numberOfFoes);

        # First order of business, if this bot is on a spawn point, we need to get him out of there. 
        if 'spawn' in rg.loc_types(self.location):
            # Try to move toward the rally point.
            moveToPoint = rg.toward(self.location, self.rallyPoint);
            if 'normal' in rg.loc_types(moveToPoint):
                return ['move', moveToPoint];
            else:
                # Can't move towards the rally point. See where we can move. 
                adjacentLocations = rg.locs_around(self.location);
                for loc in adjacentLocations:
                    if 'normal' in rg.loc_types(loc):
                        return ['move', loc];

                # If we got here, we can't move off the spawn point. Let's try to do some damage if we have a nearby enemy. 
                for loc in adjacentLocations:
                    if loc in game.robots:
                        if game.robots[loc].player_id != self.player_id:
                            return self.attackOrSuicide(loc, game.robots[loc]);

                # If we are here, nothing else we can do, but guard. We must be blocked by our guys. Hopefully they will get out of the way.
                return ['guard'];


        # Now some strategy. 
        if self.numberOfFoes > self.numberOfFriends:
            # We have less bots than the enemy. Let's play it safe until the numbers are back in our favor.
            
            # Head to the rally point if possible. Fight if someone gets in the way, but be passive otherwise. 
            if (self.location == self.rallyPoint):
                return ['guard'];

            moveToPoint = rg.toward(self.location, self.rallyPoint);
            if 'normal' in rg.loc_types(moveToPoint):
                return ['move', moveToPoint];
            else:
                # We can't move. Attack if we can.
                for loc in adjacentLocations:
                    if loc in game.robots:
                        if game.robots[loc].player_id != self.player_id:
                            return self.attackOrSuicide(loc, game.robots[loc]);

            # Guard if we can't move.                     
            return ['guard'];
        
        else:
            # We have the numbers advantage. Start hunting. 
            return ['guard'];
Exemple #25
0
    def act_kiter(self, game):
        if 'foe' in map(self.in_square, self.local_spaces()):
            return self.evade()
        for square in self.local_spaces():
            if self.square_is_threatened(square):
                return ['attack', rg.toward(self.location, square)]

        return ['move', rg.toward(self.location,
                                  random.choice(self.enemies(game)).location)]
Exemple #26
0
 def plan_move(self, game, new_loc):
     if new_loc == self.location and self.location == rg.CENTER_POINT:
         return ['guard']
     if new_loc == self.location:
         return ['move', rg.toward(self.location, rg.CENTER_POINT)]
     around_me = rg.loc_types(new_loc)
     if around_me == ['normal']:
         return ['move', rg.toward(self.location, new_loc)]
     else:
         return None
Exemple #27
0
 def act(self, game):
     available = rg.locs_around(self.location, filter_out = ('invalid', 'obstacle'))
     for loc, bot in game.robots.iteritems():
         if bot.player_id != self.player:
             if rg.dist(loc, self.location) == 1:
                 return ['attack', loc]
             elif rg.dist(loc, self.location) <= 3:
                 return ['move', rg.toward(self.location, loc)]
             else:
                 return ['move', rg.toward(self.location, rg.CENTER_POINT)]
Exemple #28
0
    def act(self, game):

        adjEnemyCount = 0 # adjacent enemy robots
        # if we're in the center, stay put
        if self.location == rg.CENTER_POINT:
            print 'guard!'
            return ['guard']

        # if in a spawn near spawn time, move towards centre
        if game.turn % 10 >= 8 and "spawn" in rg.loc_types(self.location):
            print 'Running away from spawn'
            return ['move', rg.toward(self.location, rg.CENTER_POINT)]


        # if there are enemies around, attack them
        for loc, bot in game.robots.iteritems():
            '''
            if bot.player_id == self.player_id:
                for dest in rg.locs_around(self.location, filter_out=('invalid', 'obstacle', 'spawn')):  
                    print 'diocane' 
                    return ['move', dest]
            '''
            assist_action = should_assist(self, game)
    	    if (assist_action is not None): 
    	        return assist_action
    	    '''  
    	    if not self.is_being_attacked_by_stronger(game):
    	        attack_scores = [(self.attack_score(game, friendly_locs, loc), loc) for loc in adjs]
    	        maxscore, maxloc = max(attack_scores)
    	        if maxscore > 0:
                    print 'attack weaker!'
                    return ["attack", maxloc]    
            else:
                move_scores = [(self.move_score(game, loc), loc) for loc in adjs]
                maxscore, maxloc = max(move_scores)
                guard_score = self.move_score(game, self.location)
                if maxscore > guard_score:
                    return ["move", maxloc]        
            '''       
            if bot.player_id != self.player_id:
                if rg.wdist(loc, self.location) == 1:
                    adjEnemyCount += 1
                if adjEnemyCount >= 3:
                    if self.hp <= adjEnemyCount * 9:
                        print 'suicide!'
                        return ['suicide']                    
                if rg.dist(loc, self.location) <= 1:
                    return ['attack', loc]


        # move toward the center
        return ['move', rg.toward(self.location, rg.CENTER_POINT)]
        
        
        
Exemple #29
0
    def test_toward(self):
        me = (10,10)
        dest = (0,0)
        toward = rg.toward(me, dest)
        assert toward in [(9,10), (10,9)]

        dest = (10,12)
        toward = rg.toward(me, dest)
        assert toward == (10,11)
        
        dest = (10,10)
        toward = rg.toward(me, dest)
        assert toward == (10,10)
Exemple #30
0
    def act(self, game):

        # Valid actions
        valid = []
        for loc in rg.locs_around(self.location, filter_out=('invalid', 'obstacle', 'spawn')):
            valid = valid + [['move', loc]]

        # move toward the center
        if ['move', rg.toward(self.location, rg.CENTER_POINT)] in valid:
            return ['move', rg.toward(self.location, rg.CENTER_POINT)]

        # Guard
        return ['guard']
Exemple #31
0
    def act(self, game):
        l = list(rg.locs_around(self.location, filter_out=('invalid', 'obstacle')))
        for loc, bot in game.robots.iteritems():
            if bot.player_id != self.player_id:

                if rg.dist(loc, self.location) <= 1:
                    if game.robots[loc].hp <= 10:
                        return ['move', l[0]]
        if self.hp <=11:
            for loc, bot in game.robots.iteritems():
                if bot.player_id != self.player_id:
                    if rg.dist(loc, self.location) <= 1:
                        return ['suicide']
        # if there are enemies around, attack them
        count = 0
        for loc, bot in game.robots.iteritems():
            if bot.player_id != self.player_id:
                if rg.dist(loc, self.location) <= 1:
                     count+=1
        if count >=3 and self.hp <=31:
            return ['suicide']
        if count >=2 and self.hp <=21:
            return ['suicide']

        locs = []
        count = 0
        for loc, bot in game.robots.iteritems():
            if bot.player_id != self.player_id:
                locs.append(loc)
        for loc, bot in game.robots.iteritems():
            if bot.player_id != self.player_id:
                if rg.dist(loc, self.location) <= 2:
                    if self.flag:
                        if rg.dist(loc, self.location) <= 1:
                            return ['attack', rg.toward(self.location, loc)]
                        self.flag = False
                        return['move', rg.toward(self.location, rg.CENTER_POINT)]
                    self.flag = True
                    return ['attack', rg.toward(self.location, loc)]

        for loc, bot in game.robots.iteritems():
            if bot.player_id == self.player_id:
                if rg.dist(loc, self.location) <= 3:
                     count+=1
        if count >=4:
            return ['move', rg.toward(self.location, rg.CENTER_POINT)]

        closest = min(locs)

        return ['move', rg.toward(self.location, closest)]
Exemple #32
0
    def act(self, game):

        if self.location == rg.CENTER_POINT:
            return ['guard']

        if rg.loc_types(self.location) == 'spawn':
            return ['move', rg.toward(self.location, rg.CENTER_POINT)]

        for loc, bot in game.robots.iteritems():
            if bot.player_id != self.player_id:
                if rg.dist(loc, self.location) <=2:
                    return ['attack', loc]

        return ['move', rg.toward(self.location, rg.CENTER_POINT)]
Exemple #33
0
    def act(self, game):

        # wszystkie pola
        wszystkie = {(x, y) for x in xrange(19) for y in xrange(19)}
        # punkty wejścia
        wejscia = {poz for poz in wszystkie if 'spawn' in rg.loc_types(poz)}
        # pola zablokowane
        zablokowane = {
            poz
            for poz in wszystkie if 'obstacle' in rg.loc_types(poz)
        }
        przyjaciele = {
            poz
            for poz in game.robots
            if game.robots[poz].player_id == self.player_id
        }
        # pola zajęte przez wrogów
        wrogowie = set(game.robots) - przyjaciele
        # pola sąsiednie
        sasiednie = set(rg.locs_around(self.location)) - zablokowane
        # pola sąsiednie zajęte przez wrogów
        wrogowie_obok = sasiednie & wrogowie
        wrogowie_obok2 = {
            poz
            for poz in sasiednie if (set(rg.locs_around(poz)) & wrogowie)
        } - przyjaciele
        # pola bezpieczne
        bezpieczne = sasiednie - wrogowie_obok - wejscia - przyjaciele

        # działania domyslne:
        ruch = ['move', rg.toward(self.location, rg.CENTER_POINT)]
        # jeżeli jeteś wpkt wejścia opuść go
        if self.location in wejscia:
            ruch = ['move', rg.toward(self.location, rg.CENTER_POINT)]
        # jeżeli jesteś w środku broń się
        if self.location == rg.CENTER_POINT:
            ruch = ['guard']

        # jeżeli obok są przeciwnicy, atakuj o ile to bezpieczne
        if wrogowie_obok:
            if 9 * len(wrogowie_obok) >= self.hp:
                if bezpieczne:
                    ruch['move', bezpieczne.pop()]
            else:
                ruch = ['attack', wrogowie_obok.pop()]

        if wrogowie_obok2:
            ruch = ['attack', wrogowie_obok2.pop()]

        return ruch
Exemple #34
0
def should_attack(robot, game):
	# if there's an enemy within attacking range, attack
	neighboring_enemies = get_neighboring_enemies(robot, game)
	if len(neighboring_enemies) > 0:
		return random.choice(neighboring_enemies)

	# if there's an an enemy who can move into attacking range, attack preemptively in case he moves close
	if ATTACK_PREEMPTIVELY is not False:
		for loc, other in game['robots'].items():
			if rg.wdist(loc, robot.location) == 2:
				if other.player_id != robot.player_id:
					if random.random() < ATTACK_PREEMPTIVELY:
						print "Preemptive attack!", robot.location, loc, rg.toward(robot.location, loc)
						return rg.toward(robot.location, loc)
	return None
Exemple #35
0
    def act(self, game):

        # wszystkie pola
        wszystkie = {(x, y) for x in xrange(19) for y in xrange(19)}
        # punkty wejścia
        wejscia = {poz for poz in wszystkie if 'spawn' in rg.loc_types(poz)}
        # pola zablokowane
        zablokowane = {poz for poz in wszystkie if 'obstacle' in rg.loc_types(poz)}
        # pola zajęte przez nasze roboty
        przyjaciele = {poz for poz in game.robots if game.robots[poz].player_id == self.player_id}
        # pola zajęte przez wrogów
        wrogowie = set(game.robots) - przyjaciele
        # pola sąsiednie
        sasiednie = set(rg.locs_around(self.location)) - zablokowane
        # pola sąsiednie zajęte przez wrogów
        wrogowie_obok = sasiednie & wrogowie
        wrogowie_obok2 = {poz for poz in sasiednie if (set(rg.locs_around(poz)) & wrogowie)} - przyjaciele
        # pola bezpieczne
        bezpieczne = sasiednie - wrogowie_obok - wejscia - przyjaciele

        # funkcja znajdująca najsłabszego wroga obok z podanego zbioru (bots)
        def minhp(bots):
            return min(bots, key=lambda x: game.robots[x].hp)

        # działanie domyślne:
        ruch = ['move', rg.toward(self.location, rg.CENTER_POINT)]

        # jeżeli jesteś w punkcie wejścia, opuść go
        if self.location in wejscia:
            ruch = ['move', rg.toward(self.location, rg.CENTER_POINT)]

        # jeżeli jesteś w środku, broń się
        if self.location == rg.CENTER_POINT:
            ruch = ['guard']

        # jeżeli obok są przeciwnicy, atakuj, o ile to bezpieczne,
        # najsłabszego wroga
        if wrogowie_obok:
            if 9*len(wrogowie_obok) >= self.hp:
                if bezpieczne:
                    ruch = ['move', bezpieczne.pop()]
            else:
                ruch = ['attack', minhp(wrogowie_obok)]

        if wrogowie_obok2:
            ruch = ['attack', wrogowie_obok2.pop()]

        return ruch
Exemple #36
0
    def act(self, game):
        # if we're in the center, stay put
        if self.location == rg.CENTER_POINT:
            return ['guard']

        num_enemies_near = sum([ pt in self.enemy_bot_locations(game) for pt in rg.locs_around(self.location)])
        if num_enemies_near > 1 and self.hp < 20:
            return ['suicide']

        # if there are enemies around, attack them
        for loc, bot in game.robots.items():
            if bot.player_id != self.player_id:
                if rg.dist(loc, self.location) <= 1:
                    return ['attack', loc]

        # move toward the center
        dist_to_center = rg.wdist(self.location, rg.CENTER_POINT)
        if dist_to_center > 5:
            next_location = rg.toward(self.location, rg.CENTER_POINT)
        else:
            next_location = self.random_location()
        
        if next_location in game.robots:
            return ['guard']

        return ['move', next_location]
Exemple #37
0
    def act(self, game):

        # check if being attacked
        if self.last_turns_hp < self.hp:
            self.bait = True
        last_turns_hp = self.hp

        # guard if attacked
        if self.bait:
            return ['guard']

        closest_bot_loc = None
        closest_bot_distance = 50000
        for loc, bot in game.robots.iteritems():
            if bot.player_id != self.player_id:
                if rg.dist(loc, self.location) <= 1:
                    if self.hp < 11:
                        return ['suicide']
                    else:
                        return ['attack', loc]
                if rg.dist(loc, self.location) < closest_bot_distance:
                    closest_bot_distance = rg.dist(loc, self.location)
                    closest_bot_loc = loc

        # move towards an enemy
        if closest_bot_loc:
            move_loc = rg.toward(self.location, closest_bot_loc)
            if move_loc not in game['robots']:
                return ['move', move_loc]
        return ['guard']
Exemple #38
0
    def act(self, game):
        center = rg.CENTER_POINT
        enemy_bots = [
            b for b in game.robots.values() if b.player_id != self.player_id
        ]
        target = min(enemy_bots,
                     key=lambda bot: rg.wdist(bot.location, center))

        adjacent_bots = []
        for enemy in enemy_bots:
            if rg.wdist(enemy.location, self.location) == 1:
                adjacent_bots.append(enemy)
        if len(adjacent_bots) > self.hp / 9:
            return ['suicide']
        elif adjacent_bots:
            return ['attack', min(adjacent_bots, key=lambda b: b.hp).location]

        adj = rg.locs_around(target.location,
                             filter_out=('invalid', 'obstacle'))
        closest_locs = min(rg.wdist(loc, self.location) for loc in adj)
        dests = [
            loc for loc in adj if rg.wdist(loc, self.location) == closest_locs
        ]
        dest = random.choice(dests)
        if rg.wdist(target.location, self.location) == 1:
            return ['attack', target.location]
        else:
            return ['move', rg.toward(self.location, dest)]
Exemple #39
0
 def act(self, game):
     us, them = process_game(game, self.player_id)
     x = int(sum([x[0] for x in us]) / len(us))
     y = int(sum([y[1] for y in us]) / len(us))
     if self.location == (x, y):
         return ['guard']
     enemies_around = list()
     friends_around = list()
     for each in them:
         if rg.dist(self.location, each) == 1:
             enemies_around.append(each)
     for each in us:
         if rg.dist(self.location, each) == 1:
             friends_around.append(each)
     if len(friends_around) >= 3:
         return ['guard']
     distance_border = min([
         rg.wdist(place, self.location)
         for place in rg.settings.spawn_coords
     ])
     if len(friends_around) >= 2 and distance_border > 3:
         return ['guard']
     if len(enemies_around) >= 2:
         return ['suicide']
     if self.hp < 8 and enemies_around:
         return ['suicide']
     for each in them:
         if rg.dist(self.location, each) == 1:
             if test_location(each):
                 return ['attack', each]
     if test_location((x, y)):
         return ['move', rg.toward(self.location, (x, y))]
     return ['guard']
Exemple #40
0
    def act(self, game):

        # if we're on one of the corners, guard
        if self.location in self.corners:
            return ['guard']

        # if there are enemies around, attack them
        for loc, bot in game.robots.iteritems():
            if bot.player_id != self.player_id:
                if rg.dist(loc, self.location) <= 1:
                    return ['attack', loc]
                #elif rg.dist(loc, self.location) <= 2:
                #    new_loc = rg.toward(self.location,
                #                        loc)
                #    return ['move', new_loc]

        distances = {}
        for corner in self.corners:
            distances[corner] = rg.dist(self.location, corner)

        new_loc = rg.toward(self.location, min(distances, key=distances.get))

        if 'obstacle' in rg.loc_types(new_loc):
            return ['guard']
        else:
            return ['move', new_loc]
Exemple #41
0
    def next_move(self, destination, game):
        print "next_move!"
        def is_valid_and_safe(step):
            for unsafe_type in  ['invalid', 'spawn', 'obstacle']:
                if unsafe_type in rg.loc_types(step):
                    print "unsafe_type:", unsafe_type
                    return False
            return True
        def is_friendly(step, game):
            for loc, robot in self.friendly_list(game):
                if loc == step:
                    print "is_friendly:", True
                    return True
            return False


        test_step = rg.toward(self.location, destination)
        if is_valid_and_safe(test_step) and not is_friendly(test_step,game):
            return test_step
        print "not OK from: %s to test_step: %s"%(self.location, test_step)
        #move clockwize
        move_mask = (test_step[1]-self.location[1], test_step[0]-self.location[0])
        next_step = (self.location[0]+move_mask[0], self.location[1]+move_mask[1])
        print "mask: %s, next_step: %s"%(move_mask, next_step)
        return next_step
Exemple #42
0
    def act(self, game):
        # Find nearest enemy
        enemies = {}
        nearest_enemy = (1000000, rg.CENTER_POINT)
        for loc, bot in game.robots.iteritems():
            if bot.player_id != self.player_id:
                enemies[loc] = bot
                distance = rg.dist(loc, self.location)
                if distance < nearest_enemy[0]:
                    nearest_enemy = (distance, loc)

        # If nearest enemy is next to us, ATTACK or KABOOM!
        if nearest_enemy[0] <= 1:
            potential_suicide_damage = 0
            for loc in rg.locs_around(self.location):
                if loc in enemies:
                    potential_suicide_damage += min(15, enemies[loc].hp)
            if self.hp < potential_suicide_damage:
                return ['suicide']
            else:
                return ['attack', nearest_enemy[1]]

        # If we cannot move, defend.
        desired_move = rg.toward(self.location, nearest_enemy[1])
        if rg.loc_types(desired_move) in ['obstacle', 'invalid']:
            return ['guard']

        # Otherwise, advance on the enemy without mercy
        return ['move', desired_move]
Exemple #43
0
    def act(self, game):
        num_enemies = self.num_enemies(game)
        if num_enemies * 9 > self.hp:
            return ['suicide']

        min_distance = float("inf")
        move_to = rg.CENTER_POINT
        for location, bot in game.get('robots').items():
            if bot.get('player_id') != self.player_id:
                if rg.dist(location, self.location) <= 1:
                    return ['attack', location]
            if bot.get('player_id') == self.player_id:
                if rg.wdist(location, self.location) < min_distance:
                    min_distance = rg.wdist(location, self.location)
                    move_to = location
        if min_distance < 2:
            move_to = rg.CENTER_POINT
            
        if self.location == rg.CENTER_POINT:
            return ['guard']
        
        if self.num_frieds(game) > 1:
            return ['guard']
        
        return ['move', rg.toward(self.location, move_to)]
Exemple #44
0
    def act(self, game):
        # Move out of spawning zone
        if 'spawn' in rg.loc_types(self.location):
            loc = self.get_open_adjacent(game)
            if loc:
                return ['move', loc]
            else:
                # All adjacent are occupied, or still in the spawning zone.
                loc = self.get_open_adjacent(game, spawnok=True)
                if loc:
                    return ['move', loc]

        # Find an enemy
        loc, d = self.get_closest_enemy(game)
        if d < 0:
            # The are no enemies
            return ['guard']
        elif d <= 1:
            # Enemy within range
            if self.is_worth_dying(game):
                return ['suicide']
            return ['attack', loc]
        else:
            # Enemy out of range
            closer = rg.toward(self.location, loc)
            if can_move(closer, game):
                return ['move', closer]
            loc = self.get_open_adjacent(game)
            if loc:
                return ['move', loc]
            return ['guard']
Exemple #45
0
    def act(self, game):
        num_enemies = self.num_enemies(game)
        if num_enemies * 9 > self.hp:
            return ['suicide']

        min_distance = float("inf")
        move_to = self.get_center(game)
        for location, bot in game.get('robots').items():
            if bot.get('player_id') != self.player_id:
                if rg.dist(location, self.location) <= 1:
                    return ['attack', location]
            if bot.get('player_id') == self.player_id:
                if rg.wdist(location, self.location) < min_distance:
                    min_distance = rg.wdist(location, self.location)
                    move_to = location
        if min_distance < 2:
            move_to = self.get_center(game)
        
        if self.location == self.get_center(game):
            return ['guard']
        
        if self.num_frieds(game) > 1:
            return ['guard']
        
        return ['move', rg.toward(self.location, move_to)]
Exemple #46
0
 def otherwise(self, game, current_return):
     if current_return != ['empty']:
         return current_return
     if self.location != rg.CENTER_POINT:
         towards_center = rg.toward(self.location, rg.CENTER_POINT)
         return ['move', towards_center]
     else:
         return ['guard']
Exemple #47
0
 def strong_enemy(self, game):
     hp = 0
     for loc, bot in game.get('robots').items():
         if bot.player_id != self.player_id:
             if bot.hp > hp:
                 hp = bot.hp
                 l = loc
     return self.plan_move(game, rg.toward(self.location, l))
Exemple #48
0
    def act(self, game):

        # wszystkie pola
        wszystkie = {(x, y) for x in xrange(19) for y in xrange(19)}

        # punkty wejścia (spawn)
        wejscia = {loc for loc in wszystkie if 'spawn' in rg.loc_types(loc)}

        # pola zablokowane (obstacle)
        zablokowane = {
            loc
            for loc in wszystkie if 'obstacle' in rg.loc_types(loc)
        }

        # pola zajęte przez nasze roboty
        druzyna = {
            loc
            for loc in game.robots
            if game.robots[loc].player_id == self.player_id
        }

        # pola zajęte przez wrogów
        wrogowie = set(game.robots) - druzyna

        #        for loc, bot in game.robots.iteritems():
        #            if bot.player_id != self.player_id:
        #                if rg.dist(loc, self.location) <= 1:
        #                    return ['attack', loc]

        wejscia = {loc for loc in wszystkie if 'spawn' in rg.loc_types(loc)}
        sasiednie = set(rg.locs_around(self.location)) - zablokowane
        sasiednie_wrogowie = sasiednie & wrogowie

        if sasiednie_wrogowie:
            if 9 * len(sasiednie_wrogowie) < self.hp:
                return ['attack', sasiednie_wrogowie.pop()]

        if self.location in wejscia:
            move = ['move', rg.toward(self.location, rg.CENTER_POINT)]

        if self.location == rg.CENTER_POINT:
            return ['guard']

        return ['move', rg.toward(self.location, rg.CENTER_POINT)]
Exemple #49
0
    def act(self, game):
        if 'spawn' in rg.loc_types(self.location):
            return ['move', rg.toward(self.location, rg.CENTER_POINT)]

        my_friendly_neighbours = self.get_neighbours(game)
        if my_friendly_neighbours:
            return ['move', rg.toward(self.location, rg.CENTER_POINT)]

        bad_neighbours = self.get_neighbours(game,
                                             friendly=False,
                                             onlyspawn=False)
        # CAMP THE SPAWN! SHOOT NOW!
        shoot = 'attack'
        if bad_neighbours:
            if random.randint(0, 10) > 7:
                print('HAHAHA! DIE DIE DIE!')
            return [shoot, bad_neighbours[0]['location']]

        return ['guard']
Exemple #50
0
    def act(self, game):

        # wszystkie pola
        wszystkie = {(x, y) for x in xrange(19) for y in xrange(19)}
        # punkty wejścia
        wejscia = {poz for poz in wszystkie if 'spawn' in rg.loc_types(poz)}
        # pola zablokowane
        zablokowane = {poz for poz in wszystkie if 'obstacle' in rg.loc_types(poz)}
        # pola zajęte przez nasze roboty
        przyjaciele = {poz for poz in game.robots if game.robots[poz].player_id == self.player_id}
        # pola zajęte przez wrogów
        wrogowie = set(game.robots) - przyjaciele
        # pola sąsiednie
        sasiednie = set(rg.locs_around(self.location)) - zablokowane
        # pola sąsiednie zajęte przez wrogów
        wrogowie_obok = sasiednie & wrogowie


        for wrog in wrogowie:
            if rg.wdist(poz, self.location) == 2:
                # ruch = działanie xD



        # działanie domyślne:
        ruch = ['move', rg.toward(self.location, rg.CENTER_POINT)]

        # jeżeli jesteś w punkcie wejścia, opuść go
        if self.location in wejscia:
            ruch = ['move', rg.toward(self.location, rg.CENTER_POINT)]

        # jeżeli jesteś w środku, broń się
        if self.location == rg.CENTER_POINT:
            ruch = ['guard']

        # jeżeli obok są przeciwnicy, atakuj
        if len(wrogowie_obok) > 2 and self.hp < 27:
            ruch = ['suicide']
        else wrogowie_obok:
            ruch = ['attack', wrogowie_obok.pop()]

        return ruch
Exemple #51
0
    def act(self, game):
        # list of distances to the enemy bots and their locations
        enemy_dist_and_locs = [(rg.dist(loc, self.location), loc)
                               for loc, bot in game.robots.iteritems()
                               if bot.player_id != self.player_id]

        # sort by distance.
        enemy_dist_and_locs.sort()
        neighbours = [(dist, loc) for dist, loc in enemy_dist_and_locs[:4]
                      if dist <= 1]

        # try to escape from spawn location
        # (this is buggy)
        if (game.turn + 1) % 10 and rg.loc_types(self.location) == "spawn":
            location = rg.toward(self.location, rg.CENTER_POINT)
            if location in game.robots:
                return ["suicide"]
            else:
                return ["move", location]

        # commit suicide if surrounded and likely to die soon
        if len(neighbours) >= 2 and self.hp < 1 + len(neighbours) * 10:
            return ["suicide"]

        # choose an enemy to destroy
        for dist, loc in enemy_dist_and_locs:
            # attack if close
            if dist == 1:
                self.new_locs[self.robot_id] = self.location
                return ["attack", loc]

            # move if no other robot is moving into the same position
            move_towards = rg.toward(self.location, loc)
            for key, value in self.new_locs.items():
                if value == move_towards and key != self.robot_id:
                    break
            else:
                self.new_locs[self.robot_id] = move_towards
                return ["move", move_towards]

        # if you can"t attack or move near an enemy, guard
        return ["guard"]
Exemple #52
0
    def act(self, game):
        dystans = rg.dist(self.location, rg.CENTER_POINT)

        #print dystans

        if dystans >= 7:
            return ['move', rg.toward(self.location, rg.CENTER_POINT)]

        # idź do środka planszy, ruch domyślny
        #return ['move', rg.toward(self.location, rg.CENTER_POINT)]
        return ['guard']
Exemple #53
0
    def flee_spawn(self):

        turn = self.game.turn % 10
        spawn_time = turn == 0 or turn == 9 or turn == 8

        # if in spawn point near spawn time, move towards centre
        if spawn_time and self.game.turn < 95 and self.is_spawn(self.location):
            return ['move', rg.toward(self.location, rg.CENTER_POINT)]

        else:
            return None
Exemple #54
0
    def act(self, game):
        wrogowie = self.znajdz_wrogow_obok(game)
        print(wrogowie)

        if len(wrogowie) == 1 and self.hp > 10:
            return ['attack', wrogowie[0]]

        if self.location != rg.CENTER_POINT:
            return ['move', rg.toward(self.location, rg.CENTER_POINT)]

        return ['guard']
Exemple #55
0
    def act(self, game):
        # if we're in the center, stay put
        if self.location == rg.CENTER_POINT:
            return ['guard']

        # if there are enemies around, attack them
        for loc, bot in game.robots.iteritems():
            if bot.player_id != self.player_id:
                if rg.dist(loc, self.location) <= 1:
                    return ['attack', loc]

        # move to un occupied spot
        locs = rg.locs_around(self.location, filter_out=('invalid', 'obstacle'))
        
        if rg.toward(self.location, rg.CENTER_POINT) in locs:
    		return ['move', rg.toward(self.location, rg.CENTER_POINT)]    
    	else:
    		if len(locs)>=1:
    			return ['move', locs(0)] 
    		else:
    			return ['guard']    
Exemple #56
0
    def act(self, game):
        wrogowie = []
        for poz in rg.locs_around(self.location,
                                  filter_out('invalid', 'obstacle')):
            if game.robots.get(poz) and \
               game.robots[poz].player_id != self.player_id:
                wrogowie.append(poz)

        if self.location != rg.CENTER_POINT:
            return ['move', rg.toward(self.location, rg.CENTER_POINT)]

        return ['guard']
Exemple #57
0
 def weak_enemy(self, game):
     hp = None
     l = None
     for loc, bot in game.get('robots').items():
         if bot.player_id != self.player_id:
             if None == hp:
                 hp = bot.hp
                 l = loc
             elif bot.hp < hp:
                 hp = bot.hp
                 l = loc
     return self.plan_move(game, rg.toward(self.location, l))
Exemple #58
0
    def act(self, game):
        # If we're on a spawn square, get out
        if rg.loc_types(self.loc) != 'normal':
            return ['move', rg.toward(self.location, rg.CENTER_POINT)]

        d1_us = {}
        d1_them = {}
        d2_us = {}
        d2_them = {}
        for loc, bot in game.robots.iteritems():
            if rg.wdist(self.loc, loc) == 1:
                if bot.robot_id:
                    d1_us[loc] = bot
                else:
                    d1_them[loc] = bot
            elif rg.wdist(self.loc, loc) == 2:
                if bot.robot_id:
                    d2_us[loc] = bot
                else:
                    d2_them[loc] = bot

        if d1_them:
            return ['attack', d1_them.keys()[0]]
        elif d2_them:
            return ['attack', rg.toward(self.loc, d2_them.keys()[0])]

        # move:
        # - don't move into a square an ally could move into
        # - move towards an ally
        # - move towards an enemy

        # suicide condition
        #allyNeighbours = 0 # work out
        #enemyNeightbours = 0
        #if self.hp < 10 and allyNeighbours == 0 and (enemyNeightbours > 1 or enemyNeightbours == 1 and their hp > 10)
        #  return ['suicide']

        # Default action
        #return ['guard']
        return ['move', rg.toward(self.location, rg.CENTER_POINT)]