def run(self, game_num=None):
game = Brisk(game_num, TEAM_NAME)
print "starting game {} we are player {}".format(game.game_id, game.player_id)
while True:
status = self.await_turn_and_get_status(game)
if status['eliminated']:
print "we lost :-("
break
if status['winner']:
if status['winner'] == game.player_id:
print "we won :-)"
res = game.reward()
print "send attachments to {}".format(res['upload_email'])
else:
print "We lost without getting eliminated. Guess we timed out"
break
print "We survived to {} turns!".format(status['turns_taken'])
lucky_territory = random.randint(0, len(status['territories']) - 1)
game.place_armies(status['territories'][lucky_territory]['territory'], status['num_reserves'])
game.end_turn()
class GamePlayer: def __init__(self): self.brisk = Brisk(); self.map = Map(brisk) self.me = Player_Status(brisk, self.map, true) # self.enemy_player_state = Player_State() def start(self): brisk = Brisk(); while True(): player_state = brisk.get_player_status() if player_state['current_turn']: self.take_turn(player_stateus) def update_information(self, player_state_response): self.me.update(player_state_response) # self.enemy_player_state.update(asdf)update def place_armies(self): num_reserves = self.me.num_reserves self.brisk.place_armies(self.me.territories[0].id, num_reserves) def launch_attack(self): for territory in me.territories: if territory.adjacent_territories.length > 1: adjacent_territory = territory.adjacent_territories[0] self.brisk.attack(territory.id, adjacent_territory.territory, min(3, territory.num_armies)) break def take_turn(self): self.update_information() # get first territory that is available self.place_armies() self.launch_attack() self.brisk.end_turn()
def __init__(self): self.brisk = Brisk(); self.map = Map(brisk) self.me = Player_Status(brisk, self.map, true)
def start(self): brisk = Brisk(); while True(): player_state = brisk.get_player_status() if player_state['current_turn']: self.take_turn(player_stateus)
def __init__(self, game_id=False, bot_id=1): self.brisk = Brisk(game_id, bot_id) self.map = Map(self.brisk.get_map_layout()) self.play()
class Alxndr(object):
def __init__(self, game_id=False, bot_id=1):
self.brisk = Brisk(game_id, bot_id)
self.map = Map(self.brisk.get_map_layout())
self.play()
def update_state(self):
self.game_state = self.brisk.get_game_state()
self.player_status = self.brisk.get_player_status()
def play(self):
print 'Game ID: ' + str(self.brisk.game_id)
while True:
self.update_state()
if self.game_state['winner']:
print 'WINNER: ' + str(self.game_state['winner'])
return
if self.player_status['current_turn']:
self.take_turn()
def get_my_territory_ids(self):
return [t['territory'] for t in self.player_status['territories']]
def get_my_territories_dict(self):
my_territories = {}
for territory in self.player_status['territories']:
territory_id = territory['territory']
my_territories[territory_id] = territory
return my_territories
def take_turn(self):
self.update_state()
place_troops_at = self.get_territories_to_reinforce()
num_reserves = self.player_status['num_reserves']
troops_placed = 0
troops_reserve = num_reserves
if num_reserves > 0:
if len(place_troops_at) > 3:
place_troops_at = place_troops_at[:3]
troops_to_place = num_reserves // len(place_troops_at)
remainder_troops = num_reserves % len(place_troops_at)
first_territory = True
for territory in place_troops_at:
self.brisk.place_armies(territory, troops_to_place if not first_territory else troops_to_place + remainder_troops)
first_territory = False
troops_placed += troops_to_place if not first_territory else troops_to_place + remainder_troops
self.update_state()
print 'put ' + str(troops_placed) + ' troops of ' + str(troops_reserve)
self.attack()
self.transfer()
def get_territories_to_reinforce(self):
import attack_planner
territories = []
candidate_attacks = attack_planner.computeAttackAdvantages(self.brisk, self)
candidate_attacks = sorted(candidate_attacks, key=lambda a: a['attack_advantage'], reverse=True)
for attack in candidate_attacks:
if attack['attacking_territory'] in self.map.border_territories:
territories.append(attack['attacking_territory'])
# If no candidate attacks on continent borders, fall back to selecting territory based on most enemy neighbors
if len(territories) == 0:
territories.append(self.map.territory_with_most_enemies(self.get_my_territory_ids()))
return territories
def attack(self):
import attack_planner
front = attack_planner.getAttack(self.brisk, self)
while front:
print 'Starting attack!'
if front['attack_advantage'] < 1:
return
my_territories = self.get_my_territories_dict()
my_territory_id = front['our_territory']
enemy_territory_id = front['enemy_territory']
my_armies_left = my_territories[my_territory_id]['num_armies']
attack_results = self.brisk.attack(my_territory_id, enemy_territory_id, min(3, my_armies_left-1))
self.update_state()
if attack_results['defender_territory_captured']:
print 'We won territory ' + str(enemy_territory_id) + '!'
num_to_transfer = attack_results['attacker_territory_armies_left'] - ARMIES_TO_LEAVE
if num_to_transfer > 0:
self.brisk.transfer_armies(my_territory_id, enemy_territory_id, num_to_transfer)
front = attack_planner.getAttack(self.brisk, self)
def territory_with_max_armies(self):
candidate = None
max_armies = 0
for territory_id, territory in self.get_my_territories_dict().iteritems():
if candidate == None or territory['num_armies'] > max_armies:
candidate = territory
max_armies = territory['num_armies']
return candidate
def transfer(self):
from_territory = self.territory_with_max_armies()
adjacent_territories = self.map.territories[from_territory['territory']]['adjacent_territories']
adjacent_territories = set(adjacent_territories).intersection(set(self.get_my_territory_ids()))
adjacent_territories = list(adjacent_territories)
num_to_transfer = from_territory['num_armies'] - ARMIES_TO_LEAVE
if len(adjacent_territories) == 0 or num_to_transfer <= 0:
self.brisk.end_turn()
else:
to_territory_id = self.map.territory_with_most_enemies(adjacent_territories)
self.brisk.transfer_armies(from_territory['territory'], to_territory_id, num_to_transfer)
print("ending turn!")
def __init__(self): self.brisk = Brisk(); self.map = Map(self.brisk) self.me = Player_Status(self.brisk, self.map, True) self.enemy = Player_Status(self.brisk, self.map, False) self.winner = None
class GamePlayer: def __init__(self): self.brisk = Brisk(); self.map = Map(self.brisk) self.me = Player_Status(self.brisk, self.map, True) self.enemy = Player_Status(self.brisk, self.map, False) self.winner = None def start(self): while True: player_state = self.brisk.get_player_status() if player_state['winner']: self.winner = player_state['winner'] print str(self.winner) + " WON!" return elif player_state['current_turn']: print 'strating turn' t0 = time.time() # try: self.take_turn(player_state) # except: # self.brisk.end_turn() print "Took " + str(time.time() - t0) + "seconds" def take_turn(self, player_state): self.update_information(player_state) # get first territory that is available # NEED TO IMPLEMENT self.place_armies(player_state) # NEED TO IMPLEMENT print 'launching attack' self.launch_attack() # NEED TO IMPLEMENT # self.transfer_armies_or_end_turn() print 'ending turn' self.brisk.end_turn() def update_information(self, player_state_response): self.me.update(player_state_response) # self.enemy_player_state.update(asdf)update def number_of_adjascent_enemy_armies(self, territory_id): territory = self.me.territory_map[territory_id] print territory adjascent_territories = self.me.territory_map[territory_id].adjacent_territories number = 0 for at in adjascent_territories: if self.enemy.owns_territory(at): number += self.enemy.territory_map(at).num_armies return number def number_of_adjascent_unowned_spaces(self, territory_id): territory = self.me.territory_map[territory_id] print territory adjascent_territories = self.me.territory_map[territory_id].adjacent_territories number = 0 for at in adjascent_territories: if self.enemy.owns_territory(at): number += 1 return number def can_help_claim_new_continent(self, territory_id): return 1 def place_armies(self, player_state): num_reserves = player_state['num_reserves'] territories_owned = self.me.territory_map.keys() a = -1 b = -1 c = -1 print 'here' territories_owned.sort(key=lambda x: a*self.number_of_adjascent_enemy_armies(x) + b*self.number_of_adjascent_unowned_spaces(x) + c*self.can_help_claim_new_continent(x)) if (len(territories_owned) == 0 ): print '1' return elif len(territories_owned) == 1: print '2' self.brisk.place_armies(territories_owned[0], num_reserves) num_reserves -= num_reserves elif len(territories_owned) == 2: print '3' given_to_first = int(round(num_reserves * 0.8)) self.brisk.place_armies(territories_owned[0], given_to_first) self.brisk.place_armies(territories_owned[1], num_reserves - given_to_first) num_reserves -= (given_to_first + num_reserves - given_to_first) else: print 'num reserves:' + str(num_reserves) given_to_first = int(round(num_reserves * 0.6)) num_reserves -= given_to_first given_to_second = int(round(num_reserves * 0.5)) num_reserves -= given_to_second print territories_owned[0], given_to_first self.brisk.place_armies(territories_owned[0], given_to_first) print 'made it past 1' print territories_owned[1], given_to_second self.brisk.place_armies(territories_owned[1], given_to_second) print 'made it past 2' print territories_owned[2], num_reserves self.brisk.place_armies(territories_owned[2], num_reserves) print 'made it past 3' num_reserves -= num_reserves assert num_reserves == 0 # def place_armies(self, player_state): # num_reserves = player_state['num_reserves'] # while (num_reserves > 0): # possible_actions = self.get_possible_place_armies() # DO THIS # best_value = 0 # best_action = None # for action in possible_actions: # fake_do(action) # alter our game board in place DO THIS # value = self.eval_place_armies() #see if we like the state of the board DO THIS # if (value > best_value): # best_value = value # best_action = action # fake_undo(action) # DO THIS # execute_action(action) # # update relevant information DO THIS # num_reserves = self.me.num_reserves # self.brisk.place_armies(self.me.territories[0].id, num_reserves) def launch_attack(self): for territory in self.me.territories: if len(territory.adjacent_territories) > 1: adjacent_territory_id = territory.adjacent_territories[0] if (not self.me.owns_territory(adjacent_territory_id)): sending = min(self.me.territory_map[territory.id].num_armies - 1, 3) if sending <= 0: continue print '-----------------' print 'Game won: '+str(self.winner) print 'Attacking territory id: '+str(territory.id) print 'Defendig territory id: '+str(adjacent_territory_id) print 'Attacking territory: '+str(self.me.territory_map[territory.id]) print 'Sending: '+str(sending) self.brisk.attack(territory.id, adjacent_territory_id, sending) break
def __init__(self):
self.brisk = Brisk()
self.map = Map(self.brisk)
self.me = Player_Status(self.brisk, self.map, True)
self.enemy = Player_Status(self.brisk, self.map, False)
self.winner = None
class GamePlayer:
def __init__(self):
self.brisk = Brisk()
self.map = Map(self.brisk)
self.me = Player_Status(self.brisk, self.map, True)
self.enemy = Player_Status(self.brisk, self.map, False)
self.winner = None
def start(self):
while True:
player_state = self.brisk.get_player_status()
if player_state['winner']:
self.winner = player_state['winner']
print str(self.winner) + " WON!"
return
elif player_state['current_turn']:
print 'strating turn'
t0 = time.time()
# try:
self.take_turn(player_state)
# except:
# self.brisk.end_turn()
print "Took " + str(time.time() - t0) + "seconds"
def take_turn(self, player_state):
self.update_information(player_state)
# get first territory that is available
# NEED TO IMPLEMENT
self.place_armies(player_state)
# NEED TO IMPLEMENT
print 'launching attack'
self.launch_attack()
# NEED TO IMPLEMENT
# self.transfer_armies_or_end_turn()
print 'ending turn'
self.brisk.end_turn()
def update_information(self, player_state_response):
self.me.update(player_state_response)
# self.enemy_player_state.update(asdf)update
def number_of_adjascent_enemy_armies(self, territory_id):
territory = self.me.territory_map[territory_id]
print territory
adjascent_territories = self.me.territory_map[
territory_id].adjacent_territories
number = 0
for at in adjascent_territories:
if self.enemy.owns_territory(at):
number += self.enemy.territory_map(at).num_armies
return number
def number_of_adjascent_unowned_spaces(self, territory_id):
territory = self.me.territory_map[territory_id]
print territory
adjascent_territories = self.me.territory_map[
territory_id].adjacent_territories
number = 0
for at in adjascent_territories:
if self.enemy.owns_territory(at):
number += 1
return number
def can_help_claim_new_continent(self, territory_id):
return 1
def place_armies(self, player_state):
num_reserves = player_state['num_reserves']
territories_owned = self.me.territory_map.keys()
a = -1
b = -1
c = -1
print 'here'
territories_owned.sort(
key=lambda x: a * self.number_of_adjascent_enemy_armies(
x) + b * self.number_of_adjascent_unowned_spaces(
x) + c * self.can_help_claim_new_continent(x))
if (len(territories_owned) == 0):
print '1'
return
elif len(territories_owned) == 1:
print '2'
self.brisk.place_armies(territories_owned[0], num_reserves)
num_reserves -= num_reserves
elif len(territories_owned) == 2:
print '3'
given_to_first = int(round(num_reserves * 0.8))
self.brisk.place_armies(territories_owned[0], given_to_first)
self.brisk.place_armies(territories_owned[1],
num_reserves - given_to_first)
num_reserves -= (given_to_first + num_reserves - given_to_first)
else:
print 'num reserves:' + str(num_reserves)
given_to_first = int(round(num_reserves * 0.6))
num_reserves -= given_to_first
given_to_second = int(round(num_reserves * 0.5))
num_reserves -= given_to_second
print territories_owned[0], given_to_first
self.brisk.place_armies(territories_owned[0], given_to_first)
print 'made it past 1'
print territories_owned[1], given_to_second
self.brisk.place_armies(territories_owned[1], given_to_second)
print 'made it past 2'
print territories_owned[2], num_reserves
self.brisk.place_armies(territories_owned[2], num_reserves)
print 'made it past 3'
num_reserves -= num_reserves
assert num_reserves == 0
# def place_armies(self, player_state):
# num_reserves = player_state['num_reserves']
# while (num_reserves > 0):
# possible_actions = self.get_possible_place_armies() # DO THIS
# best_value = 0
# best_action = None
# for action in possible_actions:
# fake_do(action) # alter our game board in place DO THIS
# value = self.eval_place_armies() #see if we like the state of the board DO THIS
# if (value > best_value):
# best_value = value
# best_action = action
# fake_undo(action) # DO THIS
# execute_action(action)
# # update relevant information DO THIS
# num_reserves = self.me.num_reserves
# self.brisk.place_armies(self.me.territories[0].id, num_reserves)
def launch_attack(self):
for territory in self.me.territories:
if len(territory.adjacent_territories) > 1:
adjacent_territory_id = territory.adjacent_territories[0]
if (not self.me.owns_territory(adjacent_territory_id)):
sending = min(
self.me.territory_map[territory.id].num_armies - 1, 3)
if sending <= 0:
continue
print '-----------------'
print 'Game won: ' + str(self.winner)
print 'Attacking territory id: ' + str(territory.id)
print 'Defendig territory id: ' + str(
adjacent_territory_id)
print 'Attacking territory: ' + str(
self.me.territory_map[territory.id])
print 'Sending: ' + str(sending)
self.brisk.attack(territory.id, adjacent_territory_id,
sending)
break
