build.gradle

plugins {
    id 'architectury-plugin' version '3.4-SNAPSHOT'
    id 'dev.architectury.loom' version '1.6-SNAPSHOT'
    id "com.github.johnrengelman.shadow" version "7.1.2" apply false
    id "com.modrinth.minotaur" version "2.+" apply false

    id 'maven-publish'
}

architectury {
    minecraft = rootProject.minecraft_version
    common('fabric', 'forge', 'neoforge')
}

allprojects {
    apply plugin: 'dev.architectury.loom'
    apply plugin: 'architectury-plugin'
    apply plugin: 'com.github.johnrengelman.shadow'

    version = rootProject.mod_version
    group = rootProject.maven_group

    loom {
        silentMojangMappingsLicense()
    }

    repositories {
        // Add repositories to retrieve artifacts from in here.
        // You should only use this when depending on other mods because
        // Loom adds the essential maven repositories to download Minecraft and libraries from automatically.
        // See https://docs.gradle.org/current/userguide/declaring_repositories.html
        // for more information about repositories.
        maven {
            name 'NeoForged Maven'
            url "https://maven.neoforged.net/releases"
        }
        maven {
            url 'https://maven.architectury.dev'
        }
        maven {
            url 'https://maven.minecraftforge.net'
        }
    }

    dependencies {
        // To change the versions see the gradle.properties file
        minecraft "com.mojang:minecraft:${project.minecraft_version}"
        mappings loom.officialMojangMappings()

        compileOnly 'com.google.code.findbugs:jsr305:3.0.2'
    }

    processResources {
        inputs.property "version", project.version
        filteringCharset "UTF-8"

        filesMatching(["META-INF/mods.toml", "META-INF/neoforge.mods.toml", "fabric.mod.json"]) {
            expand "version": project.version
        }
    }

    int targetJavaVersion = 21
    tasks.withType(JavaCompile).configureEach {
        // ensure that the encoding is set to UTF-8, no matter what the system default is
        // this fixes some edge cases with special characters not displaying correctly
        // see http://yodaconditions.net/blog/fix-for-java-file-encoding-problems-with-gradle.html
        // If Javadoc is generated, this must be specified in that task too.
        it.options.encoding = "UTF-8"
        if (targetJavaVersion >= 10 || JavaVersion.current().isJava10Compatible()) {
            it.options.release.set targetJavaVersion
        }
    }

    java {
        def javaVersion = JavaVersion.toVersion(targetJavaVersion)
        if (JavaVersion.current() < javaVersion) {
            toolchain.languageVersion = JavaLanguageVersion.of(targetJavaVersion)
        }
        archivesBaseName = project.archives_base_name
        // Loom will automatically attach sourcesJar to a RemapSourcesJar task and to the "build" task
        // if it is present.
        // If you remove this line, sources will not be generated.
        withSourcesJar()
    }
}

dependencies {
    modImplementation "net.fabricmc:fabric-loader:${rootProject.fabric_loader_version}"
}

loom {
	mixin {
		defaultRefmapName = "epx.refmap.json"
	}
}

subprojects { p ->
    apply plugin: "com.github.johnrengelman.shadow"

    architectury {
        platformSetupLoomIde()
    }

    base {
        archivesName = rootProject.archives_base_name + "-" + project.name
    }

    configurations {
        common
        shadowCommon // Don't use shadow from the shadow plugin because we don't want IDEA to index this.
        compileClasspath.extendsFrom common
        runtimeClasspath.extendsFrom common
    }

    shadowJar {
        exclude "architectury.common.json"

        configurations = [project.configurations.shadowCommon]
        archiveClassifier.set "dev-shadow"
    }

    remapJar {
        input.set shadowJar.archiveFile
        dependsOn shadowJar
        archiveClassifier.set null
    }

    jar {
        archiveClassifier.set "dev"
    }

    sourcesJar {
        def commonSources = project(":").sourcesJar
        dependsOn commonSources
        from commonSources.archiveFile.map { zipTree(it) }
    }

    components.java {
        withVariantsFromConfiguration(project.configurations.shadowRuntimeElements) {
            skip()
        }
    }

    jar {
        from(rootProject.file("LICENSE")) {
            rename { "${it}_${project.archivesBaseName}" }
        }
        manifest {
            attributes([
                    "Specification-Title"     : "end-poem-extension",
                    "Specification-Vendor"    : "teddyxlandlee",
                    "Specification-Version"   : "1",
                    "Implementation-Title"    : rootProject.name + '-' + project.name,
                    "Implementation-Version"  : project.version,
                    "Implementation-Vendor"   : "teddyxlandlee",
                    "Implementation-Timestamp": new Date().format("yyyy-MM-dd'T'HH:mm:ssZ")
            ])
        }
    }
}

subprojects {
    if (System.getenv("MR_TOKEN")) {
        apply plugin: 'com.modrinth.minotaur'
        def modLoaders = project.mr_loader.toString().split(",") as List
        modrinth {
            token.set System.getenv("MR_TOKEN")
            projectId.set rootProject.mr_project_id
            versionNumber.set "${project.version}-${modLoaders[0]}"
            versionName.set String.format(
                    /*format=*/rootProject.mr_version_name_format.toString(),
                    rootProject.mr_version_game_range,
                    project.mr_loader_display,
                    rootProject.mr_version_mod_abbr,
                    rootProject.mr_version_display
            )
            changelog.set rootProject.mr_version_changelog
            versionType.set rootProject.mr_version_type
            gameVersions = rootProject.mr_version_game.toString().split(",") as List
            loaders.set modLoaders
            detectLoaders.set false
            autoAddDependsOn.set false

            dependencies {
            	optional.project 'remote-resource-pack'
            }

            uploadFile.set tasks.remapJar
            additionalFiles = [tasks.remapSourcesJar]

            debugMode = System.getenv("MR_DEBUG_MODE") == '1'
        }
    }
}

// configure the maven publication
publishing {
    publications {
        create('mavenJava', MavenPublication) {
            from components.java
        }
    }

    // See https://docs.gradle.org/current/userguide/publishing_maven.html for information on how to set up publishing.
    repositories {
        // Add repositories to publish to here.
        // Notice: This block does NOT have the same function as the block in the top level.
        // The repositories here will be used for publishing your artifact, not for
        // retrieving dependencies.
    }
}