ActuallyAdditions/build.gradle

plugins {
    id 'java-library'
    id 'maven-publish'
    id 'net.neoforged.moddev' version '1.0.21'
    id "me.modmuss50.mod-publish-plugin" version "0.7.4"
}

tasks.named('wrapper', Wrapper).configure {
    distributionType = Wrapper.DistributionType.BIN
}

version = "$mod_version+mc${game_version}"
group = "de.ellpeck"

base {
    archivesName = "actuallyadditions"
}

java.toolchain.languageVersion = JavaLanguageVersion.of(21)

neoForge {
    version = project.neo_version

    parchment {
        mappingsVersion = project.parchment_mappings_version
        minecraftVersion = project.hasProperty("parchment_minecraft_version") ? project.parchment_minecraft_version : project.game_version
    }

    runs {
        client {
            client()
            systemProperty 'neoforge.enabledGameTestNamespaces', "actuallyadditions"
            programArguments.addAll '--width=1920', '--height=1080'
        }

        client2 {
            client()

            programArguments.addAll '--username', 'Dev2'

            // Comma-separated list of namespaces to load gametests from. Empty = all namespaces.
            systemProperty 'neoforge.enabledGameTestNamespaces', "actuallyadditions"
        }

        server {
            server()
            programArgument '--nogui'
            systemProperty 'neoforge.enabledGameTestNamespaces', "actuallyadditions"
        }

        gameTestServer {
            type = "gameTestServer"
            systemProperty 'neoforge.enabledGameTestNamespaces', "actuallyadditions"
        }

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

        configureEach { run ->
            systemProperty 'forge.logging.markers', 'REGISTRIES'
            logLevel = org.slf4j.event.Level.DEBUG

            jvmArgument '-Xmx4G'

            if (run.project.javaToolchains.launcherFor(java.toolchain).map { it.metadata.vendor }.getOrElse("").contains("JetBrains")) {
                run.jvmArgument("-XX:+AllowEnhancedClassRedefinition")
            }
        }
    }

    mods {
        "actuallyadditions" {
            sourceSet(sourceSets.main)
        }
    }
}

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

configurations {
    runtimeClasspath.extendsFrom localRuntime
}

repositories {
    maven {
        url = "https://maven.neoforged.net/releases"
    }
    maven {
        url = "https://maven.blamejared.com"
    }
    maven {
        url "https://cursemaven.com"
        content {
            includeGroup "curse.maven"
        }
    }
    maven { url = 'https://maven.octo-studios.com/releases' }
}

dependencies {
    compileOnly "mezz.jei:jei-${jei_minecraft}-common-api:${jei_version}"
    compileOnly "mezz.jei:jei-${jei_minecraft}-neoforge-api:${jei_version}"

    localRuntime "mezz.jei:jei-${jei_minecraft}-neoforge:${jei_version}"

    compileOnly "vazkii.patchouli:Patchouli:${patchouli_version}"
    localRuntime "vazkii.patchouli:Patchouli:${patchouli_version}"
    compileOnly "xyz.brassgoggledcoders:PatchouliProvider:${patchouli_provider_version}"
    localRuntime "xyz.brassgoggledcoders:PatchouliProvider:${patchouli_provider_version}"

    localRuntime "curse.maven:jade-324717:5803666"
    localRuntime "curse.maven:mekanism-268560:5680395"

    // Immersive Engineering, mainly for compat datagen
    localRuntime "curse.maven:ie-231951:5828000"
    compileOnly "curse.maven:ie-231951:5828000"
    localRuntime "blusunrize.immersiveengineering:ImmersiveEngineering:1.21.1-12.0.0-182.77:datagen"
    compileOnly "blusunrize.immersiveengineering:ImmersiveEngineering:1.21.1-12.0.0-182.77:datagen"
    localRuntime "blusunrize.immersiveengineering:ImmersiveEngineering:1.21.1-12.0.0-182.77:api"
    compileOnly "blusunrize.immersiveengineering:ImmersiveEngineering:1.21.1-12.0.0-182.77:api"

    implementation "top.theillusivec4.curios:curios-neoforge:${curios_version}"
}

