build.gradle

buildscript{
    ext{
        arcHash = new Properties().with{ p -> p.load(file('gradle.properties').newReader()); return p }["archash"]

        localArc = { // TODO Shouldn't this just be a boolean?
            return !project.hasProperty("release") && new File(rootDir.parent, 'Arc').exists() && !project.hasProperty("noLocalArc")
        }

        arcModule = { String name ->
            //skip to last submodule
            name = name.substring(name.lastIndexOf(':') + 1)
            return "com.github.mindustry-antigrief${localArc() ? "" : ".Arc"}:$name:$arcHash"
            // TODO: Merge recheck: Merge bala's arc
        }

        branchName = 'git branch --show-current'.execute().text.trim()
    }

    repositories{
        mavenLocal()
        mavenCentral()
        google()
        maven{ url "https://oss.sonatype.org/content/repositories/snapshots/" }
        maven{ url 'https://jitpack.io' }
    }

    dependencies{
        classpath "com.mobidevelop.robovm:robovm-gradle-plugin:2.3.16"
        classpath arcModule(":extensions:packer")
        classpath arcModule(":arc-core")
    }
}

plugins{
    id "org.jetbrains.kotlin.jvm" version "1.7.20"
    id "org.jetbrains.kotlin.kapt" version "1.7.20" apply false
}

