build.gradle

import org.jetbrains.gradle.ext.Gradle

plugins {
    id 'java'
    id 'java-library'
    id 'maven-publish'
    id 'scala'
    id 'org.jetbrains.gradle.plugin.idea-ext' version '1.4.1'
    id 'com.gradleup.shadow' version '9.4.0'
    id 'xyz.wagyourtail.unimined' version '1.4.37-kappa'
    id 'com.diffplug.spotless' version '8.4.0'
}

apply from: 'gradle/scripts/helpers.gradle'

private String gitOutput(List<String> args, String fallback) {
    try {
        def process = new ProcessBuilder(['git'] + args)
            .directory(rootProject.projectDir)
            .redirectErrorStream(true)
            .start()
        def stdout = process.inputStream.getText('UTF-8').trim()
        if (process.waitFor() == 0 && !stdout.isEmpty()) {
            return stdout
        }
    } catch (Exception ignored) {
        // Fall through to the fallback for source archives or environments without git.
    }
    return fallback
}

private String defaultModVersion() {
    def previousTag = gitOutput(['describe', '--tags', '--abbrev=0', '--exclude=dev'], '0.0.0')
    if (previousTag.startsWith('v')) {
        previousTag = previousTag.substring(1)
    }
    def shortHash = gitOutput(['rev-parse', '--short', 'HEAD'], 'unknown')
    return "${previousTag}+${shortHash}"
}

if (!gradle.startParameter.projectProperties.containsKey('mod_version')) {
    project.setProperty('mod_version', defaultModVersion())
}

// Early Assertions
assertProperty 'mod_version'
assertProperty 'root_package'
assertProperty 'mod_id'
assertProperty 'mod_name'
assertProperty 'legacy_ae_mod_id'

assertSubProperties 'use_lombok_ap', 'lombok_version'
assertSubProperties 'use_access_transformer', 'access_transformer_locations'
assertSubProperties 'is_coremod', 'coremod_includes_mod', 'coremod_plugin_class_name'
assertSubProperties 'use_asset_mover', 'asset_mover_version'

setDefaultProperty 'generate_sources_jar', true, false
setDefaultProperty 'generate_javadocs_jar', true, false
setDefaultProperty 'minecraft_username', true, 'Developer'
setDefaultProperty 'extra_jvm_args', false, ''

version = propertyString('mod_version')
group = propertyString('root_package')

base {
    archivesName = propertyString('mod_id')
}

java {
    toolchain {
        languageVersion = JavaLanguageVersion.of(25)
    }
    if (propertyBool('generate_sources_jar')) {
        withSourcesJar()
    }
    if (propertyBool('generate_javadocs_jar')) {
        withJavadocJar()
    }
}

scala {
    scalaVersion = '2.11.1'
}

configurations {
    contain
    implementation.extendsFrom(contain)
    modCompileOnly
    compileOnly.extendsFrom(modCompileOnly)
    testCompileOnly.extendsFrom(compileOnly)
    modRuntimeOnly
    runtimeOnly.extendsFrom(modRuntimeOnly)
}

String remapTaskName = propertyBool('enable_shadow') ? "remapShadowJar" : "remapJar"

def gtceuMappingsJar = layout.projectDirectory.file(".gradle/unimined/local/mappings/srg2mcp.jar")
def gtceuMappingsSrg = layout.projectDirectory.file(".gradle/unimined/local/mappings/srg2mcp.tsrg")
def gtceuMappingsCsvDir = layout.buildDirectory.dir("gtceu/mcp-csv")
def prepareGtceuDevMappings = tasks.register("prepareGtceuDevMappings", Copy) {
    from({ zipTree(gtceuMappingsJar.asFile) }) {
        include "fields.csv", "methods.csv"
    }
    into(gtceuMappingsCsvDir)
}

tasks.matching { it.name == 'runClient' || it.name == 'runServer' }.configureEach {
    dependsOn(prepareGtceuDevMappings)
}

repositories {
    // Other repositories described by default:
    // CleanroomMC: https://maven.cleanroommc.com
    maven {
        name = 'CurseMaven'
        url = 'https://cursemaven.com'
    }
    maven {
        name = 'CleanroomCurseMaven'
        url = 'https://curse.cleanroommc.com'
    }
    maven {
        name = 'Modrinth'
        url = 'https://api.modrinth.com/maven'
    }
    maven {
        name = "ModMaven"
        url  = uri("https://modmaven.dev/")
    }
    maven {
        url = "https://maven.crystaelix.com/releases/"
    }
    mavenCentral()
    mavenLocal()
    maven { url 'https://jitpack.io' }
}

