build.gradle

import net.darkhax.curseforgegradle.TaskPublishCurseForge

import java.text.SimpleDateFormat

plugins {
    id 'checkstyle'
    id 'idea'
    id 'java'
    id 'maven-publish'

    id 'com.github.breadmoirai.github-release' version '2.5.2'
    id 'com.modrinth.minotaur' version '2.+'
    id 'net.darkhax.curseforgegradle' version '1.1.16'
    id 'net.neoforged.moddev' version '2.+'
    id 'org.jetbrains.changelog' version '1.2.1'
}

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

wrapper {
    gradleVersion = '8.11'
    distributionType = Wrapper.DistributionType.BIN
}

def isSnapshotVersion = project.hasProperty('teamcityBuild')
def githubUser = 'IntelligenceModding'
def githubRepo = 'AdvancedPeripherals'

version = "${mod_version}" + (isSnapshotVersion ? "-SNAPSHOT" : "") + "${mod_artifact_suffix}"
group = 'de.srendi.advancedperipherals'

def static getenv(path = ".env") {
    def env = [:]

    def file = new File(path)
    if (file.exists()) {
        file.eachLine { line ->
            def (name, value) = line.tokenize("=")
            if (value != null) {
                env[name.trim()] = value.trim()
            }
        }
    }

    return env
}

def secretEnv = getenv()
def curseforgeKey = secretEnv["CURSEFORGE_KEY"] ?: System.getenv("CURSEFORGE_KEY") ?: ''
def modrinthKey = secretEnv["MODRINTH_KEY"] ?: System.getenv("MODRINTH_KEY")
def repositoryName = secretEnv["PUBLIC_REP_NAME"] ?: System.getenv("PUBLIC_REP_NAME")
def repositoryKey = secretEnv["PUBLIC_REP_KEY"] ?: System.getenv("PUBLIC_REP_KEY")
def githubKey = secretEnv["GITHUB_KEY"] ?: System.getenv("GITHUB_KEY")

// Include resources generated by data generators.
sourceSets.main.resources { srcDir 'src/generated/resources' }

neoForge {
    // Specify the version of NeoForge to use.
    version = project.neo_version

    parchment {
        mappingsVersion = project.parchment_mappings_version
        minecraftVersion = project.parchment_minecraft_version
    }

    validateAccessTransformers = true

    runs {
        // applies to all the run configs below
        configureEach {
            systemProperty 'forge.logging.markers', 'REGISTRIES'

            logLevel = org.slf4j.event.Level.DEBUG
        }

        client {
            client()

            systemProperty 'neoforge.enabledGameTestNamespaces', project.mod_id
        }

        server {
            server()
            systemProperty 'neoforge.enabledGameTestNamespaces', project.mod_id
        }

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

        data {
            data()

            programArguments.addAll '--mod', project.mod_id, '--all', '--output', file('src/generated/resources/').getAbsolutePath(), '--existing', file('src/main/resources/').getAbsolutePath()
        }

    }

    mods {
        "${mod_id}" {
            sourceSet(sourceSets.main)
        }
    }
}