allprojects{
    version = project.hasProperty("packageVersion") ? project.getProperty("packageVersion") : 'release'
    group = 'com.github.mindustry-antigrief'

    ext{
        versionNumber = '7'
        if(!project.hasProperty("updateUrl")) updateUrl = ''
        if(!project.hasProperty("assetUrl")) assetUrl = 'mindustry-antigrief/mindustry-client'
        if(!project.hasProperty("assetRef")) assetRef = 'v7'
        if(!project.hasProperty("versionModifier")) versionModifier = 'release'
        if(!project.hasProperty("buildversion")) buildversion = '140.3' // Modders use BE build numbers which is stupid
        if(!project.hasProperty("clientVersion")){
            try {
                def tagTokens = "git tag --sort=committerdate -l v${project.getProperties()["buildversion"]}* -n1".execute().text.trim().split('[\n]')[-1]
                        .tokenize(' ')[0].split('[.]') as String[]
                tagTokens[0] = tagTokens[0][1..-1]
                tagTokens[-1] = ((tagTokens[-1] as Integer) + 1) as String
                clientVersion = branchName + " / ${tagTokens.join('.')}"
            } catch (Exception ignored){
                clientVersion = branchName + " / ${project.getProperties()["buildversion"]}"
            }

        }
        if(!project.hasProperty("versionType")) versionType = 'official'
        appName = 'Mindustry'
        steamworksVersion = '0b86023401880bb5e586bc404bedbaae9b1f1c94'
        rhinoVersion = '73a812444ac388ac2d94013b5cadc8f70b7ea027'

        loadVersionProps = {
            return new Properties().with{p -> p.load(file('../core/assets/version.properties').newReader()); return p }
        }

        debugged = {
            return new File(projectDir.parent, '../Mindustry-Debug').exists() && !project.hasProperty("release") && project.hasProperty("args")
        }

        generateDeployName = { String platform ->
            if(platform == "windows"){
                platform += "64"
            }
            platform = platform.capitalize()

            if(platform.endsWith("64") || platform.endsWith("32")){
                platform = "${platform.substring(0, platform.length() - 2)}-${platform.substring(platform.length() - 2)}bit"
            }

            return "[${platform}]${getModifierString()}[${getNeatVersionString()}]${appName}"
        }

        getVersionString = {
            String buildVersion = getBuildVersion()
            return "$versionNumber-$versionModifier-$buildVersion"
        }

        getNeatVersionString = {
            String buildVersion = getBuildVersion()
            return "v$buildVersion"
        }

        hasSprites = {
            return new File(rootDir, "core/assets/sprites/sprites.aatls").exists()
        }

        getModifierString = {
            if(versionModifier != "release") return "[${versionModifier.toUpperCase()}]"
            return ""
        }

        getBuildVersion = {
            if(!project.hasProperty("buildversion")) return "custom build"
            return project.getProperties()["buildversion"]
        }

        getPackage = {
            return project.ext.mainClassName.substring(0, project.ext.mainClassName.indexOf("desktop") - 1)
        }

        findSdkDir = {
            //null because IntelliJ doesn't get env variables
            def v = System.getenv("ANDROID_HOME")
            if(v != null) return v
            //rootDir is null here, amazing. brilliant.
            def file = new File(rootDir, "local.properties")
            def props = new Properties().with{p -> p.load(file.newReader()); return p }
            return props.get("sdk.dir")
        }

        generateLocales = {
            def output = 'en\n'
            def bundles = new File(project(':core').projectDir, 'assets/bundles/')
            bundles.listFiles().each{ other ->
                if(other.name == "bundle.properties") return
                output += other.name.substring("bundle".length() + 1, other.name.lastIndexOf('.')) + "\n"
            }
            new File(project(':core').projectDir, 'assets/locales').text = output
            new File(project(':core').projectDir, 'assets/basepartnames').text = new File(project(':core').projectDir, 'assets/baseparts/').list().join("\n")
        }

        writeVersion = {
            def pfile = new File(project(':core').projectDir, 'assets/version.properties')
            def props = new Properties()

            try{
                pfile.createNewFile()
            }catch(Exception ignored){
            }

            if(pfile.exists()){
                props.load(new FileInputStream(pfile))

                String buildid = getBuildVersion()
                println("Compiling with build: '$buildid'")

                props["updateUrl"] = updateUrl
                props["assetUrl"] = assetUrl
                props["assetRef"] = assetRef
                props["clientVersion"] = clientVersion
                props["type"] = versionType
                props["number"] = versionNumber
                props["modifier"] = versionModifier
                props["build"] = buildid

                props.store(pfile.newWriter(), "Autogenerated file. Do not modify.")
            }
        }

        writeProcessors = {
            new File(rootDir, "annotations/src/main/resources/META-INF/services/").mkdirs()
            def processorFile = new File(rootDir, "annotations/src/main/resources/META-INF/services/javax.annotation.processing.Processor")
            def text = new StringBuilder()
            def files = new File(rootDir, "annotations/src/main/java")
            files.eachFileRecurse(groovy.io.FileType.FILES){ file ->
                if(file.name.endsWith(".java") && (file.text.contains(" extends BaseProcessor") || (file.text.contains(" extends AbstractProcessor") && !file.text.contains("abstract class")))){
                    text.append(file.path.substring(files.path.length() + 1)).append("\n")
                }
            }

            processorFile.text = text.toString().replace(".java", "").replace("/", ".").replace("\\", ".")
        }

        writePlugins = {
            new File(rootDir, "annotations/src/main/resources/META-INF/services/").mkdirs()
            def processorFile = new File(rootDir, "annotations/src/main/resources/META-INF/services/com.sun.source.util.Plugin")
            def text = new StringBuilder()
            def files = new File(rootDir, "annotations/src/main/java")
            files.eachFileRecurse(groovy.io.FileType.FILES){ file ->
                if(file.name.endsWith(".java") && (file.text.contains(" implements Plugin"))){
                    text.append(file.path.substring(files.path.length() + 1)).append("\n")
                }
            }

            processorFile.text = text.toString().replace(".java", "").replace("/", ".").replace("\\", ".")
        }
    }

    repositories{
        mavenLocal()
        mavenCentral()
        maven{ url "https://oss.sonatype.org/content/repositories/snapshots/" }
        maven{ url "https://oss.sonatype.org/content/repositories/releases/" }
        maven{ url 'https://jitpack.io' }
    }

    task clearCache(type: Delete){
        delete "$rootDir/core/assets/cache"
    }

    tasks.withType(JavaCompile){
        targetCompatibility = JavaVersion.VERSION_1_8
        sourceCompatibility = JavaVersion.VERSION_16
        options.encoding = "UTF-8"
        options.compilerArgs += ["-Xmaxerrs", "5000"]
        dependsOn clearCache

        options.forkOptions.jvmArgs += [
            '--add-opens=jdk.compiler/com.sun.tools.javac.api=ALL-UNNAMED',
            '--add-opens=jdk.compiler/com.sun.tools.javac.code=ALL-UNNAMED',
            '--add-opens=jdk.compiler/com.sun.tools.javac.model=ALL-UNNAMED',
            '--add-opens=jdk.compiler/com.sun.tools.javac.processing=ALL-UNNAMED',
            '--add-opens=jdk.compiler/com.sun.tools.javac.parser=ALL-UNNAMED',
            '--add-opens=jdk.compiler/com.sun.tools.javac.util=ALL-UNNAMED',
            '--add-opens=jdk.compiler/com.sun.tools.javac.tree=ALL-UNNAMED',
            '--add-exports=java.base/sun.reflect.annotation=ALL-UNNAMED'
        ]
    }
}

