build.gradle

buildscript {
    repositories {
        mavenLocal()
        maven { url = 'https://files.minecraftforge.net/maven' }
        jcenter()
        //mavenCentral() //TODO: Update Gradle to use HTTPS by default
        maven {
            name 'maven_central'
            url 'https://repo.maven.apache.org/maven2/'
        }
    }
    dependencies {
        classpath 'net.minecraftforge.gradle:ForgeGradle:3.0.190'
        classpath 'org.ow2.asm:asm:7.2'
        classpath 'org.ow2.asm:asm-tree:7.2'
        classpath 'com.github.abrarsyed.jastyle:jAstyle:1.3'
        classpath 'com.google.code.gson:gson:2.8.0' // because groovy JsonGenerator doesn't exist wtf
        classpath 'commons-io:commons-io:2.6'
        //classpath "gradle.plugin.com.dorongold.plugins:task-tree:1.3" // For debug purposes
    }
}

import com.github.abrarsyed.jastyle.ASFormatter;
import com.github.abrarsyed.jastyle.OptParser
import com.google.common.collect.Maps;
import com.google.gson.GsonBuilder
import groovy.json.JsonSlurper
import java.util.zip.*
import org.apache.commons.io.IOUtils
import org.apache.commons.io.input.NullInputStream
import org.objectweb.asm.*
import org.objectweb.asm.tree.*
import org.gradle.plugins.ide.eclipse.model.SourceFolder

// ===== MAIN BUILDSCRIPT ===== //

// configuration
def settings = new JsonSlurper().parseText(file('conf/settings.json').text)

apply plugin: 'eclipse'
//apply plugin: "com.dorongold.task-tree" // For debug purposes

group = 'com.example'
version = settings.modversion


// subprojects

project(':mcp') {
    apply plugin: 'net.minecraftforge.gradle.mcp'
    repositories {
        mavenLocal()
    }
    mcp {
        config = 'de.oceanlabs.mcp:mcp_config:' + settings.mcpconfig + '@zip'
        pipeline = settings.pipeline
    }
}


project(':clean') {
    evaluationDependsOn(':mcp')
    apply plugin: 'eclipse'
    apply plugin: 'net.minecraftforge.gradle.patcher'
    
    compileJava.sourceCompatibility = compileJava.targetCompatibility = sourceCompatibility = targetCompatibility = '1.8' // Need this here so eclipse task generates correctly.

    repositories {
        mavenLocal()
        //mavenCentral() //TODO: Update Gradle to use HTTPS by default
        maven {
            name 'maven_central'
            url 'https://repo.maven.apache.org/maven2/'
        }
    }
    dependencies {
        compileOnly('net.minecraftforge:forgespi:2.0.+')
    }
    patcher {
        parent = project(':mcp')
        mcVersion = settings.mcversion
        patchedSrc = file('src/main/java')
        mappings channel: 'snapshot', version: settings.mappings
    }
    task runclient(type: JavaExec) {
        doFirst {
            mkdir 'runclient'
        }
        classpath sourceSets.main.runtimeClasspath
        args = ['--accessToken', '0', '--version', '1.16.5']
        main settings.clientmain
        workingDir 'runclient'
    }
}