unimined.minecraft {
    version "1.12.2"

    mappings {
        mcp("stable", "39-1.12")
    }

    cleanroom {
        if (propertyBool('use_access_transformer')) {
            accessTransformer "${rootProject.projectDir}/src/main/resources/${propertyString('access_transformer_locations')}"
        }
        loader "0.6.10-alpha"
        runs.auth.username = minecraft_username
        runs.all {
            systemProperty("crl.dev.mixin", "${mod_id}.mixin.json")
            systemProperty("net.minecraftforge.gradle.GradleStart.srg.notch-srg", gtceuMappingsSrg.asFile.absolutePath)
            systemProperty("net.minecraftforge.gradle.GradleStart.csvDir", gtceuMappingsCsvDir.get().asFile.absolutePath)
            def extraArgs = propertyString('extra_jvm_args')
            if (extraArgs != null && !extraArgs.trim().isEmpty()) {
                jvmArgs += extraArgs.split { "\\s+" }.toList()
            }
            systemProperty('mixin.debug.export', 'true')
            if (propertyBool('enable_foundation_debug')) {
                systemProperty("foundation.dump", "true")
                systemProperty("foundation.verbose", "true")
            }
            if (propertyBool('is_coremod')) {
                systemProperty("fml.coreMods.load", propertyString('coremod_plugin_class_name'))
            }
            return
        }
    }

    defaultRemapJar = false

    String jarTaskName = propertyBool('enable_shadow') ? "shadowJar" : "jar"

    remap(tasks.named(jarTaskName).get()) {
        mixinRemap {
            enableBaseMixin()
            enableMixinExtra()
        }
    }

    mods {
        remap(configurations.modCompileOnly)
        remap(configurations.modRuntimeOnly)
    }
}

dependencies {
    if (propertyBool('use_lombok_ap')) {
        compileOnly "org.projectlombok:lombok:${propertyString('lombok_version')}"
        annotationProcessor "org.projectlombok:lombok:${propertyString('lombok_version')}"

        testCompileOnly "org.projectlombok:lombok:${propertyString('lombok_version')}"
        testAnnotationProcessor "org.projectlombok:lombok:${propertyString('lombok_version')}"
    }
    if (propertyBool('use_asset_mover')) {
        implementation "com.cleanroommc:assetmover:${propertyString('asset_mover_version')}"
    }
    if (propertyBool('enable_junit_testing')) {
        testImplementation 'org.junit.jupiter:junit-jupiter:6.0.3'
        testRuntimeOnly 'org.junit.platform:junit-platform-launcher'
        testRuntimeOnly 'com.google.code.gson:gson:2.10.1'
    }
    compileOnly 'com.google.code.findbugs:jsr305:3.0.2'
}

apply from: 'gradle/scripts/dependencies.gradle'

def generatedTagsSourceDir = layout.buildDirectory.dir('generated/sources/tags/java')
def generateTagsSource = tasks.register('generateTagsSource') {
    def tagsPackage = "${propertyString('root_package')}.${propertyString('mod_id')}"
    def outputFile = generatedTagsSourceDir.map {
        it.file("${tagsPackage.replace('.', '/')}/Tags.java")
    }

    inputs.property('root_package', propertyString('root_package'))
    inputs.property('mod_id', propertyString('mod_id'))
    inputs.property('mod_name', propertyString('mod_name'))
    inputs.property('mod_version', propertyString('mod_version'))
    outputs.file(outputFile)

    doLast {
        def file = outputFile.get().asFile
        file.parentFile.mkdirs()
        file.text = """package ${tagsPackage};

public final class Tags {

    public static final String MOD_ID = "${propertyString('mod_id')}";
    public static final String MOD_NAME = "${propertyString('mod_name')}";
    public static final String VERSION = "${propertyString('mod_version')}";

    private Tags() {
    }
}
"""
    }
}