//compile with java 8 compatibility for everything except the annotation project
configure(subprojects - project(":annotations")){
    tasks.withType(JavaCompile){
        options.compilerArgs.addAll(['--release', '16'])
    }

    tasks.withType(Javadoc){
        options{
            addStringOption('Xdoclint:none', '-quiet')
            addStringOption('-release', '16')
            encoding('UTF-8')
        }
    }
}

project(":desktop"){
    apply plugin: "java"

//    compileJava.options.fork = true

    dependencies{
        implementation project(":core")
        implementation arcModule("extensions:discord")
        implementation arcModule("natives:natives-desktop")
        implementation arcModule("natives:natives-freetype-desktop")

        if(debugged()) implementation project(":debug")

        implementation "com.github.Anuken:steamworks4j:$steamworksVersion"

        implementation arcModule("backends:backend-sdl")
    }
}

project(":core"){
    apply plugin: "kotlin"
    apply plugin: "kotlin-kapt"

//    compileJava.options.fork = true

    task preGen{
        outputs.upToDateWhen{ false }
        generateLocales()
        writeVersion()
//        writeProcessors()
//        writePlugins()
    }

    task copyChangelog{
        doLast{
            def props = loadVersionProps()
            def androidVersion = props['androidBuildCode'].toInteger() - 2
            def loglines = file("../changelog").text.split("\n")
            def notice = "[This is a truncated changelog, see Github for full notes]"
            def maxLength = 460

            def androidLogList = [notice] + loglines.findAll{ line -> !line.endsWith("]") || line.endsWith("[Mobile]") || line.endsWith("[Android]")}
            def result = ""
            androidLogList.forEach{line ->
                if(result.length() + line.length() + 1 < maxLength){
                    result += line + "\n"
                }
            }
            def changelogs = file("../fastlane/metadata/android/en-US/changelogs/")
            changelogs.mkdirs()
            try{
                new File(changelogs, androidVersion + ".txt").text = (result)
            }catch(Exception ignored){
            }
        }
    }

    task sourcesJar(type: Jar, dependsOn: classes){
        archiveClassifier = 'sources'
        from sourceSets.main.allSource
    }

    task assetsJar(type: Jar, dependsOn: ":tools:pack"){
        archiveClassifier = 'assets'
        from files("assets"){
            exclude "config", "cache", "music", "sounds"
        }
    }

    task musicJar(type: Jar){
        archiveClassifier = 'music'
        from files("assets"){
            include "music/*", "sounds/*"
        }
    }

    artifacts{
        archives sourcesJar
        archives assetsJar
    }

    kapt {
        showProcessorStats = true
        keepJavacAnnotationProcessors = true
        javacOptions{
            option("-source", "16")
            option("-target", "8")
        }
    }

    tasks.withType(org.jetbrains.kotlin.gradle.internal.KaptWithoutKotlincTask.class).configureEach {
        kaptProcessJvmArgs.addAll([
            '--add-opens=jdk.compiler/com.sun.tools.javac.api=ALL-UNNAMED',
            '--add-opens=jdk.compiler/com.sun.tools.javac.code=ALL-UNNAMED',
            '--add-opens=jdk.compiler/com.sun.tools.javac.model=ALL-UNNAMED',
            '--add-opens=jdk.compiler/com.sun.tools.javac.processing=ALL-UNNAMED',
            '--add-opens=jdk.compiler/com.sun.tools.javac.parser=ALL-UNNAMED',
            '--add-opens=jdk.compiler/com.sun.tools.javac.util=ALL-UNNAMED',
            '--add-opens=jdk.compiler/com.sun.tools.javac.tree=ALL-UNNAMED',
            '--add-exports=java.base/sun.reflect.annotation=ALL-UNNAMED'
        ])
    }

    dependencies{
        compileJava.dependsOn(preGen)

        api "org.lz4:lz4-java:1.8.0"
        api arcModule("arc-core")
        if(localArc() && project.hasProperty("debug")) implementation arcModule("extensions:profiling")
        api arcModule("extensions:flabel")
        api arcModule("extensions:freetype")
        api arcModule("extensions:g3d")
        api arcModule("extensions:fx")
        api arcModule("extensions:arcnet")
        api "com.github.Anuken:rhino:$rhinoVersion"
        if(localArc() && debugged()) api arcModule("extensions:recorder")
        if(localArc()) api arcModule(":extensions:packer")

        implementation "org.jetbrains.kotlin:kotlin-reflect:1.7.20"
//        implementation "org.jetbrains.kotlinx:kotlinx-coroutines-core:1.6.0" Unused, removed to reduce jar size

        compileOnly files("../bouncycastle/bcprov-jdk15on.jar")
        compileOnly files("../bouncycastle/bcpkix-jdk15on.jar")
        compileOnly files("../bouncycastle/bctls-jdk15on.jar")
        compileOnly files("../bouncycastle/bcutil-jdk15on.jar")
        compileOnly arcModule("backends:backend-sdl")
        implementation 'commons-net:commons-net:3.8.0'

        compileOnly project(":annotations")
        if (!project.hasProperty("noKapt")) kapt project(":annotations")
        annotationProcessor 'com.github.Anuken:jabel:0.9.0'
    }

    afterEvaluate{
        task mergedJavadoc(type: Javadoc){
            doLast {
                def blacklist = [project(":ios"), project(":desktop"), project(":server"), project(":annotations")]
                if(findProject(":android") != null){
                    blacklist += project(":android")
                }

                source rootProject.subprojects.collect{ project ->
                    if(!blacklist.contains(project) && project.hasProperty("sourceSets")){
                        return project.sourceSets.main.allJava
                    }
                }

                classpath = files(rootProject.subprojects.collect { project ->
                    if(!blacklist.contains(project) && project.hasProperty("sourceSets")){
                        return project.sourceSets.main.compileClasspath
                    }
                })
                destinationDir = new File(buildDir, 'javadoc')
            }
        }
    }

    //comp** classes are only used for code generation
    jar{
        exclude("mindustry/entities/comp/**")
    }
}

