build.gradle

import com.gtnewhorizons.retrofuturagradle.mcp.ReobfuscatedJar
import org.jetbrains.gradle.ext.Gradle

plugins {
    id("java")
    id("java-library")
    id("maven-publish")
    id("org.jetbrains.gradle.plugin.idea-ext") version "1.1.7"
    id("eclipse")
    id("com.gtnewhorizons.retrofuturagradle") version "1.3.27"
    id("com.matthewprenger.cursegradle") version "1.4.0"
    id('io.github.srdjan-v.local-git-dependency') version '0.5.2'
}

def currentBranch = ("git rev-parse --abbrev-ref HEAD").execute().inputStream.readLines().get(0)
version = project.mod_version
group = project.maven_group
archivesBaseName = project.archives_base_name

// Set the toolchain version to decouple the Java we run Gradle with from the Java used to compile and run the mod
java {
    toolchain {
        languageVersion.set(JavaLanguageVersion.of(8))
        // Azul covers the most platforms for Java 8 toolchains, crucially including MacOS arm64
        vendor.set(JvmVendorSpec.AZUL)
    }
    // Generate sources and javadocs jars when building and publishing
    withSourcesJar()
    //withJavadocJar()
}

minecraft {
    mcVersion = '1.12.2'
    def args = ["-ea:${project.group}"]
    if (project.use_coremod.toBoolean()) {
        args << '-Dfml.coreMods.load=' + coremod_plugin_class_name
    }
    if (project.use_mixins.toBoolean()) {
        args << '-Dmixin.hotSwap=true'
        args << '-Dmixin.checks.interfaces=true'
        args << '-Dmixin.debug.export=true'
    }
    extraRunJvmArguments.addAll(args)

    useDependencyAccessTransformers = true
    injectedTags.put("VERSION", project.version)
    injectedTags.put("TWEAKED_LIB_VERSION", tweaked_lib_version)
}

// Generate a my.project.Tags class with the version number as a field
tasks.injectTags.configure {
    outputClassName.set("${project.group}.${project.archives_base_name}.Tags")
}

repositories {
    mavenCentral()
    maven {
        url = 'https://maven.cleanroommc.com'
    }
    maven {
        url = 'https://repo.spongepowered.org/maven'
    }
    maven {
        url "https://cursemaven.com"
        content {
            includeGroup "curse.maven"
        }
    }
    maven { // TOP
        name 'tterrag maven'
        url "https://maven.tterrag.com/"
    }
    maven {
        name 'jared maven'
        url 'https://maven.blamejared.com/'
        content {
            includeGroup "CraftTweaker2"
        }
    }
    maven {
        // location of the maven that hosts JEI files
        name = "Progwml6 maven"
        url = "https://dvs1.progwml6.com/files/maven/"
    }
    mavenLocal()
}

configurations {
    embed
    implementation.extendsFrom(embed)
}

