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")