processResources {
    rename '(.+_at.cfg)', 'META-INF/$1'
    def legacyAeModId = propertyString('legacy_ae_mod_id')
    def resourceProps = [
        mod_id               : propertyString('mod_id'),
        mod_name             : propertyString('mod_name'),
        mod_version          : propertyString('mod_version'),
        mod_description      : propertyString('mod_description'),
        mod_authors          : propertyStringList('mod_authors', ',').collect { it.strip() }.join('", "'),
        mod_credits          : propertyString('mod_credits'),
        mod_license          : propertyString('mod_license'),
        mod_url              : propertyString('mod_url'),
        mod_issue_tracker_url: propertyString('mod_issue_tracker_url'),
        mod_update_json      : propertyString('mod_update_json'),
        mod_icon_item        : propertyString('mod_icon_item'),
        mod_logo_path        : propertyString('mod_logo_path'),
        mod_icon_path        : propertyString('mod_icon_path'),
        mod_background_path  : propertyString('mod_background_path')
    ]
    inputs.properties(resourceProps)
    inputs.property('legacy_ae_mod_id', legacyAeModId)
    filesMatching('mcmod.info') {
        expand(resourceProps + [mod_id: legacyAeModId])
    }
    filesMatching('pack.mcmeta') {
        expand(resourceProps)
    }
}

sourceSets {
    main {
        java {
            srcDir generatedTagsSourceDir
        }
    }
}

if (!propertyBool('enable_shadow')) {
    shadowJar.enabled = false
}

compileJava {
    dependsOn(generateTagsSource)
    sourceCompatibility = targetCompatibility = JavaVersion.VERSION_25
}

tasks.matching { it.name == 'sourcesJar' }.configureEach {
    dependsOn(generateTagsSource)
}

jar {
    archiveClassifier = 'dev'
    duplicatesStrategy = DuplicatesStrategy.EXCLUDE
    if (configurations.contain.size() > 0) {
        into('/') {
            from configurations.contain
        }
    }
    doFirst {
        manifest {
            def attribute_map = [:]
            attribute_map['ModType'] = "CRL"
            attribute_map['MixinConfigs'] = "${mod_id}.mixin.json"
            if (configurations.contain.size() > 0) {
                attribute_map['ContainedDeps'] = configurations.contain.collect { it.name }.join(' ')
                attribute_map['NonModDeps'] = true
            }
            if (propertyBool('is_coremod')) {
                attribute_map['FMLCorePlugin'] = propertyString('coremod_plugin_class_name')
                if (propertyBool('coremod_includes_mod')) {
                    attribute_map['FMLCorePluginContainsFMLMod'] = true
                }
            }
            if (propertyBool('use_access_transformer')) {
                attribute_map['FMLAT'] = propertyString('access_transformer_locations')
            }
            attributes(attribute_map)
        }
    }
    finalizedBy(tasks.named(remapTaskName).get())
}


shadowJar {
    configurations = [project.configurations.shadow]
    archiveClassifier = "shadow"
}


tasks.named(remapTaskName).configure {
    doFirst {
        logging.captureStandardOutput LogLevel.INFO
    }
    doLast {
        logging.captureStandardOutput LogLevel.QUIET
    }
}

idea {
    module {
        inheritOutputDirs = true
    }
    project {
        settings {
            runConfigurations {
                "0. Apply Spotless"(Gradle) {
                    taskNames = ["spotlessApply"]
                }
                "1. Run Client"(Gradle) {
                    taskNames = ["runClient"]
                }
                "2. Run Server"(Gradle) {
                    taskNames = ["runServer"]
                }
                "3. Build Mod"(Gradle) {
                    taskNames = ["build"]
                }
            }
            compiler.javac {
                afterEvaluate {
                    javacAdditionalOptions = "-encoding utf8"
                    moduleJavacAdditionalOptions = [
                            (project.name + ".main"): tasks.compileJava.options.compilerArgs.collect { '"' + it + '"' }.join(' ')
                    ]
                }
            }
        }
    }
}

compileTestJava {
    classpath += compileJava.classpath
    sourceCompatibility = targetCompatibility = JavaVersion.VERSION_25
}

test {
    classpath += compileJava.classpath
    classpath = configurations.testRuntimeClasspath.filter { it.name == 'gson-2.10.1.jar' } + classpath
    useJUnitPlatform()
    javaLauncher.set(javaToolchains.launcherFor {
        languageVersion = JavaLanguageVersion.of(25)
    })
    if (propertyBool('show_testing_output')) {
        testLogging {
            showStandardStreams = true
        }
    }
}

tasks.withType(JavaCompile).configureEach {
    options.encoding = 'UTF-8'
}

apply from: 'gradle/scripts/publishing.gradle'
apply from: 'gradle/scripts/extra.gradle'