if game.me == None: continue me = game.me # game.me.cells is a dict, where the keys are Position and the values # are MapCell. Get all my cells. for cell in game.me.cells.values(): if (cell.building.name == "home"): for pos in cell.position.get_surrounding_cardinals(): #capture all the ones around it first? c = game.game_map[pos] if c.attack_cost < me.energy and c.owner != game.uid \ and c.position not in my_attack_list: cmd_list.append(game.attack(pos, c.attack_cost)) print( "We are attacking surrounding home ({}, {}) with {} energy" .format(pos.x, pos.y, c.attack_cost)) game.me.energy -= c.attack_cost my_attack_list.append(c.position) # the surrounding cells #if (c.owner == game.uid): #check the corners #d = game.game_map[pos.directional_offset(Direction.North)] # build fortress! if c.building.is_empty and me.gold >= 100: building = BLD_FORTRESS cmd_list.append(game.build(cell.position, building)) print( "We build FORTRESS NEAR HOME YEET {} on ({}, {})".
class Inevitable: def __init__(self): self.game = Colorfight() pass def Start(self): self.game.connect(room='public') if self.game.register(username='******', password="******"): while True: if self.Refresh(): self.FetchInfo() self.GameLoop() self.Send() def GetCell(self, pos): return self.game.game_map[pos] def Attack(self, cell, energy=None): if energy == None: energy = cell.attack_cost self.me.energy -= energy self.cmdList.append(self.game.attack(cell.position, energy)) self.attackList.append(cell.position) def Upgrade(self, cell): cellType = cell.building.name cellLevel = cell.building.level if cellType == "home": if cellLevel == 1: self.me.energy -= HOME_I[0] self.me.gold -= HOME_I[1] elif cellLevel == 2: self.me.energy -= HOME_II[0] self.me.gold -= HOME_II[1] elif cellType == "energy_well": if cellLevel == 1: self.me.energy -= ENERGY_I[0] self.me.gold -= ENERGY_I[1] elif cellLevel == 2: self.me.energy -= ENERGY_II[0] self.me.gold -= ENERGY_II[1] elif cellType == "gold_mine": if cellLevel == 1: self.me.energy -= GOLD_I[0] self.me.gold -= GOLD_I[1] elif cellLevel == 2: self.me.energy -= GOLD_II[0] self.me.gold -= GOLD_II[1] elif cellType == "fortress": if cellLevel == 1: self.me.energy -= FORTRESS_I[0] self.me.gold -= FORTRESS_I[1] elif cellLevel == 2: self.me.energy -= FORTRESS_II[0] self.me.gold -= FORTRESS_II[1] self.cmdList.append(self.game.upgrade(cell.position)) def CanBuild(self, building): if building == BLD_ENERGY_WELL: return self.me.energy >= ENERGY_I[0] and self.me.gold >= ENERGY_I[1] elif building == BLD_GOLD_MINE: return self.me.energy >= GOLD_I[0] and self.me.gold >= GOLD_I[1] elif building == BLD_FORTRESS: return self.me.energy >= FORTRESS_I[ 0] and self.me.gold >= FORTRESS_I[1] def CanUpgrade(self, cell): cellType = cell.building.name cellLevel = cell.building.level if cellType == "home": if cellLevel == 1: return self.me.energy >= HOME_I[0] and self.me.gold >= HOME_I[1] elif cellLevel == 2: return self.me.energy >= HOME_II[ 0] and self.me.gold >= HOME_II[1] else: return False elif cellType == "energy_well": if cellLevel == 1: return self.me.energy >= ENERGY_I[ 0] and self.me.gold >= ENERGY_I[1] elif cellLevel == 2: return self.me.energy >= ENERGY_II[ 0] and self.me.gold >= ENERGY_II[1] else: return False elif cellType == "gold_mine": if cellLevel == 1: return self.me.energy >= GOLD_I[0] and self.me.gold >= GOLD_I[1] elif cellLevel == 2: return self.me.energy >= GOLD_II[ 0] and self.me.gold >= GOLD_II[1] else: return False elif cellType == "fortress": if cellLevel == 1: return self.me.energy >= FORTRESS_I[ 0] and self.me.gold >= FORTRESS_I[1] elif cellLevel == 2: return self.me.energy >= FORTRESS_II[ 0] and self.me.gold >= FORTRESS_II[1] else: return False def Build(self, cell, building): if building == BLD_ENERGY_WELL: self.me.energy -= ENERGY_I[0] self.me.gold -= ENERGY_I[1] elif building == BLD_GOLD_MINE: self.me.energy -= GOLD_I[0] self.me.gold -= GOLD_I[1] elif building == BLD_FORTRESS: self.me.energy -= FORTRESS_I[0] self.me.gold -= FORTRESS_I[1] self.cmdList.append(self.game.build(cell.position, building)) def FetchAdjacent(self, cell): return [ self.game.game_map[pos] for pos in cell.position.get_surrounding_cardinals() ] def Empty(self, cell): return cell.owner == 0 def Own(self, cell): return cell.owner == self.game.uid def Enemy(self, cell): return not (cell.owner == 0 or not cell.owner == self.game.uid) def FetchInfo(self): self.me = self.game.me self.mode = 0 self.tech = 0 self.data = {} self.data["adjacent"] = {} self.data["adjacent"]["all"] = set() self.data["adjacent"]["empty"] = set() self.data["adjacent"]["enemy"] = {} self.data["adjacent"]["enemy"]["all"] = set() self.data["adjacent"]["enemy"]["empty"] = set() self.data["adjacent"]["enemy"]["energy"] = [set(), set(), set()] self.data["adjacent"]["enemy"]["gold"] = [set(), set(), set()] self.data["adjacent"]["enemy"]["bases"] = [set(), set(), set()] self.data["adjacent"]["enemy"]["forts"] = [set(), set(), set()] self.data["own"] = {} self.data["own"]["all"] = set() self.data["own"]["empty"] = set() self.data["own"]["energy"] = [set(), set(), set()] self.data["own"]["gold"] = [set(), set(), set()] self.data["own"]["bases"] = [set(), set(), set()] self.data["own"]["forts"] = [set(), set(), set()] self.data["enemy"] = {} self.data["enemy"]["all"] = set() self.data["enemy"]["empty"] = set() self.data["enemy"]["energy"] = [set(), set(), set()] self.data["enemy"]["gold"] = [set(), set(), set()] self.data["enemy"]["bases"] = [set(), set(), set()] self.data["enemy"]["forts"] = [set(), set(), set()] self.cmdList = [] self.attackList = [] for x in range(30): for y in range(30): pos = Position(x, y) cell = self.GetCell(pos) if self.Own(cell): self.data["own"]["all"].add(pos) cellType = cell.building.name if cellType == "empty": self.data["own"]["empty"].add(pos) elif cellType == "home": self.data["own"]["bases"][cell.building.level - 1].add(pos) elif cellType == "energy_well": self.data["own"]["energy"][cell.building.level - 1].add(pos) elif cellType == "gold_mine": self.data["own"]["gold"][cell.building.level - 1].add(pos) elif cellType == "fortress": self.data["own"]["forts"][cell.building.level - 1].add(pos) for adj in self.FetchAdjacent(cell): if not self.Own(adj): self.data["adjacent"]["all"].add(adj.position) if self.Enemy(adj): self.data["adjacent"]["enemy"]["all"].add( adj.position) adjType = adj.building.name if adjType == "empty": self.data["own"]["empty"].add(adj.position) elif adjType == "home": self.data["own"]["bases"][ adj.building.level - 1].add( adj.position) elif adjType == "energy_well": self.data["own"]["energy"][ adj.building.level - 1].add( adj.position) elif adjType == "gold_mine": self.data["own"]["gold"][adj.building.level - 1].add( adj.position) elif adjType == "fortress": self.data["own"]["forts"][ adj.building.level - 1].add( adj.position) else: self.data["adjacent"]["empty"].add( adj.position) def Refresh(self): self.game.update_turn() return not self.game.me == None def Send(self): self.game.send_cmd(self.cmdList) def Defend(self): base = None if len(self.data["own"]["bases"][0]) > 0: base = self.GetCell(list(self.data["own"]["bases"][0])[0]) if len(self.data["own"]["bases"][1]) > 0: base = self.GetCell(list(self.data["own"]["bases"][1])[0]) if len(self.data["own"]["bases"][2]) > 0: base = self.GetCell(list(self.data["own"]["bases"][2])[0]) if base: self.tech = base.building.level if self.CanUpgrade(base): self.Upgrade(base) def Expand(self): if self.me.gold <= 500: self.BuildEnergy() targets = [self.GetCell(t) for t in self.data["adjacent"]["empty"]] targets.sort(key=lambda cell: (cell.natural_energy, -cell.attack_cost), reverse=True) for target in targets: if target.attack_cost <= self.me.energy: self.Attack(target) def Loot(self): self.BuildGold() targets = [self.GetCell(t) for t in self.data["adjacent"]["empty"]] targets.sort(key=lambda cell: (cell.natural_gold, -cell.attack_cost), reverse=True) for target in targets: if target.attack_cost <= self.me.energy: self.Attack(target) def BuildEnergy(self): energyTargets = [self.GetCell(e) for e in self.data["own"]["empty"]] energyTargets.sort(key=lambda cell: (cell.natural_energy), reverse=True) for energyTarget in energyTargets: if self.CanBuild(BLD_ENERGY_WELL): self.Build(energyTarget, BLD_ENERGY_WELL) def BuildGold(self): goldTargets = [self.GetCell(e) for e in self.data["own"]["empty"]] goldTargets.sort(key=lambda cell: (cell.natural_gold), reverse=True) for goldTarget in goldTargets: if self.CanBuild(BLD_GOLD_MINE): self.Build(goldTarget, BLD_GOLD_MINE) def UpgradeEnergy(self, level): energyTargets = [ self.GetCell(e) for e in self.data["own"]["energy"][level - 1] ] energyTargets.sort(key=lambda cell: (cell.natural_energy), reverse=True) for energyTarget in energyTargets: if self.CanUpgrade(energyTarget): self.Upgrade(energyTarget) def UpgradeGold(self, level): goldTargets = [ self.GetCell(e) for e in self.data["own"]["gold"][level - 1] ] goldTargets.sort(key=lambda cell: (cell.natural_energy), reverse=True) for goldTarget in goldTargets: if self.CanUpgrade(goldTarget): self.Upgrade(goldTarget) def Snap(self): if len(self.data["adjacent"]): pass def AllSpark(self): if random.choice((0, 1)) == 0: self.UpgradeEnergy(1) self.UpgradeEnergy(2) self.BuildEnergy() else: self.UpgradeGold(1) self.UpgradeGold(2) self.BuildGold() targets = [self.GetCell(t) for t in self.data["adjacent"]["all"]] targets.sort(key=lambda cell: (cell.attack_cost)) for target in targets: if target.attack_cost <= self.me.energy: self.Attack(target) def GameLoop(self): print("Energy Source: " + str(self.me.energy_source - self.me.tax_amount)) print("Energy Source: " + str(self.me.gold_source - self.me.tax_amount)) print("") self.Defend() if self.tech == 1: self.Expand() elif self.tech == 2: self.Loot() else: self.AllSpark()
EG = c.energy + c.gold value = c.attack_cost - 30 * EG cellDict[pos] = value # Add the attack command in the command list # Subtract the attack cost manually so I can keep track # of the energy I have. # Add the position to the attack list so I won't attack # the same cell sortedDict = sorted(cellDict.items(), key=operator.itemgetter(1)) sortedCellDict = collections.OrderedDict(sortedDict) for item in sortedCellDict: c = game.game_map[item] if c.owner != me.uid and c.attack_cost < me.energy: cmd_list.append(game.attack(item, c.attack_cost)) print( "We are attacking ({}, {}) with {} energy. It's gold is {} and energy is {}" .format(pos.x, pos.y, c.attack_cost, c.gold, c.energy)) game.me.energy -= c.attack_cost my_attack_list.append(c.position) #building buildingList = {} if cell.owner == me.uid and cell.building.is_empty and me.gold >= 100: # if cell.gold > 5 or cell.energy * 1.5 > 5: # building = BLD_GOLD_MINE if cell.gold > 1.5*cell.energy else BLD_ENERGY_WELL # else: # building = BLD_ENERGY_WELL val = 0 list = []
lenoft = 900 if c.attack_cost < me.energy and c.owner != me.uid \ and c.position not in my_attack_list \ and len(me.cells) < lenoft: # Add the attack command in the command list # Subtract the attack cost manually so I can keep track # of the energy I have. # Add the position to the attack list so I won't attack # the same cell print( "We are attacking ({}, {}) with {} energy".format( pos.x, pos.y, c.attack_cost)) game.me.energy -= c.attack_cost my_attack_list.append(c.position) cmd_list.append(game.attack(c.position, c.attack_cost)) # Build a random building if we have enough gold if cell.owner == me.uid and cell.building.is_empty and me.gold >= 100: if (game.turn <= 80): if cell.gold > cell.energy + 2 and cell.gold >= 5: building = (BLD_GOLD_MINE) else: building = (BLD_ENERGY_WELL) else: if cell.energy >= cell.gold and cell.energy >= 4: building = (BLD_ENERGY_WELL) elif cell.gold > cell.energy and cell.gold >= 5: building = (BLD_GOLD_MINE) else:
gold_val = (MAX_VALUE - 1) / 500 * game.turn + 1 energy_val = (1 - MAX_VALUE) / 500 * game.turn + MAX_VALUE # game.me.cells is a dict, where the keys are Position and the values # are MapCell. Get all my cells. cell_tax = cal_tax(cell_num) building_tax = cal_tax(building_num) attackables = attackable() home_pos = attackables[0] evaluations = attack_dict(attackables[1]) max_val = max(evaluations.keys(), key=lambda x: evaluations[x]) print(evaluations) while (game.game_map[max_val].natural_gold>cell_tax or game.game_map[max_val].natural_energy >cell_tax) \ and game.game_map[max_val].attack_cost<me.energy: cmd_list.append( game.attack(max_val, game.game_map[max_val].attack_cost)) cell_num += 1 print("We are attacking") game.me.energy -= game.game_map[max_val].attack_cost del evaluations[max_val] if len(evaluations) == 0: break max_val = max(evaluations.keys(), key=lambda x: evaluations[x]) build_evaluation = build_dict() if len(build_evaluation) > 0: max_build = max(build_evaluation.keys(), key=lambda x: build_evaluation[x]) while (game.game_map[max_val].natural_gold>building_tax or game.game_map[max_val].natural_energy >building_tax) \ and me.gold > 100: cmd_list.append(game.build(max_build, build_type(max_build)))
# is not mine, and I have not attacked it in this round already # We also try to keep our cell number under 100 to avoid tax if c.attack_cost < me.energy and c.owner != game.uid \ and c.position not in my_attack_list \ and len(me.cells) < 300\ and len(my_attack_list)<6\ and friendly>2: # Add the attack command in the command list # Subtract the attack cost manually so I can keep track # of the energy I have. # Add the position to the attack list so I won't attack # the same cell acost = c.attack_cost if (c.building.name == "home"): acost = acost * 3 cmd_list.append(game.attack(pos, acost)) print( "We are attacking ({}, {}) with {} energy".format( pos.x, pos.y, c.attack_cost)) game.me.energy -= acost my_attack_list.append(c.position) # If we can upgrade the building, upgrade it. # Notice can_update only checks for upper bound. You need to check # tech_level by yourself. if cell.building.can_upgrade and \ (cell.building.is_home) and \ cell.building.upgrade_gold < me.gold and \ cell.building.upgrade_energy < me.energy: cmd_list.append(game.upgrade(cell.position)) print("We upgraded home at({}, {})".format(
# is not mine, and I have not attacked it in this round already # [DW] buffer attack_cost with additional constant for forcefield buffer_cost = 10 # determines the growth of capacity per unit of scaling_factor advancement_factor = 80 if (c.attack_cost + buffer_cost) < me.energy and c.owner != game.uid \ and c.position not in my_attack_list \ and len(me.cells) < advancement_factor * scaling_factor: # Add the attack command in the command list # Subtract the attack cost and the buffer cost manually so I can keep track # of the energy I have. # Add the position to the attack list so I won't attack # the same cell cmd_list.append(game.attack(pos, c.attack_cost + buffer_cost)) print("We are attacking ({}, {}) with {} energy".format(pos.x, pos.y, c.attack_cost)) game.me.energy -= c.attack_cost + buffer_cost my_attack_list.append(c.position) # [Determine relevant behavior for choosing which buildings to upgrade based on home / type of building / resource bounds] # If we can upgrade the building, upgrade it. # Notice can_update only checks for upper bound. You need to check # tech_level by yourself. if cell.building.can_upgrade and \ (cell.building.is_home or cell.building.level < me.tech_level) and \ cell.building.upgrade_gold < me.gold and \ cell.building.upgrade_energy < me.energy: cmd_list.append(game.upgrade(cell.position)) print("We upgraded ({}, {})".format(cell.position.x, cell.position.y))
# [DW] buffer attack_cost with additional constant for forcefield buffer_cost = 10 # determines the growth of capacity per unit of scaling_factor advancement_factor = 80 if (c.attack_cost + buffer_cost) < me.energy and c.owner != game.uid \ and c.position not in my_attack_list \ and len(me.cells) < advancement_factor * scaling_factor: # Add the attack command in the command list # Subtract the attack cost and the buffer cost manually so I can keep track # of the energy I have. # Add the position to the attack list so I won't attack # the same cell cmd_list.append( game.attack(pos, c.attack_cost + buffer_cost)) print( "We are attacking ({}, {}) with {} energy".format( pos.x, pos.y, c.attack_cost)) game.me.energy -= c.attack_cost + buffer_cost my_attack_list.append(c.position) # [Determine relevant behavior for choosing which buildings to upgrade based on home / type of building / resource bounds] # If we can upgrade the building, upgrade it. # Notice can_update only checks for upper bound. You need to check # tech_level by yourself. if cell.building.can_upgrade and \ (cell.building.is_home or cell.building.level < me.tech_level) and \ cell.building.upgrade_gold < me.gold and \ cell.building.upgrade_energy < me.energy: cmd_list.append(game.upgrade(cell.position))
continue me = game.me hcLevel = 1 # homeCell = findHome() # game.me.cells is a dict, where the keys are Position and the values # are MapCell. Get all my cells. cellDict = {} buildingList = {} for cell in game.me.cells.values(): cmd_list.append(game.attack(cell.position, 1)) me.energy -= 1 # my_attack_list.append(cell.position) # if me.gold > 1000 * homeCell.building.level and me.energy > 1000 * homeCell.building.level: if cell.building.can_upgrade and \ cell.building.is_home and \ cell.building.upgrade_gold < me.gold and \ cell.building.upgrade_energy < me.energy: cmd_list.append(game.upgrade(cell.position)) print("We upgraded ({}, {})".format(cell.position.x, cell.position.y)) me.gold -= 1000 * cell.building.level me.energy -= 1000 * cell.building.level # Check the surrounding position for pos in cell.position.get_surrounding_cardinals():
if c.owner != game.uid and c.attack_cost < me.energy: a_cell_pair = (c.position, c.natural_energy/c.attack_cost) if a_cell_pair not in best_cells: best_cells.append(a_cell_pair) best_cells.sort(key=lambda X: X[1], reverse=True) for pair in best_cells: c = game.game_map[pair[0]] # Add the attack command in the command list # Subtract the attack cost manually so I can keep track # of the energy I have. # Add the position to the attack list so I won't attack # the same cell if c.position not in my_attack_list: cmd_list.append(game.attack(pair[0], c.attack_cost)) print("We are attacking ({}, {}) Value({})".format(pair[0].x, pair[0].y, pair[1]), end ='') game.me.energy -= c.attack_cost my_attack_list.append(c.position) print("") # game.me.cells is a dict, where the keys are Position and the values # are MapCell. Get all my cells. lvl_one_buildings = [] lvl_two_buildings = [] for cell in game.me.cells.values(): if cell.building is not None and cell.building != "home" and cell.building.level == 1: lvl_one_buildings.append(cell) elif cell.building is not None and cell.building != "home" and cell.building.level == 2: lvl_two_buildings.append(cell)
if #end if game.register(username = '******', password = '******'): status = "attack(x, y)" while True: cmd_list = [] my_attack_list = [] g.update_turn() if g.me == None continue me = g.me game_map = g.game_map #start code #early game for cell in me.cells.values(): #get home cell if (cell.is_home()): if (cell.is_empty()): cmd_list.append(g.attack(cell.position.directional_offset(Direction.North))) cmd_list.append(g.attack(cell.position.directional_offset(Direction.East))) cmd_list.append(g.attack(cell.position.directional_offset(Direction.West))) cmd_list.append(g.attack(cell.position.directional_offset(Direction.South))) if (status = "attack(x, y"): result = game.send_cmd(cmd_list) print(result)
cmd_list.append(game.upgrade(cell.position)) print("We upgraded ({}, {})".format(cell.position.x, cell.position.y)) gold_for_upgrading -= cell.building.upgrade_gold wells_gold += gold_for_upgrading mylist = [ 100, 200, 300, 400, 500, 1000, 2000, 3000, 4000, 5000, 10000000000 ] attacklist = [] for i in mylist: for cell in cells_to_attack: if cell.attack_cost < attack_energy and cell.attack_cost < i and cell not in attacklist: cmd_list.append( game.attack(cell.position, cell.attack_cost)) attack_energy -= cell.attack_cost attacklist.append(cell) for cell in cells_for_wells: if wells_gold > 100: cmd_list.append(game.build(cell.position, BLD_ENERGY_WELL)) print("We built a well on ({}, {})".format( cell.position.x, cell.position.y)) wells_gold -= 100 for cell in cells_for_mines: if mines_gold > 100: cmd_list.append(game.build(cell.position, BLD_GOLD_MINE)) print("We built a mine on ({}, {})".format( cell.position.x, cell.position.y))
class Inevitable: def __init__(self): self.game = Colorfight() pass def Start(self): self.defenseEnergy = 1 self.attackEnergy = 0 self.energyChance = 2 self.rechargeNow = False self.command = "" self.hold = False self.game.connect(room='final') if self.game.register(username='******', password="******"): self.starkThread = Thread(target=self.Stark) self.starkThread.start() while True: if self.Refresh(): self.FetchInfo() self.GameLoop() self.Send() def GetCell(self, pos): return self.game.game_map[pos] def GetUser(self, uid): return self.game.users[uid] def Attack(self, cell, energy=None): if energy == None: energy = cell.attack_cost + self.attackEnergy self.me.energy -= energy self.cmdList.append(self.game.attack(cell.position, energy)) self.attackList.append(cell.position) def Upgrade(self, cell): cellType = cell.building.name cellLevel = cell.building.level if cellType == "home": if cellLevel == 1: self.me.energy -= HOME_I[0] self.me.gold -= HOME_I[1] elif cellLevel == 2: self.me.energy -= HOME_II[0] self.me.gold -= HOME_II[1] elif cellType == "energy_well": if cellLevel == 1: self.me.energy -= ENERGY_I[0] self.me.gold -= ENERGY_I[1] elif cellLevel == 2: self.me.energy -= ENERGY_II[0] self.me.gold -= ENERGY_II[1] elif cellType == "gold_mine": if cellLevel == 1: self.me.energy -= GOLD_I[0] self.me.gold -= GOLD_I[1] elif cellLevel == 2: self.me.energy -= GOLD_II[0] self.me.gold -= GOLD_II[1] elif cellType == "fortress": if cellLevel == 1: self.me.energy -= FORTRESS_I[0] self.me.gold -= FORTRESS_I[1] elif cellLevel == 2: self.me.energy -= FORTRESS_II[0] self.me.gold -= FORTRESS_II[1] self.cmdList.append(self.game.upgrade(cell.position)) def CanSnap(self, base): owner = self.GetUser(base.owner) if self.me.energy >= (owner.energy_source + base.attack_cost): return owner.energy_source + base.attack_cost else: return -1 def CanBuild(self, building): if building == BLD_ENERGY_WELL: return self.me.energy >= ENERGY_I[0] and self.me.gold >= ENERGY_I[1] elif building == BLD_GOLD_MINE: return self.me.energy >= GOLD_I[0] and self.me.gold >= GOLD_I[1] elif building == BLD_FORTRESS: return self.me.energy >= FORTRESS_I[ 0] and self.me.gold >= FORTRESS_I[1] def CanUpgrade(self, cell): cellType = cell.building.name cellLevel = cell.building.level if cellType == "home": if cellLevel == 1: return self.me.energy >= HOME_I[0] and self.me.gold >= HOME_I[1] elif cellLevel == 2: return self.me.energy >= HOME_II[ 0] and self.me.gold >= HOME_II[1] else: return False elif cellType == "energy_well": if cellLevel == 1: return self.me.energy >= ENERGY_I[ 0] and self.me.gold >= ENERGY_I[1] elif cellLevel == 2: return self.me.energy >= ENERGY_II[ 0] and self.me.gold >= ENERGY_II[1] else: return False elif cellType == "gold_mine": if cellLevel == 1: return self.me.energy >= GOLD_I[0] and self.me.gold >= GOLD_I[1] elif cellLevel == 2: return self.me.energy >= GOLD_II[ 0] and self.me.gold >= GOLD_II[1] else: return False elif cellType == "fortress": if cellLevel == 1: return self.me.energy >= FORTRESS_I[ 0] and self.me.gold >= FORTRESS_I[1] elif cellLevel == 2: return self.me.energy >= FORTRESS_II[ 0] and self.me.gold >= FORTRESS_II[1] else: return False def Build(self, cell, building): if building == BLD_ENERGY_WELL: self.me.energy -= ENERGY_I[0] self.me.gold -= ENERGY_I[1] elif building == BLD_GOLD_MINE: self.me.energy -= GOLD_I[0] self.me.gold -= GOLD_I[1] elif building == BLD_FORTRESS: self.me.energy -= FORTRESS_I[0] self.me.gold -= FORTRESS_I[1] self.cmdList.append(self.game.build(cell.position, building)) def FetchAdjacent(self, cell): return [ self.game.game_map[pos] for pos in cell.position.get_surrounding_cardinals() ] def Empty(self, cell): return cell.owner == 0 def Own(self, cell): return cell.owner == self.game.uid def Enemy(self, cell): return not (cell.owner == 0 or cell.owner == self.game.uid) def FetchInfo(self): self.me = self.game.me self.mode = 0 self.tech = 0 self.data = {} self.data["adjacent"] = {} self.data["adjacent"]["all"] = set() self.data["adjacent"]["empty"] = set() self.data["adjacent"]["enemy"] = {} self.data["adjacent"]["enemy"]["all"] = set() self.data["adjacent"]["enemy"]["empty"] = set() self.data["adjacent"]["enemy"]["energy"] = [set(), set(), set()] self.data["adjacent"]["enemy"]["gold"] = [set(), set(), set()] self.data["adjacent"]["enemy"]["bases"] = [set(), set(), set()] self.data["adjacent"]["enemy"]["forts"] = [set(), set(), set()] self.data["own"] = {} self.data["own"]["all"] = set() self.data["own"]["empty"] = set() self.data["own"]["energy"] = [set(), set(), set()] self.data["own"]["gold"] = [set(), set(), set()] self.data["own"]["bases"] = [set(), set(), set()] self.data["own"]["forts"] = [set(), set(), set()] self.data["edges"] = set() self.data["enemy"] = {} self.data["enemy"]["all"] = set() self.data["enemy"]["empty"] = set() self.data["enemy"]["energy"] = [set(), set(), set()] self.data["enemy"]["gold"] = [set(), set(), set()] self.data["enemy"]["bases"] = [set(), set(), set()] self.data["enemy"]["forts"] = [set(), set(), set()] self.cmdList = [] self.attackList = [] for x in range(30): for y in range(30): pos = Position(x, y) cell = self.GetCell(pos) if self.Own(cell): self.data["own"]["all"].add(pos) cellType = cell.building.name if cellType == "empty": self.data["own"]["empty"].add(pos) elif cellType == "home": self.data["own"]["bases"][cell.building.level - 1].add(pos) elif cellType == "energy_well": self.data["own"]["energy"][cell.building.level - 1].add(pos) elif cellType == "gold_mine": self.data["own"]["gold"][cell.building.level - 1].add(pos) elif cellType == "fortress": self.data["own"]["forts"][cell.building.level - 1].add(pos) for adj in self.FetchAdjacent(cell): if not self.Own(adj): self.data["adjacent"]["all"].add(adj.position) if self.Enemy(adj): self.data["edges"].add(pos) self.data["adjacent"]["enemy"]["all"].add( adj.position) adjType = adj.building.name if adjType == "empty": self.data["enemy"]["empty"].add( adj.position) elif adjType == "home": self.data["enemy"]["bases"][ adj.building.level - 1].add( adj.position) elif adjType == "energy_well": self.data["enemy"]["energy"][ adj.building.level - 1].add( adj.position) elif adjType == "gold_mine": self.data["enemy"]["gold"][ adj.building.level - 1].add( adj.position) elif adjType == "fortress": self.data["enemy"]["forts"][ adj.building.level - 1].add( adj.position) else: self.data["adjacent"]["empty"].add( adj.position) def Refresh(self): self.game.update_turn() return not self.game.me == None def Send(self): self.game.send_cmd(self.cmdList) def Defend(self): base = None if len(self.data["own"]["bases"][0]) > 0: base = self.GetCell(list(self.data["own"]["bases"][0])[0]) if len(self.data["own"]["bases"][1]) > 0: base = self.GetCell(list(self.data["own"]["bases"][1])[0]) if len(self.data["own"]["bases"][2]) > 0: base = self.GetCell(list(self.data["own"]["bases"][2])[0]) if base: self.tech = base.building.level if self.CanUpgrade(base): self.Upgrade(base) def Expand(self): if self.me.gold <= 500: self.BuildEnergy() targets = [self.GetCell(t) for t in self.data["adjacent"]["empty"]] targets.sort(key=lambda cell: (cell.natural_energy, -cell.attack_cost), reverse=True) for target in targets: if target.attack_cost <= self.me.energy: self.Attack(target) def Bread(self): self.BuildGold() targets = [self.GetCell(t) for t in self.data["adjacent"]["empty"]] targets.sort(key=lambda cell: (cell.natural_gold, -cell.attack_cost), reverse=True) for target in targets: if target.attack_cost <= self.me.energy: self.Attack(target) def BuildEnergy(self): energyTargets = [self.GetCell(e) for e in self.data["own"]["empty"]] energyTargets.sort(key=lambda cell: (cell.natural_energy), reverse=True) for energyTarget in energyTargets: if self.CanBuild(BLD_ENERGY_WELL): self.Build(energyTarget, BLD_ENERGY_WELL) def BuildGold(self): goldTargets = [self.GetCell(e) for e in self.data["own"]["empty"]] goldTargets.sort(key=lambda cell: (cell.natural_gold), reverse=True) for goldTarget in goldTargets: if self.CanBuild(BLD_GOLD_MINE): self.Build(goldTarget, BLD_GOLD_MINE) def UpgradeEnergy(self, level): energyTargets = [ self.GetCell(e) for e in self.data["own"]["energy"][level - 1] ] energyTargets.sort(key=lambda cell: (cell.natural_energy), reverse=True) for energyTarget in energyTargets: if self.CanUpgrade(energyTarget): self.Upgrade(energyTarget) def UpgradeGold(self, level): goldTargets = [ self.GetCell(e) for e in self.data["own"]["gold"][level - 1] ] goldTargets.sort(key=lambda cell: (cell.natural_energy), reverse=True) for goldTarget in goldTargets: if self.CanUpgrade(goldTarget): self.Upgrade(goldTarget) def Stark(self): data = "" while not data == "endgame": data = input() if data == "hold": self.hold = True print("Holding Game State.") print("") elif data == "attack": self.hold = False print("Attack Mode Activated.") print("") elif data == "defend": if len(self.data["edges"]) > 0: self.defenseEnergy = int( int(self.me.energy_source / 2) / len(self.data["edges"])) else: self.defenseEnergy = 1 print("Defense Mode Activated.") print("") elif data == "recharge": self.rechargeNow = True self.energyChance = 1000 print("Recharge Mode Activated.") print("") elif data == "normal": self.rechargeNow = False self.energyChance = 2 print("Recharge Mode Deactivated.") print("") else: data = data.split() if data[0] == "d": print("Set defense energy to: " + data[1]) self.defenseEnergy = int(data[1]) elif data[0] == "a": print("Set attack energy to: " + data[1]) self.attackEnergy = int(data[1]) elif data[0] == "r": print("Set attack energy to: " + data[1]) self.energyChance = int(data[1]) def Armor(self): for edge in self.data["edges"]: edge = self.GetCell(edge) if self.me.energy >= 1: self.Attack(edge, self.defenseEnergy) def Loot(self): for i in (2, 1, 0): if len(self.data["adjacent"]["enemy"]["gold"][i]) > 0: goldTargets = [ self.GetCell(b) for b in self.data["adjacent"]["enemy"]["gold"][i] ] goldTargets.sort(key=lambda cell: (cell.attack_cost)) for goldTarget in goldTargets: if goldTarget.attack_cost <= self.me.energy: self.Attack(goldTarget) def Recharge(self): for i in (2, 1, 0): if len(self.data["adjacent"]["enemy"]["energy"][i]) > 0: goldTargets = [ self.GetCell(b) for b in self.data["adjacent"]["enemy"]["energy"][i] ] goldTargets.sort(key=lambda cell: (cell.attack_cost)) for goldTarget in goldTargets: if goldTarget.attack_cost <= self.me.energy: self.Attack(goldTarget) def Dominate(self): targets = [self.GetCell(t) for t in self.data["adjacent"]["empty"]] targets.sort(key=lambda cell: (cell.attack_cost)) for target in targets: if target.attack_cost <= self.me.energy: self.Attack(target) targets = [self.GetCell(t) for t in self.data["adjacent"]["all"]] targets.sort(key=lambda cell: (cell.attack_cost)) for target in targets: if target.attack_cost <= self.me.energy: self.Attack(target) def Snap(self): for i in (2, 1, 0): if len(self.data["adjacent"]["enemy"]["bases"][i]) > 0: bases = [ self.GetCell(b) for b in self.data["adjacent"]["enemy"]["bases"][i] ] for base in bases: snapCost = self.CanSnap(base) if not snapCost == -1: self.Attack(base, snapCost) def AllSpark(self): if not self.hold: if random.choice(range(self.energyChance)) == 0: self.UpgradeGold(1) self.UpgradeGold(2) self.BuildGold() else: self.UpgradeEnergy(1) self.UpgradeEnergy(2) self.BuildEnergy() else: if self.rechargeNow: self.UpgradeEnergy(1) self.UpgradeEnergy(2) self.BuildEnergy() self.Snap() self.Armor() if not self.hold: order = random.choice((0, 1, 2)) if order == 0: self.Dominate() if random.choice((0, 1)) == 0: self.Recharge() self.Loot() else: self.Loot() self.Recharge() elif order == 1: self.Recharge() self.Dominate() self.Loot() elif order == 2: self.Loot() self.Dominate() self.Recharge() def GameLoop(self): #print( str( len( self.data[ "edges" ] ) ) ) #print( str( len( self.data[ "adjacent" ][ "empty" ] ) ) ) self.Defend() if self.tech == 1: self.Expand() elif self.tech == 2 and not self.rechargeNow: self.Bread() else: self.AllSpark()
users = game.users attackDict = assessField(game)[0] enemyClassifications = Classification(users, me.username) attackAlloc = .5 * me.energy #allocate(enemyClassifications, attackDict, me, game, users) maxReward = 0 best = 0 while (best != -1): best = -1 for i in attackDict: print(i.x, i.y) if (attackDict[i][0] - attackDict[i][1] > maxReward and attackAlloc > 100 + attackDict[i][1]): maxReward = attackDict[i][0] - attackDict[i][1] best = i cmd_list.append( game.attack(i, attackDict[best][1]) + np.random.randint(0, 100)) print("We are attacking ({}, {}) with {} energy".format( best.x, best.y, game[best].attack_cost)) attackDict[best] = -1 result = game.send_cmd(cmd_list) game.update_turn() # Send the command list to the server # #Identify Nearby Players/ Use their previous plays to classify them # # classifyEnemies() #
#attack adj list for pos in my_adj_list: c = game_map[pos] #energy to expend to attack attack_expend = c.attack_cost + modifier if attack_expend <= me.energy \ and pos not in my_attack_list: print("Attacking ({}, {}) with {} energy".format( pos.x, pos.y, attack_expend)) me.energy -= attack_expend my_attack_list.append(pos) cmd_list.append(g.attack(pos, attack_expend)) #attack "defend" perimeter cells #**Problematic: should only do this when touching enemy cells for pos in my_perimeter_list: c = game_map[pos] if c.position not in my_attack_list: my_attack_list.append(pos) #attacks with modifier cmd_list.append(g.attack(pos, per)) me.energy -= per print("Defending ({}, {}) with {} energy".format( pos.x, pos.y, per)) #END OF ENERGY ACTIONS #START OF GOLD ACTIONS