def __init__(self):
self.ticker = Ticker()
self.states = States(self.ticker)
self.message = Message()
self.map = Map()
self.you = Player()
self.enemy = Player()
def __init__(self):
self.ticker = Ticker()
self.states = States(self.ticker)
self.message = Message()
self.map = Map()
self.you = Player()
self.enemy = Player()
self.history = MoveHistory(length=50, history=[])
def __init__(self):
self.values = Values()
self.ticker = Ticker()
self.states = States(self.ticker)
self.message = Message()
self.map = Map()
self.map.register_cost_and_heuristic(self.astar_move_cost,
self.astar_heuristic)
self.you = Player()
self.enemy = Player()
class AI(object):
def __init__(self):
self.ticker = Ticker()
self.states = States(self.ticker)
self.message = Message()
self.map = Map()
self.you = Player()
self.enemy = Player()
def setup(self,info):
self.message.parse_message(info)
self.map = self.message.map
self.map.load_json_map()
self.you = self.message.you
def reset_for_next_round(self):
self.you = Player()
self.enemy = Player()
self.map.reset_map()
self.ticker.reset()
def update(self, info):
self.ticker.tick()
self.message.parse_message(info)
self.you = self.message.you
self.possible_moves = self.map.get_neighbours_of(self.you.pos)
self.enemy = self.message.enemy
self.__update_danger()
self.map.update_content(self.message,[self.you.pos,self.enemy.pos])
def __update_danger(self):
if self.you.pos in self.map.super_pellets_positions:
self.ticker.start_you_are_dangerous_ticker()
if self.enemy.pos in self.map.super_pellets_positions:
self.ticker.start_other_is_dangerous_ticker()
def move(self):
move = _get_move(self,self.map)
self.map.prev_move.append(move)
if move < 0:
print("error") #TODO print all the stuff
return move
from util.AI import AI
from timeit import default_timer as timer
def run_bot():
start = timer()
while msg.is_stateupdate() or msg.is_welcome():
map.load_json_map(msg.map)
move = ai.get_move(msg)
time = timer() - start
time *= 1000
time = round(time, 2)
print("t: %s ms" % str(time))
c.send_move(move)
next_gamestate = c.fetch_data()
start = timer()
t.tick()
msg.parse_message(next_gamestate)
if __name__ == '__main__':
c = C()
json_msg = c.fetch_data()
msg = M(json_msg)
map = Map(json_map=msg.map)
t = T()
while True:
msg.await_first_stateupdate_message(c)
ai = AI(map, msg.you)
run_bot()
class AI(object):
def __init__(self):
self.values = Values()
self.ticker = Ticker()
self.states = States(self.ticker)
self.message = Message()
self.map = Map()
self.map.register_cost_and_heuristic(self.astar_move_cost,
self.astar_heuristic)
self.you = Player()
self.enemy = Player()
def setup(self, info):
self.message.parse_message(info)
self.map = self.message.map
self.map.load_json_map()
self.player = self.message.you
def reset_for_next_round(self):
self.you = Player()
self.enemy = Player()
self.map.reset_map()
self.ticker.reset()
def update(self, info):
self.ticker.tick()
self.message.parse_message(info)
self.player = self.message.you
self.possible_moves = self.map.get_neighbours_of(self.player.pos)
self.enemy = self.message.enemy
self.__update_danger()
new_poses = [self.player.pos, self.enemy.pos]
self.map.update_content(self.message, new_poses)
def __update_danger(self):
if self.player.pos in self.map.super_pellets_positions:
self.ticker.start_you_are_dangerous_ticker()
if self.enemy.pos in self.map.super_pellets_positions:
self.ticker.start_other_is_dangerous_ticker()
def get_move(self): # AI LOGIC GOES HERE!
if self.states.is_status_quo():
print("Mmmm, shiny!")
path = self.map.get_bf_path(self.player.pos,
char_goal=self.map.icon.pellet)
first_move_pos = path[1]
move = self.map.get_move_from(self.player.pos, first_move_pos)
return move
elif self.states.you_are_dangerous():
if self.map.get_euclidean_dist(
self.player.pos,
self.enemy.pos) <= self.values.enemy_distance_trigger:
print("Ima getcha!")
path = self.map.get_bf_path(self.player.pos,
pos_goal=self.enemy.pos)
first_move_pos = path[1]
move = self.map.get_move_from(self.player.pos, first_move_pos)
return move
else:
print("Pft, cba chasing that guy")
path = self.map.get_bf_path(self.player.pos,
char_goal=self.map.icon.pellet)
first_move_pos = path[1]
move = self.map.get_move_from(self.player.pos, first_move_pos)
return move
elif self.states.enemy_is_dangerous():
if self.map.get_manhattan_dist(
self.player.pos,
self.enemy.pos) <= self.values.enemy_distance_trigger:
print("HAPL!")
return self.send_random_move()
else:
print("Ima do me")
path = self.map.get_bf_path(self.player.pos,
char_goal=self.map.icon.pellet)
first_move_pos = path[1]
return self.map.get_move_from(self.player.pos, first_move_pos)
return -1 #haha, you messed up! :P
def send_random_move(self):
return self.map.get_move_from(
self.player.pos, np.random.choice(list(self.possible_moves)))
def astar_heuristic(self, start, goal):
return self.map.get_euclidean_dist(start, goal)
def astar_move_cost(self, pos1, pos2):
return 10.0
class AI(object):
def __init__(self):
self.ticker = Ticker()
self.states = States(self.ticker)
self.message = Message()
self.map = Map()
self.you = Player()
self.enemy = Player()
self.history = MoveHistory(length=50, history=[])
def setup(self, info):
self.message.parse_message(info)
self.map = self.message.map
self.map.load_json_map()
self.you = self.message.you
def reset_for_next_round(self):
self.you = Player()
self.enemy = Player()
self.map.reset_map()
self.ticker.reset()
def update(self, info):
self.ticker.tick()
self.message.parse_message(info)
self.you = self.message.you
self.possible_moves = self.map.get_neighbours_of(self.you.pos)
self.enemy = self.message.enemy
self.__update_danger()
self.map.update_content(self.message, [self.you.pos, self.enemy.pos])
def __update_danger(self):
if self.you.pos in self.map.super_pellets_positions:
self.ticker.start_you_are_dangerous_ticker()
if self.enemy.pos in self.map.super_pellets_positions:
self.ticker.start_other_is_dangerous_ticker()
def move(self):
move = self.__get_the_move(self.map)
return move
def __get_the_move(self, map):
avail_pellet_moves = []
avail_new_moves = []
avail_old_moves = []
for possible_move in self.possible_moves:
# Just do this move if it's a super pellet
if possible_move in map.super_pellets_positions:
return map.get_move_between(self.you.pos, possible_move)
# Record possible pellet move
elif possible_move in map.pellet_positions:
avail_pellet_moves.append(possible_move)
# Track old moves
if self.history.contains(possible_move):
avail_old_moves.append(possible_move)
else:
avail_new_moves.append(possible_move)
if len(avail_pellet_moves) > 0: move = r.choice(avail_pellet_moves)
else:
move = r.choice(avail_new_moves) if len(
avail_new_moves) > 0 else r.choice(avail_old_moves)
# Chase super pellets
for supahpelletz in map.super_pellets_positions:
moves_to_supapellet = map.get_breadth_first_path(
self.you.pos, supahpelletz)
if (len(moves_to_supapellet) < 10):
move = moves_to_supapellet[0]
print("Chasing a super pellet!")
break
# Chase enemy if dangerous
if (self.you.is_dangerous and not self.enemy.is_dangerous):
move = map.get_breadth_first_path(self.you.pos, self.enemy.pos)[0]
print("I'm dangerous!")
self.history.add(move)
return map.get_move_between(self.you.pos, move)
def __base_parse_map(self, json_map):
content, height, pelletsleft, width = json_map['content'], json_map[
'height'], json_map['pelletsleft'], json_map['width']
self.map = Map(height=height, width=width, pellets_left=pelletsleft)
self.map.content = content
def __init__(self):
self.type = ''
self.map = Map()
self.you = Player()
self.enemy = Player()