build.gradle

import net.minecraftforge.gradle.userdev.tasks.RenameJar
import net.minecraftforge.gradleutils.GradleUtils
import net.minecraftforge.srgutils.IMappingFile

import java.nio.file.Files
import net.minecraftforge.forge.tasks.*
import net.minecraftforge.forge.tasks.checks.*
import static net.minecraftforge.forge.tasks.Util.*

import net.minecraftforge.gradle.common.tasks.CheckJarCompatibility
import net.minecraftforge.gradle.common.tasks.DownloadMavenArtifact
import net.minecraftforge.gradle.common.tasks.ExtractInheritance
import net.minecraftforge.gradle.common.tasks.SignJar
import net.minecraftforge.gradle.common.tasks.ApplyBinPatches
import net.minecraftforge.gradle.common.tasks.ExtractMCPData
import net.minecraftforge.gradle.patcher.tasks.GenerateBinPatches

import org.apache.tools.ant.filters.ReplaceTokens
import org.gradle.plugins.ide.eclipse.model.SourceFolder
import org.apache.commons.compress.compressors.lzma.LZMACompressorOutputStream

plugins {
    id 'org.cadixdev.licenser' version '0.6.1'
    id 'net.minecraftforge.gradleutils' version '2.+'
    id 'eclipse'
    id 'de.undercouch.download' version '5.4.0'
    id 'net.minecraftforge.gradle.patcher' version '[5.1.50,5.2.0)' apply false
    id 'net.minecraftforge.gradle.mcp' version '[5.1.50,5.2.0)' apply false
}

Util.init() //Init all our extension methods!

//------------------------------------------------------------------------------------------------------------------------------------------
// Configuration
//------------------------------------------------------------------------------------------------------------------------------------------

ext {
    JAR_SIGNER = null
    if (project.hasProperty('keystore')) {
        JAR_SIGNER = [
            storepass: project.properties.keystoreStorePass,
            keypass: project.properties.keystoreKeyPass,
            keystore: project.properties.keystore
        ]
    }
    MAPPING_CHANNEL = 'snapshot_nodoc'
    MAPPING_VERSION = '20161220-1.11'
    MC_VERSION = '1.11.2'
    MCP_VERSION = '20210824.173128'
    POST_PROCESSOR = [
        tool: 'net.minecraftforge:mcpcleanup:2.3.6:fatjar',
        repo: 'https://maven.minecraftforge.net/',
        args: ['--input', '{input}', '--output', '{output}', '--fix-generic-params']
    ]
    MERGETOOL_VERSION = '0.2.3.3'
    INSTALLER_VERSION = '2.1.+'

    GIT_INFO = gradleutils.gitInfo
}

//------------------------------------------------------------------------------------------------------------------------------------------
// RetroGradle
//------------------------------------------------------------------------------------------------------------------------------------------

apply from: 'retrogradle-dev.gradle'
ext {
    LEGACY_MAJOR = 13                                      // Legacy versions have an API change prefix
    LEGACY_BUILD = 2588                                    // Base build number to not conflict with existing build numbers
    BUILD_NUMBER = LEGACY_BUILD + (GIT_INFO.offset as int) // LEGACY_BUILD + commit offset, used to mimic unique build from old versions
    SPEC_VERSION = '20.1'                                  // This is overwritten by git tag, but here so dev time doesn't explode
    VERSION = GradleUtils.getMCTagOffsetBranchVersion(GIT_INFO + [tag: "${LEGACY_MAJOR}.${SPEC_VERSION}", offset: BUILD_NUMBER], MC_VERSION)
    FORGE_VERSION = VERSION.substring(MC_VERSION.length() + 1)
    MIN_TAG_FOR_CHANGELOG = '20.0'
}

println('Version: ' + VERSION +
        ' Java: ' + System.getProperty('java.version') +
        ' JVM: ' + System.getProperty('java.vm.version') + '(' + System.getProperty('java.vendor') + ')' +
        ' Arch: ' + System.getProperty('os.arch'))

// TODO RG: Enable changelog
// changelog {
//     fromTag MIN_TAG_FOR_CHANGELOG
// }

//--------------------------------------------------------------------------------------------------------------------------------------
// Extra text files for installer
//--------------------------------------------------------------------------------------------------------------------------------------