project(':' + settings.modname) {
    evaluationDependsOn(':clean')
    apply plugin: 'java-library'
    apply plugin: 'eclipse'
    apply plugin: 'net.minecraftforge.gradle.patcher'
    
    compileJava.sourceCompatibility = compileJava.targetCompatibility = sourceCompatibility = targetCompatibility = '1.8' // Need this here so eclipse task generates correctly.
    
    sourceSets {
        main {
            java {
                srcDir "$rootDir/src/main/java"
            }
            resources {
                srcDir "$rootDir/src/main/resources"
            }
        }
    }
    
    eclipse.classpath.file.whenMerged { cls -> cls.entries.removeIf { e -> e instanceof SourceFolder && e.path.startsWith('src/') && !e.path.startsWith('src/main/') } }
    
    repositories {
        mavenLocal()
        //mavenCentral() //TODO: Update Gradle to use HTTPS by default
        maven {
            name 'maven_central'
            url 'https://repo.maven.apache.org/maven2/'
        }
    }
    patcher {
        parent = project(':clean')
        patches = file("$rootDir/patches")
        patchedSrc = file('src/main/java')
        srgPatches = false
        getRuns().each { run ->
            if (run.getName().equals(settings.modname + '_client')) {
                run.setMain(settings.clientmain)
                run.environment('assetDirectory', downloadAssets.output)
            } else if (run.getName().equals(settings.modname + '_server')) {
                run.setMain(settings.servermain)
            }
            run.workingDirectory(project.file('run'))
        }
    }
    applyPatches {
        canonicalizeAccess true
        canonicalizeWhitespace true
        maxFuzz 3
    }
    dependencies {
        compileOnly('net.minecraftforge:forgespi:2.0.+') { transitive = false }
        // Add extra dependencies here
    }
    
    tasks.eclipse.dependsOn('genEclipseRuns')
    
    task runclient(type: JavaExec, dependsOn: [":" + settings.modname + ":downloadAssets", ":" + settings.modname + ":extractNatives"]) {
        doFirst {
            mkdir "$rootDir/runclient"
        }
        doFirst {
            copy {
                from sourceSets.main.resources
                into "$buildDir/classes/java/main"
            }
        }
        classpath sourceSets.main.runtimeClasspath
        main settings.clientmain
        systemProperties = [
                "org.lwjgl.util.Debug": "true",
                "org.lwjgl.util.DebugLoader": "true"
        ]
        environment += [
                assetDirectory: file("${gradle.getGradleUserHomeDir()}/caches/forge_gradle/assets/"),
                nativesDirectory: extractNatives.output
        ]
        workingDir "$rootDir/runclient"
    }

    task runserver(type: JavaExec) {
        doFirst {
            mkdir "$rootDir/runserver"
        }
        classpath sourceSets.main.runtimeClasspath
        main settings.servermain
        args 'nogui'
        workingDir "$rootDir/runserver"
    }
}


// Main setup task
task setup() {
    dependsOn ':clean:extractMapped'
    dependsOn ':' + settings.modname + ':extractMapped' //These must be strings so that we can do lazy resolution. Else we need evaluationDependsOnChildren above
}

// ===== UTILITY ===== //
class JarFilter {
    String filename
    final InputStream istream
    final boolean newFile
    JarFilter(String filename, InputStream istream, boolean newFile) {
        this.filename = filename
        this.istream = istream
        this.newFile = newFile
    }
    static def filterJar(File jarIn, File jarOut, Closure transformer, Map<File, String> additionalDirs = [:]) {
        def existing = [] as HashSet
        def zipOut = new ZipOutputStream(new FileOutputStream(jarOut))
        additionalDirs.each { additionalDir, prefix ->
            additionalDir.eachFileRecurse { file ->
                def filter = new JarFilter(prefix + additionalDir.toPath().relativize(file.toPath()).toString().replace(File.separator, '/'), file.isDirectory() ? new NullInputStream(0) : file.newInputStream(), true)
                transformer.delegate = filter
                def content = transformer.call()
                if (content != null && !existing.contains(filter.filename)) {
                    def entryOut = new ZipEntry(filter.filename)
                    existing << filter.filename
                    zipOut.putNextEntry(entryOut)
                    zipOut << content
                    zipOut.closeEntry()
                }
            }
        }
        def zipIn = new ZipFile(jarIn)
        zipIn.entries().each { entryIn ->
            def filter = new JarFilter(entryIn.getName(), zipIn.getInputStream(entryIn), false)
            transformer.delegate = filter
            def content = transformer.call()
            if (content != null && !existing.contains(filter.filename)) {
                def entryOut = new ZipEntry(filter.filename)
                existing << filter.filename
                zipOut.putNextEntry(entryOut)
                zipOut << content
                zipOut.closeEntry()
            }
        }
        zipIn.close()
        zipOut.close()
    }
}

class CheckModifiedHelper {
    Map<String, Boolean> changedMap = Maps.<String, Boolean>newTreeMap()
    String modname
    String inputTaskName
    String inputArchiveName

    String getCleanFilepath()
    {
        return 'projects/clean/build/' + inputTaskName + '/' + inputArchiveName
    }

    String getModdedFilepath()
    {
        return 'projects/' + modname + '/build/' + inputTaskName + '/' + inputArchiveName
    }

    CheckModifiedHelper(String modname, String taskname, String archivname)
    {
        this.modname = modname
        this.inputTaskName = taskname
        this.inputArchiveName = archivname
    }