dependencies {
    compileOnly "org.jetbrains:annotations:24.0.1"
    //Hwyla
    implementation "curse.maven:hwyla-253449:2568751-sources-2568752-api-2568753"
    //compileOnly "curse.maven:hwyla-253449:2568751-sources-2568752-api-2568753"
    //implementation "curse.maven:top-245211:2667280"
    implementation "mcjty.theoneprobe:TheOneProbe-1.12:1.12-1.4.28-17"

    implementation 'CraftTweaker2:CraftTweaker2-MC1120-Main:1.12-4.1.20.679'
    implementation ("com.cleanroommc:groovyscript:${project.groovy_script_version}") {
        exclude group: 'mezz.jei', module: 'jei_1.12.2'
        exclude group: 'curse.maven', module: 'top-245211'
        exclude group: 'zone.rong', module: 'mixinbooter'
        exclude group: 'codechicken', module:'codechickenlib'
    }

    implementation rfg.deobf('curse.maven:ImmersiveEngineering-231951:2974106')
    implementation rfg.deobf('curse.maven:ImmersivePetroleum-268250:3382321')

    //AdvancedRocketry
    implementation rfg.deobf('curse.maven:AdvancedRocketry-236542:3801020')
    implementation rfg.deobf('curse.maven:Libvulpes-236541:3801015')

    //compileOnly rfg.deobf('mezz.jei:jei_1.12.2:4.16.1.302:api')
    //runtimeOnly rfg.deobf('mezz.jei:jei_1.12.2:4.16.1.302')
    //implementation fg.deobf('curse.maven:had-enough-items-557549:3862733')

    //enables java 17 features on java 8
    annotationProcessor 'com.github.bsideup.jabel:jabel-javac-plugin:1.0.0'
    annotationProcessor 'net.java.dev.jna:jna-platform:5.13.0'
    compileOnly 'com.github.bsideup.jabel:jabel-javac-plugin:1.0.0'

    if (project.use_assetmover.toBoolean()) {
        implementation 'com.cleanroommc:assetmover:2.0'
    }

    if (project.use_mixins.toBoolean()) {
        annotationProcessor 'org.ow2.asm:asm-debug-all:5.2'
        annotationProcessor 'com.google.guava:guava:32.1.2-jre'
        annotationProcessor 'com.google.code.gson:gson:2.8.9'
        String mixinBooter = modUtils.enableMixins('zone.rong:mixinbooter:8.9')
        api (mixinBooter) {transitive = false}
        annotationProcessor (mixinBooter) {transitive = false}
    }

    testImplementation 'org.junit.jupiter:junit-jupiter:5.9.2'
}

localGitDependency {
    add('https://github.com/Srdjan-V/TweakedLib.git', {
        buildLauncher {
            startup {
                mainTasks "setupCIWorkspace"
            }
        }
        configuration("runtimeOnly")
        enableIdeSupport true
        mapSourceSets({
            map "main", "main"
        })
        if (currentBranch == "master") {
            keepGitUpdated true
            tag 'v' + project.tweaked_lib_version
        } else {
            keepGitUpdated false
            branch 'develop'
        }
    })

    add('https://github.com/CleanroomMC/HadEnoughItems.git', {
        buildLauncher {
            setExecutable(javaToolchains.launcherFor {
                languageVersion = JavaLanguageVersion.of(8)
            })
            startup {
                mainTasks "setupCIWorkspace"
            }
        }
        tag project.hei_version
        configuration({
            configuration("compileOnly")
            include("mezz.jei:HadEnoughItems_1.12.2:${project.hei_version}-api")
        }, {
            configuration("runtimeOnly")
            include("mezz.jei:HadEnoughItems_1.12.2:${project.hei_version}")
        })
    })
}

def mixinConfigRefMap = 'mixins.' + project.archives_base_name + '.refmap.json'
def mixinTmpDir = buildDir.path + File.separator + 'tmp' + File.separator + 'mixins'
def refMap = "${mixinTmpDir}" + File.separator + mixinConfigRefMap
def mixinSrg = "${mixinTmpDir}" + File.separator + "mixins.srg"

if (project.use_mixins.toBoolean()) {
    tasks.named("reobfJar", ReobfuscatedJar).configure {
        extraSrgFiles.from(mixinSrg)
    }

    tasks.named("compileJava", JavaCompile).configure {
        doFirst {
            new File(mixinTmpDir).mkdirs()
        }
        options.compilerArgs += [
                "-AreobfSrgFile=${tasks.reobfJar.srg.get().asFile}",
                "-AoutSrgFile=${mixinSrg}",
                "-AoutRefMapFile=${refMap}",
        ]
    }
}

if (project.use_access_transformer.toBoolean()) {
    for (File at : sourceSets.getByName("main").resources.files) {
        if (at.name.toLowerCase().endsWith("_at.cfg")) {
            tasks.deobfuscateMergedJarToSrg.accessTransformerFiles.from(at)
            tasks.srgifyBinpatchedJar.accessTransformerFiles.from(at)
        }
    }
}