repositories {
    mavenCentral()
    maven {
        name = "Intelligence Mirror Repo"
        url = "https://mvn.intelligence-modding.de/Minecraft"
        content {
            includeGroup("com.refinedmods.refinedstorage")
        }
    }
    maven {
        name = "Blamejared maven botania patchouli"
        url = 'https://maven.blamejared.com'
        content {
            includeGroup("vazkii.botania")
            includeGroup("vazkii.patchouli")
        }
    }
    maven {
        name = "Squiddev maven cct"
        url = 'https://maven.squiddev.cc'
        content {
            includeGroup("cc.tweaked")
            includeModule("org.squiddev", "Cobalt")
        }
    }
    maven {
        name = "Theillusivec4 maven curios"
        url = "https://maven.theillusivec4.top/"
        content {
            includeGroup("top.theillusivec4.curios")
        }
    }
    maven {
        name = "LDT Team minecolonies"
        url = 'https://ldtteam.jfrog.io/ldtteam/modding'
        content {
            includeGroup("com.ldtteam")
        }
    }
    maven {
        name = "Modmaven Jei"
        url = 'https://modmaven.dev/'
        content {
            includeGroup("mezz.jei")
            includeGroup("appeng")
            includeGroup("mekanism")
        }
    }
    maven {
        name = "Create maven"
        url = "https://maven.createmod.net"
        content {
            includeGroup("com.simibubi.create")
            includeGroup("dev.engine-room.flywheel")
            includeGroup("net.createmod.ponder")
        }
    }
    maven {
        name = "Create Registrate maven"
        url = "https://maven.ithundxr.dev/snapshots"
        content {
            includeGroup("com.tterrag.registrate")
        }
    }
    maven {
        name = "TerraformersMC EMI"
        url = "https://maven.terraformersmc.com/"
    }
    maven {
        name = "SirEdvin's private repository"
        url = "https://repo.repsy.io/mvn/siredvin/default"
        content {
            includeGroup("site.siredvin.ttoolkit")
        }
    }
    maven {
        name = "Shedaniel cloth"
        url = "https://maven.shedaniel.me/"
        content {
            includeGroup("dev.architectury")
            includeGroup("me.shedaniel.cloth")
        }
    }
    maven {
        name = "EMI"
        url = uri("https://maven.terraformersmc.com/")
    }
    maven {
        name = 'Kotlin for Forge'
        url = 'https://thedarkcolour.github.io/KotlinForForge/'
        content {
            includeModule("thedarkcolour", "kotlinforforge")
        }
    }
    exclusiveContent {
        forRepository {
            maven {
                url = "https://cursemaven.com"
            }
        }
        filter {
            includeGroup("curse.maven")
        }
    }
    exclusiveContent {
        forRepository {
            maven {
                url = "https://api.modrinth.com/maven"
            }
        }
        filter {
            includeGroup("maven.modrinth")
        }
    }
}

configurations {
    implementationExtra
    testModImplementation.extendsFrom(implementation)
    testModImplementation.extendsFrom(testImplementation)
    runtimeClasspath.extendsFrom localRuntime
}

dependencies {
    // If some of the dependencies are not needed in the dev environment, you can comment the `runtimeOnly` line so it
    // will not be included in the client.

    // Minimal requirements
    compileOnly "org.jetbrains:annotations:${jb_annotations}"
    implementation "net.neoforged:neoforge:${neo_version}"
    implementation "cc.tweaked:cc-tweaked-${minecraft_version}-forge:${cc_version}"
    compileOnly "cc.tweaked:cc-tweaked-${minecraft_version}-core:${cc_version}"

    // Minimal requirements end

    compileOnly("com.refinedmods.refinedstorage:refinedstorage-neoforge:${refinedstorage_version}")
    runtimeOnly("com.refinedmods.refinedstorage:refinedstorage-neoforge:${refinedstorage_version}") {
        transitive = false
    }

    // Transitive prevents that this dependency would load other dependencies which are used by refined storage and are faulty marked
    compileOnly("com.refinedmods.refinedstorage:refinedstorage-mekanism-integration:${refinedstorage_mekanism_version}")
    runtimeOnly("com.refinedmods.refinedstorage:refinedstorage-mekanism-integration:${refinedstorage_mekanism_version}")  {
            transitive = false
    }

    // Extended requirements
    // We don't use the api since we need a specific class from mekanism
    compileOnly "mekanism:Mekanism:${mekanism_version}"
    runtimeOnly "mekanism:Mekanism:${mekanism_version}"

    // Applied Energistics 2
    compileOnly "org.appliedenergistics:appliedenergistics2:${appliedenergistics_version}"
    runtimeOnly "org.appliedenergistics:appliedenergistics2:${appliedenergistics_version}"

    // Applied Mekanistics
    compileOnly "curse.maven:applied-mekanistics-574300:${appliedmekanistics_version}"
    runtimeOnly "curse.maven:applied-mekanistics-574300:${appliedmekanistics_version}"

    // AE2 Things
    compileOnly "curse.maven:ae2things-609977:${ae2things_version}-sources"
    runtimeOnly "curse.maven:ae2things-609977:${ae2things_version}-sources"

    implementation ("com.simibubi.create:create-${minecraft_version}:${create_version}:slim") { transitive = false }
    implementation "net.createmod.ponder:Ponder-NeoForge-${minecraft_version}:${ponder_version}"
    compileOnly "dev.engine-room.flywheel:flywheel-neoforge-api-${minecraft_version}:${flywheel_version}"
    runtimeOnly "dev.engine-room.flywheel:flywheel-neoforge-${minecraft_version}:${flywheel_version}"
    implementation "com.tterrag.registrate:Registrate:${registrate_version}"

    // Minecolonies
    compileOnly "com.ldtteam:blockui:${blockui_version}"
    compileOnly "com.ldtteam:domum-ornamentum:${domumornamentum_version}"
    compileOnly "com.ldtteam:minecolonies:${minecolonies_version}"
    compileOnly "com.ldtteam:structurize:${structurize_version}"

    // Remove/Comment this section if you want to use runData.
    runtimeOnly "com.ldtteam:blockui:${blockui_version}"
    runtimeOnly "com.ldtteam:domum-ornamentum:${domumornamentum_version}"
    runtimeOnly "com.ldtteam:minecolonies:${minecolonies_version}"
    runtimeOnly "com.ldtteam:structurize:${structurize_version}"

    // Patchouli
    compileOnly "vazkii.patchouli:Patchouli:${patchouli_version}-NEOFORGE"
    runtimeOnly "vazkii.patchouli:Patchouli:${patchouli_version}-NEOFORGE"

    // Powah
    compileOnly "curse.maven:powah-633483:${powah_version}"
    runtimeOnly "me.shedaniel.cloth:cloth-config-neoforge:${cloth_config_version}"
    runtimeOnly "curse.maven:powah-633483:${powah_version}"

    testModImplementation sourceSets.main.output

    testRuntimeOnly "org.junit.jupiter:junit-jupiter-engine:${junit_version}"
    // Testing stuff
    // EMI
    runtimeOnly "dev.emi:emi-neoforge:${emi_version}"
    // Spark
    runtimeOnly "maven.modrinth:spark:1.10.124-neoforge-1.21.1"
}


