build.gradle

import org.apache.tools.ant.taskdefs.condition.Os

plugins {
    id 'java'
    id 'uk.jamierocks.propatcher' version '2.0.1'
    id 'de.undercouch.download' version '4.1.2'
}

defaultTasks 'generateSource'

project.with {
    group = 'btw.community'
    version = ''
    description = 'Better than Wolves total conversion Minecraft mod'
}

////// PLUMBING //////

ext.mcpDir = "$projectDir/mcp"

java {
    toolchain {
        languageVersion = JavaLanguageVersion.of(8)
        vendor = JvmVendorSpec.ADOPTOPENJDK
    }
}

ext.os = Os.isFamily(Os.FAMILY_WINDOWS) ? "windows" :
         Os.isFamily(Os.FAMILY_UNIX) ? "linux" :
         Os.isFamily(Os.FAMILY_MAC) ?: "osx"

def command(name) {
    if (os == 'windows') {
        return [ 'cmd', '/c', "$mcpDir\\runtime\\bin\\python\\python_mcp", "$mcpDir\\runtime\\${name}.py" ]
    }
    else {
        return [ 'python', "$mcpDir/runtime/${name}.py" ]
    }
}

task unpackMCP(type: Copy) {
    from zipTree('mcp751.zip')
    into file(mcpDir)

    onlyIf {
        !file("$mcpDir/runtime").exists()
    }

    doFirst {
        println '> Setting up MCP'
    }

    doLast {
        def commands = file("$mcpDir/runtime/commands.py")
        def lines = commands.collect { it }

        def jdkBin = javaToolchains
            .compilerFor(java.toolchain).get()
            .metadata.installationPath.asFile
            .absolutePath.replace('\\', '/')

        commands.withPrintWriter { writer ->
            def lineNumber = 1

            lines.each { String line ->
                if (lineNumber < 704 || lineNumber > 752) {
                    writer.println(line)
                }
                else if (lineNumber == 704) {
                    writer.println("        results = [os.path.normpath('$jdkBin/bin')]")
                }

                lineNumber += 1
            }
        }
    }
}

ext.natives = [
    jinput: "https://libraries.minecraft.net/net/java/jinput/jinput-platform/2.0.5/jinput-platform-2.0.5-natives-${os}.jar",
    lwjgl: "https://libraries.minecraft.net/org/lwjgl/lwjgl/lwjgl-platform/2.9.1/lwjgl-platform-2.9.1-natives-${os}.jar"
]

task downloadNatives {
    dependsOn unpackMCP

    for (jar in natives) {
        def task = tasks.create("downloadNative${jar.key.capitalize()}", Download) {
            def destination = file("$mcpDir/jars/bin/natives/${jar.key}.zip")

            src jar.value
            dest destination
            overwrite false
        }

        dependsOn task
    }
}

task unpackNatives(type: Copy) {
    dependsOn downloadNatives

    for (jar in natives) {
        from zipTree("$mcpDir/jars/bin/natives/${jar.key}.zip")
        exclude '**/META-INF/**'
    }

    into "$mcpDir/jars/bin/natives"
}

ext.jars = [
    minecraft: [
        file: 'bin/minecraft.jar',
        url: 'https://launcher.mojang.com/v1/objects/465378c9dc2f779ae1d6e8046ebc46fb53a57968/client.jar'
    ],
    minecraftServer: [
        file: 'minecraft_server.jar',
        url: 'https://launcher.mojang.com/v1/objects/f9ae3f651319151ce99a0bfad6b34fa16eb6775f/server.jar'
    ],
    jinput: [
        file: 'bin/jinput.jar',
        url: 'https://libraries.minecraft.net/net/java/jinput/jinput/2.0.5/jinput-2.0.5.jar'
    ],
    lwjgl: [
        file: 'bin/lwjgl.jar',
        url: 'https://libraries.minecraft.net/org/lwjgl/lwjgl/lwjgl/2.9.1/lwjgl-2.9.1.jar'
    ],
    lwjglUtil: [
        file: 'bin/lwjgl_util.jar',
        url: 'https://libraries.minecraft.net/org/lwjgl/lwjgl/lwjgl_util/2.9.1/lwjgl_util-2.9.1.jar'
    ]
]

