# сгенерировать случайный набор генов (генотип):
    def generate_random_genes(self):
        dbg = DBG_rogue_generate_random_genes

        self.my_genes[0] = randrange(0, len(RIGHT_HANDS))    # <-- для правой руки:
        self.my_genes[1] = randrange(0, len(LEFT_HANDS))     # <-- для левой руки:
        self.my_genes[2] = randrange(0, len(GLOVES))         # <-- для рукавиц:
        self.my_genes[3] = randrange(0, len(HEADS))          # <-- для головы:
        self.my_genes[4] = randrange(0, len(CHESTS))         # <-- для нагрудника:
        self.my_genes[5] = randrange(0, len(PANTS))          # <-- для штанов:
        self.my_genes[6] = randrange(0, len(BOOTS))          # <-- для обуви:

        if dbg:  # для отладки:
            print('\nf "generate_random_genes":' + '\n\tgenes generated:\n\t', end='')
            print(self.my_genes)


    # унаследовать родительские гены с вероятностью мутации:
    def mutate_genes(self, parent_genes):
        dbg = DBG_rogue_mutate_genes

        # взять за основу родительские гены:
        self.my_genes = parent_genes.copy()

        # произойдёт ли мутация вообще:
        event_mutation = randint(1, 10)

        # если мутация НЕ должна произойти, больше тут делать нечего:
        if event_mutation == 10:
            if dbg:  # для отладки:
                print('\nf "mutate_genes" начата и окончена:' + '\n\tмутация НЕ состоялась\n\told genes: ', end='')
                print(parent_genes)
                print('\tnew genes: ', end='')
                print(self.my_genes)
            return 0

        # если мутация должна произойти:
        else:
            # определить "силу" мутации = количество генов, которые должны мутировать:
            mutation_volume = randint(0, 30)
            mutation_iters = 1
            if 22 <= mutation_volume <= 28:
                mutation_iters = 2
            elif 29 <= mutation_volume <= 30:
                mutation_iters = 3

            if dbg:  # для отладки:
                print('\nf "mutate_genes" начата:' + '\n\tмутаций запланировано: ' + str(mutation_iters))

            # список генов, доступных для мутации:
            genes_available = [0, 1, 2, 3, 4, 5, 6]

            # список мутировавших генов:
            genes_mutated = []

            current_iter = 0
            while current_iter < mutation_iters:
                if dbg:  # для отладки:
                    print('\tw1')

                # выбрать случайный ген из доступных:
                gene_with_forced_mutation = choice(genes_available)

                # если этот ген ещё не мутировал:
                if gene_with_forced_mutation not in genes_mutated:
                    self.mutate_gene(gene_with_forced_mutation)
                    genes_mutated.append(gene_with_forced_mutation)
                    current_iter += 1
                    if dbg:  # для отладки:
                        print('\tcurrent_iter =', current_iter)
                else:
                    if dbg:  # для отладки:
                        print('\telse, because ' + str(gene_with_forced_mutation) + ' already in genes_mutated')

        if dbg:  # для отладки:
            genes_mutated_str = ''
            if len(genes_mutated) > 1:
                for x in genes_mutated:
                    genes_mutated_str += str(x) + ', '
            else:
                genes_mutated_str = str(genes_mutated[0])
            print('\nf "mutate_genes" окончена:' + '\n\told genes: ', end='')
            print(parent_genes)
            print('\tgenes_mutated: ' + genes_mutated_str)
            print('\tnew genes: ', end='')
            print(self.my_genes)


    # произвести мутацию в указанном гене, изменив его значение на любое другое:
    def mutate_gene(self, gene_id):
        dbg = DBG_rogue_mutate_gene

        current_value = self.my_genes[gene_id]
        new_value = current_value

        if dbg:  # для отладки:
            print('\nf "mutate_gene":' + '\n\tgene_id: ' + str(gene_id) + '\n\told gene value: ' + str(current_value))

        tries = 0
        while new_value == current_value:
            if dbg and tries > 0:  # для отладки:
                print('\tw2, because ' + str(new_value) + ' = ' + str(current_value) )
            new_value = randrange(0, len(LINKS_TO_EQUIP_DICTS[gene_id]))
            self.my_genes[gene_id] = new_value
            tries += 1

        if dbg:  # для отладки:
            print('\tnew gene value: ' + str(new_value) + '\n\ttries: ' + str(tries))

    # "применить" гены (генотип) путём надевания обусловленной ими экипировки:
    def apply_genes(self):
        dbg = DBG_rogue_apply_genes

        pointer = 0
        for item_id in self.my_genes:
            self.wear_item(pointer, item_id, LINKS_TO_EQUIP_DICTS[pointer])
            pointer += 1

        if dbg:  # для отладки:
            print('\nf "apply_genes":' + '\n\tприменено.')
            print(self)

    # метод для расчёта собственного рейтинга:
    def calculate_rate(self):
        dbg = DBG_rogue_calculate_rate

        # вычислить вероятность попадания:
        p_hit = self.stat_hit / 100

        # вычислить вероятность скользящего и НЕскользящего удара:
        p_glancing = self.stat_glancing_percent / 100
        not_p_glancing = 1 - self.stat_glancing_percent / 100

        # вычислить вероятность критического и НЕкритического удара:
        p_crit = self.stat_crit / 100
        not_p_crit = 1 - self.stat_crit / 100

        # вычислить ожидание модификатора:
        expectation_modificator = p_hit * (p_glancing * 0.7 + not_p_glancing * (p_crit * 2 + not_p_crit))

        # вычислить ожидание урона с таким модификатором:
        expectation_damage = expectation_modificator * self.stat_attackpower
        expectation_damage = round(expectation_damage, 3)

        if dbg:
            print('\tожидание модификатора =', expectation_modificator)
            print('\tожидание урона =', expectation_damage)

        return expectation_damage

    # оформить победу в дуэли:
    def embody_win(self):
        dbg = DBG_rogue_embody_win

        self.my_wins += 1
        stats.genes_add_win(self.my_genes)

        # после каждой второй победы:
        if self.my_wins % population.wins_to_reproduce == 0:

            # определить число рождаемых потомков:
            total_borns = choice(population.possible_birth_quantities)
            if dbg:
                print('рождений будет ' + str(total_borns))

            for x in range(0, total_borns):
                if dbg:
                    print(self.name + ' рожает потомка...')

                # родить разбойника-потомка:
                new_rogue = Rogue(self.my_genes, self.my_generation, from_parent=True)
                ROGUES_LIST.append(new_rogue)

            Population.day_of_last_changes = current_day

        # обновить рекорд количества побед у одного разбойника в популяции:
        if self.my_wins > Population.record_max_wins:
            Population.record_max_wins = self.my_wins
            Population.max_winner_name = self.name
            Population.max_winner_genes = self.my_genes


    # оформить поражение в дуэли:
    def embody_defeat(self):
        dbg = DBG_rogue_embody_defeat

        self.my_defeats += 1

        # после двух поражений выпилиться:
        if self.my_defeats == population.defeats_to_die:
            self.alive = False
            Population.how_many_rogues_alive -= 1
            Population.day_of_last_changes = current_day

            if dbg:
                print(self.name + ' выпиливается...')

    def __init__(self, genes_list_inherited, parent_generation, from_parent=True, genes_can_mutate=True):

        # инициализация списка слотов экипировки, который должен содержать id надетых предметов:
        # 0 - правая рука, 1 - левая рука, 2 - перчатки, 3 - голова, 4 - грудь, 5 - штаны, 6 - обувь
        self.equipment_slots = [0] * 7

        # инициализация списка слотов экипировки, который должен содержать названия надетых предметов:
        self.equipment_names = ['ничего'] * 7

        # БАЗОВЫЕ значения характеристик (они - точка отсчёта при смене экипировки):
        self.basic_stat_agility = 50
        self.basic_stat_power = 40
        self.basic_stat_hit = 80
        self.basic_stat_crit = 20
        self.basic_stat_mastery = 0

        # рассчитать текущие характеристики без вещей:
        self.set_stats_without_equip()

        # статистические счётчики:
        Population.how_many_rogues += 1
        Population.how_many_rogues_alive += 1

        # номер поколения:
        self.my_generation = parent_generation + 1
        if self.my_generation > Population.generations:
            Population.generations = self.my_generation

        # "имя" разбойника:
        self.name = '"' + str(Population.how_many_rogues) + '-й, из поколения ' + str(parent_generation + 1) + '"'

        # жив ли:
        self.alive = True

        # счётчики побед и поражений:
        self.my_wins = 0
        self.my_defeats = 0

        # инициализировать цепочку генов:
        self.my_genes = [0] * 7

        if genes_can_mutate:
            # если этот разбойник порождён другим разбойником, его гены должны незначительно мутировать:
            if from_parent:
                self.mutate_genes(genes_list_inherited)
            else:
                self.generate_random_genes()
        else:
            self.my_genes = genes_list_inherited

        # отобразить эти гены в статистике:
        stats.genes_add_presence(self.my_genes, self.my_generation)

        # надеть экипировку согласно полученным генам:
        self.apply_genes()

