Я научу вас неправильно играть в Hearts of iron. Оптимизация довоенной экономики: часть 126.05.2024 21:00

Экземпляры Law хранят бонусы от законов (призыв, торговля, мобилизация экономики).

Order просто для очереди строительства.

Event преобразует текст в соответствующие инструкции (просто вызывает методы всё того же класса Country.

        while (
                free_factories > 0 and
                queue_position < (len(self.queue)-1)
        ):
            queue_position += 1
            if free_factories > 15:
                factories_for_region = 15
                free_factories += -15
            else:
                factories_for_region = free_factories
                free_factories = 0
            target_region_id = self.queue[queue_position].target_region_id
            done = self.regions[target_region_id].construct(
                factories_for_region,
                self.queue[queue_position].building_type,
                civil_constr_bonus=civil_constr_bonus,
                mil_constr_bonus=mil_constr_bonus,
                inf_constr_bonus=inf_constr_bonus,
            )

    def construct(self, factories, type_of_building,
                  civil_constr_bonus=0,
                  mil_constr_bonus=0,
                  inf_constr_bonus=0):
        construction_complete = False
        if self.is_on_construction_limit(type_of_building):
            raise Exception(
                f"Нельзя построить больше {type_of_building} "
                f"в регионе "
                f"{self.name}."
            )
        if type_of_building == MILITARY_BUILDING:
            self.mil_constr_progress += (
                factories * FACTORY_OUTPUT *
                (INFRASTRUCTURE_BONUS * self.infrastructure + 1) *
                (mil_constr_bonus + 1)
            )
            if self.mil_constr_progress > MILITARY_FACTORY_COST:
                self.military_factories += 1
                self.mil_constr_progress -= MILITARY_FACTORY_COST
                construction_complete = True
        elif type_of_building == CIVIL_BUILDING:
            self.civil_constr_progress += (
                    factories * FACTORY_OUTPUT *
                    (INFRASTRUCTURE_BONUS * self.infrastructure + 1) *
                    (civil_constr_bonus + 1)
            )
            if self.civil_constr_progress > FACTORY_COST:
                self.factories += 1
                self.civil_constr_progress -= FACTORY_COST
                construction_complete = True
        elif type_of_building == INF_BUILDING:
            self.inf_constr_progress += (
                    factories * FACTORY_OUTPUT *
                    (INFRASTRUCTURE_BONUS * self.infrastructure + 1) *
                    (inf_constr_bonus + 1)
            )
            if self.inf_constr_progress > INFRASTRUCTURE_COST:
                self.infrastructure += 1
                self.inf_constr_progress -= INFRASTRUCTURE_COST
                construction_complete = True
        else:
            raise Exception("Некорректный тип здания для постройки")
        return construction_complete

    def is_on_construction_limit(self, type_of_building):
        if (
                type_of_building == MILITARY_BUILDING or
                type_of_building == CIVIL_BUILDING
        ):
            if (
                    (self.factories + self.military_factories +
                     self.shipyards + self.fuel_silo + self.synth_oil
                     ) >= self.factories_limit
            ):
                return True
            else:
                return False
        elif type_of_building == INF_BUILDING:
            if self.infrastructure >= self.infrastructure_limit:
                return True
            else:
                return False
        else:
            raise Exception(
                f"Не найден лимит для здания "
                f"{type_of_building} в регионе "
                f"{self.name}")

    def _calculate_factories(self):
        civil_fact = 0
        mil_fact = 0
        shipyards = 0
        for region in self.regions:
            if self.tag in region.cores:
                civil_fact += region.factories
                mil_fact += region.military_factories
                shipyards += region.shipyards
            else:
                civil_fact += (
                    region.factories * region.get_compliance_modifier()
                )
                mil_fact += (
                    region.military_factories * 
                  region.get_compliance_modifier()
                )
                shipyards += (
                    region.shipyards * region.get_compliance_modifier()
                )
        # Округляем вниз
        civil_fact, mil_fact, shipyards = (
            int(civil_fact), int(mil_fact), int(shipyards))
        self.factories = civil_fact  # Все фабрики государства
        civil_fact += self.factories_from_trade  # Добавляем торговлю
        self.consumer_goods = self._get_consumer_goods()
        self.factories_for_consumers = floor(
                (civil_fact + mil_fact) * self._get_consumer_goods()
        )
        factories_available = (
            civil_fact - self.factories_for_consumers
        )
        self.factories_total = civil_fact
        self.factories = civil_fact - self.factories_from_trade
        self.mil_factories = mil_fact
        self.shipyards = shipyards
        if factories_available > 0:
            self.factories_available = round(factories_available, 0)
        else:
            self.factories_available = 0

    def get_compliance_modifier(self):
        # Для национальных пров. self.compliance = None
        if not self.compliance:
            raise Exception(
                "Попытка вычислить контроль национальной территории."
            )
        industry_percent = self.compliance * 0.65 + 25
        if self.compliance > 40:
            industry_percent += 10
        return industry_percent/100    

    def calculate_day(self, compliance_modifier):
        if self.compliance:  # Для национальных пров. self.compliance = None
            grow = (1+compliance_modifier) * 0.075
            decay = self.compliance * 0.00083
            self.compliance += grow - decay
        else:
            raise Exception(
                "Попытка рассчитать рост контроля в национальной провинции."
            )

    def _recalculate_available_slots(self):
        self.available_for_construction = (
                self.factories_limit
                - self.factories
                - self.military_factories
                - self.shipyards
                - self.fuel_silo
                - self.synth_oil
        )
        self.available_for_queue = (
                self.available_for_construction
                - self.slot_for_queue
        )
        self.available_for_infrastructure = (
            self.infrastructure
            - self.infrastructure_queue_slots
        )
        self.available_for_infrastructure_queue = (
            self.available_for_infrastructure
            - self.infrastructure_queue_slots
        )

    def upgrade_industry_tech(self):
        if self.industry_tech >= 5:
            raise Exception("Лимит технологии 5 уровень")
        elif self._distributed_industry:
            self.mil_output_bonus += 0.1
        else:
            self.mil_output_bonus += 0.15
        self.industry_tech += 1
        self.factory_limit_bonus += 0.2
        for region in self.regions:
            region.recalculate_factories_limit(self.factory_limit_bonus)

Программа выдает 2092 и 5455 прогресса строительства на 1 января 1937 года.

class DayAfterDayFrance:
    name = "День за днем Французский"

    def __init__(self):
        self.country = get_france_for_tests_2_and_3()
        self.country.move_trade(+1)
        self.country.move_trade(+1)
        self.factories365 = 32
        self.days = {
            0: (0, 0, 0,),  # старт
            1: (94, 12, 0,),
            2: (189, 25, 0,),
            3: (283, 37, 0,),
            4: (378, 50, 0),
            5: (472, 63, 0),
            6: (567, 75, 0),
            7: (661, 88, 0),  # смотрим 1 неделю
            31: (2929, 390, 0),  # 1 февраля
            59: (5575, 743, 0),  # 1 марта
            90: (8505, 1134, 0),  # 1 апреля
            120: (540, 1512, 0),  # 1 мая
            151: (3469, 1902, 0),  # 1 июня
            181: (6304, 2280, 0),  # 1 июля
            212: (9234, 2671, 0),  # 1 августа
            243: (1363, 3150, 0),  # 1 сентября
            273: (4198, 3717, 0),  # 1 октября
            304: (7128, 4302, 0),  # 1 ноября
            334: (9963, 4869, 0),  # 1 декабря
            337: (10246, 4926, 0),  # 4 декабря
            339: (10435, 4964, 0),  # 6 декабря
            341: (10624, 5002, 0),  # 8 декабря
            343: (13, 5040, 0),  # 10 декабря
            353: (958, 5229, 0),  # 20 декабря
            365: (2092, 5455, 0),  # 1 января
            730: (0, 0, 8643)  # 1 января
        }

    def check(self, text=False):
        region_ids = [8, 10, 5]
        regions = self.country.regions
        no_problems = True
        for day in range(731):
            if day in self.days.keys():
                no_problem_in_the_day = True
                for x in range(3):
                    # floor не настоящий, он сперва округляет до 3 знака после ","
                    if (
                        floor(regions[region_ids[x]].civil_constr_progress)
                        != self.days[day][x] and
                        self.days[day][x] != 0
                    ):
                        no_problems = False
                        no_problem_in_the_day = False
                if not no_problem_in_the_day:
                    for_print = []
                    for i in region_ids:
                        for_print.append(floor(
                            regions[i].civil_constr_progress)
                        )
                    if text:
                        print(
                            f"День {day} не совпадает. "
                            f"Ожидаем/получили [{self.days[day][0]}, "
                            f"{self.days[day][1]}, "
                            f"{self.days[day][2]}]/"
                            f"{for_print}. "
                        )
            self.country.calculate_day(day)
        return no_problems

Ожидаем перехода с 77.60% на 77.70% с 1 на 2 января.

Что и получаем.

class ComplianceTest:
    name = "Проверка контроля (Франция)"

    def __init__(self):
        data = get_data()
        self.country = get_country(data=data, name_or_tag="FRA", by_tag=True)
        self.data = {
            364: 77.6,
            365: 77.7,
        }
        self.result = {}

    def check(self, text=False):
        successful = True
        for day in range(367):
            self.country.calculate_day(day=day)
            target_region = None
            for region in self.country.non_core_regions:
                if region.global_id == 781:
                    target_region = region
            compliance = floor(target_region.compliance*10)/10
            if day in self.data.keys():
                self.result[day] = compliance
                if self.data[day] != compliance:
                    successful = False
        if (
            successful
        ):
            return True
        else:
            if text:
                print(
                    f"Целевые показатели {self.data}\n"
                    f"Получили - {self.result}"
                )
            return False

from os import path, listdir
from ast import literal_eval
from constants_and_settings.constants import PATH_TO_PROVINCES, GAME_DATA_FILE_TYPE


def is_text(letter):
    if letter.isalpha():
        return True
    elif letter == "_":
        return True
    else:
        return False


# noinspection PyTypeChecker
def add_quotes(string, maximum_phrases=20):
    """Добавляем кавычки тексту, чтобы python распознавал его."""
    # Исправляем названия dlc
    string = string.replace(
        "Arms Against Tyranny",
        "Arms_Against_Tyranny",
    )
    text = []
    for x in range(maximum_phrases):
        text.append([None, None])
    # Находим фразы
    for x in range(len(string)-1):
        # Избегание кавычек нужно для того,
        # чтобы оставить название с номером.
        if (
            (not is_text(string[x]) and not string[x].isdigit())
            and is_text(string[x+1])
            and string[x] != '"' and string[x+1] != '"'
        ):
            for y in range(maximum_phrases):
                if not text[y][0] is None:
                    continue
                text[y][0] = x+1
                break
        if (
            is_text(string[x]) and
            (not is_text(string[x+1]) and not string[x+1].isdigit())
            and string[x] != '"' and string[x+1] != '"'
        ):
            for y in range(maximum_phrases):
                if text[y][1]:
                    continue
                text[y][1] = x+1
                break
    # Берем в кавычки полностью найденные фразы.
    for phrase in reversed(text):
        if phrase[0] and phrase[1]:
            string = (
                    string[:phrase[0]] + '"' +
                    string[phrase[0]:phrase[1]] + '"' +
                    string[phrase[1]:]
            )
    return string


def separate_numbers(string, max_spaces=6):
    """Разделяем числа запятыми. А также число строка, тоже.
    Ликвидируем все даты."""
    for x in range(len(string)-2):
        if (
            string[x].isdigit() and
            string[x+1] == " " and
            string[x+2].isalpha()
        ):
            string = string[:x+1] + "," + string[x+2:]
        # Табуляцию тоже убираем
        if (
            string[x].isdigit() and
            string[x+1] == "\t" and
            string[x+2].isdigit()
        ):
            string = string[:x+1] + "," + string[x+2:]
    for y in range(max_spaces):
        for x in range(len(string) - 2 - y):
            if (
                string[x].isdigit() and
                string[x+1:x+y+2] == " "*(y+1) and
                string[x+2+y].isdigit()
            ):
                string = string[:x+1] + "," + " "*y + string[x+2:]
    return string


def create_provinces_file(tags):
    provinces_dict = {}  # Словарь с итоговыми данными
    files_list = listdir(PATH_TO_PROVINCES)  # Список путей к файлам
    provinces_list = []  # Список путей к текстовым файлам
    # Заполняем список путей к текстовым файлам
    for file in files_list:
        if file[-len(GAME_DATA_FILE_TYPE):] == GAME_DATA_FILE_TYPE:
            provinces_list.append(path.join(PATH_TO_PROVINCES, file))
    # Цикл заполнения словаря с итоговыми данными
    for file in provinces_list:
        full_file_name = path.basename(file)  # Имя файла вместе с расширением
        file_name = full_file_name[
            :-len(full_file_name.split(".")[-1])-1  # -1 для удаления точки
                    ]  # Имя файла
        province_number = int(file_name.split("-")[0])  # Номер провинции по порядку
        province_name = file_name[
                        len(file_name.split("-")[0]) + 1:  # +1 для удаления "-"
                        ]  # Название провинции
        province_name = province_name.replace("-", "_")
        province_name = province_name.lower()
        province_name = province_name.strip()  # Удаляем пробелы с краев

        with open(file) as link_to_the_file:  # Читаем данные
            raw_string = link_to_the_file.read()  # Получаем сырую строку данных
        # Уничтожаем все даты
        for year in range(36, 51):
            for month in range(1, 13):
                raw_string = raw_string.replace(
                    f"{year}.{month}.",
                    "",
                )
        # Переменные начинающиеся с чисел это ересь.
        # Судя по всему число в начале это дата, или что-то подобное.
        raw_string = raw_string.replace(
            "843.ETH_state_development_production_speed",
            "Why_variable_starts_with_a_number",
        )
        raw_string = raw_string.replace(
            "908.ETH_state_development_production_speed",
            "Another_one"
        )
        raw_list = raw_string.split("\n")  # Делим текст по строкам
        new_list = []  # Будущий итоговый лист с файлом построчно
        # Удаляем пустые строки
        for element_number in reversed(range(len(raw_list))):
            if not raw_list[element_number]:
                raw_list.pop(element_number)
        raw_list[0] = raw_list[0].split("=")[1]  # Удаляем "state="

        # Преобразуем в python код
        for old_line in raw_list:
            if "#" in old_line:
                line = old_line.split("#")[0]  # Удаляем комментарии
            else:
                line = old_line
            # Заменяем "=" на ":" т.к. преобразовываем в словарь
            new_line = line.replace("=", ":")
            # Запятые в конце строки
            if (
                ":" in new_line and
                new_line[-1] != ":" and
                not ("{" in new_line and "}" not in new_line)
                or "}" in new_line
            ):
                new_line = new_line + ","
            new_line = separate_numbers(new_line)  # Разделяем числа запятыми
            new_line = add_quotes(new_line)  # Добавляем свои кавычки
            new_list.append(new_line)  # Для итогового листа
        # Собираем итоговый текст
        new_text = ""
        for line in new_list:
            new_text = f"{new_text}{line}\n"
        data_dict = literal_eval(new_text)[0]

        # Теперь можно начать заполнять наш словарь
        provinces_dict[province_number] = {}  # Добавляем словарь для данных провинции
        # Для удобства берем ссылки на словари
        prov = provinces_dict[province_number]
        history = data_dict.get("history", {})
        buildings = history.get("buildings", {})
        # Читаем данные
        prov["name"] = province_name.replace(" ", "_")  # Добавляем имя
        prov["owner"] = history["owner"].lower()
        prov["cores"] = []
        for line in new_list:
            for tag in tags:
                if "add_core_of" in line and tag in line:
                    prov["cores"].append(tag.lower())
        prov["infrastructure"] = buildings.get("infrastructure", 0)
        prov["factories"] = buildings.get("industrial_complex", 0)
        prov["military_factories"] = buildings.get("arms_factory", 0)
        prov["shipyards"] = buildings.get("dockyard", 0)
        prov["fuel_silo"] = buildings.get("fuel_silo", 0)
        prov["anti_air"] = buildings.get("anti_air_building", 0)
        prov["air_base"] = buildings.get("air_base", 0)
        prov["radar"] = buildings.get("radar_station", 0)
        prov["synth_oil"] = buildings.get("synthetic_refinery", 0)
        # Список типов регионов с максимумами слотов
        lands = {
            "wasteland": 0,
            "enclave": 0,
            "tiny_island": 0,
            "pastoral": 1,
            "small_island": 1,
            "rural": 2,
            "town": 4,
            "large_town": 5,
            "city": 6,
            "large_city": 8,
            "metropolis": 10,
            "megalopolis": 12,
        }
        for k, v in lands.items():  # Устанавливаем максимум слотов
            if data_dict["state_category"] == k:
                prov["max_factories"] = v
    return provinces_dict

from os import path, listdir
from constants_and_settings.constants import PATH_TO_PROVINCES, GAME_DATA_FILE_TYPE


def create_tags_file():
    files_list = listdir(PATH_TO_PROVINCES)  # Список путей к файлам
    provinces_list = []  # Список путей к текстовым файлам
    # Заполняем список путей к текстовым файлам
    for file in files_list:
        if file[-len(GAME_DATA_FILE_TYPE):] == GAME_DATA_FILE_TYPE:
            provinces_list.append(path.join(PATH_TO_PROVINCES, file))
    # Лист с уникальными кодами стран
    tags = []
    # Цикл заполнения словаря с итоговыми данными
    for file in provinces_list:
        with open(file) as link_to_the_file:  # Читаем данные
            raw_string = link_to_the_file.read()  # Получаем сырую строку данных
        raw_list = raw_string.split("\n")  # Делим текст по строкам
        # Удаляем пустые строки
        for element_number in reversed(range(len(raw_list))):
            if not raw_list[element_number]:
                raw_list.pop(element_number)
        for line in raw_list:
            if "add_core_of" in line:
                core = line.split("=")[1]
                if "#" in core:
                    core = core.split("#")[0]
                core = core.strip()
                if core not in tags:
                    tags.append(core)
    return tags

from read_game_data.create_tags_file import create_tags_file
from read_game_data.create_provinces_file import create_provinces_file
from json import dump


tags = create_tags_file()
with open("tags.txt", "w") as json_file:
    dump(tags, json_file)
provinces_dict = create_provinces_file(tags)
with open("provinces.txt", "w") as json_file:
    dump(provinces_dict, json_file)