fun chooseEgg(form: FormData, parents: Pair<Pokemon, Pokemon>): PokemonProperties {
    return PokemonProperties.Builder(form)
        .setParent1(parents.first.uuid)           // UUID первого родителя
        .setParent2(parents.second.uuid)          // UUID второго родителя
        .setIVs(calcStats(parents))               // Расчёт IV (уникальных параметров)
        .setNature(calcNature(parents))           // Характер
        .setAbility(calcAbility(form, parents))   // Способность
        .setCaughtBall(calcBall(parents))         // Покебол
        .setShiny(calcShiny(parents))             // Шайн-статус
        .setEggMoves(calcEggMoves(parents, form)) // Наследуемые приёмы
        .setAspects(calcAspects(parents))         // Аспекты (визуальные/сезонные)
        .build()                                   // Построение объекта потомка
}

private fun calcStats(parents: Pair<Pokemon, Pokemon>): IVs {
    // Создаём случайные IV для потомка
    val finalStats = IVs.createRandomIVs()

    // Извлекаем родителей из пары
    val (father, mother) = parents

    // Набор всех возможных характеристик (IV)
    val ivs = mutableSetOf(
        Stats.HP,
        Stats.ATTACK,
        Stats.DEFENCE,
        Stats.SPECIAL[/i]ATTACK,
        Stats.SPECIAL[/i]DEFENCE,
        Stats.SPEED
    )

    // Определяем, какие IV будут переданы с помощью удерживаемых предметов (Power Items)
    val ivsToChooseFrom = mapOf(
        Pair(father, powerItemToIV(father.heldItem().item)),
        Pair(mother, powerItemToIV(mother.heldItem().item))
    ).filterNot { it.value == null }

    // Временные переменные для текущего IV и родителя
    var iv: Stats
    var parent: Pokemon

    // Если ни у одного из родителей нет Power Item — выбираем случайную характеристику и случайного родителя
    if (ivsToChooseFrom.isEmpty()) {
        iv = ivs.random()
        parent = parents.random()
    } else {
        // Если Power Items есть у обоих — выбираем одного случайным образом и сохраняем соответствующий параметр
        val (pokemon, stat) = ivsToChooseFrom.toList().random()
        iv = stat!!
        parent = pokemon
    }

    // Устанавливаем выбранное значение IV у потомка
    parent.ivs[iv]?.let { finalStats[iv] = it }

    // Исключаем переданный параметр из списка оставшихся
    ivs.remove(iv)

    // Определяем, сколько параметров будет дополнительно унаследовано:
    // если есть узел судьбы (Destiny Knot) — 4 параметра, иначе — 2
    var ivCount =
        if (father.heldItem().item == CobblemonItems.DESTINY[/i]KNOT  |  |  mother.heldItem().item == CobblemonItems.DESTINY[/i]KNOT) 4
        else 2

    // Передаём оставшиеся характеристики, пока не будет достигнуто нужное количество
    while (ivCount != 0) {
        // Выбираем случайную характеристику из оставшихся
        iv = ivs.random()
        // Выбираем случайного родителя
        parent = parents.random()
        // Если у родителя есть значение IV — передаём его потомку
        parent.ivs[iv]?.let { finalStats[iv] = it }
        // Удаляем характеристику из оставшихся
        ivs.remove(iv)
        // Уменьшаем счётчик
        ivCount--
    }

    // Возвращаем сформированные IV потомка
    return finalStats
}

private fun calcNature(parents: Pair < Pokemon, Pokemon > ): Nature {
    // Извлекаем родителей
    val(father, mother) = parents

    // Проверяем, держит ли кто-то из родителей Камень вечности (Everstone)
    val parentsItems = mapOf(
        Pair(father, father.heldItem().item),
        Pair(mother, mother.heldItem().item)
    ).filterNot {
        it.value != CobblemonItems.EVERSTONE
    }

    // Если ни у кого нет Everstone — возвращаем случайный характер
    if (parentsItems.isEmpty())
        return Natures.getRandomNature()

    // Иначе выбираем одного из родителей с Everstone и передаём его характер
    return parentsItems.toList().random().first.nature
}

