build.gradle

buildscript {
    repositories {
        mavenCentral()
        maven {
            name = "jitpack"
            url = "https://jitpack.io"

            content {
                includeGroup "com.github.Juuxel"
            }
        }
    }

    dependencies {
        classpath "com.github.Juuxel:fc0-tools:1.1.4"
    }
}

import juuxel.fc0.tools.bytecodetweaker.BytecodeTweaker
import net.fabricmc.stitch.commands.CommandFixNesting

import java.nio.file.Files

plugins {
    id 'java'
    id 'application'
    id 'org.jetbrains.gradle.plugin.idea-ext' version '0.7'
}

mainClassName = 'tk.valoeghese.fc0.client.Main'
sourceCompatibility = JavaVersion.VERSION_1_8

group 'tk.valoeghese'
version '0.2.3'

repositories {
    mavenCentral()
    
    maven {
        name = "FabricMC"
        url = "https://maven.fabricmc.net"
    }
}

configurations {
    enigma {
        extendsFrom runtimeClasspath
    }

    game {
        extendsFrom runtimeClasspath
    }
}

def gameJar = project.file("2fc0f18-${version}.jar")
def mappingsDir = project.file('mappings')
def intermediaryJar = project.file("build/intermediary-${gameJar.name}")
def runDirectory = project.file('run')

if (!gameJar.exists()) {
    def url = new URL("https://github.com/valoeghese/2fc-early-releases/raw/master/2fc0f18-${version}.jar")
    try {
        println "Downloading 2fc0f18 v$version"

        def stream = url.openStream()
        try {
            Files.copy(stream, gameJar.toPath())
        } finally {
            stream.close()
        }
    } catch (IOException e) {
        System.err.println "Could not download 2fc0f18 v$version"
        e.printStackTrace()
    }
}

if (!runDirectory.exists()) {
    runDirectory.mkdir()
}

dependencies {
    game files(gameJar)

    // lwjgl
    implementation "org.lwjgl:lwjgl:${project.lwjgl_version}"
    implementation "org.lwjgl:lwjgl-assimp:${project.lwjgl_version}"
    //implementation "org.lwjgl:lwjgl-jawt:${project.lwjgl_version}"
    implementation "org.lwjgl:lwjgl-opengl:${project.lwjgl_version}"
    implementation "org.lwjgl:lwjgl-glfw:${project.lwjgl_version}"
    implementation "org.lwjgl:lwjgl-openal:${project.lwjgl_version}"
    implementation "org.lwjgl:lwjgl-stb:${project.lwjgl_version}"
    // joml
    implementation "org.joml:joml:${project.joml_version}"
    // fastutil
    implementation "it.unimi.dsi:fastutil:${project.fastutil_version}"
    // lwjgl natives
    runtimeOnly "org.lwjgl:lwjgl:${project.lwjgl_version}:${project.natives}"
    runtimeOnly "org.lwjgl:lwjgl-assimp:${project.lwjgl_version}:${project.natives}"
    runtimeOnly "org.lwjgl:lwjgl-opengl:${project.lwjgl_version}:${project.natives}"
    runtimeOnly "org.lwjgl:lwjgl-glfw:${project.lwjgl_version}:${project.natives}"
    runtimeOnly "org.lwjgl:lwjgl-openal:${project.lwjgl_version}:${project.natives}"
    runtimeOnly "org.lwjgl:lwjgl-stb:${project.lwjgl_version}:${project.natives}"

    compileOnly "com.google.code.findbugs:jsr305:3.0.2"
    testCompile group: 'junit', name: 'junit', version: '4.12'
    
    enigma "cuchaz:enigma:$project.enigma_version"
}

task intermediary(type: RemapJarTask) {
    inputJar = gameJar
    mappings = file("intermediary/${version}.tiny")
    libraries = configurations.runtimeClasspath
    outputJar = intermediaryJar
    from = "official"
    to = "intermediary"

    doLast {
        CommandFixNesting.run(outputJar)

        def tweakFile = file("bytecode_tweaks/${version}.json")
        if (tweakFile.exists()) {
            new BytecodeTweaker(tweakFile).run(outputJar.toPath())
        }
    }
}