jar {
    manifest {
        def attribute_map = [:]
        if (project.use_coremod.toBoolean()) {
            attribute_map['FMLCorePlugin'] = project.coremod_plugin_class_name
            if (project.include_mod.toBoolean()) {
                attribute_map['FMLCorePluginContainsFMLMod'] = true
                attribute_map['ForceLoadAsMod'] = project.gradle.startParameter.taskNames[0] == "build"
            }
        }
        if (project.use_access_transformer.toBoolean()) {
            attribute_map['FMLAT'] = project.archives_base_name + '_at.cfg'
        }
        attributes(attribute_map)
    }
    // Add all embedded dependencies into the jar
    from(provider { configurations.embed.collect { it.isDirectory() ? it : zipTree(it) } })
}

processResources {
    // this will ensure that this task is redone when the versions change.
    inputs.property 'version', project.version
    inputs.property 'mcversion', project.minecraft.version
    // replace stuff in mcmod.info, nothing else
    filesMatching(['mcmod.info', 'pack.mcmeta']) { fcd ->
        // replace version and mcversion
        fcd.expand(
                'version': project.version,
                //'mcversion': project.minecraft.version
        )
    }

    if (project.use_access_transformer.toBoolean()) {
        rename '(.+_at.cfg)', 'META-INF/$1' // Access Transformers
    }

    if (project.use_mixins.toBoolean()) {
        // Embed mixin refmap
        from refMap
        dependsOn("compileJava")
    }
}

tasks.register('updateGitVersionTag') {
    doLast {
        def versionTagArray = new ArrayList<Integer>()
        for (versionString in project.version.toString().trim().split("\\.")) {
            versionTagArray.add(Integer.valueOf(versionString))
        }

        def gitVersionTagArray = new ArrayList<Integer>()
        def gitStringTag = ("git describe --tags --abbrev=0").execute().inputStream.readLines().get(0)
        for (versionString in gitStringTag.substring(1, gitStringTag.length()).trim().split("\\.")) {
            gitVersionTagArray.add(Integer.valueOf(versionString))
        }

        def invalid = true
        def smallestSizeArray = versionTagArray.size() > gitVersionTagArray.size() ? gitVersionTagArray.size() : versionTagArray.size()
        for (i in 0..<smallestSizeArray) {
            if (versionTagArray.get(i) > gitVersionTagArray.get(i)) {
                invalid = false
                break
            }
        }

        if (!invalid && versionTagArray.size() > gitVersionTagArray.size()) {
            invalid = false
        }

        if (invalid) {
            project.logger.error("Current project version is the same or lower then the latest tag")
            return
        }

        project.logger.lifecycle('Pushing tag {}', project.version)
        ("git tag v${project.version}").execute()
        ("git push --tags").execute()
    }
}

idea {
    module {
        inheritOutputDirs = true
        downloadJavadoc = true
        downloadSources = true
    }
    project {
        settings {
            runConfigurations {
                "1. Run Client"(Gradle) {
                    taskNames = ["runClient"]
                }
                "2. Run Server"(Gradle) {
                    taskNames = ["runServer"]
                }
                "3. Run Obfuscated Client"(Gradle) {
                    taskNames = ["runObfClient"]
                }
                "4. Run Obfuscated Server"(Gradle) {
                    taskNames = ["runObfServer"]
                }
            }
            compiler.javac {
                afterEvaluate {
                    javacAdditionalOptions = "-encoding utf8"
                    moduleJavacAdditionalOptions = [
                            (project.name + ".main"): tasks.compileJava.options.compilerArgs.collect { '"' + it + '"' }.join(' ')
                    ]
                }
            }
        }
    }
}

tasks.named("processIdeaSettings").configure {
    dependsOn("injectTags")
}

afterEvaluate {
    tasks.withType(JavaCompile.class).configureEach {
        options.encoding = "UTF-8"
        sourceCompatibility = 17 // for the IDE support
        options.release = 8

        javaCompiler = javaToolchains.compilerFor {
            languageVersion = JavaLanguageVersion.of(17)
        }
    }
}

configure([tasks.javadoc]) {
    javadocTool.set(javaToolchains.javadocToolFor {
        languageVersion = JavaLanguageVersion.of(17)
    })
}

tasks.named('test') {
    useJUnitPlatform()
}

publishing {
    publications {
        mavenJava(MavenPublication) {
            from components.java
            artifact sourcesJar
        }
    }
}