def extraTxts = [
    rootProject.file('CREDITS.txt'),
    rootProject.file('LICENSE.txt'),
    rootProject.file('LICENSE-Paulscode IBXM Library.txt'),
    rootProject.file('LICENSE-Paulscode SoundSystem CodecIBXM.txt')
]

if (rootProject.tasks.findByName('createChangelog'))
    extraTxts.add rootProject.tasks.createChangelog.outputFile

subprojects {
    apply plugin: 'maven-publish'
    apply plugin: 'eclipse'
    apply plugin: 'java'

    group = 'net.minecraftforge'
    version = VERSION

    repositories {
        mavenLocal()
        mavenCentral()
        maven {
            name = 'forge'
            url = 'https://maven.minecraftforge.net/'
        }
        maven {
            name = 'minecraft'
            url = 'https://libraries.minecraft.net/'
        }
    }

    java.toolchain.languageVersion = JavaLanguageVersion.of(8)

    tasks.withType(Javadoc).configureEach {
        options.tags = [
                'apiNote:a:<em>API Note:</em>',
                'implSpec:a:<em>Implementation Requirements:</em>',
                'implNote:a:<em>Implementation Note:</em>'
        ]
        options.addStringOption('Xdoclint:all,-missing', '-public')
    }

    publishing {
        publications {
            mavenJava(MavenPublication) {
                // Normal Maven/old gradle doesn't support '2.+' version wildcards
                // For now we just suppress. We *should* force the resolution to pinned versions.
                suppressPomMetadataWarningsFor('apiElements')
                suppressPomMetadataWarningsFor('runtimeElements')
                pom {
                    name = project.name
                    description = 'Modifactions to Minecraft to enable mod developers.'
                    url = 'https://github.com/MinecraftForge/MinecraftForge'

                    scm {
                        url = 'https://github.com/MinecraftForge/MinecraftForge'
                        connection = 'scm:git:git://github.com/MinecraftForge/MinecraftForge.git'
                        developerConnection = 'scm:git:git@github.com:MinecraftForge/MinecraftForge.git'
                    }

                    issueManagement {
                        system = 'github'
                        url = 'https://github.com/MinecraftForge/MinecraftForge/issues'
                    }

                    licenses {
                        license {
                            name = 'LGPL 2.1'
                            url = 'https://github.com/MinecraftForge/MinecraftForge/blob/1.13-pre/LICENSE.txt'
                            distribution = 'repo'
                        }
                    }
                }
            }
        }
        repositories {
            maven gradleutils.getPublishingForgeMaven()
        }
    }
}

//------------------------------------------------------------------------------------------------------------------------------------------
// MCP
//------------------------------------------------------------------------------------------------------------------------------------------

project(':mcp') {
    apply plugin: 'net.minecraftforge.gradle.mcp'
    tasks.withType(AbstractPublishToMaven.class).forEach{tsk -> tsk.enabled = false } // We don't want to publish anything
    mcp {
        config MC_VERSION + '-' + MCP_VERSION
        pipeline = 'joined'
    }
}

//------------------------------------------------------------------------------------------------------------------------------------------
// Clean
//------------------------------------------------------------------------------------------------------------------------------------------

project(':clean') {
    evaluationDependsOn(':mcp')
    apply plugin: 'net.minecraftforge.gradle.patcher'
    apply plugin: 'idea'
    tasks.withType(AbstractPublishToMaven.class).forEach{tsk -> tsk.enabled = false } // We don't want to publish anything

    idea {
        module {
            // Fix resource loading with older FML versions that relied on a unified output folder
            inheritOutputDirs = true
        }
    }

    sourceSets.all {
        output.resourcesDir = java.destinationDirectory
    }

    dependencies {
        implementation "net.minecraftforge:mergetool:${MERGETOOL_VERSION}:forge"
    }

    patcher {
        parent = project(':mcp')
        mcVersion = MC_VERSION
        patchedSrc = file('src/main/java')

        mappings channel: MAPPING_CHANNEL, version: MAPPING_VERSION
        processor = POST_PROCESSOR

        runs {
            clean_client {
                client true
                taskName 'clean_client'
                ideaModule "${rootProject.name}.${project.name}.main"

                main 'net.minecraft.client.main.Main'
                workingDirectory project.file('run')

                args '--gameDir', '.'
                args '--version', MC_VERSION
                args '--assetsDir', downloadAssets.output
                args '--assetIndex', '{asset_index}'
                args '--accessToken', '0'
            }

            clean_server {
                client false
                taskName 'clean_server'
                ideaModule "${rootProject.name}.${project.name}.main"

                main 'net.minecraft.server.MinecraftServer'
                workingDirectory project.file('run')
            }
        }
    }
}