task deobf(type: DeobfuscateTask, dependsOn: intermediary) {
    group = "fc0"
    mappings = mappingsDir
    intermediaryMappings = file("intermediary/${version}.tiny")
    inputJar = intermediaryJar
    outputJar = file("build/deobf-${gameJar.name}")
    libraries = configurations.runtimeClasspath
    outputMappings = file("build/mappings.tiny")
}

task decompile(type: DecompileTask, dependsOn: deobf) {
    group = "fc0"
    input = deobf.outputJar
    output = file('src/main/java')
    cleanOutput = file('src/raw/java')
    libraries = configurations.runtimeClasspath

    doLast {
        println "Decompiled! Note that you should only modify src/main and leave src/clean and src/raw untouched!"
    }
}

task extractResources(type: ExtractResourcesTask) {
    group = "fc0"
    input = gameJar
    output = file('src/main/resources')
}

task applyPatches(type: ApplyPatchesTask) {
    group = "fc0"
    patches = file('patches')
    // raw -> clean
    cleanSources = decompile.cleanOutput
    intermediateSources = file('src/clean/java')
    userSources = decompile.output
}

task generateModPatches(type: GeneratePatchesTask) {
    group = "fc0"
    cleanSources = applyPatches.intermediateSources
    revisedSources = applyPatches.userSources
    patchOutput = file('src/main/diff')
}

task generateFullPatches(type: GeneratePatchesTask) {
    group = "fc0"
    cleanSources = applyPatches.cleanSources
    revisedSources = applyPatches.userSources
    patchOutput = file('build/full-diff')
}

task setup(dependsOn: [decompile, extractResources]) {
    group = "fc0"
}

task obfuscate(type: RemapJarTask, dependsOn: [deobf, jar]) {
    group = "fc0"
    inputJar = jar.outputs.files.singleFile
    mappings = deobf.outputMappings
    libraries = configurations.runtimeClasspath
    outputJar = file("build/libs/${archivesBaseName}-${version}-obfuscated.jar")
    from = "named"
    to = "official"
}

task modJar(type: DiffJarTask, dependsOn: [deobf, generateModPatches, obfuscate]) {
    group = "fc0"
    originJar = gameJar
    patches = files(generateModPatches.patchOutput)
    modifiedJar = obfuscate.outputJar
    mappings = deobf.outputMappings
    output = file("build/libs/${archivesBaseName}-${version}-mod.jar")
}

task fullPatchZip(type: Zip, dependsOn: generateFullPatches) {
    group = "fc0"
    from fileTree(generateFullPatches.patchOutput)
    archiveName "${archivesBaseName}-${project.version}-patches.zip"
    destinationDir file('build/libs')
}

task runUnmoddedGame(type: JavaExec) {
    group = "fc0"
    classpath = configurations.game
    main = "tk.valoeghese.fc0.client.Main"
    workingDir = runDirectory
}

run {
    workingDir = runDirectory
}

build.dependsOn modJar, fullPatchZip

task enigma(dependsOn: intermediary) {
    group = "fc0"
    doLast {
        ant.setLifecycleLogLevel "WARN"
        ant.java(
            classname: 'cuchaz.enigma.Main',
            classpath: configurations.enigma.asPath,
            fork: true,
            spawn: true
        ) {
            jvmarg(value: "-Xmx2048m")
            arg(value: '-jar')
            arg(value: intermediaryJar.getAbsolutePath())
            arg(value: '-mappings')
            arg(value: mappingsDir.getAbsolutePath())
        }
    }
}

idea {
    project.settings {
        delegateActions {
            delegateBuildRunToGradle = false
        }

        runConfigurations {
            "Run"(org.jetbrains.gradle.ext.Application) {
                mainClass = application.mainClassName
                workingDirectory = runDirectory.absolutePath
                moduleName = module.name + ".main"
            }
        }
    }
}