build.gradle

import java.time.format.DateTimeFormatter

buildscript{
    ext.kotlin_version = '1.6.0'
    ext{
        def properties = new Properties().with{ p -> p.load(file('gradle.properties').newReader()); return p }
        mindustryVersion = properties["mindustryVersion"]
        jparcerVersion = properties["jparcerVersion"]
        jabelVersion = properties["jabelVersion"]
        parserVersion = properties["parserVersion"]
        aciVersion = properties["aciVersion"]
        modCoreVersion = properties["modCoreVersion"]
        arcLibVersion = properties["arcLibVersion"]
        kotlin_version = kotlinVersion = properties["kotlinVersion"]
//        kotlinVersion = "1.5.31"

        sdkRoot = System.getenv("ANDROID_HOME") ?: System.getenv("ANDROID_SDK_ROOT")
        mindustryModule = { String name ->
            //skip to last submodule
            if(name.contains(':')) name = name.split(':').last()
            return "com.github.Anuken.Mindustry:$name:$mindustryVersion"
        }
        arcModule = { String name ->
            //skip to last submodule
            if(name.contains(':')) name = name.split(':').last()
            return "com.github.Anuken.Arc:$name:$mindustryVersion"
        }
        coreModule = { String name ->
            //skip to last submodule
            if(name.contains(':')) name = name.split(':').last()
            return "com.github.Zelaux.ZelauxModCore:$name:$modCoreVersion"
        }
        arcLibModule = { String name ->
            //skip to last submodule
            if(name.contains(':')) name = name.split(':').last()
            return "com.github.Zelaux.ZelauxArcLib:$name:$arcLibVersion"
        }
    }
    repositories{
        mavenLocal()
        mavenCentral()
        google()
        maven{ url "https://oss.sonatype.org/content/repositories/snapshots/" }
        maven{ url 'https://jitpack.io' }
    }

    dependencies{
        classpath arcModule("arc-core")
        classpath mindustryModule("core")
        classpath arcModule("packer")
        classpath coreModule("annotations")
        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlinVersion"
    }
}
plugins{
    id 'org.jetbrains.kotlin.jvm' version "$kotlinVersion"
    id "org.jetbrains.kotlin.kapt" version "$kotlinVersion"
}
ext{
    //the build number that this mod is made for
    //version of SDK you will be using
    sdkVersion = '30'
    sdkRoot = System.getenv("ANDROID_HOME")
    doExec = { cmd ->
        def proc = cmd.execute(null, new File("$buildDir/libs"))
        proc.waitForProcessOutput(System.out, System.err)
    }
}

version '1.0'
allprojects{
    apply plugin: 'groovy'
    apply plugin: "kotlin"

//    version = 'release'
    group = 'com.github.Zelaux'
    ext{
        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 ->
                boolean isProcessor = file.text.contains(" extends ModBaseProcessor") ||
                        (file.text.contains(" extends AbstractProcessor") && !file.text.contains("abstract class")) ||
                        file.text.contains("@ModAnnotations.AnnotationProcessor");
                if(file.name.endsWith(".java") && isProcessor){
                    text.append(file.path.substring(files.path.length() + 1)).append("\n")
                }
            }

            processorFile.text = text.toString().replace(".java", "").replace("/", ".").replace("\\", ".")
        }
    }
    apply plugin: 'maven-publish'
    repositories{
        mavenLocal()
        google()
        mavenCentral()
        maven{ url "https://oss.sonatype.org/content/repositories/snapshots/" }
        maven{ url "https://oss.sonatype.org/content/repositories/releases/" }
        maven{ url 'https://jitpack.io' }
    }
    compileKotlin{
        sourceCompatibility = JavaVersion.VERSION_16
        targetCompatibility = JavaVersion.VERSION_1_8
    }
    tasks.withType(JavaCompile){
        targetCompatibility = 8
        sourceCompatibility = JavaVersion.VERSION_16
        options.encoding = "UTF-8"
//        options.encoding = "windows-1251"
        options.compilerArgs += ["-Xlint:deprecation"]

        options.forkOptions.jvmArgs.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-opens=java.base/sun.reflect.annotation=ALL-UNNAMED'
        ])
    }
}


configure(project(":annotations")){
    tasks.withType(JavaCompile){
        targetCompatibility = 8
        sourceCompatibility = 8
        options.fork = true
    }
}

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

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

