build.gradle

buildscript {
    repositories {
        maven { url = 'https://maven.minecraftforge.net' }
        maven { url "https://plugins.gradle.org/m2/" }
        jcenter()
        mavenCentral()
        maven {
            name = 'sponge'
            url = 'https://repo.spongepowered.org/maven'
        }
    }
    dependencies {
        classpath group: 'net.minecraftforge.gradle', name: 'ForgeGradle', version: '5.1.+', changing: true
        classpath "gradle.plugin.com.matthewprenger:CurseGradle:1.4.0"
        classpath 'org.spongepowered:mixingradle:0.7.+'
    }
}

plugins {
    id "com.modrinth.minotaur" version "2.+"
    id 'com.github.johnrengelman.shadow' version '6.1.0'
}

apply plugin: 'net.minecraftforge.gradle'
apply plugin: 'idea'
apply plugin: 'maven-publish'
apply plugin: "com.matthewprenger.cursegradle"
apply plugin: 'org.spongepowered.mixin'

ext.configFile = file("build.txt")
configFile.withReader {
    def prop = new Properties()
    prop.load(it)
    project.ext.config = new ConfigSlurper().parse(prop)
    project.ext.hasConfig = { key ->
        return config.isSet(key);
    }
}

version = config.mod_version
group = config.maven_group
archivesBaseName = "${config.archive_name}-${config.mc_version}"

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

mixin {
    add sourceSets.main, "mixins.${config.mod_id}.refmap.json"
}

println('Java: ' + System.getProperty('java.version') + ' JVM: ' + System.getProperty('java.vm.version') + '(' + System.getProperty('java.vendor') + ') Arch: ' + System.getProperty('os.arch'))
minecraft {
    mappings channel: 'official', version: config.mc_version
    accessTransformer = file('src/main/resources/META-INF/accesstransformer.cfg')
    runs {
        client {
            workingDirectory project.file('run/client')
            property 'forge.logging.console.level', 'debug'
            setArgs(Arrays.asList("--mixin mixins.${config.mod_id}.json --username ${config.mc_user.split(',')[0]} --uuid ${config.mc_user.split(',')[1]}".split(' ')))
            mods {
                examplemod {
                    source sourceSets.main
                }
            }
        }

        server {
            workingDirectory project.file('run/server')
            property 'forge.logging.console.level', 'debug'
            setArgs(Arrays.asList("--mixin mixins.${config.mod_id}.json -Dmixin.env.disableRefMap=true".split(' ')))
            mods {
                examplemod {
                    source sourceSets.main
                }
            }
        }
    }
}

repositories {
    maven {
        name = "Zeitheron Maven"
        url = "https://maven.zeith.org/"
    }
    flatDir { dirs "libraries/${config.mc_version}/all" }
    flatDir { dirs "libraries/${config.mc_version}/classpathOnly" }
    flatDir { dirs "libraries/${config.mc_version}/runtimeOnly" }
    flatDir { dirs "libraries/embedded" }
}

dependencies {
    minecraft "net.minecraftforge:forge:${config.mc_version}-${config.forge_version}"

    implementation "org.zeith.hammerlib:HammerLib-${config.mc_version}:${config.hl_version}:deobf"

    annotationProcessor("org.spongepowered:mixin:0.8.5:processor")

    def libraries = new File(file("libraries"), "${config.mc_version}")
    if (!libraries.isDirectory()) libraries.mkdirs()

    def libDir = new File(libraries, "all");
    if (libDir.isDirectory()) {
        libDir.eachFile { file ->
            def splitPos = file.name.lastIndexOf("-")
            def modartifact = file.name.substring(0, splitPos)
            def modversion = file.name.substring(splitPos + 1, file.name.length() - 4)
            dependencies {
                implementation fg.deobf(project.dependencies.create("_all:$modartifact:$modversion") {
                    transitive = false
                })
            }
        }
    } else libDir.mkdir();

    libDir = new File(libraries, "classpathOnly");
    if (libDir.isDirectory()) {
        libDir.eachFile { file ->
            def splitPos = file.name.lastIndexOf("-")
            def modartifact = file.name.substring(0, splitPos)
            def modversion = file.name.substring(splitPos + 1, file.name.length() - 4)
            dependencies {
                compileClasspath fg.deobf(project.dependencies.create("_classpath:$modartifact:$modversion") {
                    transitive = false
                })
            }
        }
    } else libDir.mkdir();

    libDir = new File(libraries, "runtimeOnly");
    if (libDir.isDirectory()) {
        libDir.eachFile { file ->
            def splitPos = file.name.lastIndexOf("-")
            def modartifact = file.name.substring(0, splitPos)
            def modversion = file.name.substring(splitPos + 1, file.name.length() - 4)
            dependencies {
                runtimeClasspath fg.deobf(project.dependencies.create("_runtime:$modartifact:$modversion") {
                    transitive = false
                })
            }
        }
    } else libDir.mkdir();

    libDir = new File(file("libraries"), "embedded");
    if (libDir.isDirectory()) {
        libDir.eachFile { file ->
            def splitPos = file.name.lastIndexOf("-")
            def modartifact = file.name.substring(0, splitPos)
            def modversion = file.name.substring(splitPos + 1, file.name.length() - 4)
            def modreference = "lib:$modartifact:$modversion"

            dependencies {
                def dep = project.dependencies.create(modreference) {
                    transitive = false
                }
                implementation dep
                shadow dep
            }
        }
    } else libDir.mkdir();
}

