build.gradle

plugins {
    id 'java-library'
    id 'idea'
    id 'eclipse'
    id 'maven-publish'
    id 'net.neoforged.gradle.userdev' version '7.0.152'
    id 'com.diffplug.eclipse.apt' version '3.42.2'
    id 'net.darkhax.curseforgegradle' version '1.1.18'
}

base {
    archivesName = "${fileName}-${mcVersion}"
}

java.toolchain.languageVersion = JavaLanguageVersion.of(project.properties.javaVersion)

minecraft {
    accessTransformers.file file('src/main/resources/META-INF/accesstransformer.cfg')
}

subsystems {
    parchment {
        def split = "${parchmentVersion}".split('-')
        minecraftVersion = split[1]
        mappingsVersion = split[0]
    }
}

runs {
    configureEach {
        systemProperty 'forge.logging.markers', ''
        systemProperty 'forge.logging.console.level', 'debug'
        modSource project.sourceSets.main
    }

    client {
        systemProperty 'forge.enabledGameTestNamespaces', "${modid}"
    }

    server {
        systemProperty 'forge.enabledGameTestNamespaces', "${modid}"
        programArgument '--nogui'
    }

    data {
        programArguments.addAll '--mod', "${modid}", '--all', '--output', file('src/generated/resources/').getAbsolutePath(), '--existing', file('src/main/resources/').getAbsolutePath()
    }
}

sourceSets.main.resources {
    srcDir 'src/generated/resources'
}

repositories {
    maven {
        // CurseForge
        url "https://www.cursemaven.com"
        content {
            includeGroup "curse.maven"
        }
    }
    maven {
        // Curios
        url "https://maven.theillusivec4.top"
        content {
            includeGroupByRegex "top\\.theillusivec4.*"
        }
    }
    maven {
        // Patchouli
        url "https://maven.blamejared.com"
        content {
            includeGroup "vazkii.patchouli"
            includeGroupByRegex "net\\.darkhax.*"
            includeGroupByRegex "com\\.blamejared.*"
            includeGroup "org.openzen.zencode"
            includeGroup "mezz.jei"
        }
    }
    maven {
        // Shadows
        url "https://maven.shadowsoffire.dev/releases"
        content {
            includeGroup "dev.shadowsoffire"
        }
    }
    maven {
        // Emi
        url "https://maven.terraformersmc.com/"
        content {
            includeGroup "dev.emi"
        }
    }
}

dependencies {
    implementation "net.neoforged:neoforge:${forgeVersion}"
    if(project.mixin.toBoolean())                   annotationProcessor "org.spongepowered:mixin:${mixinVersion}:processor"
    if(project.hasProperty('placeboVersion'))       implementation "dev.shadowsoffire:Placebo:${mcVersion}-${placeboVersion}"
    if(project.hasProperty('jeiVersion'))           implementation "mezz.jei:jei-${mcVersion}-neoforge:${jeiVersion}"
    if(project.hasProperty('jadeFileId'))           implementation "curse.maven:jade-324717:${jadeFileId}"
    if(project.hasProperty('curiosVersion'))        implementation "top.theillusivec4.curios:curios-neoforge:${curiosVersion}"
    if(project.hasProperty('patchouliVersion'))     implementation "vazkii.patchouli:Patchouli:${patchouliVersion}"
    if(project.hasProperty('bookshelfVersion'))     compileOnly    "net.darkhax.bookshelf:Bookshelf-Forge-${mcVersion}:${bookshelfVersion}"
    if(project.hasProperty('gamestagesVersion'))    compileOnly    "net.darkhax.gamestages:GameStages-Forge-${mcVersion}:${gamestagesVersion}"
    if(project.hasProperty('twilightFileId'))       implementation "curse.maven:the-twilight-forest-227639:${twilightFileId}"
    if(project.hasProperty('gatewaysVersion'))      implementation "dev.shadowsoffire:GatewaysToEternity:${mcVersion}-${gatewaysVersion}"
    if(project.hasProperty('attributeslibVersion')) implementation "dev.shadowsoffire:ApothicAttributes:${mcVersion}-${attributeslibVersion}"
    if(project.hasProperty('emiVersion'))           compileOnly    "dev.emi:emi-neoforge:${emiVersion}+${mcVersion}:api"
}

