addon.gradle

import org.gradle.jvm.toolchain.internal.DefaultToolchainSpec

def newJavaToolchainSpec = new DefaultToolchainSpec(objects)
newJavaToolchainSpec.vendor.set(JvmVendorSpec.AZUL)
newJavaToolchainSpec.languageVersion.set(JavaLanguageVersion.of(17))

def extraJavaArgs = [
    "--illegal-access=warn",
     "-Djava.security.manager=allow",
     "-Dfile.encoding=UTF-8",
     "--add-opens", "java.base/jdk.internal.loader=ALL-UNNAMED",
     "--add-opens", "java.base/java.net=ALL-UNNAMED",
     "--add-opens", "java.base/java.nio=ALL-UNNAMED",
     "--add-opens", "java.base/java.io=ALL-UNNAMED",
     "--add-opens", "java.base/java.lang=ALL-UNNAMED",
     "--add-opens", "java.base/java.lang.reflect=ALL-UNNAMED",
     "--add-opens", "java.base/java.text=ALL-UNNAMED",
     "--add-opens", "java.base/java.util=ALL-UNNAMED",
     "--add-opens", "java.base/jdk.internal.reflect=ALL-UNNAMED",
     "--add-opens", "java.base/sun.nio.ch=ALL-UNNAMED",
     "--add-opens", "jdk.naming.dns/com.sun.jndi.dns=ALL-UNNAMED,java.naming",
     "--add-opens", "java.desktop/sun.awt.image=ALL-UNNAMED",
     "--add-opens", "java.desktop/com.sun.imageio.plugins.png=ALL-UNNAMED",
     "--add-modules", "jdk.dynalink",
     "--add-opens", "jdk.dynalink/jdk.dynalink.beans=ALL-UNNAMED",
     "--add-modules", "java.sql.rowset",
     "--add-opens", "java.sql.rowset/javax.sql.rowset.serial=ALL-UNNAMED",
]

SourceSet forgePatchesSet
SourceSet hotswapSet

sourceSets {
    create("util") {
        java {}
    }
    forgePatchesSet = create("forgePatches") {
        java {
            compileClasspath += mcpTasks.patchedMcSources.output
            compileClasspath += mcpTasks.patchedConfiguration
        }
    }
    hotswapSet = create("hotswap") {
        java {}
    }
    named("main").configure {
        java {
            srcDirs += ["src/generated/java"]
            compileClasspath = forgePatchesSet.output + compileClasspath
            runtimeClasspath = forgePatchesSet.output + runtimeClasspath
        }
    }
}

configurations {
    def forgePatchesEmbedded = create("forgePatchesEmbedded") {
        canBeConsumed = false
        canBeResolved = true
    }
    forgePatchesImplementation.extendsFrom(forgePatchesEmbedded)
    patchedMinecraft.extendsFrom(forgePatchesEmbedded)
}

tasks.named("shadowJar", Jar) {
    from(hotswapSet.output)
}

tasks.named("compileHotswapJava", JavaCompile).configure {
    javaCompiler = javaToolchains.compilerFor(newJavaToolchainSpec)
    sourceCompatibility = JavaVersion.VERSION_17
    targetCompatibility = JavaVersion.VERSION_17
}

tasks.named("compileHotswapScala").configure {
    enabled = false
}

repositories {
    mavenCentral()
}

dependencies {
    utilImplementation("org.ow2.asm:asm:9.5")
    utilImplementation("org.ow2.asm:asm-tree:9.5")
    utilImplementation("org.apache.commons:commons-lang3:3.12.0")
    utilImplementation("commons-io:commons-io:2.11.0")
    utilImplementation("commons-collections:commons-collections:3.2.2")
    utilImplementation("com.google.guava:guava:31.1-jre")

    hotswapCompileOnly("org.hotswapagent:hotswap-agent-core:1.4.1")
    hotswapCompileOnly("net.minecraft:launchwrapper:1.15")
}

