build.gradle

//file:noinspection GroovyAssignabilityCheck

plugins {
    id 'java-library'
    id 'net.fabricmc.fabric-loom' version '1.15.5' apply(false)
    id 'net.neoforged.moddev' version '2.0.141' apply(false)
    id "me.modmuss50.mod-publish-plugin" version "1.1.0"
}

tasks.named('wrapper', Wrapper).configure {
    distributionType = Wrapper.DistributionType.BIN
}

def isSnapshot = providers.environmentVariable("SNAPSHOT").map {it == "true"}.getOrElse(false)

version = mod_version + (isSnapshot ? '-SNAPSHOT' : '')
group = 'dev.wuffs'

allprojects {
    apply plugin: 'idea'
    apply plugin: 'java-library'
    apply plugin: 'maven-publish'

    version = mod_version

    tasks.withType(JavaCompile).configureEach {
        options.encoding = 'UTF-8'
        options.release = 25
    }

    idea {
        module {
            downloadSources = true
            downloadJavadoc = true
        }
    }

    jar {
        from(rootProject.file("LICENSE").toString()) {
            rename { "${it}_bettercompatabilitychecker" }
        }
    }
}

subprojects {
    base {
        archivesName = "$project.archives_base_name-$project.name"
    }

    repositories {
        maven {
            name = "Fuzs Mod Resources"
            url = "https://raw.githubusercontent.com/Fuzss/modresources/main/maven/"
        }
    }

    if (project.name != "common") {
        dependencies {
            api project(":common")
        }

        jar {
            from project(":common").sourceSets.main.output
        }
    }

    def replaceProperties = [
            minecraft_version: project.minecraft_version,
            minecraft_version_range_mvn: project.minecraft_version_range_mvn,
            minecraft_version_range_sem: project.minecraft_version_range_sem,
            neoforge_version: project.neoforge_version,
            neoforge_version_range: project.neoforge_version_range,
            loader_version_range: project.loader_version_range,
            fabric_api_version: project.fabric_api_version,
            fabric_api_version_range: project.fabric_api_version_range,
            fabric_loader_version: project.fabric_loader_version,
            fabric_loader_version_range: project.fabric_loader_version_range,
            version: version,
            mod_id: project.mod_id,
            mod_name: project.mod_name,
            mod_license: project.mod_license,
            mod_group_id: project.mod_group_id,
            mod_authors: project.mod_authors,
            mod_description: project.mod_description,
            mod_github: project.mod_github,
            pack_version: project.pack_version,
    ]

    processResources {
        inputs.properties replaceProperties

        filesMatching(["META-INF/neoforge.mods.toml", "fabric.mod.json", "META-INF/mods.toml", "pack.mcmeta"]) {
            expand replaceProperties
        }
    }

    publishing {
        repositories {
            maven {
                url "file://${project.projectDir}/repo"
            }
            if (providers.environmentVariable("NANITE_TOKEN").orNull) {
                maven {
                    url "${maven_url}${isSnapshot ? 'snapshots' : 'releases'}"
                    credentials {
                        username = "nanite"
                        password = providers.environmentVariable("NANITE_TOKEN").get()
                    }
                }
            }
        }
    }
}

publishMods {
    dryRun = providers.environmentVariable("CURSE_TOKEN").getOrNull() == null
    changelog = createChangelog()
    version = "${mod_version}"
    type = STABLE
    def compatibleMcVersions = additional_compatible_mc_versions.split(',')


    def createOptions = (String platform) -> {
        publishOptions {
            file = project.provider { project(":$platform").tasks.jar }.flatMap { it.archiveFile }
            displayName = "${mod_name} - ${platform} - ${mod_version}"
            modLoaders.add(platform.toLowerCase())
        }
    }

    def curseForgeOptions = curseforgeOptions {
        accessToken = providers.environmentVariable("CURSE_TOKEN")
        minecraftVersions.add("${minecraft_version}")
        compatibleMcVersions.each { mcVer ->
            minecraftVersions.add(mcVer.trim())
        }
        javaVersions.add(JavaVersion.VERSION_25)
    }

    def modrinthOptions = modrinthOptions {
        accessToken = providers.environmentVariable("MODRINTH_TOKEN")
        minecraftVersions.add("${minecraft_version}")
        compatibleMcVersions.each { mcVer ->
            minecraftVersions.add(mcVer.trim())
        }
    }

    curseforge("curseforgeNeoforge") {
        from(curseForgeOptions, createOptions("neoforge"))
        projectId = curseforge_id
        clientRequired = true
        serverRequired = true
    }

    curseforge("curseforgeFabric") {
        from(curseForgeOptions, createOptions("fabric"))
        projectId = curseforge_id
        requires("fabric-api")
        clientRequired = true
        serverRequired = true
    }

    modrinth("modrinthNeoforge") {
        from(modrinthOptions, createOptions("neoforge"))
        projectId = "${modrinth_id}"
    }

    modrinth("modrinthFabric") {
        from(modrinthOptions, createOptions("fabric"))
        projectId = "${modrinth_id}"
        requires("fabric-api")
    }

    github {
        accessToken = providers.environmentVariable("GITHUB_TOKEN")
        repository = "${github_repo}"
        commitish = providers.environmentVariable("GITHUB_SHA").orElse("dryRun")
        tagName = providers.environmentVariable("GITHUB_REF_NAME").orElse("dryRun")

        file = project.provider { project(":neoforge").tasks.jar }.flatMap { it.archiveFile }
        additionalFiles.from project.provider { project(":fabric").tasks.jar }.flatMap { it.archiveFile }
    }
}

def createChangelog() {
    def changelogFile = file("./CHANGELOG.md")
    if (!changelogFile.exists()) {
        return "No changelog available."
    }

    def changelogText = changelogFile.text
    def lines = changelogText.readLines()

    def output = ""
    def capture = false
    for (line in lines) {
        if (line.startsWith("## ")) {
            if (capture) {
                break
            }

            if (line.contains(project.version)) {
                capture = true
                continue
            }
        }

        if (capture) {
            output += line + "\n"
        }
    }

    return output.trim()
}