jar {
    manifest {
        attributes([
                "Specification-Title"     : "${config.mod_id}",
                "Specification-Vendor"    : "Zeitheron",
                "Specification-Version"   : "1",
                "Implementation-Title"    : project.name,
                "Implementation-Version"  : archiveVersion,
                "Implementation-Vendor"   : "Zeitheron",
                "Implementation-Timestamp": new Date().format("yyyy-MM-dd'T'HH:mm:ssZ"),
                "MixinConfigs"            : "mixins.${config.mod_id}.json"
        ])
    }
}

task deobfJar(type: Jar) {
    classifier = 'deobf'
    from sourceSets.main.output
    manifest {
        attributes(["Specification-Title"     : "${config.mod_id}",
                    "Specification-Vendor"    : "Zeitheron",
                    "Specification-Version"   : "1",
                    "Implementation-Title"    : project.name,
                    "Implementation-Version"  : archiveVersion,
                    "Implementation-Vendor"   : "Zeitheron",
                    "Implementation-Timestamp": new Date().format("yyyy-MM-dd'T'HH:mm:ssZ"),
                    "MixinConfigs"            : "mixins.${config.mod_id}.json"
        ])
    }
}

shadowJar {
    classifier ''
    configurations = [project.configurations.shadow]
}

reobf {
    shadowJar {}
}
shadowJar.finalizedBy('reobfShadowJar')

task srcJar(type: Jar, dependsOn: classes) {
    from sourceSets.main.allJava
    classifier = 'sources'
}

artifacts {
    archives deobfJar
    archives srcJar
}

modrinth {
    token = System.env.MODRINTH_TOKEN != null ? System.env.MODRINTH_TOKEN : "NONE"
    projectId = config.modrinth_project as String
    versionNumber = config.mod_version as String
    versionType = config.release_type as String
    uploadFile = jar
    gameVersions = [config.mc_version as String]
    dependencies {
        def mods = (config.required_mods as String).split(";")
        if (mods.length > 0 && (mods.length > 1 || !mods[0].isEmpty()))
            for (final def one in mods) {
                if (one.isBlank()) continue
                if (one.startsWith("@")) {
                    def pars = one.substring(1).split(":", 2)
                    if (pars[0].equalsIgnoreCase("m")) {
                        required.project pars[1].trim()
                    }
                } else
                    required.project one.trim()
            }

        mods = (config.optional_mods as String).split(";")
        if (mods.length > 0 && (mods.length > 1 || !mods[0].isEmpty()))
            for (final def one in mods) {
                if (one.isBlank()) continue
                if (one.startsWith("@")) {
                    def pars = one.substring(1).split(":", 2)
                    if (pars[0].equalsIgnoreCase("m")) {
                        optional.project pars[1].trim()
                    }
                } else
                    optional.project one.trim()
            }

        mods = (config.incompatible_mods as String).split(";")
        if (mods.length > 0 && (mods.length > 1 || !mods[0].isEmpty()))
            for (final def one in mods) {
                if (one.isBlank()) continue
                if (one.startsWith("@")) {
                    def pars = one.substring(1).split(":", 2)
                    if (pars[0].equalsIgnoreCase("m")) {
                        incompatible.project pars[1].trim()
                    }
                } else
                    incompatible.project one.trim()
            }

        mods = (config.embedded_mods as String).split(";")
        if (mods.length > 0 && (mods.length > 1 || !mods[0].isEmpty()))
            for (final def one in mods) {
                if (one.isBlank()) continue
                if (one.startsWith("@")) {
                    def pars = one.substring(1).split(":", 2)
                    if (pars[0].equalsIgnoreCase("m")) {
                        embedded.project pars[1].trim()
                    }
                } else
                    embedded.project one.trim()
            }
    }
}

