build.gradle

plugins {
    id 'java'
    id 'org.jetbrains.gradle.plugin.idea-ext' version '1.4'
    id 'maven-publish'
    id 'org.jreleaser' version '1.22.0'
    id 'signing'
}

import org.gradle.internal.os.OperatingSystem

ext {
    if (project.hasProperty('hytale_home')) {
        hytaleHome = project.findProperty('hytale_home')
        // Traverse up to the Hytale base directory
        //                            latest/    game/      package/   $patchline/install/
        //                            |          |          |          |          |
        hytaleBase = file(hytaleHome).parentFile.parentFile.parentFile.parentFile.parentFile.absolutePath
    }
    else {
        def os = OperatingSystem.current()
        def base = null
        if (os.isWindows()) {
            base = "${System.getProperty("user.home")}/AppData/Roaming/Hytale"
        }
        else if (os.isMacOsX()) {
            base = "${System.getProperty("user.home")}/Library/Application Support/Hytale"
        }
        else if (os.isLinux()) {
            base = "${System.getProperty("user.home")}/.var/app/com.hypixel.HytaleLauncher/data/Hytale"
            if (!file(base).exists()) {
                base = "${System.getProperty("user.home")}/.local/share/Hytale"
            }
        }

        if (base != null) {
            hytaleBase = base
            hytaleHome = "${hytaleBase}/install/$patchline/package/game/latest/Server"
        }
    }
}

if (project.hasProperty('hytale_home')) {
    if (!file(hytaleHome).exists()) {
        throw new GradleException("Failed to find Hytale at the specified hytale_home: $hytaleHome")
    }
} else if (hytaleHome == null || !file(hytaleHome).exists()) {
    // Use HytaleServer.jar from the current directory as a fallback.
    hytaleBase = "."
    hytaleHome = "${hytaleBase}/server"

    println "Warning: Could not locate Hytale installation. Falling back to using ${hytaleHome}/HytaleServer.jar from the current directory."
    println "If you have a copy of Hytale install it via the official way or consider specifying the 'hytale_home' project property to point to your custom installation."
    println "Example: gradle build -Phytale_home=\"/path/to/Hytale/install/<patchline>/package/game/latest/Server\""
}

group = maven_group

java {
    toolchain.languageVersion = JavaLanguageVersion.of(java_version)
    withSourcesJar()
    withJavadocJar()
}

// Quiet warnings about missing Javadocs.
javadoc {
    options.addStringOption('Xdoclint:-missing', '-quiet')
}

repositories {
    mavenCentral()

    exclusiveContent {
        forRepository {
            maven {
                url "https://cursemaven.com"
            }
        }
        filter {
            includeGroup "curse.maven"
        }
    }
}

dependencies {
    // Adds the Hytale server as a build dependency, allowing you to reference and
    // compile against their code. This requires you to have Hytale installed using
    // the official launcher for now or using the script from `CONTRIBUTING.md`.
    // `implementation` allows the HytaleServer.jar to be executed by IDEA run configuration
    // and VSCode launch configuration. The `jar {}` section below excludes it from being bundled
    // into the plugin jar.
    implementation files("$hytaleHome/HytaleServer.jar")
    implementation 'com.google.code.gson:gson:2.13.2'
    implementation 'com.google.dagger:dagger:2.59.1'
    annotationProcessor 'com.google.dagger:dagger-compiler:2.59.1'
    implementation 'org.xerial:sqlite-jdbc:3.51.1.0'
    // HyUI library for building Hytale-compatible user interfaces.
    // Currently pointing to: HyUI-0.8.0-all.jar
    implementation "curse.maven:hyui-1431415:7588625"

    testRuntimeOnly 'org.junit.platform:junit-platform-launcher:6.1.0-M1'
    testImplementation 'org.junit.jupiter:junit-jupiter-api:6.1.0-M1'
    testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine:6.1.0-M1'
    testImplementation 'org.junit.jupiter:junit-jupiter-params:6.1.0-M1'
    testRuntimeOnly 'org.mockito:mockito-core:5.21.0'
    testImplementation 'org.mockito:mockito-junit-jupiter:5.21.0'
}

jar {
    enabled = true
    archiveClassifier = ""
    duplicatesStrategy = DuplicatesStrategy.EXCLUDE
    from {
        configurations.runtimeClasspath.collect {
            // Exclude the HytaleServer.jar from being included in the plugin jar.
            (it.isDirectory() || it.name != "HytaleServer.jar") ? (it.isDirectory() ? it : zipTree(it)) : []
        }
    }
}

test {
    useJUnitPlatform()
}

