build.gradle

configure(
        subprojects.findAll {
            it.parent == rootProject && !it.name.startsWith("modules")
        }
) {
    apply plugin: 'java'

    group = $group
    version = $version
    archivesBaseName = $modBaseName

    configurations {
        library
        implementation.extendsFrom library
    }

    dependencies {
        library 'com.github.JnCrMx:discord-game-sdk4j:v0.5.5'

        library 'com.fasterxml.jackson.core:jackson-core:2.8.8'
        library 'com.fasterxml.jackson.core:jackson-annotations:2.8.8'
        library 'com.fasterxml.jackson.core:jackson-databind:2.8.8'

        testImplementation 'org.junit.jupiter:junit-jupiter-api:5.9.1'
        testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine:5.9.1'

        if (project.name != "common") {
            library project(":common")
        }
    }

    repositories {
        mavenCentral()
        maven { url = "https://jitpack.io" }
        maven {
            name = 'Fabric'
            url = 'https://maven.fabricmc.net/'
        }
        maven {
            name = 'ParchmentMC'
            url = 'https://maven.parchmentmc.org'
        }
    }

    test {
        useJUnitPlatform()
    }

    jar {
        manifest {
            attributes([
                    "Specification-Title"     : $modBaseName,
                    "Specification-Vendor"    : $vendor,
                    "Specification-Version"   : "1", // We are version 1 of ourselves
                    "Implementation-Title"    : $modBaseName,
                    "Implementation-Version"  : $version,
                    "Implementation-Vendor"   : $vendor,
                    "Implementation-Timestamp": new Date().format("yyyy-MM-dd'T'HH:mm:ssZ")
            ])
        }

        if (project.name != "common" && project.name != "network-api") {
            //destinationDirectory = rootProject.buildDir
            doFirst {
                archiveClassifier = project.name
            }
        }

        duplicatesStrategy = DuplicatesStrategy.EXCLUDE
        with copySpec {
            from {
                configurations.library.collect { it.isDirectory() ? it : zipTree(it) }
            }
            exclude 'META-INF/*.SF', 'META-INF/*.DSA', 'META-INF/*.RSA'
        }
        from {
            "../LICENSE"
            "${project(":common").compileJava.temporaryDir}${File.separator}classes.txt"
        }
    }

    java {
        toolchain {
            languageVersion = JavaLanguageVersion.of(project.properties.getOrDefault("jdkVersion", 17) as int)
        }
    }


    tasks.withType(JavaCompile).configureEach {
        int jdkVersion = project.properties.getOrDefault("jdkVersion", 17) as int

        sourceCompatibility = jdkVersion
        targetCompatibility = jdkVersion

        if (jdkVersion >= 9)
            options.release.set(jdkVersion)

        options.encoding = 'UTF-8'
    }

    if (project.name != "common" && project.name != "network-api") {
        project.afterEvaluate {
            tasks.withType(JavaExec).configureEach {
                javaLauncher.set(javaToolchains.launcherFor(java.toolchain))
            }

            remapJar {
                inputFile.set project.jar.archiveFile
                destinationDirectory = file("${rootProject.buildDir}/libs")
                dependsOn project.jar
                archiveFileName = project.jar.archiveFileName
            }

            // Fix unimined runs bug
            afterEvaluate {
                runClient.doFirst {
                    var classPathFile = null
                    if (project.name.startsWith("forge")) classPathFile = "legacy_classpath"
                    if (project.name.startsWith("fabric")) classPathFile = "remapClasspath"

                    if (classPathFile != null) {
                        logger.lifecycle("Fixing ${classPathFile}")
                        copy {
                            from "${rootProject.buildDir}/unimined/classpaths/${classPathFile}-${project.name}.txt"
                            into "${rootProject.buildDir}/unimined"
                            rename { "${classPathFile}.txt" }
                        }
                    }
                }

                var classPathFile = null
                if (project.name.startsWith("forge")) classPathFile = "legacy_classpath"
                if (project.name.startsWith("fabric")) classPathFile = "remapClasspath"

                if (classPathFile != null) {
                    logger.lifecycle("Saving ${classPathFile} for project: ${project.name}")
                    copy {
                        from "${rootProject.buildDir}/unimined/${classPathFile}.txt"
                        into "${rootProject.buildDir}/unimined/classpaths"
                        rename { "${classPathFile}-${project.name}.txt" }
                    }
                }
            }
        }
    }
}