jar {
    group = 'artifact'
    manifest {
        attributes(["Specification-Title"     : "Actually Additions",
                    "Specification-Version"   : "1",
                    "Implementation-Title"    : project.archivesBaseName,
                    "Implementation-Version"  : project.version,
                    "Implementation-Timestamp": new Date().format("yyyy-MM-dd'T'HH:mm:ssZ"),
                    "Modloader": "Neoforge",
                    "Modloader-Version": project.neo_version,
        ])
    }

    from sourceSets.main.output
}

var generateModMetadata = tasks.register("generateModMetadata", ProcessResources) {
    var replaceProperties = [
            minecraft_version      : game_version,
            minecraft_version_range: game_version_range,
            neo_version            : neo_version,
            neo_version_range      : neo_version_range,
            loader_version_range   : loader_version_range,
            mod_id                 : "actuallyadditions",
            mod_name               : "Actually Additions",
            mod_version            : mod_version,
    ]

    inputs.properties replaceProperties
    expand replaceProperties
    from "src/main/templates"
    into "build/generated/sources/modMetadata"
}

sourceSets.main.resources.srcDir generateModMetadata
neoForge.ideSyncTask generateModMetadata

tasks.register('apiJar', Jar) {
    from sourceSets.main.output
    from sourceSets.main.java
    archiveClassifier.set('api')
    include 'de/ellpeck/actuallyadditions/api/**'
}

javadoc {
    include 'de/ellpeck/actuallyadditions/api/**'
}

tasks.register('javadocJar', Jar) {
    dependsOn javadoc
    from 'build/docs/javadoc'
    archiveClassifier.set('javadoc')
}

tasks.register('sourcesJar', Jar) {
    from sourceSets.main.java
    archiveClassifier.set('sources')
}

artifacts {
    archives sourcesJar, apiJar, javadocJar
}


publishing {
    publications {
        register('mavenJava', MavenPublication) {
            from components.java

            // Add sources and javadoc to the publication
            artifact sourcesJar
            artifact apiJar
            artifact javadocJar
        }
    }

    repositories {
        def token = providers.environmentVariable("MAVEN_TOKEN")
        if (token.isPresent()) {
            maven {
                url "https://maven.saps.dev/releases"
                credentials {
                    username = "ell"
                    password = token.get()
                }
            }
        }
    }
}


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

idea {
    module {
        downloadSources = true
        downloadJavadoc = true
    }
}

/**
 * Seek out the changelog for the current version and return it as a string.
 */
def createChangelog = () -> {
    def changelogText = new File("CHANGELOG.md").text
    def changelog = ""

    def lines = changelogText.split("\n")
    def inChangelog = false
    for (int i = 0; i < lines.size(); i++) {
        def line = lines[i]
        if (line.startsWith("# ")) {
            if (inChangelog) {
                break
            } else {
                if (line.contains(mod_version)) {
                    inChangelog = true
                }
            }
        }

        if (inChangelog) {
            changelog += line + "\n"
        }
    }

    def output = changelog.trim()
    return output.empty ? "No changelog found" : output
}

def cfToken = providers.environmentVariable("CF_TOKEN")
def mrToken = providers.environmentVariable("MR_TOKEN")
def ghToken = providers.environmentVariable("GITHUB_TOKEN")

publishMods {
    dryRun = !cfToken.isPresent() || !mrToken.isPresent() || !ghToken.isPresent()
    changelog = createChangelog().trim()
    version = mod_version
    displayName = "Actually Additions ${mod_version}"
    type = STABLE

    file = jar.archiveFile

    additionalFiles.from apiJar.archiveFile
    additionalFiles.from javadocJar.archiveFile
    additionalFiles.from sourcesJar.archiveFile

    modLoaders.add("neoforge")

    curseforge {
        accessToken = cfToken
        projectId = "228404"
        minecraftVersions.add(game_version)
        javaVersions.add(JavaVersion.VERSION_21)
    }

    modrinth {
        accessToken = mrToken
        projectId = "4K7Q3nqd"
        minecraftVersions.add(game_version)
    }

    github {
        repository = "Ellpeck/ActuallyAdditions"
        accessToken = ghToken
        commitish = providers.environmentVariable("GITHUB_SHA").orElse("dryRun")
        tagName = providers.environmentVariable("GITHUB_REF_NAME").orElse("dryRun")
    }
}