publishing {
    publications {
        maven(MavenPublication) {
            groupId = group
            artifactId = artifact_id

            from components.java

            pom {
                name = "Sloud Hytale Portals"
                description = "Portal system for Hytale. Teleport to other worlds or points of interest."
                url = "https://github.com/${System.getenv("GITHUB_REPOSITORY")}"
                inceptionYear = "2026"
                licenses {
                    license {
                        name = "MIT License"
                        url = "https://opensource.org/licenses/MIT"
                    }
                }
                developers {
                    developer {
                        id = "joeyaurel"
                        name = "Joey Aurel"
                    }
                }
                scm {
                    connection = "scm:git:git://github.com/${System.getenv("GITHUB_REPOSITORY")}.git"
                    developerConnection = "scm:git:ssh://github.com/${System.getenv("GITHUB_REPOSITORY")}.git"
                    url = "https://github.com/${System.getenv("GITHUB_REPOSITORY")}"
                }
            }
        }
    }
    repositories {
        maven {
            name = "GitHubPackages"
            url = "https://maven.pkg.github.com/${System.getenv("GITHUB_REPOSITORY")}"
            credentials {
                username = System.getenv("GITHUB_ACTOR")
                password = System.getenv("GITHUB_TOKEN")
            }
        }
        maven {
            name = "LocalStaging"
            url = layout.buildDirectory.dir('staging-deploy')
        }
    }
}

jreleaser {
    signing {
        pgp {
            active = 'ALWAYS'
            armored = true
        }
    }
    release {
        github {
            skipRelease = true
        }
    }
    deploy {
        maven {
            mavenCentral {
                sonatype {
                    active = 'ALWAYS'
                    url = 'https://central.sonatype.com/api/v1/publisher'
                    stagingRepository('build/staging-deploy')
                }
            }
        }
    }
}

// Create the working directory to run the server if it does not already exist.
def serverRunDir = file("$projectDir/run")
if (!serverRunDir.exists()) {
    serverRunDir.mkdirs()
}

// Updates the manifest.json file with the latest properties defined in the
// build.properties file. Currently we update the version and if packs are
// included with the plugin.
tasks.register('updatePluginManifest') {
    def manifestFile = file('src/main/resources/manifest.json')
    doLast {
        if (!manifestFile.exists()) {
            throw new GradleException("Could not find manifest.json at ${manifestFile.path}!")
        }
        def manifestJson = new groovy.json.JsonSlurper().parseText(manifestFile.text)
        manifestJson.Version = version
        manifestJson.IncludesAssetPack = includes_pack.toBoolean()
        manifestFile.text = groovy.json.JsonOutput.prettyPrint(groovy.json.JsonOutput.toJson(manifestJson))
    }
}

// Makes sure the plugin manifest is up to date.
tasks.named('processResources') {
    dependsOn 'updatePluginManifest'
}

def createServerRunArguments(String srcDir) {
    def programParameters = '--allow-op --disable-sentry --assets="' + "${hytaleBase}/install/$patchline/package/game/latest/Assets.zip" + '"'
    def modPaths = []
    if (includes_pack.toBoolean()) {
        modPaths << srcDir
    }
    if (load_user_mods.toBoolean()) {
        modPaths << "${hytaleBase}/UserData/Mods"
    }
    if (!modPaths.isEmpty()) {
        programParameters += ' --mods="' + modPaths.join(',') + '"'
    }
    return programParameters
}

// Creates a run configuration in IDEA that will run the Hytale server with
// your plugin and the default assets.
idea.project.settings.runConfigurations {
    'HytaleServer'(org.jetbrains.gradle.ext.Application) {
        mainClass = 'com.hypixel.hytale.Main'
        moduleName = project.idea.module.name + '.main'
        programParameters = createServerRunArguments(sourceSets.main.java.srcDirs.first().parentFile.absolutePath)
        workingDirectory = serverRunDir.absolutePath
    }
}

// Creates a launch.json file for VSCode with the same configuration
tasks.register('generateVSCodeLaunch') {
    def vscodeDir = file("$projectDir/.vscode")
    def launchFile = file("$vscodeDir/launch.json")
    doLast {
        if (!vscodeDir.exists()) {
            vscodeDir.mkdirs()
        }
        def programParams = createServerRunArguments("\${workspaceFolder}")
        def launchConfig = [
            version: "0.2.0",
            configurations: [
                [
                    type: "java",
                    name: "HytaleServer",
                    request: "launch",
                    mainClass: "com.hypixel.hytale.Main",
                    args: programParams,
                    cwd: "\${workspaceFolder}/run"
                ]
            ]
        ]
        launchFile.text = groovy.json.JsonOutput.prettyPrint(groovy.json.JsonOutput.toJson(launchConfig))
    }
}