build.gradle

import java.util.regex.Pattern

buildscript {
    repositories {
        mavenCentral()
    }

    dependencies {
        classpath("com.google.guava:guava:33.3.1-jre")
        classpath("commons-io:commons-io:2.18.0")
    }
}

plugins {
    id("idea")
    alias(libs.plugins.curse)
    alias(libs.plugins.modrinth)
    alias(libs.plugins.names)
    alias(libs.plugins.gitVersion)
}

allprojects {
    apply plugin: "java"
    apply plugin: "idea"

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

    tasks.withType(JavaCompile).configureEach {
        options.encoding = "UTF-8"
        options.compilerArgs = ["-Xlint:deprecation"]
    }

    dependencies {
        compileOnly(libs.jetbrainsAnnotations)
        compileOnly(libs.lombok)
        annotationProcessor(libs.lombok)
    }

    repositories {
        mavenCentral()
        maven {
            name = "Minecraft Libraries"
            url = uri("https://libraries.minecraft.net")
        }
        maven {
            name = 'CurseForge'
            url = 'https://minecraft.curseforge.com/api/maven'
        }
        maven {
            name = "ModMenu"
            url = "https://maven.terraformersmc.com/releases/"
        }
        maven {
            name = "Cloth Config"
            url = "https://maven.shedaniel.me/"
        }
    }

    if (version == null || version == "unspecified") {
        try {
            def details = versionDetails()
            if (details.commitDistance > 0) {
                version = "${details.lastTag}-${details.commitDistance}"
            } else {
                version = details.lastTag
            }
        } catch (Exception e) {
            version = "0.0.1-dev"
        }
    }
}

def minecraftVersion = libs.versions.minecraftVersion.get()
group = "fr.rakambda"
archivesBaseName = "${project.modName}-${minecraftVersion}"

def relType = "release"
def isAlpha = false
if (version.contains("b")) {
    relType = "beta"
}
if (version.contains("a") || version.contains("dev")) {
    relType = "alpha"
    isAlpha = true
}

tasks.register('buildJar', Jar) {
    group("Modding")
    dependsOn(assemble)
    dependsOn(":common:build")
    if (project.includeFabric.toBoolean()) {
        dependsOn(":fabric:build")
    }
    if (project.includeForge.toBoolean()) {
        dependsOn(":forge:build")
    }
    if (project.includeNeoForge.toBoolean()) {
        dependsOn(":neoforge:build")
    }

    duplicatesStrategy = DuplicatesStrategy.EXCLUDE
    from {
        zipTree("common/build/libs/common-${project.version}.jar")
    }
    if (project.includeFabric.toBoolean()) {
        from {
            zipTree("fabric/build/libs/fabric-${project.version}.jar")
        }
    }
    if (project.includeForge.toBoolean()) {
        from {
            zipTree("forge/build/libs/forge-${project.version}.jar")
        }
    }
    if (project.includeNeoForge.toBoolean()) {
        from {
            zipTree("neoforge/build/libs/neoforge-${project.version}.jar")
        }
    }

    manifest {
        attributes([
                "Specification-Title"     : project.modId,
                "Specification-Vendor"    : "Rakambda",
                "Specification-Version"   : project.version,
                "Implementation-Title"    : project.modName,
                "Implementation-Version"  : "${project.version}",
                "Implementation-Vendor"   : "Rakambda",
                "Implementation-Timestamp": new Date().format("yyyy-MM-dd'T'HH:mm:ssZ")
        ])
    }
}
assemble.finalizedBy("buildJar")

static def extractMainVersion(String ver) {
    def match = Pattern.compile("(\\d+\\.\\d+(\\.\\d+)?)(-.*)?").matcher(ver)
    if (match.matches()) {
        return match.group(1)
    }
    return null;
}

curseforge {
    apiKey = "${project.findProperty("curseforgeApiKey")}"
    project {
        id = "${project.curseforge_project_id}"
        changelogType = "markdown"

        if (isAlpha) {
            def extracted = extractMainVersion(minecraftVersion)
            if (extracted != null) {
                addGameVersion(extracted + "-Snapshot")
            }
        } else {
            addGameVersion(minecraftVersion)
        }

        addGameVersion("Java 21")
        if (project.includeFabric.toBoolean()) {
            addGameVersion("Fabric")
        }
        if (project.includeForge.toBoolean()) {
            addGameVersion("Forge")
        }
        if (project.includeNeoForge.toBoolean()) {
            addGameVersion("NeoForge")
        }
        changelog = getFTChangelog() ?: "No changelog provided"
        releaseType = relType
        mainArtifact(jar) {
            displayName = "${minecraftVersion}-${project.version}"
        }
        relations {
            if (project.includeFabric.toBoolean()) {
                optionalDependency("fabric-api") //It's actually required
                optionalDependency("modmenu")
                optionalDependency("cloth-config")
            }

            optionalDependency("cloth-config")
        }
    }
    options {
        javaVersionAutoDetect = false
        javaIntegration = false
        forgeGradleIntegration = false
    }

    afterEvaluate {
        tasks.named("curseforge${project.curseforge_project_id}").get().dependsOn("buildJar")
    }
}

modrinth {
    token.set(project.findProperty("modrinthToken") as String)
    projectId.set(project.modrinth_project_id)
    versionNumber.set("${minecraftVersion}-${project.version}")
    versionName.set("${minecraftVersion}-${project.version}")
    uploadFile.set(tasks.jar)
    gameVersions.add(minecraftVersion)
    if (project.includeFabric.toBoolean()) {
        loaders.add("fabric")
    }
    if (project.includeForge.toBoolean()) {
        loaders.add("forge")
    }
    if (project.includeNeoForge.toBoolean()) {
        loaders.add("neoforge")
    }
    versionType.set(relType)
    changelog.set(getFTChangelog() ?: "No changelog provided")
    syncBodyFrom.set(rootProject.file("README.md").getText())
    debugMode.set(false)

    dependencies {
        if (project.includeFabric.toBoolean()) {
            optional.project("P7dR8mSH") //Fabric-api / It's actually required
            optional.project("mOgUt4GM") //Modmenu
        }

        optional.project("9s6osm5g") //Cloth config
    }

    afterEvaluate {
        tasks.named("modrinth").get().dependsOn("buildJar")
    }
}

String getFTChangelog(){
    String changelog = project.findProperty("changelog")
    if(changelog == null){
        return null;
    }
    if(changelog.startsWith("\"")){
        changelog = changelog.substring(1)
    }
    if(changelog.endsWith("\"")){
        changelog = changelog.substring(0, changelog.length() - 1)
    }
    return changelog
}