def forgePatchesJar = tasks.register(forgePatchesSet.jarTaskName, Jar) {
    from(forgePatchesSet.output)
    // Bootleg shadow jar
    configurations.forgePatchesEmbedded.resolve().each {dep ->
        from(zipTree(dep)) {
            filesMatching("META-INF/*") { fcd ->
                fcd.name = "${dep.name}-${fcd.name}"
            }
        }
    }
    exclude("module-info.class")
    archiveClassifier.set("forgePatches")
    manifest {
        def libraryList = [
            "libraries/com/typesafe/akka/akka-actor_2.11/2.3.3/akka-actor_2.11-2.3.3.jar",
            "libraries/com/typesafe/config/1.2.1/config-1.2.1.jar",
            "libraries/org/scala-lang/scala-actors-migration_2.11/1.1.0/scala-actors-migration_2.11-1.1.0.jar",
            "libraries/org/scala-lang/scala-compiler/2.11.1/scala-compiler-2.11.1.jar",
            "libraries/org/scala-lang/plugins/scala-continuations-library_2.11/1.0.2/scala-continuations-library_2.11-1.0.2.jar",
            "libraries/org/scala-lang/plugins/scala-continuations-plugin_2.11.1/1.0.2/scala-continuations-plugin_2.11.1-1.0.2.jar",
            "libraries/org/scala-lang/scala-library/2.11.1/scala-library-2.11.1.jar",
            "libraries/org/scala-lang/scala-parser-combinators_2.11/1.0.1/scala-parser-combinators_2.11-1.0.1.jar",
            "libraries/org/scala-lang/scala-reflect/2.11.1/scala-reflect-2.11.1.jar",
            "libraries/org/scala-lang/scala-swing_2.11/1.0.1/scala-swing_2.11-1.0.1.jar",
            "libraries/org/scala-lang/scala-xml_2.11/1.0.2/scala-xml_2.11-1.0.2.jar",
            "libraries/lzma/lzma/0.0.1/lzma-0.0.1.jar",
            "libraries/net/sf/jopt-simple/jopt-simple/4.5/jopt-simple-4.5.jar",
            "libraries/com/google/guava/guava/17.0/guava-17.0.jar",
            "forge-1.7.10-10.13.4.1614-1.7.10-universal.jar",
            "minecraft_server.1.7.10.jar"
        ]
        attributes(
            "Class-Path": libraryList.join(" "),
            "Main-Class": "cpw.mods.fml.relauncher.ServerLaunchWrapper"
        )
    }
}

def mmcInstanceFilesZip = tasks.register("mmcInstanceFiles", Zip) {
    archiveClassifier.set("multimc")
    from(new File(projectDir, "prism-libraries/"))
    exclude("forgepatches-for-dev-work.json", "META-INF", "META-INF/**")
    filesMatching(["mmc-pack.json", "patches/me.eigenraven.lwjgl3ify.forgepatches.json"]) {
        expand "version": project.version,
            "jvmArgs": extraJavaArgs.collect { '"' + it + '"' }.join(", ")
    }
}

tasks.named("assemble").configure {
    dependsOn(forgePatchesSet.jarTaskName)
    dependsOn(mmcInstanceFilesZip)
}

tasks.register("runComparisonTool", JavaExec) {
    classpath(sourceSets.util.runtimeClasspath)
    dependsOn("jar")
    mainClass.set("me.eigenraven.lwjgl3ify.ComparisonTool")
    minHeapSize = "2G"
    maxHeapSize = "2G"
}

afterEvaluate {
    publishing.publications.named("maven", MavenPublication) {
        artifact forgePatchesJar
        artifact mmcInstanceFilesZip
    }

    def lwjgl2Zips = configurations.named("lwjgl2Classpath").get().resolve().findAll {!it.name.contains("natives") && !it.path.contains("net.java.j")}
    def lwjgl3Zips = configurations.named("lwjgl3Classpath").get().resolve().findAll {!it.name.contains("natives")}
    def lwjgl2Args = lwjgl2Zips.collect {"--2:" + it}
    def lwjgl3Args = lwjgl3Zips.collect {"--3:" + it}
    def allArgs = lwjgl2Args + lwjgl3Args + ["--M:" + tasks.jar.archiveFile.get().asFile.path]
    tasks.named("runComparisonTool", JavaExec).configure {
        args(allArgs)
    }
}

def newJavaLauncher = javaToolchains.launcherFor(newJavaToolchainSpec)

minecraft.extraRunJvmArguments.addAll(extraJavaArgs)

for (runTask in ["runClient", "runServer"]) {
    tasks.named(runTask, JavaExec).configure {
        classpath = forgePatchesSet.output + classpath
        javaLauncher.set(newJavaLauncher)
    }
}

for (runTask in ["runObfClient", "runObfServer"]) {
    tasks.named(runTask, JavaExec).configure {
        classpath = files(forgePatchesJar) + classpath
        javaLauncher.set(newJavaLauncher)
    }
}

tasks.named("runObfServer", JavaExec) {
    tweakClasses.set([])
}