private fun calcAbility(form: FormData, parents: Pair<Pokemon, Pokemon>): String {
    val (father, mother) = parents

    // Определяем родителя, от которого будет передаваться способность:
    // если в паре участвует Дитто — используем второго родителя,
    // если нет — используем мать.
    val ancestor =
        if (mother.species == getByName("ditto")) father
        else mother
    val oldAbility = ancestor.ability

    // Если способность "заставлена" (forced) и соответствующая настройка включена,
    // то возвращаем её напрямую, без шанса.
    // Однако по умолчанию (если настройка отключена), это поведение игнорируется.
    return if (oldAbility.forced && Cobbreeding.config.forcedAbilitiesEnabled) oldAbility.name
    else {
        // Получаем приоритет и индекс способности родителя.
        // Если индекс определён (≥ 0), используем его напрямую.
        val (priority, index) = if (oldAbility.index >= 0) Pair(oldAbility.priority, oldAbility.index)
        else {
            // Если индекс не задан, пытаемся определить его вручную:
            // ищем в мапе способностей ту, что соответствует шаблону родителя.
            // Если не находим — по умолчанию берём 0 и наименьший приоритет.
            val entry = ancestor.form.abilities.mapping.entries.firstOrNull { ([/i], abilities) ->
                abilities.map { it.template }.contains(oldAbility.template)
            }
            entry?.run {
                Pair(key, value.map { it.template }.indexOf(oldAbility.template))
            } ?: Pair(Priority.LOWEST, 0)
        }

        // Определяем унаследованную способность:
        // 1) сперва пытаемся взять способность на той же позиции и с тем же приоритетом;
        // 2) если не находим — берём первую из этого приоритета;
        // 3) если и тут не находим — первую из самого низкого приоритета;
        // 4) если вообще ничего нет — подставляем "заглушку" (DUMMY).
        val inheritedAbility = form.abilities.mapping[priority]?.getOrNull(index)?.template ?: 
                               form.abilities.mapping[priority]?.firstOrNull()?.template ?:  
                               form.abilities.mapping[Priority.LOWEST]?.firstOrNull()?.template ?:  
                               Abilities.DUMMY

        // Формируем список возможных альтернативных способностей (не совпадающих с inheritedAbility).
        // Если скрытые способности разрешены — используем все приоритеты.
        // Если запрещены — исключаем способности с приоритетом LOW (скрытые).
        val remainingAbilities =
            if (Cobbreeding.config.hiddenAbilitiesEnabled)
                form.abilities.mapping.values
                    .flatten()
                    .map { it.template }
                    .filterNot { it == inheritedAbility }
            else
                form.abilities.mapping.values
                    .flatten()
                    .filterNot { it.priority == Priority.LOW }
                    .map { it.template }
                    .filterNot { it == inheritedAbility }

        // Определяем шанс сохранить способность родителя:
        // 60% для скрытых, 80% для остальных.
        val chance = when (priority) {
            Priority.LOW -> 6u  // 60% для приоритета LOW (Hidden)
            else -> 8u          // 80% для остальных
        }

        // Если список альтернатив пуст или шанс прошёл — оставляем способность родителя.
        // Иначе выбираем случайную из альтернативных.
        val template = if (remainingAbilities.isEmpty()  |  |  Random.nextUInt(10u) < chance) inheritedAbility
        else remainingAbilities.random()

        // Возвращаем имя итоговой способности
        return template.name
    }
}

Настройка hiddenAbilitiesEnabled в конфиге включена — скрытые способности передаются.
Настройка forcedAbilitiesEnabled по умолчанию выключена — «заставленные» способности игнорируются.

private fun calcBall(parents: Pair < Pokemon, Pokemon > ): String {
    var ball = parents.second.caughtBall // По умолчанию — Покебол матери

    // Если оба родителя одного вида — Покебол выбирается случайно от одного из них
    if (parents.first.species.name == parents.second.species.name)
        ball = parents.random().caughtBall

    // Если мать — Дитто, Покебол наследуется от отца
    if (parents.second.species.name == "Ditto")
        ball = parents.first.caughtBall

    // Некоторые Покеболы нельзя передать напрямую: заменяются на обычный
    if (ball == PokeBalls.CHERISH[/i]BALL  |  |  ball == PokeBalls.MASTER[/i]BALL)
        ball = PokeBalls.POKE[/i]BALL

    return ball.name.toString()
}

