build.gradle

buildscript {
    repositories {
        mavenCentral()
        maven { url = "https://repo1.maven.org/maven2/" }
        maven { url = "https://maven.google.com/" }
        maven {
            name = "forge"
            url = "https://maven.minecraftforge.net/"
        }
        maven {
            name = "sonatype"
            url = "https://oss.sonatype.org/content/repositories/snapshots/"
        }
    }
    dependencies {
        classpath ('com.anatawa12.forge:ForgeGradle:1.2-1.1.+') {
            changing = true
        }
        classpath 'com.guardsquare:proguard-gradle:7.3.2'
    }
}

plugins {
    id 'java-library'
    id 'maven-publish'
}

// Reproducible builds! https://docs.gradle.org/4.9/userguide/working_with_files.html#sec:reproducible_archives
tasks.withType(AbstractArchiveTask).configureEach {
    preserveFileTimestamps = false
    reproducibleFileOrder = true
}

apply plugin: 'java'
apply plugin: 'forge'

// Defines a Java 7 compatible JDK. Java 6 would be ideal, but it isn't usable on my computer anymore :(
// This is used to get properties requiring a reference to a JDK (rt.jar etc).
// Unofficially, the codebase of MoreBows attempts to retain Java 5 compatibility, for ease of backports in the future, but Gradle doesn't support building with Java 5 in toolchains yet. I should make a bug report about it at some point...
def compiler = javaToolchains.compilerFor {
    languageVersion = JavaLanguageVersion.of(7)
}

// Tells Gradle to use the previously defined Java 7 compatible JDK.
java {
    toolchain {
        compiler
    }
}

// Tells Gradle to always compile with the previously defined Java 7 compatible JDK.
tasks.withType(JavaCompile).configureEach {
    javaCompiler = compiler
}

import groovy.json.JsonSlurper
import groovy.json.JsonOutput

version = project.mod_version
group = project.mod_group

def modName = project.mod_name
def build_release = System.getenv("BUILD_RELEASE") == "true"

// Add snapshot suffix to version if not building a release.
// To build a release, set the environment variable BUILD_RELEASE to true.
if (!build_release) {
    version += "-SNAPSHOT"
}

// Information for ForgeGradle to configure the Minecraft / Forge version.
minecraft {
    version = project.minecraft_version + "-" + project.forge_version
    runDir = "run"
}

processResources {
    // This will ensure that this task is redone when the versions change.
    inputs.property "version", project.version
    inputs.property "mcversion", project.minecraft.version
    inputs.property "modName", project.mod_name

    // Replace values in only mcmod.info.
    filesMatching('mcmod.info') {
        expand 'version': version, 'modName': modName, 'mcversion': project.minecraft.version
    }

    // Here's a super unnecessary micro-optimisation: a mcmod.info file is a JSON file, and JSON files can be minified!
    doLast {
        fileTree(dir: outputs.files.asPath, include: "**/mcmod.info").each {
            File file -> file.text = JsonOutput.toJson(new JsonSlurper().parse(file))
        }
    }
}

tasks.withType(JavaCompile).configureEach {
    // Ensures that the encoding of source files is set to UTF-8, see http://yodaconditions.net/blog/fix-for-java-file-encoding-problems-with-gradle.html
    options.encoding = "UTF-8"
}

// This task creates a .jar file containing the source code of this mod.
task sourcesJar(type: Jar, dependsOn: classes) {
    archiveClassifier = "sources"
    from sourceSets.main.allSource
}

// This task creates a .jar file containing a deobfuscated version of this mod, for ProGuard to minimise.
task unmappedJar(type: Jar) {
    archiveClassifier = "unmapped"
    from sourceSets.main.output
}

// This task uses ProGuard to shrink the built .jar's file size and optimise the bytecode. TODO Cleanup.
task proguard(dependsOn: unmappedJar, type: proguard.gradle.ProGuardTask) {
    verbose

    // Use the non-remapped .jar as the input file, because ForgeGradle has a convenient task to map it to obfuscate Minecraft class names for us when we're done optimising it
    injars "build/libs/" + rootProject.name + "-" + version + "-unmapped.jar"
    outjars "build/libs/" + rootProject.name + "-" + version + ".jar"

    // Get the location of rt.jar from the provided toolchain.
    // Note to self: probably support building with not outdated versions of Java in the future.
    libraryjars compiler.get().metadata.installationPath.asFile.absolutePath + "/lib/rt.jar"
    // Probably linux?
    libraryjars compiler.get().metadata.installationPath.asFile.absolutePath + "/jre/lib/rt.jar"
    // Dumb MacOS stuff, Apple's Legacy JDK 6 "rt.jar" equivalent is not in any standard place
    libraryjars compiler.get().metadata.installationPath.asFile.absolutePath + "/../Classes/classes.jar"

    // Add relevant Minecraft libraries to ProGuard's list of libraries to obfuscate against. See ForgeGradle 1.2's UserConstants.
    libraryjars project.configurations.minecraft
    libraryjars project.configurations.minecraftDeps

    // The rest of the configs are in this file
    configuration 'guard.pro'
}

def optimisedJar = proguard.outputs.files.singleFile

// This task remaps the ProGuard obfuscated .jar file from MCP mappings into Minecraft mappings. TODO Find a less cursed way to do this that doesn't only half-remap the .jar file, document more.
task remapProguardProperly(dependsOn: ['genSrgs', 'proguard'], type: net.minecraftforge.gradle.tasks.user.reobf.ReobfTask) {
    def forgeGradlePlugin = plugins.findPlugin 'forge'

    exceptorCfg = forgeGradlePlugin.delayedFile net.minecraftforge.gradle.user.UserConstants.EXC_SRG
    srg = forgeGradlePlugin.delayedFile net.minecraftforge.gradle.user.UserConstants.REOBF_SRG
    fieldCsv = forgeGradlePlugin.delayedFile net.minecraftforge.gradle.user.UserConstants.FIELD_CSV
    fieldCsv = forgeGradlePlugin.delayedFile net.minecraftforge.gradle.user.UserConstants.METHOD_CSV
    mcVersion = forgeGradlePlugin.delayedString '{MC_VERSION}'

    reobf(optimisedJar) { arg ->
        def javaConv = project.convention.plugins.get 'java'
        arg.classpath = javaConv.getSourceSets().getByName('main').compileClasspath
    }

    extraSrg = forgeGradlePlugin.extension.srgExtra

    afterEvaluate {
        if (forgeGradlePlugin.extension.decomp) {
            deobfFile = tasks.deobfuscateJar.delayedOutput
            recompFile = forgeGradlePlugin.delayedDirtyFile forgeGradlePlugin.srcDepName, null, 'jar'
        }
    }
}

// TODO Not sure if this should be kept.
reobf.dependsOn 'remapProguardProperly'

jar {
    archiveClassifier = "debug" // Contains things like variables with actual names, line numbers etc. Useful for debugging, but these things take up file size, so they have to go.
}

// Creates the listed artifacts on building the mod.
artifacts {
    archives sourcesJar
    archives optimisedJar
}

build.finalizedBy(cleanUnmappedJar)

publishing {
    publications {
        mavenJava(MavenPublication) {
            artifact(jar) {
                builtBy build
            }
            artifact(sourcesJar) {
                builtBy sourcesJar
            }
            artifact(optimisedJar) {
                builtBy remapProguardProperly
            }
        }
    }
}