build.gradle

plugins {
    id "dev.architectury.loom-no-remap" version "1.14-SNAPSHOT" apply false
    id "architectury-plugin" version "3.5-SNAPSHOT"
    id "com.gradleup.shadow" version "9.4.+" apply false
    id "com.matthewprenger.cursegradle" version "1.4.0" apply false
    id "com.modrinth.minotaur" version "2.+" apply false
    id "minepkg-publish" version "latest.release" apply false
}

architectury {
    minecraft = rootProject.minecraft_version
}

allprojects {
    group = rootProject.maven_group
}

subprojects {
    apply plugin: 'dev.architectury.loom-no-remap'
    apply plugin: 'architectury-plugin'

    loom {
        runs {
            client {
                vmArgs "-Dmixin.debug.export=true -Dfabric-tag-conventions-v2.missingTagTranslationWarning=VERBOSE"
                programArgs "--username", "Test"
            }
        }
    }

    base {
        archivesName = project.archives_base_name
    }

    repositories {
        maven { url = "https://maven.shedaniel.me/" }
        maven { url = "https://maven.terraformersmc.com/" }
        maven { url = "https://jitpack.io" }
        mavenCentral()
        exclusiveContent {
            forRepository {
                maven {
                    name = "Modrinth"
                    url = "https://api.modrinth.com/maven"
                }
            }
            filter {
                includeGroup "maven.modrinth"
            }
        }
    }

    dependencies {
        minecraft "com.mojang:minecraft:${rootProject.minecraft_version}"
    }

    tasks.withType(JavaCompile).configureEach {
        it.options.release = project.java_version as Integer
    }

    java {
        targetCompatibility = sourceCompatibility = JavaVersion.toVersion(project.java_version as Integer)
    }

    processResources {
        def stringProperties = providers.gradlePropertiesPrefixedBy('').get()
        inputs.properties(stringProperties)

        filesMatching(["*.mixins.json", "*.mod.json*", "META-INF/*mods.toml"]) {
            expand(stringProperties) {
                escapeBackslash = true
            }
        }
    }

    def loader = project.name
    if (!enabled_platforms.split(',').contains(loader))
        return

    version = project.mod_version + "-" + loader +  "-" + project.minecraft_version

    def toList = (String s) -> s.split(',').collect{ it.trim() }

    def changesMd = rootProject.file('changes.md').exists() ? rootProject.file('changes.md').getText("UTF-8") : ''
    def projectGameVersions = toList(property("${loader}_game_version_list".toString()) as String)
    def capitalizedLoader = loader == 'neoforge' ? 'NeoForge' : loader.capitalize()

    apply plugin: 'com.gradleup.shadow'

    loom {
        accessWidenerPath = project(":common").loom.accessWidenerPath
    }

    configurations {
        common {
            canBeResolved = true
            canBeConsumed = false
        }
        compileClasspath.extendsFrom common
        runtimeClasspath.extendsFrom common

        // Files in this configuration will be bundled into your mod using the Shadow plugin.
        // Don't use the `shadow` configuration from the plugin itself as it's meant for excluding files.
        shadowBundle {
            canBeResolved = true
            canBeConsumed = false
        }
    }

    jar {
        archiveClassifier = "raw"
    }

    // see https://gist.github.com/shedaniel/18d4eebf940e9c3296e87d994ebb2838
    shadowJar {
        dependsOn(jar)
        mainSpec.sourcePaths.clear()       // Remove default source set inclusion
        from(zipTree(jar.archiveFile))     // Unpack jar output (preserves Loom modifications)

        configurations = [project.configurations.shadowBundle]
        archiveClassifier = null           // shadowJar becomes the main artifact
    }

    apply plugin: "com.modrinth.minotaur"

    modrinth {
        token = System.getenv("MODRINTH_TOKEN")
        projectId = project.modrinth_id
        versionName = project.mod_version
        versionNumber = project.version
        versionType = "release"
        uploadFile = shadowJar
        changelog = changesMd
        gameVersions = projectGameVersions
        loaders = [loader]
        dependencies {
            toList(project.modrinth_dependencies).each{ required.project(it) }
            if (loader == 'fabric') toList(project.modrinth_fabric_dependencies).each{ required.project(it) }
        }
    }

    apply plugin: "com.matthewprenger.cursegradle"

    curseforge {
        def token = System.getenv("CURSEFORGE_TOKEN")
        if (token != null) {
            apiKey = token
        }

        project {
            id = project.curseforge_id
            releaseType = "release"
            changelogType = "markdown"
            changelog = changesMd

            addGameVersion capitalizedLoader
            projectGameVersions.each{ addGameVersion(it) }

            relations {
                toList(project.curseforge_dependencies).each{ requiredDependency(it) }
                if (loader == 'fabric') toList(project.curseforge_fabric_dependencies).each{ requiredDependency(it) }
            }
            mainArtifact(shadowJar.archiveFile.get().asFile) { // needs to be configured after shadowJar
                displayName = "${project.mod_version} [${capitalizedLoader} ${versionRange(projectGameVersions)}]"
            }
            afterEvaluate {
                uploadTask.dependsOn("build")
            }
        }
        options {
            forgeGradleIntegration = false
            javaVersionAutoDetect = false
        }
    }

    if (loader != 'fabric')
        return

    apply plugin: "minepkg-publish"

    minepkg {
        def MINEPKG_TOKEN = System.getenv("MINEPKG_TOKEN")
        if (MINEPKG_TOKEN != null) {
            apiKey = MINEPKG_TOKEN
            artifact = shadowJar
            platform = loader
            name = project.minepkg_id
            version = project.mod_version + "+" + project.minecraft_version
            license = "MIT"
            minecraftVersionRange = project.fabric_game_version_range
            toList(project.minepkg_dependencies).each{ require(it) }
        }
    }
}

static String versionRange(List<String> gameVersions) {
    if (gameVersions.size() == 1)
        return gameVersions[0]

    def v0 = gameVersions.first()
    def v1 = gameVersions.last()

    def m0 = v0.split('[.]')[1]
    def m1 = v1.split('[.]')[1]

    if (m0 == m1)
        return v1

    return "${v0} - ${v1}"
}