class Population():
    """Класс используется для работы с популяцией."""

    how_many_rogues = 0 # <-- счётчик всех разбойников
    how_many_rogues_alive = 0 # <-- счётчик живых разбойников
    how_many_battles = 0 # <-- счётчик битв
    how_many_ties = 0 # <-- счётчик ничьих
    generations = 0 # <-- счётчик поколений
    day_of_last_changes = 0  # <-- день последних изменений в изменении численности популяции
    max_days_without_changes = 0  # <-- счётчик дней без изменений

    # рекорд количества побед у одного разбойника в популяции, а также его имя и генотип:
    record_max_wins = 0
    max_winner_name = 'none'
    max_winner_genes = 'none'


    # при создании популяции сразу же наполнить её:
    def __init__(self, total, possible_birth_quantities, wins_to_reproduce, defeats_to_die):

        # запомнить начальное значение:
        self.initial_size = total

        # сохранить биологические параметры, которые будут справедливы для каждого разбойника в популяции:
        self.wins_to_reproduce = wins_to_reproduce
        self.defeats_to_die = defeats_to_die
        self.possible_birth_quantities = possible_birth_quantities

        while total > 0:

            # создать нового разбойника, передав "пустой генотип" и отметку о том, что ему нужно сгенерировать гены:
            new_rogue = Rogue('', 0, from_parent=False)

            # пополнить список разбойников:
            ROGUES_LIST.append(new_rogue)

            total -= 1


    # вывести актуальную информацию о популяции:
    def __str__(self):
        text = 'Популяция:\n'
        text += 'поколений: ' + str(Population.generations) + '\n'
        text += 'всего агентов: ' + str(Population.how_many_rogues) + '\n'
        text += 'живых агентов: ' + str(Population.how_many_rogues_alive) + '\n'
        text += 'рекорд побед: ' + str(Population.record_max_wins) + '\n'
        text += 'имя рекордсмена: ' + str(Population.max_winner_name) + '\n'
        text += 'генотип рекордсмена: ' + str(Population.max_winner_genes) + '\n'
        return text


    # перезагрузить популяцию, оставив в ней how_many_to_save разбойников с наиболее успешными генотипами:
    def reload(self, how_many_to_save):

        # обнулить кол-во разбойников:
        Population.how_many_rogues_alive = 0

        # "убить" всех существующих разбойников:
        for x in ROGUES_LIST:
            x.alive = False

        # извлечь из словаря генотипов данные о лучших генотипах:
        list_genotypes_top = stats.get_ordered_list_from_dict(LIST_FOR_DICTS_GENOTYPES[current_stage], inner_index=2)

        # наполнить популяцию разбойниками с этими генотипами:
        for x in range(0, how_many_to_save):

            # преобразовать генотип из строки в список:
            genotype_in_str = list_genotypes_top[x][0]
            genotype_in_list = []
            for char in genotype_in_str:
                if char != '-':
                    genotype_in_list.append( int(char) )

            # создать нового разбойника, передав генотип и отметку о том, что гены НЕ должны мутировать:
            new_rogue = Rogue(genotype_in_list, 0, from_parent=True, genes_can_mutate=False)

            # пополнить список разбойников:
            ROGUES_LIST.append(new_rogue)