project(":server"){
    apply plugin: "java"

    dependencies{
        implementation project(":core")
        implementation arcModule("backends:backend-headless")
    }
}

project(":tests"){
    apply plugin: "java"

    dependencies{
        testImplementation project(":core")
        testImplementation "org.jetbrains.kotlin:kotlin-reflect:1.7.20"
        testImplementation "org.junit.jupiter:junit-jupiter-params:5.7.1"
        testImplementation "org.junit.jupiter:junit-jupiter-api:5.7.1"
        testImplementation arcModule("backends:backend-headless")
        testRuntimeOnly "org.junit.jupiter:junit-jupiter-engine:5.7.1"
        testImplementation "org.bouncycastle:bcprov-jdk15on:1.69"
        testImplementation "org.bouncycastle:bcpkix-jdk15on:1.69"
        testImplementation "org.bouncycastle:bctls-jdk15on:1.69"
    }

    test{
        //fork every test so mods don't interact with each other
        forkEvery = 1
        useJUnitPlatform()
        workingDir = new File("../core/assets")
        testLogging{
            exceptionFormat = 'full'
            showStandardStreams = true
        }
    }
}

project(":tools"){
    apply plugin: "java"

    dependencies{
        implementation project(":core")

        implementation arcModule("natives:natives-desktop")
        implementation arcModule("natives:natives-freetype-desktop")
        implementation arcModule("backends:backend-headless")
    }
}

configure(project(":annotations")){
    apply plugin: "kotlin"

    tasks.withType(JavaCompile){
        targetCompatibility = 8
        sourceCompatibility = 8
    }

    dependencies{
        implementation "com.squareup:javapoet:1.12.1"
        implementation arcModule("arc-core")
    }
}

configure([":core", ":server"].collect{project(it)}){
    apply plugin: 'maven-publish'
    java{
        withJavadocJar()
        withSourcesJar()
    }

    publishing{
        publications{
            maven(MavenPublication){
                from components.java
            }
        }
    }
}

task deployAll{
    task cleanDeployOutput{
        doFirst{
            if(getBuildVersion() == "custom build" || getBuildVersion() == "") throw new IllegalArgumentException("----\n\nSET A BUILD NUMBER FIRST!\n\n----")
            if(!project.hasProperty("release")) throw new IllegalArgumentException("----\n\nSET THE RELEASE PROJECT PROPERTY FIRST!\n\n----")

            delete{
                delete "deploy/"
            }
        }
    }

    dependsOn cleanDeployOutput
    dependsOn "desktop:packrLinux64"
    dependsOn "desktop:packrWindows64"
    dependsOn "desktop:packrWindows32"
    dependsOn "desktop:packrMacOS"
    if(versionModifier != "steam"){
        dependsOn "server:deploy"
        dependsOn "android:deploy"
    }
}

task resolveDependencies{
    doLast{
        rootProject.allprojects{ project ->
            Set<Configuration> configurations = project.buildscript.configurations + project.configurations
            configurations.findAll{c -> c.canBeResolved}.forEach{c -> c.resolve()}
        }
    }
}