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 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 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
}