def generate_map(self):
self.territories = {}
if self.map == 'USA':
for state, adjacents in usa_states.items():
self.territories[state] = Territory(state, adjacents)
elif self.map == 'Egypt':
for state, adjacents in egypt_states.items():
self.territories[state] = Territory(state, adjacents)
def bunker_case(args, return_queue=None):
a_troops = args[0]
b_troops = args[1]
a = Territory("A", "Leon", a_troops)
b = Territory("B", "Leon", b_troops, defence_modifications=[mods.bunker])
while (a.attack_max() > 0 and b.defend_max() > 0):
game.attack(a, a.attack_max(), b, b.defend_max())
if return_queue is None:
return a.troops, b.troops
else:
return_queue.put([a.troops, b.troops])
def readConcejosAndTerritories():
concejos = []
territories = []
with open(concejosFile, 'r') as f:
reader = csv.reader(f, delimiter=';')
for i, row in enumerate(reader):
concejos.append(Concejo(i, row[0]))
territories.append(
Territory(i, row[0], int(row[1]), int(row[2]), eval(row[3])))
return concejos, territories
def __init__(self,point_array):
self.hull = ConvexHull(point_array).hull_points
#self.delaunay = DelaunayTri(point_array)
#self.vor = VoronoiTess(point_array)
self.delaunay = Delaunay(point_array)
self.vor = Voronoi(self.delaunay)
self.N = len(self.vor.regions)
self.hull_points = []
for point in self.hull:
self.hull_points.append(self.vor.points.index(point))
self.interior_points = set(range(self.N))
for point in self.hull:
self.interior_points.discard(point)
#create a position dependant list of VoronoiCells
#adj_list = self._create_adj_matrix() # only needed in pyhull version
self.cells = []
for i in range(self.N):
theCell = Territory()
theCell.id = i
theCell.center = self.vor.points[i]
cleanVerts = list(self.vor.regions[i]) #list of indices into vetex array
points = []
for vertexIndex in cleanVerts:
points.append(self.vor.vertices[vertexIndex].tolist())
#if 0 in cleanVerts: cleanVerts.remove(0)
#if len(points)>2: #figure out where this isnt true
orderedVertices = ConvexHull(points).hull_points
theVerts = np.array(orderedVertices)#[self.vor.vertices[vert] for vert in cleanVerts])
theCell.vertices = theVerts
theCell.neighbors = list(self.vor.neighbors[i])
if theCell.center in self.hull:
theCell.hull_point = True
self.cells.append(theCell)
def rivalry_ammo_shortage_case(args, return_queue=None):
a_troops = args[0]
b_troops = args[1]
a = Territory("A", "Leon", a_troops, attack_modifications=[mods.rivalry])
b = Territory("B",
"Leon",
b_troops,
defence_modifications=[mods.ammo_shortage])
while (a.attack_max() > 0 and b.defend_max() > 0):
game.attack(a, a.attack_max(), b, b.defend_max())
if return_queue is None:
return a.troops, b.troops
else:
return_queue.put([a.troops, b.troops])
def __init__(self):
self.turn = 0
self.moves = 0
self.players = []
self.territories = []
self.game_over = False
self.start_phase = True
for i in range(0, reg.player_count):
self.players.append(Player(self, i, bool(random.randint(0, 1))))
self.terr_conns = utils.generateMatrix(self.territories)
for i in range(0, reg.territory_count):
self.territories.append(Territory(i))
def __init__(self, id, x, y, name, color, client):
self.id = id
self.x = x
self.y = y
self.color = [i - 25 if i >= 25 else i
for i in color[:-1]] + [color[-1]]
self.line_color = list(color[:-1]) + [160]
self.territory = Territory(x, y, color)
self.lines = []
self.bonuses = []
self.name = name
self.score = 0
self.debug_log = []
self.client = client
self.is_disconnected = False
def from_config_file(path_to_file):
new_territories = {}
new_paths = []
new_continents = {}
continent_colors = [
'#EF6C00', '#9E9D24', '#689F38', '#00ACC1', '#6D4C41', '#F06292'
]
with open(path_to_file) as f:
continent_count, territory_count = map(int, f.readline().split())
# read continents and their respective territories
for i in range(continent_count):
continent_name = f.readline().strip()
continent_bonus, continent_territory_count = map(
int,
f.readline().split())
new_continent = Continent(continent_name, [], continent_bonus)
new_continents[continent_name] = new_continent
for _ in range(continent_territory_count):
name = f.readline().strip()
board_pos, size_on_board = f.readline().strip().split()
new_territory = Territory(name, board_pos, size_on_board,
continent_colors[i])
new_continent.add_territory(new_territory)
new_territories[name] = new_territory
f.readline()
# read territories and their neighbors
for _ in range(territory_count):
from_territory_name = f.readline().strip()
from_territory = new_territories[from_territory_name]
neighbor_count = int(f.readline())
for _ in range(neighbor_count):
to_territory_name = f.readline().strip()
to_territory = new_territories[to_territory_name]
from_territory.add_neighbor(to_territory)
new_path = Path(from_territory, to_territory)
new_paths.append(new_path)
f.readline()
return Board(new_territories, new_paths, new_continents)
from territory import Territory
new_land = Territory("New Land","red")
sater = Territory("sater", "red")
new_land.takeover("player1")
sater.takeover("player2")
new_land.add_troops(6)
sater.add_troops(3)
def battle(self):
"""
- Choose a random Empire ∑ (attacker reign)
- Choose a random Territory from ∑'s neighbours => defender
- defender's Empire Ω = Territory.sovereign
- intersection(Ω's territory neighbours, ∑) => attackers
- random(attackers) => Territory attacker (of ∑)
- attacker vs defender
- if attack > defense:
if len(Ω) > 1:
remove defender geometry from Ω geometry
else:
defender.empire defeated
remaining_territories => len(Empires with more than one Territory)
Do always:
expand ∑ geometry including the defender geometry
attacker.empire => defender.empire
recompute neighbours of empires
else:
defender, of Ω, resisted
"""
self.logger.info("Round: %d", self.battle_round)
# Choose ∑
empire_list = self.obj.Empire.values.tolist()
unique_empires, empire_weights = np.unique(empire_list,
return_counts=True)
# If the number of remaining empires is less than threshold, increase the chance to pick up a small empire
# to be the attacker
if len(unique_empires) < self.min_empire_size:
min_empire_weight = max(
empire_weights) / self.max_empire_weight_ratio
empire_weights[
empire_weights < min_empire_weight] = min_empire_weight
empire = random.choices(unique_empires, empire_weights)[0]
empire_neighbours = self.obj.query(
f'Empire == "{empire}"').iloc[0].empire_neighbours
# Choose the defender Territory among the empire's neighbours
defender = random.choice(empire_neighbours)
defender = Territory(self.obj.loc[defender])
# Find the attackers as the intersection between ∑'s all territories and Ω's neighbours
attacker_territories = self.obj.query(
f'Empire == "{empire}"').index.values.tolist()
attackers = list(set(attacker_territories) & set(defender.neighbours))
assert len(
attackers
) > 0, f"Defender territory: {defender.Territory}; possible attackers: {attacker_territories}"
# Pick a random attacker Territory from Territories at the border
attacker = random.choice(attackers)
attacker = Territory(self.obj.loc[attacker])
assert attacker.Territory != defender.Territory, f"Attacker and defender territories are equal: {attacker.Territory}"
assert attacker.Empire != defender.Empire, f"Attacker and defender empires are equal: {attacker.Empire}"
assert attacker.Territory not in self.obj.query(
f'Empire == "{defender.Empire}"').index.tolist(), f"Attacker territory {attacker.Territory} " \
f"in defender empire {defender.Empire}"
# Send message
if defender.Territory == defender.Empire:
message = messages["battle_a"] % (attacker.Empire, defender.Empire)
else:
message = messages["battle_b"] % (
attacker.Empire, defender.Territory, defender.Empire)
self.logger.info(
message.replace("\n", " ").replace("*", "").replace("_", ""))
# Send map with caption
message = "*Round %d:*\n" % self.battle_round + message
if self.should_hide_map:
self.__telegram_handler.send_message(message)
else:
self.__send_map_to_bot(attacker=attacker,
defender=defender,
caption=message)
# Send poll. If cannot open poll skip the turn
poll_results = self.__send_poll(attacker, defender)
if poll_results:
total_votes = sum(poll_results.values())
else:
total_votes = 0
# Compute the strength of the attacker and defender
attacker_votes = poll_results[attacker.Empire]
defender_votes = poll_results[defender.Territory]
if total_votes > 0:
w = 0.66 # users votes weight 2/3 vs 1/3 random
duel = random.random() * (1 - w) + attacker_votes / (
attacker_votes + defender_votes) * w
else:
duel = random.random()
# The attacker won
if duel > 0.5:
message = messages["attacker_won"] % (
attacker.Empire, defender.Territory, defender.Empire)
# Copy the attacker and defender state as it is before the battle
old_defender = deepcopy(defender)
# If the capitol city looses, the attacker takes the whole empire
if defender.Territory == defender.Empire:
message = messages["capitol_defeated"] % (attacker.Empire,
defender.Empire)
message += '\n' + messages[
"defender_defeated"] % defender.Empire
self.__merge_empires_geometry(attacker=attacker,
defender=defender)
self.__update_defender_attrs(attacker=attacker,
defender=defender)
if self.remaining_empires == 1: # The war is over
the_winner = self.obj.Empire.unique()[0]
message = messages["the_winner_is"] % the_winner.upper()
self.__send_map_to_bot(attacker=attacker,
defender=None,
caption=message)
self.logger.info(
message.replace("\n",
" ").replace("*", "").replace("_", ""))
return
else: # Continue the battle
message += '\n' + messages[
"remaining_territories"] % self.remaining_empires
else:
# If the empire has more than one territory, reduce its geometry
# Change the empire geometry for the whole defender empire
# Change the sovereign for the whole defender empire
defender_empire_index = self.obj.query(
f'Empire == "{defender.Empire}"').index
self.obj.loc[defender.Territory,
"empire_color"] = attacker.empire_color
self.obj.loc[defender_empire_index, "empire_geometry"] = [
self.__reduce_defender_geometry(defender)
] * len(defender_empire_index)
self.obj.loc[defender.Territory]["Empire"] = attacker.Empire
self.__expand_empire_geometry(attacker, old_defender)
# Update geometries and neighbours
self.__update_empire_neighbours(attacker.Empire)
self.__update_empire_neighbours(old_defender.Empire)
self.__expand_empire_geometry(attacker, defender)
# Send map to Telegram
self.__telegram_handler.send_message(message)
self.logger.info(
message.replace("\n", " ").replace("*", "").replace("_", ""))
# The defender won
else:
message = messages["defender_won"] % (defender.Territory,
attacker.Empire)
self.logger.info(
message.replace("\n", " ").replace("*", "").replace("_", ""))
self.__telegram_handler.send_message(message)
self.battle_round += 1
from territory import Territory from graph.graph import Graph acre = Territory(1, "acre", color="#FF0A0A") alagoas = Territory(2, "alagoas", color="#CC0A44") amapa = Territory(3, "amapa", color="#FF0A0A") amazonas = Territory(4, "amazonas", color="#FF0A0A") bahia = Territory(5, "bahia", color="#FF0A0A") ceara = Territory(6, "ceara", color="#FF0A0A") df = Territory(7, "df", color="#FF0A0A") espirito_santo = Territory(8, "espirito_santo", color="#FF0A0A") goias = Territory(9, "goias", color="#FF0A0A") maranhao = Territory(10, "maranhao", color="#FF0A0A") mato_grosso = Territory(11, "mato_grosso", color="#FF0A0A") mato_grosso_sul = Territory(12, "mato_grosso_sul", color="#FF0A0A") minas_gerais = Territory(13, "minas_gerais", color="#FF0A0A") para = Territory(14, "para", color="#FF0A0A") paraiba = Territory(15, "paraiba", color="#FF0A0A") parana = Territory(16, "parana", color="#FF0A0A") pernambuco = Territory(17, "pernambuco", color="#FF0A0A") piaui = Territory(18, "piaui", color="#FF0A0A") rio = Territory(19, "rio", color="#FF0A0A") rio_grande_norte = Territory(20, "rio_grande_norte", color="#FF0A0A") rio_grande_sul = Territory(21, "rio_grande_sul", color="#FF0A0A") rondonia = Territory(22, "rondonia", color="#FF0A0A") roraima = Territory(23, "roraima", color="#FF0A0A") santa_catarina = Territory(24, "santa_catarina", color="#FF0A0A") sao_paulo = Territory(25, "sao_paulo", color="#FF0A0A") sergipe = Territory(26, "sergipe", color="#FF0A0A") tocantins = Territory(27, "tocantins", color="#FF0A0A")
