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