changelog {
    version = "${project.version}"
    path = "${project.projectDir}/CHANGELOG.md"
    header = "[${minecraft_version}-${-> version.get()}] - ${new SimpleDateFormat("yyyy-MM-dd").format(new Date())}"
    // Valid patterns would be:
    //   1.16.5-1.1.1.1b
    //   1.18-1.0r
    //   1.19-1.0.0a
    headerParserRegex = ~/\d+(\.\d+){1,2}-\d+(\.\d+){1,3}\w/
    itemPrefix = "-"
    keepUnreleasedSection = true
    unreleasedTerm = "[Unreleased]"
    groups = []
}

afterEvaluate {
    tasks.withType(JavaCompile) {
        options.compilerArgs << "-Xmaxerrs" << "2000"
    }
}

jar {
    manifest({
        attributes(["Specification-Title"     : "advancedperipherals",
                    "Specification-Vendor"    : "Srendi",
                    "Specification-Version"   : "${version}",
                    "Implementation-Title"    : "advancedperipherals",
                    "Implementation-Version"  : "${version}",
                    "Implementation-Vendor"   : "Srendi",
                    "Implementation-Timestamp": new Date().format("yyyy-MM-dd'T'HH:mm:ssZ")])
    })
    archiveFileName = "AdvancedPeripherals-${minecraft_version}-${mod_version}.jar"
}

tasks.withType(Checkstyle) {
    reports {
        xml.required = false
        html.required = false
    }
    // Checkstyle is compatible with the configuration cache, however we need to disable it to prevent a build issue with teamcity
    notCompatibleWithConfigurationCache()
    outputs.upToDateWhen { false }
}

tasks.withType(ProcessResources).configureEach {
    var replaceProperties = [minecraft_version         : minecraft_version,
                             neo_version               : neo_version,
                             loader_version            : loader_version,
                             mod_id                    : mod_id,
                             version                   : version,
                             cc_version                : cc_version,
                             minecolonies_version      : minecolonies_version,
                             appliedenergistics_version: appliedenergistics_version,
                             patchouli_version         : patchouli_version,
                             mekanism_version          : mekanism_version,
                             ae2things_version         : ae2things_version,
                             powah_version             : powah_version,]

    inputs.properties replaceProperties

    filesMatching(['META-INF/neoforge.mods.toml']) {
        expand replaceProperties
    }
}