curseforge {
    apiKey = System.env.CURSEFORGE_API_KEY != null ? System.env.CURSEFORGE_API_KEY : "NONE"
    project {
        id = config.cf_project as String
        changelogType = 'html'
        changelog = ""
        releaseType = config.release_type as String
        addGameVersion config.mc_version as String
        addGameVersion "Forge"
        mainArtifact(jar) {
            displayName = "[${config.mc_version}] ${config.mod_name} - ${config.mod_version}"
        }
        relations {
            def mods = (config.required_mods as String).split(";")
            if (mods.length > 0 && (mods.length > 1 || !mods[0].isEmpty()))
                for (final def one in mods) {
                    if (one.isBlank()) continue
                    if (one.startsWith("@")) {
                        def pars = one.substring(1).split(":", 2)
                        if (pars[0].equalsIgnoreCase("c")) {
                            requiredDependency pars[1].trim()
                        }
                    } else
                        requiredDependency one.trim()
                }

            mods = (config.optional_mods as String).split(";")
            if (mods.length > 0 && (mods.length > 1 || !mods[0].isEmpty()))
                for (final def one in mods) {
                    if (one.isBlank()) continue
                    if (one.startsWith("@")) {
                        def pars = one.substring(1).split(":", 2)
                        if (pars[0].equalsIgnoreCase("c")) {
                            optionalDependency pars[1].trim()
                        }
                    } else
                        optionalDependency one.trim()
                }

            mods = (config.incompatible_mods as String).split(";")
            if (mods.length > 0 && (mods.length > 1 || !mods[0].isEmpty()))
                for (final def one in mods) {
                    if (one.isBlank()) continue
                    if (one.startsWith("@")) {
                        def pars = one.substring(1).split(":", 2)
                        if (pars[0].equalsIgnoreCase("c")) {
                            incompatible pars[1].trim()
                        }
                    } else
                        incompatible one.trim()
                }

            mods = (config.embedded_mods as String).split(";")
            if (mods.length > 0 && (mods.length > 1 || !mods[0].isEmpty()))
                for (final def one in mods) {
                    if (one.isBlank()) continue
                    if (one.startsWith("@")) {
                        def pars = one.substring(1).split(":", 2)
                        if (pars[0].equalsIgnoreCase("c")) {
                            embeddedLibrary pars[1].trim()
                        }
                    } else
                        embeddedLibrary one.trim()
                }
        }
    }
}

import net.minecraftforge.gradle.common.tasks.SignJar

task signJar(type: SignJar, dependsOn: jar) {
    onlyIf {
        System.env.MC_KS_PASS != null
    }
    keyStore = System.env.MC_KS_PATH
    alias = System.env.MC_KS_ALIAS
    storePass = System.env.MC_KS_PASS
    keyPass = System.env.MC_KS_PASS
    inputFile = jar.archiveFile
    outputFile = jar.archiveFile
}

def reobfFile = jar.archiveFile.get().asFile
def reobfArtifact = artifacts.add('default', reobfFile) {
    type 'jar'
    builtBy 'signJar'
}

jar.finalizedBy('reobfJar')
publish.dependsOn('reobfJar')

build.dependsOn signJar

tasks.register('buildAndUploadMod') {
    group = "upload"
    dependsOn "curseforge${config.cf_project}", 'modrinth'

    doLast {
        println "Upload complete."
    }
}

afterEvaluate {
    tasks["curseforge${config.cf_project}"].dependsOn.add(publish)
    tasks["modrinth"].dependsOn.add(publish)
}

publishing {
    publications {
        mavenJava(MavenPublication) {
            groupId = config.maven_group
            artifactId = config.archive_name + "-" + config.mc_version

            artifact reobfArtifact
            artifact srcJar
            artifact deobfJar

            pom.withXml {
                def dependenciesNode = asNode().appendNode('dependencies')

                def dependencyNode = dependenciesNode.appendNode('dependency')
                dependencyNode.appendNode('groupId', "org.zeith.hammerlib")
                dependencyNode.appendNode('artifactId', "HammerLib-${config.mc_version}")
                dependencyNode.appendNode('version', config.hl_version)
            }
        }
    }
    repositories {
        maven {
            url "file:///SERVER//Maven"
        }
    }
}