private fun calcShiny(parents: Pair<Pokemon, Pokemon>): Boolean? {
    // Получаем список включённых методов повышения шанса (из конфигурации)
    val shinyMethod = Cobbreeding.config.shinyMethod

    // Если shiny-статус отключён полностью — не рассчитываем, возвращаем null
    if ("disabled" in shinyMethod) return null

    // Множитель, на который делится шанс при срабатывании условий (по умолчанию: 4)
    val shinyMultiplier = Cobbreeding.config.shinyMultiplier

    // Базовый шанс получения шайни (по умолчанию: 1 / 8192)
    var shinyOdds = Cobblemon.config.shinyRate

    // Метод crystal: увеличивает шанс, если один или оба родителя — шайни
    if ("crystal" in shinyMethod) {
        // Если первый родитель — шайни
        if (parents.first.shiny)
            shinyOdds /= shinyMultiplier

        // Если второй родитель — шайни
        if (parents.second.shiny)
            shinyOdds /= shinyMultiplier
    }

    // Метод masuda: увеличивает шанс, если родители от разных оригинальных тренеров
    if ("masuda" in shinyMethod) {
        // Получаем UUID оригинальных тренеров обоих родителей
        val owner1 = parents.first.originalTrainer ?: parents.first.getOwnerPlayer()?.stringUUID
        val owner2 = parents.second.originalTrainer ?: parents.second.getOwnerPlayer()?.stringUUID

        // Если тренеры отличаются — делим шанс ещё раз
        if (owner1 != null && owner2 != null && owner1 != owner2)
            shinyOdds /= shinyMultiplier
    }

    // Если шанс меньше 1 (например, при методе "always") — потомок точно будет шайни
    if (shinyOdds < 1) return true

    // Генерируем случайное число от 0 до shinyOdds
    // Если выпадает 0 — потомок будет шайни
    return Random.nextInt(0, shinyOdds.toInt()) == 0
}

private fun calcEggMoves(parents: Pair < Pokemon, Pokemon > , child: FormData): List < String > {
    // Получаем список возможных яйцевых приёмов у данной формы потомка
    val possibleEggMoves = child.moves.eggMoves
    val eggMoves = LinkedList < String > ()

    // Перебираем каждого родителя
    for (parent in parents.toList()) {
        // Получаем все потенциально доступные приёмы (включая наследуемые, ТМ и по уровню)
        val allAccessibleMoves = parent.allAccessibleMoves.toMutableSet()

        // Добавляем текущие выученные приёмы
        for (move in parent.moveSet.getMoves())
            allAccessibleMoves += move.template

        // Сравниваем с яйцевыми приёмами потомка — добавляем совпадения
        for (accessibleMove in allAccessibleMoves) {
            if (possibleEggMoves.contains(accessibleMove))
                eggMoves.add(accessibleMove.name)
        }
    }

    // Специальный случай: если вылупляется Пичу и один из родителей держит Light Ball
    if (
        child.species.name == "Pichu" &&
        parents.toList().any {
            p - > p.heldItem().item == CobblemonItems.LIGHT[/i]BALL
        }
    )
        eggMoves.add("volttackle")

    return eggMoves
}

fun applyMirrorHerb(pokemon: List<Pokemon?>)
{
    // Ищем покемонов, держащих Mirror Herb
    for (holder in pokemon)
    {
        if (holder != null && holder.heldItem().item == CobblemonItems.MIRROR_HERB)
        {
            // Получаем список приёмов, которые этот покемон может получить при рождении
            val possibleEggMoves = getBaby(holder.form).moves.eggMoves

            // Перебираем всех других покемонов в загоне
            for (other in pokemon)
            {
                if (other != null)
                {
                    // Собираем все приёмы, к которым у них есть доступ
                    val allAccessibleMoves = other.allAccessibleMoves.toMutableSet()
                    for (move in other.moveSet.getMoves())
                        allAccessibleMoves.add(move.template)

                    // Если у другого покемона есть приём, совпадающий с возможностями holder'а — передаём
                    for (accessibleMove in allAccessibleMoves) {
                        if (possibleEggMoves.contains(accessibleMove))
                            holder.benchedMoves.add(BenchedMove(accessibleMove, 0))
                    }
                }
            }
        }
    }
}

private fun calcAspects(parents: Pair<Pokemon, Pokemon>): List<String> {
    // Определяем родителя, от которого будут унаследованы аспекты:
    // если второй родитель — Дитто, используем первого (отца),
    // иначе — второго (матери). Т.е. при наличии Дитто аспекты не берутся от него.
    val mother = if (parents.second.species == getByName("ditto")) parents.first else parents.second

    // Копируем все аспекты выбранного родителя (например, сезонные, пользовательские и т.п.)
    val aspects = mother.aspects.toMutableList()

    // Удаляем аспекты, которые не должны передаваться:
    // shiny — рассчитывается отдельно;
    // male/female — определяется системой пола.
    aspects.remove("shiny")
    aspects.remove("male")
    aspects.remove("female")

    // Возвращаем оставшиеся аспекты — они будут применены к потомку
    return aspects
}

Определение возможных яиц