    def filterUnchanged() {
        def cleanFilename = getCleanFilepath()
        def moddedFilename = getModdedFilepath()

        def zipIn = new ZipFile(moddedFilename)
        zipIn.entries().each { moddedFile ->
            def entryName = moddedFile.toString()

            def vanillaJar = new ZipFile(cleanFilename)
            def vanillaEntry = vanillaJar.getEntry entryName

            if (vanillaEntry != null) {
                def moddedJar = new ZipFile(moddedFilename)
                def moddedEntry = moddedJar.getEntry entryName

                boolean modded = !IOUtils.contentEquals(vanillaJar.getInputStream(vanillaEntry), moddedJar.getInputStream(moddedEntry))
                changedMap.put(entryName, modded)
            }
        }
        zipIn.close()
    }

    boolean isModified(String entryName) {
        if (changedMap.containsKey(entryName)) {
            boolean changed = changedMap.get(entryName)
            if (changed)
                return true

            if (entryName.contains('$')) { // Check if outer Class has changed, if yes we need this too
                String parentEntry = entryName.substring(0, entryName.lastIndexOf('$')) + '.class'
                return changedMap.containsKey(parentEntry) && isModified(parentEntry)
            }

            return false
        }

        return true // Propably a new file so include it
    }
}

// ===== FIXES ===== //

// Fix recompilation requiring extractSrg output
setup.dependsOn ':clean:extractSrg'

// Generic fixMcpConfig task for anything that needs to modify the mcpconfig
class FixMcpConfigTask extends DefaultTask {
    List<Closure> configActions = []
    List<Closure> filterActions = []
    Map<File, String> additionalDirs = [:]
    void configAction(Closure action) {
        configActions.add(action)
    }
    void filterAction(Closure action) {
        filterActions.add(action)
    }
    void additionalDir(Object dir, String prefix) {
        additionalDirs.put(project.file(dir), prefix)
    }
    @TaskAction
    void filterMcpConfig() {
        JarFilter.filterJar(project.file(project.downloadConfig.output), project.file('build/mcp_config.zip'), {
            if (filename == 'config.json') {
                def cfg = new JsonSlurper().parse(istream)
                for (def action : configActions) {
                    action.call(cfg)
                }
                return new GsonBuilder().setPrettyPrinting().create().toJson(cfg)
            } else {
                for (def action : filterActions) {
                    action.delegate = delegate
                    def newistream = action.call()
                    if (!istream.is(newistream))
                        return newistream
                }
                return istream
            }
        }, additionalDirs)
    }
    
    static def register(def proj) {
        if (!proj.ext.properties.containsKey('registered')) {
            proj.ext.registered = true
            proj.downloadConfig.output = proj.file('build/mcp_config_broken.zip')
            proj.task('fixMcpConfig', type: FixMcpConfigTask) {
                dependsOn proj.downloadConfig
                inputs.file proj.downloadConfig.output
                outputs.file 'build/mcp_config.zip'
            }
            proj.loadConfig.dependsOn proj.fixMcpConfig
        }
    }
}

// Fix https://github.com/MinecraftForge/ForgeGradle/issues/517 - FG3 server pipeline missing download version JSON
// Also fix recompile error on server due to mcp.client.Start being present
if (settings.pipeline == 'server') {
    project(':mcp') {
        FixMcpConfigTask.register(project)
        fixMcpConfig.configAction {cfg -> cfg.steps.server.add(1, [type: 'downloadJson'])}
        fixMcpConfig.filterAction {return filename.startsWith('config/inject/mcp/client/') ? null : istream}
    }
}

// Custom SRG
if (settings.customsrg != null) {
    project(':mcp') {
        FixMcpConfigTask.register(project)
        fixMcpConfig.configAction { cfg ->
            cfg.version = settings.mcversion
            cfg.data.mappings = 'config/' + settings.customsrg
        }
        fixMcpConfig.filterAction {
            if (filename == 'config/joined.tsrg') {
                filename = 'config/' + settings.customsrg
                return new FileInputStream(rootProject.file('conf/' + settings.customsrg))
            } else if (filename.startsWith('patches/') && !newFile) {
                return null
            } else {
                return istream
            }
        }
        if (settings.customconstructors != null) {
            fixMcpConfig.configAction { cfg ->
                cfg.data.constructors = 'config/' + settings.customconstructors
            }
            fixMcpConfig.filterAction {
                if (filename == 'config/constructors.txt') {
                    filename = 'config/' + settings.customconstructors
                    return new FileInputStream(rootProject.file('conf/' + settings.customconstructors))
                } else {
                    return istream
                }
            }
        }
    }
} else if (settings.nopatches) {
    project(':mcp') {
        FixMcpConfigTask.register(project)
        fixMcpConfig.filterAction {
            if (filename.startsWith('patches/') && !newFile) {
                return null
            } else {
                return istream
            }
        }
    }
}

