build.gradle

import groovy.json.JsonSlurper

import java.nio.charset.StandardCharsets
import java.nio.file.FileVisitResult
import java.nio.file.Files
import java.nio.file.SimpleFileVisitor
import java.nio.file.StandardCopyOption
import java.nio.file.Paths
import java.nio.file.attribute.BasicFileAttributes

plugins {
    alias(libs.plugins.kotlin.jvm)
    alias(libs.plugins.kotlin.serialization)
    alias(libs.plugins.kotlin.ksp)
    alias(libs.plugins.kotlin.assert)

    id 'maven-publish'
    id 'java-library'
}

def json = new JsonSlurper()
def mod = json.parse("${projectDir}/src/main/resources/plugin.json" as File)

group = 'mindurka'
version = "${mod['version']}" 

compileJava.options.encoding = "UTF-8" 

def workspacePath = gradle.ext.workspacePath

allprojects {
    repositories {
        mavenCentral()
    }
}

apply from: "$workspacePath/.cache/tools/buildscript/shared.repos.gradle"

java {
    withSourcesJar()
    withJavadocJar()
}

publishing {
    publications {
        internal(MavenPublication) {
            from components.java

            version "latest-SNAPSHOT"
        }
    }
    repositories {
        maven {
            url = "file://$workspacePath/.cache/maven"
        }
    }
}

dependencies {
    compileOnly files("$workspacePath/.cache/tools/buildscript/server-release.jar")

    implementation libs.bundles.kotlin.serialization
    implementation libs.kotlin.reflect
    implementation libs.kotlin.datetime
    implementation libs.kotlin.coro

    implementation libs.rabbitmq.amqp
    implementation libs.surrealdb

    implementation libs.bundles.jline
    implementation libs.jansi

    testImplementation "org.jetbrains.kotlin:kotlin-test"
    testImplementation files("$workspacePath/.cache/tools/buildscript/server-release.jar")

    implementation project(':annotations')
    implementation project(':buildExtras')
    ksp project(':processor')
}

sourceSets {
    main {
        kotlin {
            srcDir "build/generated/buildtime"
        }
    }
}

jar {
    from ({ configurations.runtimeClasspath.collect { it.isDirectory() ? it : zipTree(it) } }) {
        exclude 'doc/**'
    }

    duplicatesStrategy = DuplicatesStrategy.EXCLUDE
}

powerAssert {
    functions = ["kotlin.assert", "kotlin.test.assertTrue", "kotlin.test.assertEquals", "kotlin.test.assertNull"]
    includedSourceSets = ["main", "test"]
}

test {
    useJUnitPlatform()
    testLogging {
        events "skipped", "failed"

        showExceptions true
        exceptionFormat "full"
        showCauses true
        showStackTraces true
    }
}

tasks.named("compileKotlin") {
    dependsOn "generateExtras"
}

tasks.register("generateExtras") {
    def rpath = rootDir

    doLast {
        def path = rpath.toPath().resolve("build/generated/buildtime")
        if (Files.exists(path)) Files.walkFileTree(path, new SimpleFileVisitor<java.nio.file.Path>() {
            @Override
            FileVisitResult visitFile(java.nio.file.Path file, BasicFileAttributes attrs) {
                Files.delete(file)
                return FileVisitResult.CONTINUE
            }

            @Override
            FileVisitResult postVisitDirectory(java.nio.file.Path file, IOException exc) {
                Files.delete(file)
                return FileVisitResult.CONTINUE
            }
        })
        Files.createDirectories(path.resolve("mindurka/coreplugin/"))

        def builder = new StringBuilder()
        builder.append("package mindurka.coreplugin\n\n")

        builder.append("/** Compile time info passed to CorePlugin. */\n")
        builder.append("object Build {\n")
        builder.append("    /** Commit hash of CorePlugin. */\n")
        builder.append("    @JvmField\n")
        builder.append("    val gitCommit = \"${"git rev-parse HEAD".execute().inputReader().readLine().trim()}\"\n")
        builder.append("}\n")

        Files.write(path.resolve("mindurka/coreplugin/Build.kt"), builder.toString().getBytes(StandardCharsets.UTF_8))
    }
}

tasks.named("build") {
    dependsOn ":test"

    def jarPath = Paths.get("${jar.archivePath}")
    doLast {
        Files.createDirectories(workspacePath.resolve(".bin"))
        Files.copy(
            jarPath,
            workspacePath.resolve(".bin/CorePlugin.jar"),
            StandardCopyOption.REPLACE_EXISTING)
        println "Copied CorePlugin to '$workspacePath/.bin/CorePlugin.jar'"
    }
}

// tasks.register("runServer") {
//     dependsOn build
// 
//     doLast {
//         def path = rootProject.rootDir.toPath().resolve("run")
//         Files.createDirectories(path.resolve("config/mods"))
//         Files.createDirectories(path.resolve("config/maps"))
// 
//         if (!Files.exists(path.resolve("server.jar"))) {
//             println "Downloading Mindustry server..."
//             Files.copy(
//                     new URI("https://github.com/Anuken/Mindustry/releases/download/v146/server-release.jar").toURL().openStream(),
//                     path.resolve("server.jar"))
//             Files.copy(
//                     rootDir.toPath().resolve("assets/Crashtest.msav"),
//                     path.resolve("config/maps/Crashtest.msav"))
//             Files.copy(
//                     rootDir.toPath().resolve("assets/settings.bin"),
//                     path.resolve("config/settings.bin"))
//         }
// 
//         Files.copy(
//                 jar.archiveFile.get().asFile.toPath(),
//                 path.resolve("config/mods/Debug.jar"),
//                 StandardCopyOption.REPLACE_EXISTING)
// 
//         javaexec {
//             classpath = files(path.resolve("server.jar"))
//             workingDir = path.toFile()
//             standardInput = System.in
// 
//             debugOptions {
//                 enabled = true
//                 port = 7857
//                 server = true
//                 suspend = false
//             }
//         }
//     }
// }