tasks.named('processResources', ProcessResources).configure {
    def replaceProperties = [
        modGroup: modGroup,
        modid: modid,
        version: version,
        modName: modName,
        author: author,
        desc: desc,
        mcVersion: mcVersion,
        javaVersion: javaVersion,
        forgeVersion: forgeVersion
    ]

    def licenseFile = file('LICENSE')
    if (!licenseFile.exists()) {
        throw new Exception('Missing LICENSE file in repository root.')
    }
    replaceProperties.put 'license', file('LICENSE').readLines().get(0)

    if (project.hasProperty('placeboVersion'))       replaceProperties.put 'placeboVersion', placeboVersion
    if (project.hasProperty('attributeslibVersion')) replaceProperties.put 'attributeslibVersion', attributeslibVersion
    if (project.hasProperty('curiosVersion'))        replaceProperties.put 'curiosVersion', curiosVersion
    if (project.hasProperty('topVersion'))           replaceProperties.put 'topVersion', topVersion
    if (project.hasProperty('patchouliVersion'))     replaceProperties.put 'patchouliVersion', patchouliVersion

    replaceProperties.put 'mixinConfig', project.mixin.toBoolean() ? "[[mixins]]\nconfig=\"${modid}.mixins.json\"" : ""

    inputs.properties replaceProperties

    def resourceTargets = [
        'META-INF/neoforge.mods.toml'
    ]

    filesMatching(resourceTargets) {
        expand replaceProperties
    }

    // Automatically populate mixins.json from the mixin package and rename to modid.mixins.json
    filesMatching('mixins.json') {
        def mixinFiles = []
        def clientMixinFiles = []

        def path = "${project.projectDir}/src/main/java/${modGroup}/${modid}/mixin".replaceAll('\\.', '/')
        fileTree(path).visit { FileVisitDetails details ->
            def name = details.file.path.replace('\\', '/')
            name = name.substring(name.indexOf('mixin/') + 'mixin/'.length(), name.length())
            if(name.endsWith('.java')) {
                name = name.substring(0, name.length() - '.java'.length())
                if(name.startsWith('client')) {
                    clientMixinFiles.add(name)
                } else {
                    mixinFiles.add(name)
                }
            }
        }

        def mixins = ''
        def clientMixins = ''

        for (int i = 0; i < mixinFiles.size(); i++) {
            def name = mixinFiles[i]
            name = name.replaceAll('\\/', '.')
            mixins += '        "' + name + '"'
            if (i != mixinFiles.size() - 1) {
                mixins += ',\n'
            }
        }

        for (int i = 0; i < clientMixinFiles.size(); i++) {
            def name = clientMixinFiles[i]
            name = name.replaceAll('\\/', '.')
            clientMixins += '        "' + name + '"'
            if (i != clientMixinFiles.size() - 1) {
                clientMixins += ',\n'
            }
        }

        replaceProperties.put('mixins', mixins)
        replaceProperties.put('clientMixins', clientMixins)

        expand replaceProperties
        name "${modid}.mixins.json".toString()
    }

    // Automatically populate coremods.json file from existing coremod js files in /coremods
    filesMatching('META-INF/coremods.json') {
        def names = []
        fileTree("${project.projectDir}/src/main/resources/coremods").visit { FileVisitDetails details ->
            def name = details.file.path.replace('\\', '/')
            name = name.substring(name.indexOf('coremods'), name.length())
            if(name.endsWith('.js')) {
                names.add(name)
            }
        }

        def coremods = ''

        for (int i = 0; i < names.size(); i++) {
            def name = names[i]
            coremods += "\t\"${modid}_" + name.substring('coremods/'.length(), name.length() - 3) + '": "' + name + '"'
            if (i != names.size() - 1) {
                coremods += ',\n'
            }
        }

        replaceProperties.put('coremods', coremods)

        expand replaceProperties
    }
}

java {
    withSourcesJar()
    // withJavadocJar()
}

publishing {
    repositories {
        maven {
            name = "shadowsMaven"
            url = "https://maven.shadowsoffire.dev/releases"
            credentials(PasswordCredentials)
            authentication {
                basic(BasicAuthentication)
            }
        }
    }
    publications {
        mavenJava(MavenPublication) {
            groupId = "${modGroup}"
            artifactId = "${fileName}"
            version = "${mcVersion}-${version}"
            pom.withXml {
                def node = asNode()
                if(node.dependencies.size() > 0)
                    node.remove(node.dependencies) // Remove deps, as they are all mappings-dependent and/or forge
            }
            from components.java
        }
    }
}

tasks.withType(JavaCompile).configureEach {
    options.encoding = 'UTF-8' // Use the UTF-8 charset for Java compilation
}

tasks.withType(GenerateModuleMetadata) {
    enabled = false // Can't figure out how to disable the dependencies block here, and it's wrong by default (it pulls deobf deps).
}

def getChangelogLink() {
    def repo = ''
    def proc = 'git config --get remote.origin.url'.execute();
    proc.in.eachLine { line -> repo = line}
    proc.err.eachLine { line -> println line }
    proc.waitFor();

    def branch = ''
    proc = 'git rev-parse --abbrev-ref HEAD'.execute()
    proc.in.eachLine { line -> branch = line }
    proc.err.eachLine { line -> println line }
    proc.waitFor()
    // Remove ".git" and append /blob/branch/changelog.md
    if (!repo.isBlank() && !branch.isBlank()) {
        return repo.substring(0, repo.length() - 4) + '/blob/' + branch + '/changelog.md'
    }
    else {
        return ''
    }
}

// Splits a list of values separated by ', ' (comma + space).
def splitList(list) {
    def split = list.split(', ')
    assert split.length == list.count(',') + 1
    return split
}

tasks.register('publishCurseForge', net.darkhax.curseforgegradle.TaskPublishCurseForge).configure {
    if (project.hasProperty('curseforgeUploadToken') && project.hasProperty('curseforgeProjectId')) {
        apiToken = getProperty('curseforgeUploadToken')
        disableVersionDetection()
    
        def projectId = getProperty('curseforgeProjectId')
        def mainFile = upload(projectId, jar)
        mainFile.changelog = getChangelogLink()
        mainFile.addModLoader(splitList("${modLoaders}"))
        mainFile.addJavaVersion("Java ${javaVersion}")
        mainFile.addGameVersion("${mcVersion}")
        mainFile.releaseType = "${releaseType}"
    
        if (project.hasProperty('requiredDeps')) {
            mainFile.addRequirement(splitList("${requiredDeps}"))
        }
        if (project.hasProperty('optionalDeps')) {
            mainFile.addOptional(splitList("${optionalDeps}"))
        }
        if (project.hasProperty('incompatibleDeps')) {
            mainFile.addIncompatibility(splitList("${incompatibleDeps}"))
        }
    
        mainFile.withAdditionalFile(sourcesJar)
    }
}

task publishAll() {
    dependsOn publish
    dependsOn publishCurseForge
}