class Challenger():
    """Класс обеспечивает проведение боёв между случайными разбойниками."""

    # провести серию боёв:
    def perform_battles(self):
        dbg = DBG_challenger_perform_battles

        # создать список живых разбойников:
        rogues_alive = []
        for x in ROGUES_LIST:
            if x.alive:
                rogues_alive.append(x)

        # перемешать список:
        shuffle(rogues_alive)

        # получить количество пар живых разбойников в популяции:
        pairs_total = int(len(rogues_alive) // 2)

        if dbg:
            print('pairs_total =', pairs_total)

        # запускать бои между соседними по списку разбойниками:
        counter = 0
        pointer = 0
        while counter < pairs_total:
            a_1 = rogues_alive[pointer]
            a_2 = rogues_alive[pointer + 1]
            self.perform_battle(a_1, a_2)
            counter += 1
            pointer += 2


    # провести бой между двумя разбойниками:
    def perform_battle(self, rogue_1, rogue_2):
        dbg = DBG_challenger_perform_battle

        if dbg:
            print('\nновый бой между:', rogue_1.name, 'и', rogue_2.name)

        # рассчитать рейтинг каждого разбойника (в более совершенной симуляции тут может быть полноценное сражение):
        rating_1 = rogue_1.calculate_rate()
        rating_2 = rogue_2.calculate_rate()

        # счётчик боёв:
        Population.how_many_battles += 1

        if dbg:
            print('\tих рейтинг:', rating_1, 'и', rating_2, 'соответственно.')

        # раскидать очки между победителем и проигравшим:
        if rating_1 > rating_2:
            rogue_1.embody_win()
            rogue_2.embody_defeat()
        elif rating_1 < rating_2:
            rogue_1.embody_defeat()
            rogue_2.embody_win()
        else:
            Population.how_many_ties += 1
            if dbg:
                print('\tО чудо! Произошла ничья!')

# КОНСТАНТЫ:
MAX_STAGES = 8 # <-- сколько стадий перезагрузки популяции должно пройти
MAX_DAYS_AT_STAGE = 20 # <-- сколько дней будет содержать одна стадия перезагрузки популяции
SLIDING_FREQUENCY = 10 # <-- как часто нужно создавать HTML-слайды с полями генотипов (1 = раз в день, 10 = раз в 10 дней)
ROGUES_AT_BEGIN = 10 # <-- начальное население популяции (для каждой стадии)
WINS_TO_REPRODUCE = 2 # <-- сколько побед разбойнику нужно одержать, чтобы размножиться
DEFEATS_TO_DIE = 2 # <-- сколько поражений приведёт разбойника к смерти
POSSIBLE_BIRTH_QUANTITIES = [1] # <-- варианты количеств потомков, которые могут родиться у разбойника за раз, например:
# [1, 2] означает, что с 50%-ной вероятностью родится либо 1, либо 1 потомка
# [1, 1, 2] означает, что с 66%-ной вероятностью родится 1 потомок

HTML_GSQUARE_SIDE = 10 # <-- ширина стороны квадратика, обозначающего генотип в интерактивном отчёте
HTML_GSQUARE_MARGIN = 3 # <-- отступы между квадратиками, обозначающими генотип в интерактивном отчёте

# список ссылок на словари экипировки:
LINKS_TO_EQUIP_DICTS = [RIGHT_HANDS, LEFT_HANDS, GLOVES, HEADS, CHESTS, PANTS, BOOTS]

# список для хранения словарей со статистикой по генотипам (отдельный словарь для каждой стадии):
LIST_FOR_DICTS_GENOTYPES = [{}] * MAX_STAGES

# словарь для хранения перечня всех появившихся разновидностей генотипов:
DICT_UNIQUE_GENOTYPES = {}

# словарь для хранения статистики по дням:
DICT_DAYS = {}

# список, где будут храниться ссылки на всех когда-либо появившихся разбойников:
ROGUES_LIST = list()

# переменная для хранения значения текущей стадии (должна находиться в глобальной области видимости)
current_stage = 0

# КОНСТАНТЫ для точечного управления "отладкой" (выводом отчётов о работе функций/методов):
DBG_rogue_mutate_genes = False
DBG_rogue_generate_random_genes = False
DBG_rogue_apply_genes = False
DBG_rogue_calculate_rate = False
DBG_rogue_mutate_gene = False
DBG_rogue_embody_win = False
DBG_rogue_embody_defeat = False
DBG_rogue_wear_item = False
DBG_challenger_perform_battles = False
DBG_challenger_perform_battle = False
DBG_days_report = False  # <-- общий отчёт о каждом дне



# ЗАПУСК:
if __name__ == '__main__':

    # засечь время:
    time_begin = time()

    # запустить цикл на указанное количество стадий перезагрузки популяции:
    max_days_for_current_stage = 0
    current_day = 1
    while current_stage < MAX_STAGES:

        # на старте первой стадии:
        if current_stage == 0:

            # создать объект статистики:
            stats = Stats()

            # создать объект популяции и наполнить его разбойниками в указанном количестве, а также указать их биологические параметры:
            population = Population(ROGUES_AT_BEGIN, POSSIBLE_BIRTH_QUANTITIES, wins_to_reproduce=WINS_TO_REPRODUCE, defeats_to_die=DEFEATS_TO_DIE)

            # создать объект для управления состязаниями:
            challenger = Challenger()

            # "прочитать" популяцию:
            print(population)

        # высчитать новый максимум с учётом наступления новой стадии:
        max_days_for_current_stage += MAX_DAYS_AT_STAGE

        # запустить/продолжить цикл на доступное количество дней (1 день = 1 столкновение у каждого (почти*) разбойника)
        # * - когда в популяции в какой-то день нечётное количество разбойников, кто-то из них остаётся без пары и не дерётся в этот день
        while current_day <= max_days_for_current_stage:
            print('st ' + str(current_stage) + ', day ' + str(current_day))
            if DBG_days_report:
                print('\n\nДЕНЬ/DAY', current_day)

            # выполнить серию соревнований:
            challenger.perform_battles()

            if DBG_days_report:
                print('\nДень', current_day, 'завершён.')
                print(population)

            # статистика для этого дня:
            stats.add_new_day(current_day)

            # сколько дней подряд нет изменений в численности популяции:
            if current_day - Population.day_of_last_changes > Population.max_days_without_changes:
                Population.max_days_without_changes = current_day - Population.day_of_last_changes

            # в конце каждого SLIDING_FREQUENCY дня (а также в первый и последний) отрисовывать слайды по распространённости генотипов:
            if current_day % SLIDING_FREQUENCY == 0 or current_day == 1 or current_day == MAX_DAYS_AT_STAGE * MAX_STAGES:
                stats.draw_genes_distribution(current_day)

            # в конце каждого SLIDING_FREQUENCY дня (а также в первый и последний) отрисовывать слайды по победам генотипов:
            if current_day % SLIDING_FREQUENCY == 0 or current_day == 1 or current_day == MAX_DAYS_AT_STAGE * MAX_STAGES:
                stats.draw_genes_wins(current_day)

            current_day += 1

        # когда НЕпоследняя стадия подходит к концу, перезагрузить популяцию, оставив в ней указанное кол-во лучших генотипов:
        if current_stage < MAX_STAGES - 1:
            population.reload(ROGUES_AT_BEGIN)

        current_stage += 1


    # теперь понизить назад счётчик текущей стадии, чтобы удобно работать со списком LIST_FOR_DICTS_GENOTYPES:
    current_stage -= 1

    # вывести статистику дней:
    print('\nДНИ:')
    print(DICT_DAYS)

    # нарисовать график о динамике одновременно живущих разбойников:
    stats.draw_and_put_line_chart_to_file(DICT_DAYS, 1, 'живое население', 'дни', 'разбойников', 'charts/chart_population_demography.png')

    # нарисовать график о динамике общей численности когда-либо живших разбойников:
    stats.draw_and_put_line_chart_to_file(DICT_DAYS, 0, 'родившихся всего', 'дни', 'разбойников', 'charts/chart_population_total.png')

    # нарисовать график о динамике разнообразия генотипов:
    stats.draw_and_put_line_chart_to_file(DICT_DAYS, 2, 'разнообразие генотипов', 'дни', 'уникальных генотипов', 'charts/chart_genotypes_variety.png')

    # нарисовать график о динамике ничьих (= столкновение одинаковых генотипов):
    stats.draw_and_put_line_chart_to_file(DICT_DAYS, 3, 'динамика ничьих', 'дни', 'ничьих', 'charts/chart_genotypes_ties.png')

    # создать общий HTML для изучения сессии:
    stats.create_index_html()

    # вычислить затраченное время:
    time_session = time() - time_begin
    duration_info = 'работа программы длилась: ' + str(round(time_session, 2)) + ' сек.'
    print('\n' + duration_info)

else:
    print('__name__ is not "__main__".')

# Эти словари содержат перечни предметов соответствующего типа.
# Каждый элемент содержит кортеж, в котором значения означают следующее:
# 0 - название, 1 - атака, 2 - ловкость, 3 - сила, 4 - меткость, 5 - крит, 6 - мастерство

EQUIPMENT_COLLECTION = 'obvious_strong'

RIGHT_HANDS = dict()
RIGHT_HANDS[1] = ('Сильнейший меч', 5000, 0, 0, 0, 0, 0)
RIGHT_HANDS[2] = ('Средний меч', 800, 0, 0, 0, 0, 0)
RIGHT_HANDS[3] = ('Слабый меч', 20, 0, 0, 0, 0, 0)

LEFT_HANDS = dict()
LEFT_HANDS[1] = ('Сильнейший кинжал', 4000, 0, 0, 0, 0, 0)
LEFT_HANDS[2] = ('Слабый кинжал', 10, 0, 0, 0, 0, 0)

GLOVES = dict()
GLOVES[1] = ('Сильнейшие перчатки', 300, 0, 0, 0, 0, 0)
GLOVES[2] = ('Слабые перчатки', 1, 0, 0, 0, 0, 0)

HEADS = dict()
HEADS[1] = ('Сильнейший шлем', 300, 0, 0, 0, 0, 0)
HEADS[2] = ('Слабый шлем', 1, 0, 0, 0, 0, 0)

CHESTS = dict()
CHESTS[1] = ('Сильнейший нагрудник', 300, 0, 0, 0, 0, 0)
CHESTS[2] = ('Слабый нагрудник', 1, 0, 0, 0, 0, 0)

PANTS = dict()
PANTS[1] = ('Сильнейшие поножи', 300, 0, 0, 0, 0, 0)
PANTS[2] = ('Слабые поножи', 1, 0, 0, 0, 0, 0)

BOOTS = dict()
BOOTS[1] = ('Сильнейшие сапоги', 300, 0, 0, 0, 0, 0)
BOOTS[2] = ('Слабые сапоги', 1, 0, 0, 0, 0, 0)

        # выписать в список все делители числа-суммы генотипов:
        list_divisors = list()
        current_number = int(self.genotypes_total // 2)
        while current_number >= 2:
            if self.genotypes_total % current_number == 0:
                list_divisors.append(current_number)
            current_number -= 1
        print('list_divisors:', list_divisors)

        # взять индекс примерно из середины полученного списка делителей:
        somewhere_in_the_middle = len(list_divisors) // 2

        # получить длины сторон будущего прямоугольника:
        side_1 = list_divisors[somewhere_in_the_middle]
        side_2 = self.genotypes_total / side_1

        # определить, какая сторона длиннее, чтобы в будущем прямоугольник "положить" на бок:
        self.side_x = int(side_1 if side_1 >= side_2 else side_2)
        self.side_y = int(self.genotypes_total / self.side_x)
        print('side_x =', self.side_x, 'side_y =', self.side_y)

MAX_STAGES = 30
MAX_DAYS_AT_STAGE = 50
SLIDING_FREQUENCY = 100
ROGUES_AT_BEGIN = 20
WINS_TO_REPRODUCE = 2
DEFEATS_TO_DIE = 2
POSSIBLE_BIRTH_QUANTITIES = [1, 2]

HTML_GSQUARE_SIDE = 4
HTML_GSQUARE_MARGIN = 1

MAX_STAGES = 8
MAX_DAYS_AT_STAGE = 20
SLIDING_FREQUENCY = 10
ROGUES_AT_BEGIN = 10
WINS_TO_REPRODUCE = 2
DEFEATS_TO_DIE = 2
POSSIBLE_BIRTH_QUANTITIES = [1]

HTML_GSQUARE_SIDE = 10
HTML_GSQUARE_MARGIN = 3