// Custom Fernflower
if (settings.fernflower != null) {
    project(':mcp') {
        FixMcpConfigTask.register(project)
        fixMcpConfig.configAction { cfg ->
            cfg.functions.decompile.version = settings.fernflower
        }
    }
}

// Custom patches
if (rootProject.file('conf/patches/').exists()) {
    project(':mcp') {
        FixMcpConfigTask.register(project)
        fixMcpConfig.additionalDir(rootProject.file('conf/patches/'), 'patches/' + settings.pipeline + '/')
    }
}
if (rootProject.file('conf/inject/').exists()) {
    project(':mcp') {
        FixMcpConfigTask.register(project)
        fixMcpConfig.additionalDir(rootProject.file('conf/inject/'), 'config/inject/')
    }
}

// Fix formatting, optionally
if (settings.reformat) {
    project(':mcp') {
        task reformat {
            dependsOn setupMCP
            inputs.file setupMCP.output
            outputs.file 'build/reformat/output.zip'
            doLast {
                def formatter = new ASFormatter()
                formatter.setUseProperInnerClassIndenting(false)
                def parser = new OptParser(formatter)
                parser.parseOptionFile(rootProject.file('conf/astyle.cfg'))
                
                JarFilter.filterJar(file(setupMCP.output), file('build/reformat/output.zip')) {
                    if (filename.endsWith('.java') && !filename.endsWith('package-info.java')) {
                        def sw = new StringWriter()
                        try {
                            formatter.format(new InputStreamReader(istream), sw)
                            return sw.toString()
                        } catch (RuntimeException e) {
                            println('Failed to reformat ' + filename)
                            return istream
                        }
                    } else {
                        return istream
                    }
                }
            }
        }
    }
    project(':clean') {
        applyPatches.dependsOn project(':mcp').reformat
        applyPatches.setClean(project(':mcp').file('build/reformat/output.zip'))
    }
}

// Fix reobf error due to local variable signatures (with lambdas?). Apply to both clean and modded to keep the classes the same
for (def projname : [':clean', ':' + settings.modname]) {
    project(projname) {
        def reobfArgs = []
        reobfJar.args.each {reobfArgs << it}
        reobfArgs << '--kill-lvt'
        reobfJar.args = reobfArgs.toArray([] as String[])
    }
}

// ===== RELEASE TASKS ===== //

// Utility class for dealing with @OnlyIn(Dist.XXX) using ASM
class DistUtils {
    static def containsUnwanted(List<AnnotationNode> anns, String unwanted) {
        if (anns == null)
            return false
        def annItr = anns.iterator()
        while (annItr.hasNext()) {
            def ann = annItr.next()
            if (ann.desc == 'Lnet/minecraftforge/api/distmarker/OnlyIn;') {
                annItr.remove()
                def value = ann.values[1]
                value = value[1]
                return value == unwanted
            }
        }
        return false
    }
    
    static def classUnwanted(InputStream istream, String unwanted) {
        ClassReader reader = new ClassReader(istream)
        ClassNode clazz = new ClassNode()
        reader.accept(clazz, ClassReader.SKIP_CODE)
        return containsUnwanted(clazz.visibleAnnotations, unwanted)
    }
    