task downloadJars {
    dependsOn unpackMCP

    for (jar in jars) {
        def task = tasks.create("download${jar.key.capitalize()}", Download) {
            def destination = file("$mcpDir/jars/$jar.value.file")

            src jar.value.url
            dest destination
            overwrite false
        }

        dependsOn task
    }
}

task decompile(type: Exec) {
    dependsOn unpackMCP, unpackNatives, downloadJars
    group = 'MCP'
    description = 'Generates the vanilla sources.'
    
    onlyIf {
        !file("$mcpDir/src").exists()
    }

    outputs.dir("$mcpDir/bin")
    outputs.dir("$mcpDir/lib")
    outputs.dir("$mcpDir/logs")
    outputs.dir("$mcpDir/src")
    outputs.dir("$mcpDir/temp")
    
    workingDir mcpDir

    if (os == 'windows') {
        commandLine 'cmd', '/c', 'runtime\\bin\\python\\python_mcp', 'runtime\\decompile.py', '--norecompile'
    }
    else {
        commandLine 'python', 'runtime/decompile.py', '--norecompile'
    }
}

task recompile(type: Exec) {
    dependsOn decompile
    group = 'MCP'
    description = 'Builds the code.'

    outputs.dir("$mcpDir/bin")

    workingDir mcpDir

    commandLine(*command('recompile'))
}

task reobfuscate(type: Exec) {
    dependsOn decompile, recompile
    group = 'MCP'
    description = 'Prepares the mod for release in `mcp/reobf`.'

    outputs.dir("$mcpDir/reobf")

    workingDir mcpDir

    commandLine(*command('recompile'))
}

task getchangedsrc(type: Exec) {
    dependsOn decompile, recompile
    group = 'MCP'
    description = 'Outputs the modded source files to `mcp/modsrc`.'

    outputs.dir("$mcpDir/modsrc")

    workingDir mcpDir

    commandLine(*command('recompile'))
}

patches {
    rootDir = file("$mcpDir/src")
    target = file("$projectDir/src")
    patches = file("$projectDir/patches")
}

makePatches {
    dependsOn decompile

    onlyIf {
        file("$projectDir/src").exists()
    }

    doFirst {
        println '> Creating patches'

        file("$projectDir/patches").mkdir()
    }
}

resetSources {
    dependsOn decompile

    onlyIf {
        file("$projectDir/src").exists()
    }
}

applyPatches {
    dependsOn decompile, makePatches
    
    outputs.dir("$mcpDir/src")
    
    doFirst {
        println '> Applying BTW patches'

        file("$projectDir/patches").mkdir()
    }

    onlyIf {
        file("$projectDir/patches").exists() &&
        !file("$mcpDir/src/minecraft/net/minecraft/src/FCAddon.java").exists()
    }

    afterEvaluate {
        tasks.applyPatches.target = file("$mcpDir/src")
    }
}

task generateSource(type: Exec) {
    dependsOn decompile, applyPatches

    outputs.dir("$mcpDir/temp")
    outputs.dir("$mcpDir/logs")

    workingDir mcpDir

    commandLine(*command('updatemd5'), '--force')

    onlyIf {
        file("$projectDir/patches").exists() &&
        !file("$mcpDir/src/minecraft/net/minecraft/src/FCAddon.java").exists()
    }
}

task ingest {
    dependsOn tasks.clean
    finalizedBy generateSource

    doFirst {
        delete "$projectDir/changelog.txt"
        delete "$projectDir/resources"

        delete "$projectDir/src/minecraft"
        delete "$projectDir/src/minecraft_server"

        delete "$mcpDir/src"
        delete "$mcpDir/temp"

        copy {
            eachFile {
                path -= ~/^.+?\//
            }

            from zipTree(fileTree("$projectDir/src").singleFile)
            into "$projectDir/src"

            exclude '**/README.md'
            include '**/changelog.txt'
            include '**/resources/**'
            include '**/minecraft/**'
            include '**/minecraft_server/**'

            includeEmptyDirs = false
        }

        copy {
            from "$projectDir/src/changelog.txt"
            from("$projectDir/src/resources") {
                into 'resources'
            }
            into projectDir
        }

        delete "$projectDir/src/changelog.txt"
        delete "$projectDir/src/resources"

        delete fileTree("$projectDir/src").filter { it.path.endsWith('zip') }
    }
}