def empty_score(this_robot, loc, game): score = 0 if (verbose > 1): print "here" if (this_robot.hp > 25): score -= abs( rg.dist(loc, rg.CENTER_POINT) - best_center_distance_param) * best_center_distance_weight else: score -= rg.dist(loc, rg.CENTER_POINT) * best_center_distance_weight if (verbose > 1): print "here2" for loc2 in rg.locs_around(loc, filter_out=('obstacle', 'invalid')): if (loc2 in game.robots): if (game.robots[loc2].player_id != this_robot.player_id): score -= adjacent_robot_penalty else: score -= adjacent_friendly_penalty #if we are trying to run away from spawn, non-spawn adjacent squares with no enemies by them are good, because we need to move if (spawn(loc) & game.turn < 91): for loc2 in rg.locs_around(loc, filter_out=('obstacle', 'invalid')): clear_square = 1 for loc3 in rg.locs_around(loc2, filter_out=('obstacle', 'invalid', 'spawn')): if (loc3 in game.robots and game.robots[loc3].player_id != this_robot.player_id): clear_square = 0 score += ((game.turn + 1) % 10) * spawn_weight * clear_square / 2 if (spawn(loc) & game.turn < 91): score -= ((game.turn + 1) % 10) * spawn_weight if (surrounded_spawn(loc) & game.turn < 91): score -= (game.turn % 10) * spawn_weight return score
def attack_moving_enemy(this_robot, game, illegals): if (this_robot.location in illegals): return 'no_action' square_dictionary = {} for square in rg.locs_around(this_robot.location): square_dictionary[square] = 0 if square in game.robots: square_dictionary[ square] -= 40 #don't fire if our robot is there, they probably won't move there for bot in two_robots: if bot.player_id != this_robot.player_id: loc = bot.location targetx = towardx(this_robot.location, loc) targety = towardy(this_robot.location, loc) if targetx != 'no_move': square_dictionary[targetx] += 70 - bot.hp - rg.dist( rg.CENTER_POINT, targetx) if targety != 'no_move': square_dictionary[targety] += 70 - bot.hp - rg.dist( rg.CENTER_POINT, targety) best_score = 0 best_move = 'no_action' for square in rg.locs_around(this_robot.location): if square_dictionary[square] > best_score: best_score = square_dictionary[square] best_move = ['attack', square] return best_move
def act(self, game): # We don't want to die during spawn turns so we move to an empty # non-spawn position if game.turn % rg.settings.spawn_every == 0 and "spawn" in rg.loc_types(self.location): empty_pos = rg.locs_around(self.location, filter_out=("invalid", "obstacle", "spawn")) if empty_pos: return ["move", empty_pos[0]] else: return ["suicide"] # Move to one of the "quarters" around = rg.locs_around(self.location, filter_out=("obstacle", "invalid")) position = rg.toward(self.location, random.choice(self.DIRECTION)) position = self.closest(around, position) action = "move" if self.is_surrounded(game): return ["suicide"] # By the end we guard if we have low hp if 0 < self.hp < 15 and (rg.settings.max_turns - game.turn) < 5: return ["guard"] # Attack the weakest opponent around if any weakest = self.weakest_opponent(game) if weakest: # We go KABOOOOOM if we're low on hp!! if self.hp < 10: return ["suicide"] return ["attack", weakest.location] return [action, position]
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
def act(self, game): # zbiory pól na planszy # 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 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 bezpieczne = sasiednie - sasiednie_wrogowie - sasiednie_wrogowie2 - wejscia - druzyna print wejscia # domyślne działanie robota: ruch do środka ruch = ['move', rg.toward(self.location, rg.CENTER_POINT)] return ruch
def _analyze_explosions(self): turn = self.current_turn old_enemiesl = {x.location: x for x in self.enemies(turn-1)} # Players to examine are non-exploding ones. old_players = [y for y in self.players(turn-1) if y.location not in self.turns[turn-1].explode_locs] new_players_id = {y.robot_id: y for y in self.players(turn)} # Find players hit with abnormal damage, or 7 w/ guarding for y in old_players: num_nearby_enemies = sum (1 for loc in rg.locs_around(y.location) if loc in old_enemiesl) max_norm_dmg = 10*num_nearby_enemies new_hp = (new_players_id[y.robot_id].hp if y.robot_id in new_players_id else 0) hp_diff = y.hp - new_hp guarded = y.location in self.turns[turn-1].guard_locs if ((hp_diff == 7 and guarded) or hp_diff > max_norm_dmg): print "{0} hit with {1} damage.".format(y, hp_diff) # find culprit(s) candidates = [old_enemiesl[loc] for loc in rg.locs_around(y.location) if loc in old_enemiesl] if len(candidates) == 1: self._record_explosion_point(candidates[0]) elif len(candidates) > 1: for e in candidates: l = e.location if self.exploded in self.reconstructed_info[l].actions: self._record_explosion_point(old_enemiesl[l])
def _get_danger(self, game, loc): """Returns the danger of the given location as an integer between 1 and 10. """ baseline = 5 if 'spawn' in rg.loc_types(loc): baseline += 2 enemy_bots = self._get_enemies(game, loc) for enemy_loc, bot in enemy_bots: if enemy_loc in rg.locs_around(loc): baseline = 10 # Can't go here for adj in rg.locs_around(loc): if adj in rg.locs_around(enemy_loc): baseline += (bot.hp - self.hp) // 10 friends = self._get_friends(game, loc) for friend_loc, bot in friends: if friend_loc in rg.locs_around(loc): baseline = 10 # Can't go here if baseline < 1: baseline = 1 elif baseline > 10: baseline = 10 return baseline
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']
def act(self, game): global runda_numer, wybrane_pola if game.turn != runda_numer: runda_numer = game.turn wybrane_pola = set() # jeżeli się ruszamy, zapisujemy docelowe pole def ruszaj(loc): wybrane_pola.add(loc) return ['move', loc] # jeżeli stoimy, zapisujemy zajmowane miejsce def stoj(act, loc=None): wybrane_pola.add(self.location) return [act, loc] # 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 # bezpieczne = sasiednie - sasiednie_wrogowie - sasiednie_wrogowie2 - wejscia - druzyna bezpieczne = sasiednie - sasiednie_wrogowie - sasiednie_wrogowie2 - \ wejscia - druzyna - wybrane_pola def mindist(bots, loc): return min(bots, key=lambda x: rg.dist(x, loc)) def minhp(bots): return min(bots, key=lambda x: game.robots[x].hp) if wrogowie: najblizszy_wrog = mindist(wrogowie,self.location) else: najblizszy_wrog = rg.CENTER_POINT ruch = ['guard'] if self.location in wejscia: if bezpieczne: ruch = ['move', mindist(bezpieczne, rg.CENTER_POINT)] elif sasiednie_wrogowie: if 9*len(sasiednie_wrogowie) < self.hp: ruch = stoj('attack',minhp(sasiednie_wrogowie.pop())) elif bezpieczne: ruch = ruszaj(mindist(bezpieczne, rg.CENTER_POINT)) else: ruch = stoj('suicide') elif sasiednie_wrogowie2 and self.location not in wybrane_pola: ruch = ['attack', sasiednie_wrogowie2.pop()] elif bezpieczne: ruch = ruszaj(mindist(bezpieczne, najblizszy_wrog)) return ruch
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 bezpieczne = sasiednie - sasiednie_wrogowie - sasiednie_wrogowie2 - wejscia - druzyna def mindist(bots, loc): return min(bots, key=lambda x: rg.dist(x, loc)) ruch = ['guard'] if self.location in wejscia: if bezpieczne: ruch = ['move', mindist(bezpieczne, 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
def getNearbyOpenLocations(self, loc): locs = set(rg.locs_around(loc, filter_out=('invalid', 'obstacle', 'spawn'))) locs = locs - self.blocked_move_locs if len(locs) == 0: locs = set(rg.locs_around(loc, filter_out=('invalid', 'obstacle'))) locs = locs - self.blocked_move_locs return list(locs)
def getNearbyOpenLocations(self, loc): locs = set( rg.locs_around(loc, filter_out=('invalid', 'obstacle', 'spawn'))) locs = locs - self.blocked_move_locs if len(locs) == 0: locs = set(rg.locs_around(loc, filter_out=('invalid', 'obstacle'))) locs = locs - self.blocked_move_locs return list(locs)
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
def test_locs_around(self): locs = set(rg.locs_around((0,0))) assert locs == set(((0, 1), (1, 0), (0, -1), (-1, 0))) locs = set(rg.locs_around((10, 100))) assert locs == set(((10, 101), (11, 100), (10, 99), (9, 100))) locs = set(rg.locs_around((0,0), filter_out=["invalid"])) assert locs == set(((0, 1), (1, 0)))
def places_to_go(from_loc, occupied_space_list): ret_list = [] nearby_places = rg.locs_around(from_loc , filter_out=('invalid', 'obstacle')) if(game['turn']%10 == 0 or game['turn']%10 == 9): nearby_places = rg.locs_around(from_loc , filter_out=('invalid', 'obstacle', 'spawn')) for targ in nearby_places: if not occupied(targ,occupied_space_list): ret_list.append(targ) return ret_list
def open_locs_around(self, loc, spawn=True): locs = [] if spawn: locs = rg.locs_around(loc, filter_out=('invalid', 'obstacle', 'spawn')) else: locs = rg.locs_around(loc, filter_out=('invalid', 'obstacle')) for i in locs: if i in self.enemy_bots or i in self.planned_move_locs: locs.remove(i) return locs
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 bezpieczne = sasiednie - sasiednie_wrogowie - sasiednie_wrogowie2 - wejscia - druzyna def mindist(bots, poz): return min(bots, key=lambda x: rg.dist(x, poz)) if wrogowie: najblizszy_wrog = mindist(wrogowie, self.location) else: najblizszy_wrog = rg.CENTER_POINT # działanie domyślne: ruch = ['guard'] if self.location in wejscia: if bezpieczne: ruch = ['move', mindist(bezpieczne, rg.CENTER_POINT)] if self.location == rg.CENTER_POINT: ruch = ['guard'] if sasiednie_wrogowie: if 9 * len(sasiednie_wrogowie) >= self.hp: if bezpieczne: ruch = ['move', mindist(bezpieczne, rg.CENTER_POINT)] else: ruch = ['attack', sasiednie_wrogowie.pop()] if sasiednie_wrogowie2: ruch = ['attack', sasiednie_wrogowie2.pop()] if bezpieczne: ruch = ['move', mindist(bezpieczne, najblizszy_wrog)] return ruch
def isTrapped(self, loc, with_spawn=False): trap = True nearby = [] if with_spawn: nearby = rg.locs_around(loc, filter_out=('invalid','obstacle','spawn')) else: nearby = rg.locs_around(loc, filter_out=('invalid','obstacle')) for near in nearby: if near not in self.all_bots: trap = False return trap
def panic(include_suicide): poss = [] ar = rg.locs_around(curr, filter_out=('invalid','obstacle')) if include_suicide: ar = rg.locs_around(curr, filter_out=('invalid','obstacle','spawn')) for around in ar: if around not in game_bots: poss.append(around) if len(poss) == 0: return None return poss[random.randint(0, len(poss) - 1)]
def act(self, game): global runda_numer, wybrane_ruchy if game.turn != runda_numer: runda_numer = game.turn wybrane_ruchy = set() def ruszaj(loc): wybrane_ruchy.add(loc) return ['move', loc] def stoj(act, loc=None): wybrane_ruchy.add(self.location) return [act, loc] 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 bezpieczne = sasiednie - sasiednie_wrogowie - sasiednie_wrogowie2 - wejscia - druzyna - wybrane_ruchy def mindist(bots, loc): return min(bots, key=lambda x: rg.dist(x, loc)) if wrogowie: najblizszy_wrog = mindist(wrogowie,self.location) else: najblizszy_wrog = rg.CENTER_POINT # akcja domyślna, którą nadpiszemy, jak znajdziemy coś lepszego ruch = ['guard'] if self.location in wejscia: if bezpieczne: ruch = ['move', mindist(bezpieczne, rg.CENTER_POINT)] elif sasiednie_wrogowie: if 9*len(sasiednie_wrogowie) >= self.hp: if bezpieczne: ruch = ['move', mindist(bezpieczne, rg.CENTER_POINT)] else: ruch = ['attack', sasiednie_wrogowie.pop()] elif sasiednie_wrogowie2 and self.location not in wybrane_ruchy: #ruch = ['attack', sasiednie_wrogowie2.pop()] if sasiednie_wrogowie: ruch = stoj('attack',sasiednie_wrogowie.pop()) elif bezpieczne: #ruch = ['move', mindist(bezpieczne, najblizszy_wrog)] ruch = ruszaj(mindist(bezpieczne, najblizszy_wrog)) return ruch
def guessShot(): for potentialShot in rg.locs_around(self.location, filter_out=('invalid', 'obstacle')): allyCount = 0 enemyCount = 0 if potentialShot not in game['robots']: for enemy in rg.locs_around(potentialShot, filter_out=('invalid', 'obstacle')): if enemy in game['robots']: if game['robots'][enemy].player_id != self.player_id: enemyCount += 1 if enemyCount > 0: return ['attack', potentialShot] return ['attack', rg.toward(self.location, closestEnemy)]
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
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
def generate_move(self, robot): ''' Entry-point for turn generation ''' if robot.hp <= FLEE_HP_THRESHHOLD: return self._flee(robot) if Utils.is_spawn(robot.location) and Utils.new_robots_spawning(self.turn + 1): for loc in rg.locs_around(robot.location, filter_out=('invalid', 'obstacle', 'spawn')): return ['move', loc] enemyId = 0 if robot.player_id == 1 else 1 closestEnemy = self._closest_robot(enemyId, robot.location) if closestEnemy != None: if rg.wdist(robot.location, closestEnemy.location) <= 1: return ['attack', closestEnemy.location] else: path = self._cooperative_shortest_path(self.graph, robot.location, closestEnemy.location) if path == None: return ['guard'] else: self._commit_path_to_future_locations(path) return ['move', path[1]] # move toward the center path = self._cooperative_shortest_path(self.graph, robot.location, rg.CENTER_POINT) if path == None: return ['move', rg.toward(robot.location, rg.CENTER_POINT)] else: self._commit_path_to_future_locations(path) return ['move', path[1]]
def znajdz_wrogow_obok(self, game, wrogowie, bezpieczne): 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) elif not czy_wejscie(poz): bezpieczne.append(poz)
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]
def in_danger(self,game): if 'spawn' in rg.loc_types(self.location): return True for location in rg.locs_around(self.location): if location in game['robots']: return True return False
def nearby_robots(self, center, allies=True): if not center: return [] locs = rg.locs_around(center) return [bot for loc, bot in self.g['robots'].items() if loc in locs and self.on_team(bot) == allies]
def find_path(self, game): location = self.location if location == rg.CENTER_POINT: return ['guard'] locations_around = rg.locs_around(location, filter_out=('invalid', 'obstacle')) locations_around.append(location) rated_locations = [] for possible_location in locations_around: center_dist = rg.wdist(possible_location, rg.CENTER_POINT) rated_locations.append(( self.location_score(self.location, possible_location, game), -center_dist, possible_location )) rated_locations.sort(reverse=True) selected_location = rated_locations[0][2] if selected_location != location: return ['move', selected_location] else: return ['guard']
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']
def znajdz_wrogow_obok(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) return wrogowie
def __init__(self, robot, game): self.robot = robot self.game = game self.current_loc_types = rg.loc_types(robot.location) self.unobstructed_locs = [] self.normal_unobstructed_locs = [] self.safe_locs = [] self.immediate_friends = [] self.immediate_enemies = [] valid_and_wall_locs = rg.locs_around(robot.location, filter_out='invalid') self.valid_locs = [] for vwloc in valid_and_wall_locs: if not 'obstacle' in rg.loc_types(vwloc): self.unobstructed_locs.append(vwloc) self.valid_locs.append(vwloc) elif vwloc in self.game.robots: # valid locs INCLUDES robots self.valid_locs.append(vwloc) self.immediate_enemies = self.enemies_around(self.robot.location, self.robot.player_id) self.immediate_friends = self.friends_around(self.robot.location, self.robot.player_id, self.robot.location) for unobloc in self.unobstructed_locs: if not 'spawn' in rg.loc_types(unobloc): self.normal_unobstructed_locs.append(unobloc) if not self.enemies_around(unobloc, robot.player_id): self.safe_locs.append(unobloc)
def panic(self, currLoc): locs = rg.locs_around(currLoc, filter_out=('invalid','obstacle','spawn')) target = currLoc for loc in locs: if self.isEmptySpace(loc) is True: target = loc return target
def spawn(self, game, current_return): if current_return != ['empty']: return current_return #If bot is in spawn, determine how to move out. if rg.loc_types(self.location) == 'spawn': possible_locations = rg.locs_around(self.location, filter_out=('invalid', 'obstacle', 'spawn')) enemy_locs = [] for locs in possible_locations: if locs in game.robots and game.robots[ locs].player_id != self.player_id: enemy_locs.append(locs) for enemy in enemy_locs: if enemy.hp < 9: return ['attack', enemy] elif enemy in possible_locations: possible_locations.remove(enemy) best_option = [100, (0, 0)] for locs in possible_locations: current = [rg.wdist(locs, rg.CENTER_POINT), locs] if current[0] <= best_option[0]: best_option = current return ['move', best_option[1]] return current_return
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]
def find_five_points(loc): self._five_points = [loc] #self._five_points.append(loc) self._new_points = rg.locs_around(loc, filter_out=('invalid', 'obstacle')) for point in self._new_points: self._five_points.append(point) return self._five_points
def act(self, game): # When a new turn is started need to clear the new_locs list. if self.last_turn != game.turn: self.new_locs = [] self.last_turn = game.turn # 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: self.new_locs.append(self.location) return ['attack', loc] random.seed() # Otherwise move around pick a direction that can randomly # move to and move there. moves = rg.locs_around(self.location, filter_out=('invalid', 'obstacle')) moves = [loc for loc in moves if loc not in self.new_locs] if len(moves) > 0: choice = random.choice(moves) self.new_locs.append(choice) return ['move', choice] self.new_locs.append(self.location) return ['guard']
def attack(self, game, current_return): if current_return != ['empty']: return current_return possible_locations = rg.locs_around(self.location, filter_out=('invalid', 'obstacle', 'spawn')) enemy_locs = [] enemy_num = 0 for locs in possible_locations: if locs in game.robots and game.robots[ locs].player_id != self.player_id: enemy_num += 1 enemy_locs.append(locs) #Once we have a list of enemies, we can follow a process to determine how to deal with them. """ if 1 enemy: if myhealth > enemyhealth: attack if myhealth < enemyhealth: if they have less than 15, suicide else back away if 2 or more enemy: if both less than 15 and mine less than 20, suicide else back away else go to move """ for enemy in enemy_locs: return ['attack', enemy] #Need to flesh out attack strategy if enemy_num == 1: return ['attack', enemy] return current_return
def call_suicide(self, action_table): self.hp = 0 self.call_attack(self.location, action_table, damage=settings.suicide_damage) for loc in rg.locs_around(self.location): self.call_attack(loc, action_table, damage=settings.suicide_damage)
def act(self, game): robots = game['robots'] locs = rg.locs_around(self.location, filter_out=('invalid', 'obstacle')) enemies = [loc for loc in locs if loc in robots and robots[loc]['player_id'] != self.player_id] if enemies: ## attack weakest loc = sorted(enemies, key=lambda x: robots[x]['hp'])[0] return ['attack', loc] ## so no enemy nearby, walk around randomly but prefer non-spawn points ## filter out my own occupied spots locs = [loc for loc in locs if loc not in robots] ## empty non spawn points? non_spawn = [loc for loc in locs if 'spawn' not in rg.loc_types(loc)] if non_spawn: loc = random.choice(non_spawn) return ['move', loc] spawn = [loc for loc in locs if 'spawn' in rg.loc_types(loc)] if spawn: loc = random.choice(spawn) return ['move', loc] ## no more options return ['guard']
def local_enemies(self, game): locs = rg.locs_around(self.location) bots = {} for loc, bot in game.robots.iteritems(): if bot.player_id != self.player_id and loc in self.local_spaces(): bots[loc] = bot return bots
def escape_spawn_trap_move(self, game): if 'spawn' in rg.loc_types(self.location): locs = [x for x in rg.locs_around(self.location) if self.is_empty_loc(game, x)] free_locs = [x for x in locs if 'spawn' not in rg.loc_types(x)] safe_locs = [x for x in locs if self.is_safe_from_attacks(game, x)] safe_and_free_locs = [x for x in free_locs if x in safe_locs] # Try moving away first, even if may get hit. if len(safe_and_free_locs) > 0: return ['move', random.choice(safe_and_free_locs)] elif len(safe_locs) > 0: return ['move', random.choice(safe_locs)] elif len(free_locs) > 0: return ['move', random.choice(free_locs)] elif len(locs) > 0: return ['move', random.choice(locs)] # No where to move. else: # Todo: for friendlies, can tell them to gtfo out lol. # Todo: find a route, instead of just moving back n forth lol # Gonna die anyways, explode and cause some damage! # Enemies likely to guard. Some may move but hard to tell. if self.is_spawn_reset(game): return ['suicide'] # Else, go to some other behaviour return False
def collided(self, loc, game): """ Checks whether robots collided at loc in the last turn """ # TODO: Improve collision detection. # This method results in false positives because downhill last turn # may not be downhill this turn. # Sometimes it also results in false negatives. Cause unknown. Perhaps # it is not being called. if not self.last_game: # This is the first turn. return False collided_friend = collided_enemy = False adjacent = rg.locs_around(loc) for adj in adjacent: if ( adj in game['robots'] and adj in self.last_game['robots'] and game['robots'][adj].player_id == self.last_game['robots'][adj]['player_id'] and game['robots'][adj].hp == self.last_game['robots'][adj]['hp'] - settings.collision_damage ): if game['robots'][adj].player_id == self.player_id: collided_friend = True else: collided_enemy = True if collided_friend and collided_enemy: if DEBUG: print('Avoided collision at {}'.format(loc)) return True return False
def coward(self, game): # First, make sure you are not in a spawn point if 'spawn' in rg.loc_types(self.location): #Move out of spawn point! return ['move', rg.toward(self.location, rg.CENTER_POINT)] # second, make sure you are not next to an enemy locations = rg.locs_around(self.location, filter_out=('invalid', 'obstacle')) enemies = [] for l in locations: bot = game['robots'].get(l) if bot and bot['player_id'] != self.player_id: enemies.append(bot) if enemies: #Find a safe place! for l in locations: if not game['robots'].get(l): # unoccupied spot! return ['move', l] else: # surrounded! if self.hp < rg.settings.attack_range[1] * len(enemies): return ['suicide'] else: target = min(enemies, key=lambda x: x['hp']) return ['attack', target['location']] # finally, just chill out. return ['guard']
def attack(self, game, current_return): if current_return != ['empty']: return current_return possible_locations = rg.locs_around(self.location, filter_out = ('invalid', 'obstacle', 'spawn')) enemy_locs = [] enemy_num = 0 for locs in possible_locations: if locs in game.robots and game.robots[locs].player_id != self.player_id: enemy_num += 1 enemy_locs.append(locs) #Once we have a list of enemies, we can follow a process to determine how to deal with them. """ if 1 enemy: if myhealth > enemyhealth: attack if myhealth < enemyhealth: if they have less than 15, suicide else back away if 2 or more enemy: if both less than 15 and mine less than 20, suicide else back away else go to move """ for enemy in enemy_locs: return ['attack', enemy] #Need to flesh out attack strategy if enemy_num == 1: return ['attack', enemy] return current_return
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)]
def adjacents(self, location=None, filter_id=None, filter_empty=False, only_empty=False, only_id=False): if location == None: location = self.location locs = rg.locs_around(location, filter_out=('invalid', 'obstacle')) if only_empty != None: return [loc for loc in locs if loc not in self.robots] if only_id != None: return [ loc for loc in locs if loc in self.robots and self.robots[loc]['player_id'] == only_id ] if filter_empty != None: locs = [loc for loc in locs if loc in self.robots] if filter_id != None: locs = [loc for loc in locs if loc not in self.robots \ or self.robots[loc]['player_id'] != filter_id] return locs
def validate_action(self, formatted_action, game): if len(formatted_action) > 1: if formatted_action[1] == None: return False if formatted_action[0] == "move": return formatted_action[1] in rg.locs_around(self.location) return True #placeholder
def act(self, game): bestDistance = 999 bestLoc = (0, 0) otherPlaces = 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.wdist(loc, self.location) < bestDistance: bestDistance = rg.dist(loc, self.location) bestLoc = loc if game['robots'][self.location].hp <= 10: away = tuple( map(lambda x, y: x - y, rg.toward(self.location, bestLoc), self.location)) move = tuple(map(lambda x, y: x - y, self.location, away)) goodPlaces = rg.locs_around(self.location, filter_out=('invalid', 'obstacle', 'spawn')) if move in goodPlaces: return ['move', move] for loc in rg.locs_around(self.location, filter_out=('invalid', 'obstacle')): if loc in game['robots']: if game['robots'][loc].player_id != self.player_id: return ['suicide'] else: return ['guard'] for loc, bot in game['robots'].iteritems(): if bot.player_id != self.player_id: if rg.dist(loc, self.location) <= 1: if loc in otherPlaces: return ['attack', loc] if rg.dist(bestLoc, self.location) <= enemyDistance: if rg.toward(self.location, bestLoc) in otherPlaces: return ['move', rg.toward(self.location, bestLoc)] # otherwise clump up for loc, bot in game['robots'].iteritems(): if bot.player_id == self.player_id: if rg.wdist(loc, self.location) <= allyDistance: if loc in otherPlaces: return ['move', rg.toward(self.location, loc)] if self.location == rg.CENTER_POINT: return ['guard'] if rg.toward(self.location, rg.CENTER_POINT) in otherPlaces: return ['move', rg.toward(self.location, rg.CENTER_POINT)]
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 bezpieczne = sasiednie - sasiednie_wrogowie - sasiednie_wrogowie2 - wejscia - druzyna def mindist(bots, loc): return min(bots, key=lambda x: rg.dist(x, loc)) if wrogowie: najblizszy_wrog = mindist(wrogowie, self.location) else: najblizszy_wrog = rg.CENTER_POINT ruch = ['guard'] if self.location in wejscia: if bezpieczne: ruch = ['move', mindist(bezpieczne, rg.CENTER_POINT)] elif sasiednie_wrogowie: if 9 * len(sasiednie_wrogowie) < self.hp: ruch = ['attack', sasiednie_wrogowie.pop()] elif bezpieczne: ruch = ['move', mindist(bezpieczne, rg.CENTER_POINT)] elif sasiednie_wrogowie2: ruch = ['attack', sasiednie_wrogowie2.pop()] elif bezpieczne: ruch = ['move', mindist(bezpieczne, najblizszy_wrog)] return ruch
def move(bot, game): x, y = bot.location RIGHT, UP, LEFT, DOWN = (1, 0), (0, -1), (-1, 0), (0, 1) prio = () result = False if rg.locs_around(tuple(bot.location), filter_out=('invalid', 'obstacle', 'normal')): #We are out of order return False if x <= 9 and y > 9: #lower left quadrant; moving right and down priority if bot.hp >= CRITICAL_HP: prio = (DOWN, RIGHT, UP, LEFT) else: prio = (LEFT, UP, RIGHT, DOWN) elif x > 9 and y >= 9: #lower right; right and up if bot.hp >= CRITICAL_HP: prio = (RIGHT, UP, LEFT, DOWN) else: prio = (DOWN, LEFT, UP, RIGHT) elif x > 9 and y <= 9: #upper right; up and left if bot.hp >= CRITICAL_HP: prio = (UP, LEFT, DOWN, RIGHT) else: prio = (RIGHT, DOWN, LEFT, UP) elif x <= 9 and y <= 9: #upper left; left and down if bot.hp >= CRITICAL_HP: prio = (LEFT, DOWN, RIGHT, UP) else: prio = (UP, RIGHT, DOWN, LEFT) else: prio = (UP, ) for d in prio: dest = (x + d[0], y + d[1]) occupied = False for loc, nbot in game.get('robots').items(): if bot.hp >= CRITICAL_HP and nbot.hp < CRITICAL_HP and nbot.get( "location") == dest: continue if occupied: #if it is occupied by an ally, check for a less prioritized move, but if not, try moving anyway result = ["move", dest] continue elif "spawn" in rg.loc_types(dest) or "invalid" in rg.loc_types( dest): continue elif bot.hp < CRITICAL_HP: x2 = dest[0] + d[0] y2 = dest[1] + d[ 1] # Also check the tile after, so we go in the second row instead if "spawn" in rg.loc_types((x2, y2)): continue else: result = ["move", dest] else: result = ["move", dest] break return result
def find_random_safe_loc(loc, grid): arounds = filter( lambda x: not x in spawns and 0 == count_enemies(x) and not np. inf == grid[x], rg.locs_around(loc, filter_out=['invalid', 'obstacle'])) if 0 == len(arounds): return None return choice(arounds)
def surrounders(this_robot, game, loc): number_found = 0 for loc2 in rg.locs_around(loc): if (loc2 in game.robots): bot2 = game.robots[loc2] if bot2.player_id != this_robot.player_id: number_found += 1 #print "surrounders found ", loc, game return number_found
def get_neighboring_enemies(robot, game): neighboring_enemies = [] neighbors = rg.locs_around(robot.location) for loc, other in game['robots'].items(): if loc in neighbors: if other.player_id != robot.player_id: neighboring_enemies.append(other.location) return neighboring_enemies
def guessShot(): for potentialShot in rg.locs_around(self.location, filter_out=('invalid', 'obstacle')): allyCount = 0 enemyCount = 0 if potentialShot not in game['robots']: for enemy in rg.locs_around(potentialShot, filter_out=('invalid', 'obstacle')): if enemy in game['robots']: if game['robots'][ enemy].player_id != self.player_id: enemyCount += 1 if enemyCount > 0: return ['attack', potentialShot] return ['attack', rg.toward(self.location, closestEnemy)]