build.gradle

import java.nio.file.Files
import java.util.function.Function
import io.github.brassmc.bradle.util.gson.Library.OS

plugins {
    id 'java'
    id 'io.github.brassmc.bradle' version '0.6.0'
}

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

minecraft {
    minecraftVersion = '1.20'
    mappings 'official', '1.20'
}

sourceSets {
    boot
    mixin
}

configurations {
    mcServer
    mcClient

    boot
    bootImplementation.extendsFrom(boot)

    minecraftRuntime
    minecraftClientRuntime.extendsFrom(minecraftRuntime)
    minecraftServerRuntime.extendsFrom(minecraftRuntime)
    bootImplementation.extendsFrom(minecraftRuntime)
    bootImplementation.extendsFrom(minecraftClientRuntime)
    mixinImplementation.extendsFrom(minecraftClientRuntime)

    mixinCompileOnly.extendsFrom(mcClient)
    compileOnly.extendsFrom(mcClient)
}

final asm = [
        "org.ow2.asm:asm:$asmVersion",
        "org.ow2.asm:asm-util:$asmVersion",
        "org.ow2.asm:asm-tree:$asmVersion"
]

dependencies {
    bootImplementation 'com.google.guava:guava:31.1-jre'
    bootImplementation 'org.jetbrains:annotations:23.0.0'
    bootImplementation 'org.hjson:hjson:3.0.0'
    bootImplementation 'commons-validator:commons-validator:1.7'

    boot 'cpw.mods:bootstraplauncher:1.1.2'
    boot "cpw.mods:securejarhandler:$sshVersion"
    compileOnly "cpw.mods:securejarhandler:$sshVersion"

    asm.each {
        boot it
        bootCompileOnly it
    }

    mcClient bradle.deobf('net.minecraft:client:1.20:joined')
    mcServer bradle.deobf('net.minecraft:server:1.20:joined', 'server')

    bootCompileOnly "cpw.mods:securejarhandler:$sshVersion"
    mixinCompileOnly "cpw.mods:securejarhandler:$sshVersion"
    minecraftRuntime "cpw.mods:modlauncher:$mmlVersion"
    minecraftRuntime "org.spongepowered:mixin:$mixinVersion"

    minecraftRuntime 'com.google.guava:guava:31.1-jre'
    minecraftRuntime 'org.jetbrains:annotations:23.0.0'
    minecraftRuntime 'org.hjson:hjson:3.0.0'
    minecraftRuntime 'commons-validator:commons-validator:1.7'

    bootCompileOnly group:'com.google.auto.service', name:'auto-service', version:'1.0.1'
    bootAnnotationProcessor group:'com.google.auto.service', name:'auto-service', version:'1.0.1'

    compileOnly sourceSets.boot.output

    mixinImplementation sourceSets.main.output
    mixinImplementation sourceSets.boot.output
}

processMixinResources {
    inputs.properties([
            'mixinVersion': mixinVersion
    ])
    filesMatching('brassloader.mixins.json') {
        expand 'mixinVersion': mixinVersion
    }
}

java {
    toolchain {
        languageVersion.set(JavaLanguageVersion.of(17))
    }
}

jar {
    from sourceSets.mixin.output
    manifest.attributes([
            'Automatic-Module-Name': 'io.github.brassmc.brassloader',
    ])
}

tasks.create('fatJar', Jar) {
    it.from sourceSets.boot.output
    it.dependsOn(jar)
    classifier 'fat'
    it.from(jar.archiveFile.get().asFile) {
        rename(inTxt -> 'brass.jar')
        into 'META-INF/jars'
    }
    manifest.attributes([
            'Automatic-Module-Name': 'io.github.brassmc.brassloader.boot'
    ])
}

final Function<String, java.nio.file.Path> legacyCpPath = (String type) -> project.file("$buildDir/resources/boot/mc_cp_${type}.txt").toPath().toAbsolutePath()

processBootResources {
    doLast {
        final configurationResolver = { String type ->
            final lines = configurations."minecraft${type.capitalize()}Runtime".resolve().stream()
                    .map { it.toPath().toAbsolutePath().toString() }
                    .toList()
            final outPath = legacyCpPath.apply(type)
            lines.add(fatJar.archiveFile.get().asFile.toString())
            Files.createDirectories(outPath.parent)
            Files.write(outPath, lines)
        }
        configurationResolver('client')
        configurationResolver('server')
    }
}

//noinspection GroovyAssignabilityCheck
final var configureRunTask = { JavaExec it, String type ->
    println "Using Java version ${it.getJavaVersion()} for $type configuration"
    it.dependsOn('fatJar')
    it.getMainClass().set('cpw.mods.bootstraplauncher.BootstrapLauncher')
    final sshModule = 'cpw.mods.securejarhandler'
    it.jvmArgs(
            '--module-path', configurations.boot.resolve().stream().map { it.toString() }.toList().join(File.pathSeparator),
            "-DlegacyClassPath.file=${legacyCpPath.apply(type)}",
            '--add-modules', 'ALL-MODULE-PATH',
            '--add-opens', "java.base/java.util.jar=$sshModule",
            '--add-opens', "java.base/java.lang.invoke=$sshModule",
            '--add-exports', "java.base/sun.security.util=$sshModule",
            '--add-exports', 'jdk.naming.dns/com.sun.jndi.dns=java.naming',
            '-Dmixin.debug.verbose=true', '-Dmixin.debug.export=true',
    )
    if (OS.current in [OS.LINUX, OS.OSX]) it.jvmArgs('-XstartOnFirstThread')
    it.group = 'minecraft'

    Files.createDirectories(it.workingDir.toPath())

    it.dependsOn(gradle.includedBuild('BrassAPI').task(':jar'))
    it.doFirst {
        if (gradle.includedBuild('BrassAPI') === null) return
        final libsDir = gradle.includedBuild('BrassAPI').projectDir.toPath().resolve('build/libs')
        Files.list(libsDir)
                .map { it.toAbsolutePath() }
                .filter { it.toString().endsWith('.jar') }
                .max(Comparator.comparing({ Files.getLastModifiedTime(it) }))
                .ifPresent {
                    final dest = project.file("run/$type/mods/brassapi.jar").toPath()
                    Files.createDirectories(dest.parent)
                    Files.deleteIfExists(dest)
                    Files.copy(it, dest)
                }
    }
}

tasks.register('runClient', JavaExec) {
    it.setWorkingDir(project.file('run/client'))
    it.jvmArgs(
            "-Dbrassloader.mclocation=${configurations.mcClient.resolve().stream().findFirst().orElseThrow()}"
    )
    args(
            '--launchTarget', 'brass:mcclient',
            '--accessToken', '***',
            '--version', '1.20',
            '--assetIndex', '1.20',
            '--assetsDir', downloadAssets.output
    )
    configureRunTask(it, 'client')
}
tasks.register('runServer', JavaExec) {
    it.setWorkingDir(project.file('run/server'))
    it.jvmArgs(
            "-Dbrassloader.mclocation=${configurations.mcServer.resolve().stream().findFirst().orElseThrow()}"
    )
    it.args(
            '--launchTarget', 'brass:mcserver',
    )
    configureRunTask(it, 'server')
}