//project(":core")
[":core:original", ":core"].collect{
    project(it){
        apply plugin: "java-library"
        apply plugin: "kotlin"
        apply plugin: "kotlin-kapt"


        kapt{
            javacOptions{
                option("-source", "17")
                option("-target", "1.8")
            }
        }

        compileJava.options.fork = true


        task preGen{

            outputs.upToDateWhen{ false }

//        generateLocales()
//        writeVersion()
            writeProcessors()
//        writePlugins()
        }
        task sourcesJar(type: Jar, dependsOn: classes){
            duplicatesStrategy = DuplicatesStrategy.EXCLUDE
            archiveClassifier = 'sources'
            from sourceSets.main.allSource
        }

        task assetsJar(type: Jar, dependsOn: ":tools:pack"){
            duplicatesStrategy = DuplicatesStrategy.EXCLUDE
            archiveClassifier = 'assets'
            from files("assets"){
                exclude "config", "cache", "music", "sounds"
            }
        }
        artifacts{
            archives sourcesJar
            archives assetsJar
        }

        repositories{
            mavenCentral()
        }
        compileKotlin{
            kotlinOptions{
                jvmTarget = "1.8"
            }
        }
        compileTestKotlin{
            kotlinOptions{
                jvmTarget = "1.8"
            }
        }
        dependencies{
            compileJava.dependsOn(preGen)

            implementation arcLibModule("defaults")
            implementation arcLibModule("utils")
            implementation arcLibModule("tooltips")
            implementation arcLibModule("components")
            implementation arcLibModule("listeners")

            implementation coreModule("tiledStructures")
            implementation coreModule("core")
            implementation coreModule("utils")
            implementation coreModule("graphics")

            compileOnly "org.lz4:lz4-java:1.7.1"
            compileOnly arcModule("arc-core")
            compileOnly arcModule("extensions:flabel")
            compileOnly arcModule("extensions:freetype")
            compileOnly arcModule("extensions:g3d")
            compileOnly arcModule("extensions:fx")
            compileOnly arcModule("extensions:arcnet")
            compileOnly mindustryModule("core")
//        implementation "com.github.Zelaux:AdvancedContentInfo:$aciVersion"


            annotationProcessor 'com.github.Anuken:jabel:34e4c172e65b3928cd9eabe1993654ea79c409cd'

            compileOnly coreModule("annotations")
            compileOnly project(":annotations")

//            println "it is ${project.displayName}"
            if(project.name == "core"){
                kapt(
                        coreModule("annotations"), project(":annotations"))
//                kapt project(":annotations")
            }
            implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk8"
//        annotationProcessor 'com.github.Anuken:jabel:34e4c172e65b3928cd9eabe1993654ea79c409cd'

        }

        afterEvaluate{
            task mergedJavadoc(type: Javadoc){
                if(true) return null;
                def blacklist = [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')
            }
        }
        jar{
            duplicatesStrategy = DuplicatesStrategy.EXCLUDE
            exclude("bytelogic/entities/comp/**")
            exclude("bytelogic/entities/compByAnuke/**")
        }
    }
}
project(":tools"){
    apply plugin: "java"

    dependencies{
        implementation fileTree(dir: 'libs', include: ['*.jar'])
        implementation 'commons-io:commons-io:2.5'
        implementation("org.apache.xmlgraphics:batik-svgrasterizer:1.9")


        implementation project(":core")

        implementation 'com.github.javaparser:javaparser-symbol-solver-core:3.22.1'
        implementation mindustryModule("core")

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


        implementation coreModule("core")

        implementation 'com.github.sterlp:svg2png:1.0.0'
        implementation coreModule("tools")

        implementation arcModule(":extensions:packer")
    }

}

project(":annotations"){
    apply plugin: "java-library"
    dependencies{
        implementation 'com.squareup:javapoet:1.12.1'
        implementation arcModule('arc-core')
        implementation mindustryModule("core")


        implementation "com.github.javaparser:javaparser-symbol-solver-core:$jparcerVersion"
        implementation "com.github.Zelaux.ZelauxModCore:core:$modCoreVersion"
        implementation "com.github.Zelaux.ZelauxModCore:tools:$modCoreVersion"
        implementation "com.github.Zelaux.ZelauxModCore:annotations:$modCoreVersion"
    }
}
configure([project(":core")]){
    java{
        withJavadocJar()
        withSourcesJar()
    }

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

task jarAndroid{
    dependsOn "jar"

    doLast{
        //collect dependencies needed for desugaring
        def files = (
                project(":core").configurations.compileClasspath.asList() +
                        project(":core").configurations.runtimeClasspath.asList() +
                        configurations.runtimeClasspath.asList() +
                        [new File("$sdkRoot/platforms/android-$sdkVersion/android.jar")]
        )
        def dependencies = files.collect{ "--classpath $it.path" }.join(" ")

        //dex and desugar files - this requires d8 in your PATH
        doExec("d8 $dependencies --min-api 14 --output ${project.archivesBaseName}Android.jar ${project.archivesBaseName}Desktop.jar")
    }
}
jar{
    duplicatesStrategy = DuplicatesStrategy.EXCLUDE
    dependsOn "core:jar"
    archiveFileName = "${project.archivesBaseName}Desktop.jar"
    //  if (!file(rootDir+"/core/assets/sprites").exists())dependsOn "tools:pack"
    from{
//        configurations.runtimeClasspath.collect { it.isDirectory() ? it : zipTree(it) }
        project(":core").fileTree("build/libs/core.jar").collect{ it.isDirectory() ? it : zipTree(it) }
    }
    from{
        project(":core").configurations.runtimeClasspath.collect{ it.isDirectory() ? it : zipTree(it) }
//        project(":core").fileTree("build/libs/core.jar").collect { it.isDirectory() ? it : zipTree(it) }
    }

    from(rootDir){
        include "mod.hjson"
        include "mod.json"
        include "icon.png"
    }

    from("core/assets/"){
        include "**"
    }
}
task deploy(type: Jar){
    duplicatesStrategy = DuplicatesStrategy.EXCLUDE
    dependsOn jarAndroid
    dependsOn jar
    archiveFileName = "${project.archivesBaseName}.jar"

    from{ [zipTree("$buildDir/libs/${project.archivesBaseName}Desktop.jar"), zipTree("$buildDir/libs/${project.archivesBaseName}Android.jar")] }

    doLast{
        delete{ delete "$buildDir/libs/${project.archivesBaseName}Desktop.jar" }
        delete{ delete "$buildDir/libs/${project.archivesBaseName}Android.jar" }
    }
}
task resolveDependencies{
    doLast{
        rootProject.allprojects{ project ->
            Set<Configuration> configurations = project.buildscript.configurations + project.configurations
            configurations.findAll{ c -> c.canBeResolved }.forEach{ c -> c.resolve() }
        }
    }
}
publishToMavenLocal{
    dependsOn("tools:pack")
    dependsOn("jar")
}

def os(){ //Returns OS name
    String s = System.getProperty("os.name");
    return s == null ? "" : s;
}

def getdatadir(){ //Returns Mindustry data directory path
    def ret = System.getenv("MINDUSTRY_DATA_DIR")
    if(ret == null){
        def os = os()
        if(os.contains("Windows")){
            return System.getenv("AppData") + "\\Mindustry\\"
        }else if(os.contains("Linux") || os.contains("BSD")){
            if(System.getenv("XDG_DATA_HOME") != null){
                String dir = System.getenv("XDG_DATA_HOME")
                if(!dir.endsWith("/")) dir += "/"
                return dir + "Mindustry/"
            }
            return System.getProperty("user.home") + "/.local/share/Mindustry/"
        }else if(os.contains("Mac")){
            return System.getProperty("user.home") + "/Library/Application Support/Mindustry/";
        }
    }
    return ret
}

task mjar(){
    dependsOn "jar"
    doFirst{}
    ext{
        acopy = { String intoPath ->
            delete{
                delete "${intoPath}/${project.archivesBaseName}Desktop.jar"
            }
            copy{
                from "$buildDir/libs/${project.archivesBaseName}Desktop.jar"
                into intoPath
            }
            println "Moved to ${intoPath}"
        }
    }
    doLast{
        def modsDirectories = [];
        def file = new File(rootDir, "modsDirectories.txt");

        if(file.exists()){
            BufferedReader reader = new BufferedReader(new FileReader(file));
            reader.lines().forEach(line -> modsDirectories.add(line))
            reader.close();
        }else{
            modsDirectories.add("classic");
        }
        for(String directory : modsDirectories){
            if(directory.startsWith("//") || directory.startsWith("#")){
                println "Directory \"$directory\" skipped"
                continue
            }
            if(directory.equals("classic")){
                directory = getdatadir() + "mods";
            }
            acopy(directory);
        }
        def time = LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy/MM/dd HH:mm:ss"));
        println "Build ended at: ${time}"
    }
}
repositories{
    mavenCentral()
}
compileKotlin{
    kotlinOptions{
        jvmTarget = "1.8"
    }
}
compileTestKotlin{
    kotlinOptions{
        jvmTarget = "1.8"
    }
}