    static def stripDist(InputStream istream, String unwanted, Closure classProvider) {
        ClassReader reader = new ClassReader(istream)
        ClassNode clazz = new ClassNode()
        reader.accept(clazz, 0)
        
        if (containsUnwanted(clazz.visibleAnnotations, unwanted))
            return null
        
        if (clazz.interfaces != null) {
            def itfItr = clazz.interfaces.iterator()
            while (itfItr.hasNext()) {
                def itf = classProvider.call(itfItr.next())
                if (itf != null && classUnwanted(itf, unwanted))
                    itfItr.remove()
            }
        }
        
        if (clazz.fields != null) {
            def fieldItr = clazz.fields.iterator()
            while (fieldItr.hasNext())
                if (containsUnwanted(fieldItr.next().visibleAnnotations, unwanted))
                    fieldItr.remove()
        }
        
        if (clazz.methods != null) {
            def methodItr = clazz.methods.iterator()
            while (methodItr.hasNext())
                if (containsUnwanted(methodItr.next().visibleAnnotations, unwanted))
                    methodItr.remove()
        }
        
        if (clazz.innerClasses != null) {
            def innerClassItr = clazz.innerClasses.iterator()
            while (innerClassItr.hasNext()) {
                def innerClass = innerClassItr.next()
                if (innerClass.outerName == clazz.name && classUnwanted(classProvider.call(innerClass.name), unwanted))
                    innerClassItr.remove()
            }
        }
        
        ClassWriter writer = new ClassWriter(0)
        clazz.accept(writer)
        return writer.toByteArray()
    }
}

// Tasks to split joined jars into client and server jars
if (settings.pipeline == 'joined') {
    for (def projname : [':clean', ':' + settings.modname]) {
        project(projname) {
            def dists = ['Client', 'Server']
            def unwantedDists = ['DEDICATED_SERVER', 'CLIENT']
            for (def i = 0; i < 2; i++) {
                def idx = i
                task('filterDist' + dists[idx]) {
                    reobfJar.doFirst {
                        setSrg createMcp2Obf.getOutput()
                    }
                    dependsOn 'createMcp2Obf', reobfJar
                    inputs.file reobfJar.output
                    outputs.file 'build/filterDist' + dists[idx] + '/output.zip'
                    doLast {
                        JarFilter.filterJar(file(reobfJar.output), file('build/filterDist' + dists[idx] + '/output.zip')) {
                            if (filename.endsWith('.class')) {
                                return DistUtils.stripDist(istream, unwantedDists[idx]) { classname ->
                                    def zip = new ZipFile(file(reobfJar.output))
                                    def entry = zip.getEntry(classname + '.class')
                                    if (entry == null)
                                        return null
                                    return zip.getInputStream(entry)
                                }
                            } else {
                                return istream
                            }
                        }
                    }
                }
            }
        }
    }
}

// Tasks to produce zip files containing only the changed classes, making the final release zip
for (def dist : ['Client', 'Server']) {
    task('createRelease' + dist, type: Zip) {
        def inputTaskName = settings.pipeline == 'joined' ? 'filterDist' + dist : 'reobfJar'
        def inputArchiveName = settings.pipeline == 'joined' ? 'output.zip' : 'output.jar'

        dependsOn ':clean:' + inputTaskName, ':' + settings.modname + ':' + inputTaskName
        
        CheckModifiedHelper check = new CheckModifiedHelper(settings.modname, inputTaskName, inputArchiveName)
        doFirst {
            check.filterUnchanged()
        }

        from(zipTree(check.getModdedFilepath())) {
            eachFile { moddedFile ->
                def entryName = moddedFile.getRelativePath().toString()
                if (!check.isModified(entryName))
                    moddedFile.exclude()
            }
        }

        archiveName = "${settings.modname}_${project.version}_${dist}.zip"
        destinationDir = file('build/distributions')
        includeEmptyDirs = false
    }
}

// Master task to invoke all createRelease tasks
task createRelease {
    if (settings.pipeline != 'server')
        dependsOn createReleaseClient
    if (settings.pipeline != 'client')
        dependsOn createReleaseServer
}

//Adds idea tools tab
project(':tools') {
    task setupProject {
        group = 'tools ' + settings.modname
        description = 'Sets project up from patches, or clean project running it the first time'
        dependsOn setup
    }
    task generatePatches {
        group = 'tools ' + settings.modname
        description = 'Convert project to patches for public distribution'
        dependsOn project(':' + settings.modname).genPatches
    }
    task releaseProject {
        group = 'tools ' + settings.modname
        description = 'Creates a release from the current project'
        dependsOn createRelease
    }
    task runServer {
        group = 'tools ' + settings.modname
        description = 'Runs server'
        dependsOn project(':' + settings.modname).runserver
    }
    task runClient {
        group = 'tools ' + settings.modname
        description = 'Runs client'
        dependsOn project(':' + settings.modname).runclient
    }
}