build.gradle

plugins {
    id 'java-library'
    id 'net.neoforged.moddev' version '1.0.21'
    id "com.modrinth.minotaur" version "2.+"
    id 'net.darkhax.curseforgegradle' version '1.1.+'
}

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

version = project.mod_version
group = 'terrails.xnetgases'

base {
    archivesName = "xnetgases-${project.minecraft_version}"
}

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

neoForge {
    version = project.neoforge_version

    parchment {
        minecraftVersion = project.minecraft_version
        mappingsVersion = project.parchment_version
    }

    runs {
        client {
            client()
            programArgument '--width=1280'
            programArgument '--height=720'
        }

        server {
            server()
            programArgument '--nogui'
        }

        configureEach {
            gameDirectory = layout.projectDir.dir("run/$name")

            // "SCAN": For mods scan.
            // "REGISTRIES": For firing of registry events.
            // "REGISTRYDUMP": For getting the contents of all registries.
            systemProperty 'forge.logging.markers', 'REGISTRIES'
            systemProperty 'neoforge.enabledGameTestNamespaces', 'xnetgases'

            logLevel = org.slf4j.event.Level.DEBUG
        }
    }

    mods {
        xnetgases {
            sourceSet(sourceSets.main)
        }
    }
}

sourceSets.main.resources { srcDir 'src/generated/resources' }

repositories {
    maven { url 'https://modmaven.dev/' }
    exclusiveContent {
        forRepository {
            maven {
                url "https://cursemaven.com"
            }
        }
        filter {
            includeGroup "curse.maven"
        }
    }
}

dependencies {
    // XNet
    implementation "curse.maven:xnet-260912:${project.xnet_fileId}"
    implementation "curse.maven:rftools-base-326041:${project.rftoolsbase_fileId}"
    implementation "curse.maven:mcjtylib-233105:${project.mcjtylib_fileId}"

    // Mekanism
    implementation "mekanism:Mekanism:${project.mekanism_version}"
}

java {
    withSourcesJar()
}

artifacts {
    archives sourcesJar
}

tasks.named('jar', Jar).configure {
    manifest.attributes([
            "Specification-Title"     : "xnetgases",
            "Specification-Vendor"    : "Terrails",
            "Specification-Version"   : "1",
            "Implementation-Title"    : project.name,
            "Implementation-Version"  : project.mod_version,
            "Implementation-Timestamp": new Date().format("yyyy-MM-dd'T'HH:mm:ssZ")
    ])
}

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

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

tasks.register('printChangelog') {
    doLast {
        println(fetchChangelog())
    }
}

ext.fetchChangelog = {
    def branch = "git rev-parse --abbrev-ref HEAD".execute().in.text.trim()
    if (branch.isBlank() || branch == "HEAD") {
        throw new GradleException("Branch name could not be fetched.")
    }

    def repoUrl = "https://github.com/Terrails/xnet-gases"
    def changes = new StringBuilder("Latest changes ([See all](${repoUrl}/commits/${branch}))\n---")
    def log = "git log --max-count=30 --no-merges --pretty=format:\"* %s ([%h](${repoUrl}/commit/%H))\"".execute()
    log.in.eachLine { line ->
        if (!line.startsWithIgnoreCase("* bump")) { // version change commits should be ignored
            changes << "\n${line}"
        }
    }

    if (log.waitFor() == 0) {
        return changes.toString()
    } else {
        throw new GradleException("Received an error while executing git log.")
    }
}

tasks.build.mustRunAfter(tasks.clean)
tasks.register('publishProduction') {
    dependsOn([tasks.clean, tasks.build])
    finalizedBy([tasks.modrinth, tasks.publishCurseForge])
}

modrinth {
    token = System.getenv("MODRINTH_TOKEN")
    projectId = "${rootProject.modrinth_id}"
    versionNumber = "${project.version}"
    versionName = "${rootProject.minecraft_version}-v${project.version}"
    uploadFile = tasks.jar.getArchiveFile().get()
    gameVersions = [rootProject.minecraft_version]
    loaders = ["neoforge"]
    dependencies {
        required.project "xnet"
        required.project "mekanism"
    }
    changelog = fetchChangelog()
    additionalFiles = [tasks.sourcesJar.getArchiveFile().get()]
}

import net.darkhax.curseforgegradle.TaskPublishCurseForge

tasks.register('publishCurseForge', TaskPublishCurseForge) {
    apiToken = System.getenv("CURSEFORGE_TOKEN")
    disableVersionDetection()

    def mainFile = upload(rootProject.curseforge_id, tasks.jar.getArchiveFile().get())
    mainFile.displayName = "${rootProject.minecraft_version}-v${project.version}"
    mainFile.releaseType = "release"
    mainFile.changelog = fetchChangelog()
    mainFile.changelogType = "markdown"
    mainFile.addGameVersion(rootProject.minecraft_version)
    mainFile.addModLoader("neoforge")
    mainFile.addRequirement("xnet", "mekanism")
    mainFile.withAdditionalFile(tasks.sourcesJar.getArchiveFile().get())
}