fun getPossibleEggs(pokemon: List<Pokemon>): Collection<Map.Entry<FormData, List<Pair<Pokemon, Pokemon>>>> {
    // Словарь, где ключ — форма потенциального потомка, значение — список родительских пар
    val eggs = HashMap<FormData, MutableList<Pair<Pokemon, Pokemon>>>()

    // Перебираем все возможные уникальные пары покемонов
    for (i in pokemon.indices) {
        for (j in i + 1 until pokemon.size) {
            val pokemon1 = pokemon[i]
            val species1 = pokemon1.species
            val eggGroups1 = species1.eggGroups

            val pokemon2 = pokemon[j]
            val species2 = pokemon2.species
            val eggGroups2 = species2.eggGroups

            // Проверяем, что оба покемона не находятся в группе Undiscovered
            // (такие покемоны не могут размножаться вообще)
            if (!eggGroups1.contains(EggGroup.UNDISCOVERED) && !eggGroups2.contains(EggGroup.UNDISCOVERED)) {

                // Если один из покемонов — Дитто
                if (eggGroups1.contains(EggGroup.DITTO)) {
                    // Потомок формируется от второго покемона
                    dittoBreed(pokemon2)?.let {
                        // Добавляем пару (отец, мать) в список потомков соответствующей формы
                        if (eggs.containsKey(it)) eggs[it]?.add(Pair(pokemon2, pokemon1))
                        else eggs[it] = mutableListOf(Pair(pokemon2, pokemon1))
                    }
                } else if (eggGroups2.contains(EggGroup.DITTO)) {
                    dittoBreed(pokemon1)?.let {
                        if (eggs.containsKey(it)) eggs[it]?.add(Pair(pokemon1, pokemon2))
                        else eggs[it] = mutableListOf(Pair(pokemon1, pokemon2))
                    }
                }

                // Если оба покемона НЕ Дитто и их группы яиц пересекаются
                else if (eggGroups1.any(eggGroups2::contains)) {
                    // Женщина-самка слева
                    if (pokemon1.gender == Gender.FEMALE && pokemon2.gender == Gender.MALE) {
                        // Вид потомка определяется по самке
                        getBaby(pokemon1).let {
                            if (eggs.containsKey(it)) eggs[it]?.add(Pair(pokemon2, pokemon1))
                            else eggs[it] = mutableListOf(Pair(pokemon2, pokemon1))
                        }
                    }
                    // Женщина-самка справа
                    else if (pokemon2.gender == Gender.FEMALE && pokemon1.gender == Gender.MALE) {
                        getBaby(pokemon2).let {
                            if (eggs.containsKey(it)) eggs[it]?.add(Pair(pokemon1, pokemon2))
                            else eggs[it] = mutableListOf(Pair(pokemon1, pokemon2))
                        }
                    }
                }
            }
        }
    }

    // Специальный случай: Нидоран♀ и Нидоран♂ — всегда выводятся вместе
    if (eggs.containsKey(getByName("nidoranf")!!.standardForm)) {
        eggs[getByName("nidoranm")!!.standardForm] = eggs[getByName("nidoranf")!!.standardForm]!!
    } else if (eggs.containsKey(getByName("nidoranm")!!.standardForm)) {
        eggs[getByName("nidoranf")!!.standardForm] = eggs[getByName("nidoranm")!!.standardForm]!!
    }

    // То же самое для Volbeat и Illumise — возможны оба результата
    if (eggs.containsKey(getByName("illumise")!!.standardForm)) {
        eggs[getByName("volbeat")!!.standardForm] = eggs[getByName("illumise")!!.standardForm]!!
    } else if (eggs.containsKey(getByName("volbeat")!!.standardForm)) {
        eggs[getByName("illumise")!!.standardForm] = eggs[getByName("volbeat")!!.standardForm]!!
    }

    // Возвращаем мапу: форма → список допустимых родительских пар
    return eggs.mapValues { (_, v) -> v.toList() }.entries
}

Определение формы потомка

fun getBaby(pokemon: FormData): FormData {
    // Переход к базовому виду — пока у текущего вида есть предэволюция
    var species = pokemon.species
    while (species.preEvolution != null) {
        species = species.preEvolution!!.species
    }

    // Обработка исключений для региональных форм:
    // У этих форм потомок — не стандартная базовая форма, а конкретный слот формы
    if (pokemon.species.name == "Sirfetch’d" ||
        pokemon.species.name == "Cursola" ||
        pokemon.species.name == "Obstagoon" ||
        pokemon.species.name == "Runerigus" ||
        pokemon.species.name == "Clodsire" ||
        pokemon.species.name == "Overqwil" ||
        pokemon.species.name == "Sneasler")
        return species.forms[1]

    // Исключения, у которых потомок — третья форма (слот 2)
    if (pokemon.species.name == "Perrserker" ||
        pokemon.species.name == "Basculegion")
        return species.forms[2]

    // В остальных случаях: ищем подходящую форму по showdownId
    return species.forms.find {
        it.formOnlyShowdownId().contains(pokemon.formOnlyShowdownId())
    } ?: species.standardForm
}