//------------------------------------------------------------------------------------------------------------------------------------------
// Forge
//------------------------------------------------------------------------------------------------------------------------------------------

project(':forge') {
    evaluationDependsOn(':clean')
    apply plugin: 'java-library'
    apply plugin: 'idea'
    apply plugin: 'net.minecraftforge.gradle.patcher'
    apply plugin: 'org.cadixdev.licenser'

    idea {
        module {
            // Fix resource loading with older FML versions that relied on a unified output folder
            inheritOutputDirs = true
        }
    }

    sourceSets {
        main {
            java {
                srcDirs = ["$rootDir/src/main/java"]
            }
            resources {
                srcDirs = ["$rootDir/src/main/resources"]
            }
        }
        test {
            java {
                srcDirs = ["$rootDir/src/test/java"]
            }
            resources {
                srcDirs = ["$rootDir/src/test/resources"]
            }
        }
        all {
            output.resourcesDir = java.destinationDirectory
        }
    }
    //Eclipse adds the sourcesets twice, once where we tell it to, once in the projects folder. No idea why. So delete them
    eclipse.classpath.file.whenMerged { cls -> cls.entries.removeIf { e -> e instanceof SourceFolder && e.path.startsWith('src/') && !e.path.startsWith('src/main/') } }

    ext {
        MCP_ARTIFACT = project(':mcp').mcp.config.get()
        SPECIAL_SOURCE = 'net.md-5:SpecialSource:1.11.0:shaded'
        VERSION_JSON = project(':mcp').file('build/mcp/downloadJson/version.json')
        BINPATCH_TOOL = 'net.minecraftforge:binarypatcher:1.1.1:fatjar'
        INSTALLER_TOOLS = 'net.minecraftforge:installertools:1.1.11'
    }

    // compileJava {
    //     javaCompiler = javaToolchains.compilerFor {
    //         languageVersion = JavaLanguageVersion.of(7)
    //     }
    // }

    //--------------------------------------------------------------------------------------------------------------------------------------
    // Dependencies
    //--------------------------------------------------------------------------------------------------------------------------------------

    configurations {
        installer {
            // Don't pull all libraries, if we're missing something, add it to the installer list so the installer knows to download it.
            transitive = false
        }
        api.extendsFrom(installer)
    }

    dependencies {
        installer 'org.ow2.asm:asm-debug-all:5.2'
        installer 'net.minecraft:launchwrapper:1.12'
        installer 'com.typesafe.akka:akka-actor_2.11:2.3.3'
        installer 'com.typesafe:config:1.2.1'
        installer 'org.scala-lang:scala-actors-migration_2.11:1.1.0'
        installer 'org.scala-lang:scala-compiler:2.11.1'
        installer 'org.scala-lang.plugins:scala-continuations-library_2.11:1.0.2_mc'  //We change the version so old installs don't break, as our clone of the jar is different the maven central
        installer 'org.scala-lang.plugins:scala-continuations-plugin_2.11.1:1.0.2_mc' // --^
        installer 'org.scala-lang:scala-library:2.11.1'
        installer 'org.scala-lang:scala-parser-combinators_2.11:1.0.1'
        installer 'org.scala-lang:scala-reflect:2.11.1'
        installer 'org.scala-lang:scala-swing_2.11:1.0.1'
        installer 'org.scala-lang:scala-xml_2.11:1.0.2'
        installer 'lzma:lzma:0.0.1'
        installer 'java3d:vecmath:1.5.2'
        installer 'net.sf.trove4j:trove4j:3.0.3'
        installer 'org.apache.maven:maven-artifact:3.5.3'
        installer 'net.sf.jopt-simple:jopt-simple:5.0.3'
        installer 'jline:jline:2.13'

        implementation 'net.minecraftforge:legacydev:0.2.3.+:fatjar'

        testImplementation 'org.junit.jupiter:junit-jupiter-api:5.0.0'
        testImplementation 'org.junit.vintage:junit-vintage-engine:5.+'
        testImplementation 'org.opentest4j:opentest4j:1.0.0' // needed for junit 5
        testImplementation 'org.hamcrest:hamcrest-all:1.3' // needs advanced matching for list order
    }

    //--------------------------------------------------------------------------------------------------------------------------------------
    // Setup
    //--------------------------------------------------------------------------------------------------------------------------------------

    patcher {
        excs.from file("$rootDir/src/main/resources/forge.exc")
        parent = project(':clean')
        patches = file("$rootDir/patches/minecraft")
        patchedSrc = file('src/main/java')
        srgPatches = true
        notchObf = true

        accessTransformers.from file("$rootDir/src/main/resources/forge_at.cfg")
        // sideAnnotationStripper.from file("$rootDir/src/main/resources/forge.sas")
        processor = POST_PROCESSOR

        //----------------------------------------------------------------------------------------------------------------------------------
        // Run Configurations
        //----------------------------------------------------------------------------------------------------------------------------------

        runs {
            forge_client {
                client true
                main 'net.minecraftforge.legacydev.MainClient'

                environment 'target', 'fmldevclient'
                environment 'tweakClass', 'net.minecraftforge.fml.common.launcher.FMLTweaker'
                environment 'assetIndex', '{asset_index}'
                environment 'assetDirectory', downloadAssets.output
                environment 'nativesDirectory', extractNatives.output.get().asFile

                mods {
                    forge { source sourceSets.main }
                }
            }

            forge_test_client {
                parent runs.forge_client

                environment 'MOD_CLASSES', 'dummy' // Needed to work around FG limitation, FG will replace this!

                ideaModule "${rootProject.name}.${project.name}.test"

                mods {
                    tests { sources sourceSets.test }
                }
            }

            forge_server {
                client false
                main 'net.minecraftforge.legacydev.MainServer'

                environment 'target', 'fmldevserver'
                environment 'tweakClass', 'net.minecraftforge.fml.common.launcher.FMLServerTweaker'

                mods {
                    forge { source sourceSets.main }
                }
            }

            forge_test_server {
                parent runs.forge_server

                environment 'MOD_CLASSES', 'dummy' // Needed to work around FG limitation, FG will replace this!

                ideaModule "${rootProject.name}.${project.name}.test"

                mods {
                    tests { sources sourceSets.test }
                }
            }
        }

        for (def run : runs) {
            if (run.parents) continue // We already added this to the parent run config

            run.workingDirectory project.file('run')
            run.ideaModule "${rootProject.name}.${project.name}.main"

            run.environment 'mainClass', 'net.minecraft.launchwrapper.Launch'
            run.environment 'MC_VERSION', MC_VERSION
            run.environment 'MCP_VERSION', MCP_VERSION
            run.environment 'MCP_TO_SRG', createSrg2Mcp.getOutput().get().getAsFile().getAbsolutePath()
            run.environment 'FORGE_GROUP', project.group
            run.environment 'FORGE_VERSION', FORGE_VERSION
        }
    }

    //--------------------------------------------------------------------------------------------------------------------------------------
    // Manifest
    //--------------------------------------------------------------------------------------------------------------------------------------

    ext {
        MANIFESTS = [
            '/': [
                'Timestamp': new Date().format("yyyy-MM-dd'T'HH:mm:ssZ"),
                'GitCommit': GIT_INFO.abbreviatedId,
                'Git-Branch': GIT_INFO.branch
            ] as LinkedHashMap,
            'net/minecraftforge/common/': [
                'Specification-Title': 'Forge',
                'Specification-Vendor': 'Forge Development LLC',
                'Specification-Version': SPEC_VERSION,
                'Implementation-Title': project.group,
                'Implementation-Version': FORGE_VERSION,
                'Implementation-Vendor': 'Forge Development LLC'
            ] as LinkedHashMap
        ]
    }

    //--------------------------------------------------------------------------------------------------------------------------------------
    // Bin Patch Generation
    //--------------------------------------------------------------------------------------------------------------------------------------

    // We apply the bin patches we just created to make a jar that is JUST our changes
    ['Client', 'Server', 'Joined'].each { side ->
        def gen = tasks.getByName("gen${side}BinPatches")
        gen.tool = BINPATCH_TOOL
        task "apply${side}BinPatches"(type: ApplyBinPatches, dependsOn: gen) {
            clean = gen.cleanJar
            patch = gen.output
            tool = BINPATCH_TOOL
        }
    }

    task genRuntimeBinPatches(type: GenerateBinPatches, dependsOn: [genClientBinPatches, genServerBinPatches]) {
        tool = BINPATCH_TOOL
        cleanJar = genClientBinPatches.cleanJar
        dirtyJar = genClientBinPatches.dirtyJar
        srg = genClientBinPatches.srg
        patchSets.setFrom(genClientBinPatches.patchSets)
        afterEvaluate {
            getArgs().set([
                    '--output', '{output}',
                    '--patches', '{patches}',
                    '--srg', '{srg}',
                    '--legacy',

                    '--clean', '{clean}',
                    '--dirty', '{dirty}',
                    '--prefix', 'binpatch/client',

                    '--clean', genServerBinPatches.cleanJar.get().asFile.absolutePath,
                    '--dirty', genServerBinPatches.dirtyJar.get().asFile.absolutePath,
                    '--prefix', 'binpatch/server'
            ])
        }
    }

    task downloadLibraries(type: DownloadLibraries, dependsOn: ':mcp:setupMCP') {
        input = VERSION_JSON
        output = rootProject.file('build/libraries/')
    }

    task extractInheritance(type: ExtractInheritance, dependsOn: [genJoinedBinPatches, downloadLibraries]) {
        tool = INSTALLER_TOOLS + ':fatjar'
        // args.add '--annotations'
        input = genJoinedBinPatches.cleanJar
        libraries.addAll downloadLibraries.librariesOutput.map { rf -> Files.readAllLines(rf.asFile.toPath()).stream().map(File::new).collect(java.util.stream.Collectors.toList()) }
    }

    tasks.register('checkAll') {
        dependsOn 'checkLicenses'
        group = 'checks'
    }
    tasks.register('checkAllAndFix') {
        dependsOn 'findFieldInstanceChecks', 'checkLicenses'
        group = 'checks'
    }

    CheckTask.registerTask(tasks, 'ATs', CheckATs) {
        dependsOn extractInheritance, createSrg2Mcp
        ats.from patcher.accessTransformers
        inheritance = extractInheritance.output
        mappings = createSrg2Mcp.output
    }

    CheckTask.registerTask(tasks, 'SAS', CheckSAS) {
        dependsOn extractInheritance
        sass.from patcher.sideAnnotationStrippers
        inheritance = extractInheritance.output
    }

    CheckTask.registerTask(tasks, 'Excs', CheckExcs) {
        dependsOn jar
        binary = jar.archiveFile.get().asFile
        excs.from patcher.excs
    }

    CheckTask.registerTask(tasks, 'Patches', CheckPatches) {
        dependsOn genPatches
        patchDir = file("$rootDir/patches")
        patchesWithS2SArtifact = [
                'minecraft/net/minecraft/client/renderer/ViewArea.java.patch',
                'minecraft/net/minecraft/data/models/blockstates/Variant.java.patch',
        ]
    }

    //--------------------------------------------------------------------------------------------------------------------------------------
    // Patches
    //--------------------------------------------------------------------------------------------------------------------------------------

    applyPatches {
        originalPrefix = '../src-base/minecraft/'
        modifiedPrefix = '../src-work/minecraft/'
    }

    genPatches {
        finalizedBy checkAndFixPatches
        autoHeader false
        lineEnding = '\n'

        originalPrefix = '../src-base/minecraft/'
        modifiedPrefix = '../src-work/minecraft/'
    }

    def baseForgeVersionProperty = project.objects.property(String)
    baseForgeVersionProperty.set(project.provider { getLatestForgeVersion(MC_VERSION) }.map { MC_VERSION + '-' + it })
    baseForgeVersionProperty.finalizeValueOnRead()
    def jarCompatibilityTaskSetup = { task ->
        task.group = 'jar compatibility'
        task.onlyIf {
            baseForgeVersionProperty.getOrNull() != null
        }
    }

    tasks.register('setupCheckJarCompatibility', SetupCheckJarCompatibility) {
        inputVersion = baseForgeVersionProperty
    }

    tasks.register('applyBaseCompatibilityJarBinPatches', ApplyBinPatches) {
        jarCompatibilityTaskSetup(it)

        clean = project.tasks.named('genJoinedBinPatches').flatMap { it.cleanJar }
        patch = project.tasks.named('setupCheckJarCompatibility').flatMap { it.baseBinPatchesOutput }
        output = project.layout.buildDirectory.dir(name).map { it.file('output.jar') }

        args.add '--unpatched'
    }

    tasks.register('downloadBaseForgeJar', Download) {
        jarCompatibilityTaskSetup(it)

        src baseForgeVersionProperty.map {"https://maven.minecraftforge.net/net/minecraftforge/forge/${it}/forge-${it}-universal.jar" }
        dest project.layout.buildDirectory.dir(name).map { it.file('output.jar') }
    }

    tasks.register('mergeBaseForgeJar', MergeJars) {
        jarCompatibilityTaskSetup(it)

        inputJars.from(project.tasks.named('applyBaseCompatibilityJarBinPatches').flatMap { it.output })
        inputJars.from(project.tasks.named('downloadBaseForgeJar').map { it.dest })
    }

    tasks.register('deobfMergedBaseForgeJar', RenameJar) {
        jarCompatibilityTaskSetup(it)

        // This won't be a perfect deobfuscation because we don't provide inheritance data, but it should be good enough for compatibility checking
        tool = SPECIAL_SOURCE
        args = [
                '--in-jar', '{input}',
                '--out-jar', '{output}',
                '--srg-in', '{mappings}',
                '--live'
        ]
        mappings = tasks.named('extractObf2Srg').flatMap { it.output }
        input = project.tasks.named('mergeBaseForgeJar').flatMap { it.output }
        output = project.layout.buildDirectory.dir(name).map { it.file('output.jar') }

    }

    tasks.register('deobfReobfJar', RenameJar) {
        jarCompatibilityTaskSetup(it)

        // This won't be a perfect deobfuscation because we don't provide inheritance data, but it should be good enough for compatibility checking
        tool = SPECIAL_SOURCE
        args = [
                '--in-jar', '{input}',
                '--out-jar', '{output}',
                '--srg-in', '{mappings}'
        ]
        mappings = tasks.named('extractObf2Srg').flatMap { it.output }
        input = project.tasks.named('reobfJar').flatMap { it.output }
        output = project.layout.buildDirectory.dir(name).map { it.file('output.jar') }
    }

    tasks.register('checkJarCompatibility', CheckJarCompatibility) {
        jarCompatibilityTaskSetup(it)
        dependsOn 'setupCheckJarCompatibility'

        baseJar = project.tasks.named('deobfMergedBaseForgeJar').flatMap { it.output }

        inputJar = project.tasks.named('deobfReobfJar').flatMap { it.output }

        commonLibraries.from(project.configurations.minecraftImplementation)
        commonLibraries.from(project.configurations.installer)
    }

    task launcherJson(type: LauncherJson) {
        doFirst {
            json = [
                _comment_: comment,
                id: id,
                time: timestamp,
                releaseTime: timestamp,
                type: 'release',
                mainClass: 'net.minecraft.launchwrapper.Launch',
                inheritsFrom: MC_VERSION,
                logging: {},
                minecraftArguments: [
                    '--username', '${auth_player_name}',
                    '--version', '${version_name}',
                    '--gameDir', '${game_directory}',
                    '--assetsDir', '${assets_root}',
                    '--assetIndex', '${assets_index_name}',
                    '--uuid', '${auth_uuid}',
                    '--accessToken', '${auth_access_token}',
                    '--userType', '${user_type}',
                    '--tweakClass', 'net.minecraftforge.fml.common.launcher.FMLTweaker',
                    '--versionType', 'Forge'
                ].join(' '),
                libraries: []
            ]
        }
    }

    task installerJson(type: InstallerJson, dependsOn: [launcherJson, genClientBinPatches, applyClientBinPatches, applyServerBinPatches, 'signUniversalJar']) {
        input.from applyClientBinPatches.output, applyServerBinPatches.output, genClientBinPatches.toolJar, launcherJson.output
        icon = rootProject.file('icon.ico')

        doFirst {
            def libs = libraries
            json = [
                _comment_: launcherJson.comment,
                spec: 0,
                profile: project.name,
                version: launcherJson.id,
                path: "${project.group}:${project.name}:${project.version}:universal",
                minecraft: MC_VERSION,
                data: [:],
                processors: []
            ]
            getClasspath(project, libs, MCP_ARTIFACT.descriptor) //Tell it to download mcp_config
        }
    }

    task extractObf2Srg(type: ExtractMCPData, dependsOn: [':mcp:downloadConfig']) {
        config = project(':mcp').downloadConfig.output
    }

    task deobfDataLzma(dependsOn: [extractObf2Srg]) {
        ext {
            output_srg = file('build/deobfDataLzma/data.srg')
            output = file('build/deobfDataLzma/data.lzma')
        }

        doLast {
            IMappingFile.load(extractObf2Srg.output.get().getAsFile()).write(output_srg.toPath(), IMappingFile.Format.SRG, false)
            output_srg.withInputStream { ins ->
                output.withOutputStream { outs ->
                    def lz = new LZMACompressorOutputStream(outs)

                    def i = -1
                    def buf = new byte[0x100]
                    while ((i = ins.read(buf)) != -1)
                        lz.write(buf, 0, i)

                    lz.close()
                }
            }
        }
    }

    universalJar {
        from(extraTxts)
        dependsOn(deobfDataLzma)
        from(deobfDataLzma.output) {
            rename { "deobfuscation_data-${MC_VERSION}.lzma" }
        }
        dependsOn(genRuntimeBinPatches)
        from(genRuntimeBinPatches.output) {
            rename { 'binpatches.pack.lzma' }
        }
        doFirst {
            def classpath = new StringBuilder()
            def artifacts = getArtifacts(project, project.configurations.installer, false)
            artifacts.each { key, lib ->
                classpath.append("libraries/${lib.downloads.artifact.path} ")
            }
            classpath += "minecraft_server.${MC_VERSION}.jar"
            MANIFESTS.each { pkg, values ->
                if (pkg == '/') {
                    manifest.attributes(values += [
                        'Main-Class': 'net.minecraftforge.fml.relauncher.ServerLaunchWrapper',
                        'Class-Path': classpath.toString(),
                        'Tweak-Class': 'net.minecraftforge.fml.common.launcher.FMLTweaker'
                    ])
                } else {
                    manifest.attributes(values, pkg)
                }
            }
        }
    }

    task downloadInstaller(type: DownloadMavenArtifact) {
        artifact = "net.minecraftforge:installer:${INSTALLER_VERSION}:shrunk"
        changing = true
    }

    task installerJar(type: InstallerJar, dependsOn: [genClientBinPatches, genServerBinPatches, 'signUniversalJar', launcherJson]) {
        from(extraTxts)
        from(rootProject.file('/src/main/resources/forge_logo.png')) {
            rename { 'big_logo.png' }
        }
    }

    [tasks.universalJar, tasks.installerJar].each { t ->
        def signTask = task "sign${t.name.capitalize()}"([type: SignJar, dependsOn: t]) {
            onlyIf {
                JAR_SIGNER != null && t.state.failure == null
            }
            def jarsigner = JAR_SIGNER == null ? [:] : JAR_SIGNER
            alias = 'forge'
            storePass = jarsigner.storepass
            keyPass = jarsigner.keypass
            keyStore = jarsigner.keystore
            inputFile = t.archiveFile.get().asFile
            outputFile = t.archiveFile.get().asFile
            doFirst {
                project.logger.lifecycle('Signing: ' + inputFile)
            }
        }
        t.finalizedBy(signTask)
    }

    task makeMdk(type: Zip) {
        archiveBaseName = project.name
        archiveClassifier = 'mdk'
        archiveVersion = project.version
        destinationDirectory = file('build/libs')

        from rootProject.file('gradlew')
        from rootProject.file('gradlew.bat')
        from extraTxts
        from(rootProject.file('gradle/')) {
            into('gradle/')
        }
        from(rootProject.file('mdk/')) {
            rootProject.file('mdk/gitignore.txt').eachLine {
                if (!it.trim().isEmpty() && !it.trim().startsWith('#'))
                    exclude it
            }
            filter(ReplaceTokens, tokens: [
                FORGE_VERSION: project.version,
                FORGE_GROUP: project.group,
                FORGE_NAME: project.name,
                MC_VERSION: MC_VERSION,
                MAPPING_CHANNEL: MAPPING_CHANNEL,
                MAPPING_VERSION: MAPPING_VERSION
            ])
            rename 'gitignore\\.txt', '.gitignore'
        }
    }

    userdevConfig {
        def artifacts = getArtifacts(project, project.configurations.installer, true)
        artifacts.each { key, lib ->
            libraries.add(lib.name)
        }
        libraries.add('net.minecraftforge:legacydev:0.2.3.+:fatjar')
        universalFilters.add('^(?!binpatches\\.pack\\.lzma$).*$')

        runs {
            client {
                main 'net.minecraftforge.legacydev.MainClient'

                environment 'tweakClass', 'net.minecraftforge.fml.common.launcher.FMLTweaker'
                environment 'mainClass', 'net.minecraft.launchwrapper.Launch'
                environment 'assetIndex', '{asset_index}'
                environment 'assetDirectory', '{assets_root}'
                environment 'nativesDirectory', '{natives}'
                environment 'MC_VERSION', MC_VERSION
                environment 'MCP_MAPPINGS', '{mcp_mappings}'
                environment 'MCP_TO_SRG', '{mcp_to_srg}'
                environment 'FORGE_GROUP', project.group
                environment 'FORGE_VERSION', FORGE_VERSION
            }

            server {
                main 'net.minecraftforge.legacydev.MainServer'

                environment 'tweakClass', 'net.minecraftforge.fml.common.launcher.FMLServerTweaker'
                environment 'mainClass', 'net.minecraft.launchwrapper.Launch'
                environment 'MC_VERSION', MC_VERSION
                environment 'MCP_MAPPINGS', '{mcp_mappings}'
                environment 'MCP_TO_SRG', '{mcp_to_srg}'
                environment 'FORGE_GROUP', project.group
                environment 'FORGE_VERSION', FORGE_VERSION
            }
        }
    }

    userdevJar {
        classifier 'userdev3' // Should be 'userdev', but FG5 hardcodes pre 1.13 versions to 'userdev3'
    }

    reobfJar {
        args.addAll('--srg-in', rootProject.file('src/main/resources/forge.srg').absolutePath)
    }

    tasks.eclipse.dependsOn('genEclipseRuns')

    if (project.hasProperty('UPDATE_MAPPINGS')) {
        extractRangeMap {
            sources.from sourceSets.test.java.srcDirs
            addDependencies compileTestJava.classpath
        }
        applyRangeMap {
            sources.from sourceSets.test.java.srcDirs
        }
        sourceSets.test.java.srcDirs.each { extractMappedNew.addTarget it }
    }

    tasks.named('javadoc', Javadoc).configure {
        description 'Generates the combined javadocs for the FML projects and the main Forge project'

        var docsDir = rootProject.file('src/docs/')
        inputs.dir(docsDir)
            .withPropertyName('docs resources directory')
            .withPathSensitivity(PathSensitivity.RELATIVE)
            .optional()

        failOnError = false

        // Exclude the Minecraft classes if not enabled
        if (!project.hasProperty('generateAllDocumentation')) {
            exclude 'net/minecraft/**'
            exclude 'com/mojang/**'
        }
        exclude 'mcp/**'

        options.addStringOption('Xdoclint:all,-missing', '-public')
        options {
            stylesheetFile = new File(docsDir, 'stylesheet.css')

            tags = [
                'apiNote:a:<em>API Note:</em>',
                'implSpec:a:<em>Implementation Requirements:</em>',
                'implNote:a:<em>Implementation Note:</em>'
            ]

            groups = [
                'Forge Mod Loader': [
                    'net.minecraftforge.fml*'
                ],
                'Minecraft Forge API': [
                    'net.minecraftforge*'
                ]
            ]

            author = false
            noSince = true
            noHelp = true

            bottom = "Minecraft Forge is an open source modding API for Minecraft: Java Edition, licensed under the Lesser GNU General Public License, version 2.1."
            windowTitle = "Minecraft Forge API ${VERSION}"
            docTitle = "Minecraft Forge API - ${FORGE_VERSION} for Minecraft ${MC_VERSION}"
            header = "<div style=\"margin-top: 9px;padding: 5px 6px;\"><strong>${FORGE_VERSION} for Minecraft ${MC_VERSION}</strong></div>"
        }

        doLast {
            project.copy {
                from docsDir
                exclude '/stylesheet.css'
                into destinationDir
            }
        }
    }

    publishing {
        publications {
            mavenJava(MavenPublication) {
                artifact universalJar
                artifact installerJar
                //TODO: installer-win
                artifact makeMdk
                artifact userdevJar
                artifact sourcesJar
            }
        }
    }

    tasks.withType(JavaCompile).configureEach {
        options.encoding = 'UTF-8' // Use the UTF-8 charset for Java compilation
    }
}

task setup() {
    dependsOn ':clean:extractMapped'
    dependsOn ':forge:extractMapped'
}