tasks.register('publishCurseForge', TaskPublishCurseForge, { task ->
    setGroup("publishing")
    setDescription("Upload Advanced Peripherals to CurseForge")

    // This token is used to authenticate with CurseForge. It should be handled
    // with the same level of care and security as your actual password. You
    // should never share your token with an untrusted source or publish it
    // publicly to GitHub or embed it within a project. The best practice is to
    // store this token in an environment variable or a build secret.
    apiToken = curseforgeKey

    // Tells CurseForgeGradle to publish the output of the jar task. This will
    // return a UploadArtifact object that can be used to further configure the
    // file.
    task.upload(431725, jar) { file ->
        try {
            file.changelog = "${project.changelog.get("${minecraft_version}-${project.version}").withHeader(false).toText()}"
            file.changelogType = "markdown"
        } catch (err) {
            System.out.println(err)
            file.changelog = ""
        }

        addOptional('applied-energistics-2', 'curios', 'mekanism', 'refined-storage')

        addRequirement('cc-tweaked')

        addModLoader("neoforge")

        releaseType = "${release_type}"
    }
})

githubRelease {
    releaseAssets = jar.archiveFile

    if (githubKey != null)
        token = githubKey
    owner = githubUser
    repo = githubRepo
    tagName = "${minecraft_version}-${version}"
    releaseName = "${minecraft_version}-${version}"
    targetCommitish = "release/${minecraft_version}"
    generateReleaseNotes = false
    try {
        body = project.changelog.get("${minecraft_version}-${version}").withHeader(false).toText()
    } catch (err) {
        System.out.println(err)
        body = ""
    }
    draft = false
    prerelease = release_type.equalsIgnoreCase("alpha")
}

modrinth {
    token = modrinthKey
    projectId = 'SOw6jD6x'
    versionNumber = "${minecraft_version}-${project.version}"
    versionName = "Advanced Peripherals ${minecraft_version} ${version}"
    versionType = release_type
    uploadFile = jar
    gameVersions = [minecraft_version]
    loaders = ["neoforge"]
    dependencies {
        required.project "cc-tweaked"
    }

    try {
        changelog = project.changelog.get("${minecraft_version}-${project.version}").withHeader(false).toText()
    } catch (err) {
        System.out.println(err)
        changelog = ""
    }
}

publishing {
    publications { PublicationContainer publicationContainer ->
        publicationContainer.register("maven", MavenPublication) { MavenPublication publication ->
            publication.from((SoftwareComponent) components.java)
            publication.groupId = project.group
            publication.version = isSnapshotVersion ? "${minecraft_version}-${version}-${project.teamcityBuild}" : "${minecraft_version}-${version}"
            publication.artifactId = isSnapshotVersion ? "advancedperipherals-snapshots" : "advancedperipherals"
            publication.artifacts = [jar, sourcesJar]
            publication.pom {
                name.set("AdvancedPeripherals")
                packaging = 'jar'
                description.set(
                    'Advanced Peripherals provides multiple extensions for ComputerCraft in form of Peripherals, Pocket Upgrades, Turtles or new gear.\n' +
                    'It also integrates with multiple third party mods.')
                url.set('https://docs.intelligence-modding.de/')
                scm {
                    url.set("https://github.com/${githubUser}/${githubRepo}.git")
                }
                issueManagement {
                    system.set('github')
                    url.set("https://github.com/${githubUser}/${githubRepo}/issues")
                }
                licenses {
                    license {
                        name.set('Apache-2.0')
                        distribution.set('repo')
                    }
                }
                withXml {
                    NodeList dependencies = asNode().dependencies
                    NodeList allDeps = dependencies.'*'

                    allDeps.<Node> findAll() { Node el ->
                        el.artifactId.text() == 'forge' && el.groupId.text() == 'net.neoforged'
                    }.forEach() { Node el ->
                        el.parent().remove(el)
                    }
                    // remove ForgeGradle's mapped suffix from versions & set as optional so anyone else doesn't inherit them
                    allDeps.<Node> findAll() { Node el ->
                        el.version.text().contains('_mapped_')
                    }.each { Node el ->
                        el.version.each { Node version ->
                            def versionText = version.text()
                            version.setValue(versionText.substring(0, versionText.indexOf('_mapped_')))
                        }
                        el.appendNode('optional', true)
                    }
                }
            }
        }
    }
    repositories {
        maven {
            name = "public"
            url = "https://mvn.intelligence-modding.de/Intelligence"
            credentials {
                username = repositoryName
                password = repositoryKey
            }
        }
    }
}

// IDEA no longer automatically downloads sources/javadoc jars for dependencies, so we need to explicitly enable the behavior.
idea {
    module {
        downloadSources = true
        downloadJavadoc = true
    }
}