build.gradle

import org.jetbrains.changelog.Changelog

plugins {
    id "architectury-plugin" version "3.4-SNAPSHOT"
    id "dev.architectury.loom" version "1.7-SNAPSHOT" apply false
    id "me.modmuss50.mod-publish-plugin" version "0.+"
    id 'org.jetbrains.changelog' version '2.+'
}

subprojects {
    apply plugin: "dev.architectury.loom"

    loom {
        silentMojangMappingsLicense()
        accessWidenerPath.set(project(":common").file("src/main/resources/servercore.accesswidener"))
    }

    repositories {
        maven { url "https://oss.sonatype.org/content/repositories/snapshots" }
        mavenCentral()
    }

    dependencies {
        minecraft "com.mojang:minecraft:${project.minecraft}"
        mappings loom.officialMojangMappings()

        // Spark API
        compileOnly "me.lucko:spark-api:${project.spark_api}"

        // Configuration
        compileOnly "org.yaml:snakeyaml:${project.snakeyaml}"
        compileOnly "space.arim.dazzleconf:dazzleconf-core:${project.dazzleconf}"
        compileOnly "space.arim.dazzleconf:dazzleconf-ext-snakeyaml:${project.dazzleconf}"

        // Mixin Extras
        compileOnly(annotationProcessor("io.github.llamalad7:mixinextras-common:${project.mixin_extras}"))
    }
}

allprojects {
    apply plugin: "java"
    apply plugin: "architectury-plugin"
    apply plugin: "maven-publish"

    var formattedVersion = "${mod_version}+${minecraft}"
    archivesBaseName = project.archives_base_name

    version = formattedVersion
    group = project.maven_group

    tasks.withType(JavaCompile).configureEach {
        options.encoding = "UTF-8"
        options.release.set(21)
    }

    tasks.withType(org.gradle.jvm.tasks.Jar).configureEach {
        archiveVersion.set(formattedVersion)
    }

    java.toolchain.languageVersion = JavaLanguageVersion.of(21)
}

publishMods {
    changelog = fetchChangelog()
    type = STABLE

    def nameFormat = "ServerCore %s ${version.get()}"
    def fabric = findProject(':fabric')
    def neoforge = findProject(':neoforge')

    def curseforgeOpts = curseforgeOptions {
        accessToken = providers.environmentVariable("CURSEFORGE_TOKEN")
        minecraftVersions.add(project.minecraft)
        projectId = "550579"
    }

    def modrinthOpts = modrinthOptions {
        accessToken = providers.environmentVariable("MODRINTH_TOKEN")
        minecraftVersions.add(project.minecraft)
        projectId = "4WWQxlQP"
    }

    if (fabric != null) {
        def fabricJar = fabric.remapJar.archiveFile

        curseforge("CurseForge - Fabric") {
            from curseforgeOpts
            file = fabricJar
            modLoaders.add("fabric")
            displayName = nameFormat.formatted("Fabric")
        }

        modrinth("Modrinth - Fabric") {
            from modrinthOpts
            file = fabricJar
            modLoaders.add("fabric")
            displayName = nameFormat.formatted("Fabric")
        }
    }

    if (neoforge != null) {
        def neoforgeJar = neoforge.remapJar.archiveFile

        curseforge("CurseForge - NeoForge") {
            from curseforgeOpts
            file = neoforgeJar
            modLoaders.add("neoforge")
            displayName = nameFormat.formatted("NeoForge")
        }

        modrinth("Modrinth - NeoForge") {
            from modrinthOpts
            file = neoforgeJar
            modLoaders.add("neoforge")
            displayName = nameFormat.formatted("NeoForge")
        }
    }

    dryRun = curseforgeOpts.get().accessToken.getOrNull() == null || modrinthOpts.get().accessToken.getOrNull() == null
}

private String fetchChangelog() {
    def log = getChangelog.changelog.get()
    if (log.has(project.mod_version)) {
        return log.renderItem(
                log.get(project.mod_version).withHeader(false),
                Changelog.OutputType.MARKDOWN
        )
    } else {
        return ""
    }
}