build.gradle

import net.darkhax.curseforgegradle.TaskPublishCurseForge
import groovy.json.JsonSlurper

import java.net.http.HttpClient
import java.net.http.HttpRequest
import java.net.http.HttpResponse

plugins {
    id "fabric-loom" version "1.10-SNAPSHOT"
    id "com.modrinth.minotaur" version "2.+"
    id 'net.darkhax.curseforgegradle' version '1.1.23'
}

version = "${rootProject.mod_version}+${project.name}"
group = "me.gravityio"

def javaVersionNum = project.java_version.toInteger()
def javaVersion = JavaVersion.toVersion(javaVersionNum)
def supportedVersions = project.minecraft_versions.split(" ").toList()

base {
    archivesName = project.mod_id
}

loom {
    runConfigs.all {
        ideConfigGenerated true // Run configurations are not created for subprojects by default
        runDir "../../run" // Use a shared run folder and just create separate worlds
    }
}

if (project.name != "1.21.2") {
    configurations.configureEach {
        resolutionStrategy {
            force "com.twelvemonkeys.common:common-io:3.10.0"
            force "com.twelvemonkeys.common:common-lang:3.10.0"
            force "com.twelvemonkeys.common:common-image:3.10.0"

            force "com.twelvemonkeys.imageio:imageio-metadata:3.10.0"
            force "com.twelvemonkeys.imageio:imageio-webp:3.10.0"
            force "com.twelvemonkeys.imageio:imageio-core:3.10.0"
        }
    }
}


repositories {
    exclusiveContent {
        forRepository {
            maven {
                name = "Modrinth"
                url = "https://api.modrinth.com/maven"
            }
        }
        filter {
            includeGroup "maven.modrinth"
        }
    }
    maven {
        name 'Xander Maven'
        url 'https://maven.isxander.dev/releases'
    }
    maven {
        name = "Terraformers"
        url = "https://maven.terraformersmc.com/"
    }
    maven {
        name = 'ParchmentMC'
        url = 'https://maven.parchmentmc.org'
    }
}

project.dependencies.add("minecraft", "com.mojang:minecraft:${project.name}")
project.dependencies.add("mappings", loom.layered() {
    officialMojangMappings()
    parchment("org.parchmentmc.data:parchment-${project.parchment_version_mc}:${project.parchment_version}@zip")
})
project.dependencies.add("modImplementation", "net.fabricmc:fabric-loader:${rootProject.loader_version}")
// Optional
project.dependencies.add("modImplementation", "net.fabricmc.fabric-api:fabric-api:${project.fabric_version}")

dependencies {
    /*if (project.name == "1.21.2") {
        modImplementation("dev.isxander:yet-another-config-lib:${project.yacl_version}-fabric") {
            exclude group: "net.fabricmc.fabric-api"
        }
    } else*/ if (project.name == "1.20" || project.name == "1.20.2") {
        modImplementation("dev.isxander.yacl:yet-another-config-lib-fabric:${project.yacl_version}") {
            exclude group: "net.fabricmc.fabric-api"
        }
    } else {
        modImplementation("dev.isxander:yet-another-config-lib:${project.yacl_version}-fabric") {
            exclude group: "net.fabricmc.fabric-api"
        }
    }
    modImplementation("com.terraformersmc:modmenu:${project.modmenu_version}") {
        exclude group: "net.fabricmc.fabric-api"
    }
//    modCompileOnly "maven.modrinth:blur-fabric:${blur_version}"
//    modImplementation "maven.modrinth:iris:1.7.0+1.20.6"
}

tasks.register("depVersions") {
    group = "help"
    doLast {
        def projects = ["fabric-api", "modmenu", "yacl"]
        def client = HttpClient.newBuilder().build()
        for (aproject in projects) {
            def encLoaders = URLEncoder.encode("[\"fabric\"]", "UTF-8")
            def encVersions = URLEncoder.encode("[\"${project.name}\"]", "UTF-8")

            def query = "${aproject}/version?loaders=${encLoaders}&game_versions=${encVersions}"
            def uri = URI.create("https://api.modrinth.com/v2/project/${query}")
            def req = HttpRequest.newBuilder()
                    .uri(uri)
                    .header("User-Agent", "GravityCY/gradle_test_project/0.0.0")
                    .GET()
                    .build()

            def res = client.send(req, HttpResponse.BodyHandlers.ofString())
            def json = new JsonSlurper().parseText(res.body()) as List<Map<String, String>>
            println "Most recent version of ${aproject}: ${json[0].version_number}"
        }
    }
}

tasks.register('publishMod') {
    group = "publishing"

    dependsOn "publishCurseForge"
    dependsOn "modrinth"
}

tasks.register('publishCurseForge', TaskPublishCurseForge) {
    disableVersionDetection()

    group = "publishing"
    apiToken = System.getenv("CURSEFORGE_UPLOAD");

    def mainFile = upload(rootProject.curseforge_id, remapJar)
    mainFile.changelog = rootProject.changelog
    supportedVersions.forEach {
        mainFile.addGameVersion(it)
    }
    mainFile.addJavaVersion("Java ${javaVersionNum}")
    mainFile.displayName = "${rootProject.mod_name} ${project.version}"
    mainFile.addModLoader("Fabric")
    mainFile.releaseType = "release"
    mainFile.addRequirement("fabric-api", "yacl")
    mainFile.addOptional("modmenu")
    doLast {
        rootProject.ext.data.get(stonecutter.current.project).curseFileId = mainFile.curseFileId
    }
}

modrinth {
    token = System.getenv("MODRINTH_UPLOAD")
    projectId = rootProject.modrinth_id
    versionName = "${rootProject.mod_name} ${project.version}"
    versionNumber = project.version
    uploadFile = remapJar
    gameVersions = supportedVersions
    loaders = ["fabric"]
    delegate.changelog = rootProject.changelog
    dependencies {
        required.project "fabric-api"
        required.project "yacl"
        optional.project "modmenu"
    }
}

tasks.named("modrinth").configure {
    doLast {
        rootProject.ext.data.get(stonecutter.current.project).modrinthFileId = it.uploadInfo.id
    }
}

processResources  {
    def modProperties = [
            "mod_id": rootProject.mod_id,
            "mod_name": rootProject.mod_name,
            "mod_version": project.version,
            "mod_description": rootProject.mod_description,
            "mod_author": rootProject.mod_author,
            "mod_sources": rootProject.mod_sources,
            "mod_license": rootProject.mod_license,
            "loader_version": rootProject.loader_version,
            "minecraft_version_range": project.minecraft_version_range,
            "fabric_version": project.fabric_version,
            "yacl_version": project.yacl_version,
            "java_version": javaVersionNum
    ]

    def mixinProperties = [
            "java_version": javaVersionNum
    ]

    inputs.properties(modProperties)

    filesMatching("fabric.mod.json") {
        expand modProperties
    }
    filesMatching("itemio.compat.mixins.json") {
        expand mixinProperties
    }
    filesMatching("itemio.mixins.json") {
        expand mixinProperties
    }
}

tasks.withType(JavaCompile).configureEach {
    it.options.release = javaVersionNum
}

java {
    withSourcesJar()

    sourceCompatibility = javaVersion
    targetCompatibility = javaVersion
}

jar {
    from("LICENSE") {
        rename { "${it}_${base.archivesName.get()}" }
    }
}