build.gradle

plugins {
	id 'fabric-loom' version '1.13-SNAPSHOT'
	id 'maven-publish'
	id 'com.modrinth.minotaur' version '2.9.0'
}

version = project.mod_version
group   = project.maven_group

base {
	archivesName = project.archives_base_name
}

repositories {
	maven {
		name = "Fabric"
		url = "https://maven.fabricmc.net/"
	}
	maven {
		url = "https://api.modrinth.com/maven"
	}
	maven {
		name = "Terraformers"
		url = "https://maven.terraformersmc.com/"
	}
	maven {
		name 'Xander Maven'
		url 'https://maven.isxander.dev/releases'
	}
}

loom {
	splitEnvironmentSourceSets()
	mods {
		"immersive-hotbar" {
			sourceSet sourceSets.main
			sourceSet sourceSets.client
		}
	}
}

fabricApi {
	configureDataGeneration { client = true }
}

loom {
	accessWidenerPath = file("src/main/resources/immersive-hotbar.accesswidener")
}

dependencies {
	minecraft "com.mojang:minecraft:${project.minecraft_version}"
	mappings loom.officialMojangMappings()
	modImplementation "net.fabricmc:fabric-loader:${project.loader_version}"

	modImplementation "com.terraformersmc:modmenu:${project.modmenu_version}"
	modImplementation "dev.isxander:yet-another-config-lib:${project.yacl_version}"
	modImplementation "net.fabricmc.fabric-api:fabric-api:${project.fabric_version}"
}

processResources {
	inputs.property "version", project.version
	filesMatching("fabric.mod.json") {
		expand "version": inputs.properties.version
	}
}

def isModernMc = stonecutter.eval(project.minecraft_version, ">=1.20.5")

java {
	sourceCompatibility = isModernMc ? JavaVersion.VERSION_21 : JavaVersion.VERSION_17
	targetCompatibility = isModernMc ? JavaVersion.VERSION_21 : JavaVersion.VERSION_17

	toolchain {
		languageVersion = JavaLanguageVersion.of(isModernMc ? 21 : 17)
	}
}

tasks.withType(JavaCompile).configureEach {
	options.release = isModernMc ? 21 : 17
}

jar {
	inputs.property "archivesName", project.base.archivesName
	from("LICENSE") {
		rename { "${it}_${inputs.properties.archivesName}" }
	}
}

publishing {
	publications {
		create("mavenJava", MavenPublication) {
			artifactId = project.archives_base_name
			from components.java
		}
	}
	repositories {
		// …your publishing repositories…
	}
}

def changelogFile = rootProject.file("CHANGELOG.md")
def changelogText = project.findProperty("changelog") ?: (
		changelogFile.exists() ? changelogFile.getText("UTF-8").trim() : ""
)

if (changelogText.isEmpty()) {
	throw new GradleException("CHANGELOG.md is missing or empty.")
}

def supportedVersions = project.supported_minecraft_versions
		.split(",")
		.collect { it.trim() }
		.findAll { !it.isEmpty() }

modrinth {
	token = System.getenv("MODRINTH_TOKEN")
	projectId = "immersive-hotbar"

	versionNumber = project.version.toString()
	versionName = "${project.archives_base_name} ${project.version}"
	versionType = "release"

	uploadFile = remapJar
	gameVersions = supportedVersions
	loaders = ["fabric"]

	changelog = changelogText

	dependencies {
		required.project("fabric-api")
		required.project("yacl")
		optional.project("modmenu")
	}
}

tasks.modrinth {
	dependsOn tasks.remapJar
	doFirst {
		println "Uploading to Modrinth"
		println "Game versions: ${supportedVersions}"
		println "Changelog length: ${changelogText.length()}"
	}
}

def parseMcVersion = { String v ->
	v.tokenize('.').collect { it as int }
}

tasks.register("publishModrinthBuild") {
	group = "publishing"

	if (project == rootProject && !subprojects.isEmpty()) {
		description = "Builds and uploads all subprojects to Modrinth"

		def publishTasks = subprojects
				.findAll { it.tasks.findByName("publishModrinthBuild") != null && it.hasProperty("minecraft_version") }
				.sort { a, b ->
					def av = parseMcVersion(a.property("minecraft_version").toString())
					def bv = parseMcVersion(b.property("minecraft_version").toString())

					for (int i = 0; i < Math.max(av.size(), bv.size()); i++) {
						def ai = i < av.size() ? av[i] : 0
						def bi = i < bv.size() ? bv[i] : 0
						if (ai != bi) return ai <=> bi
					}
					return 0
				}
				.collect { it.tasks.named("publishModrinthBuild") }

		for (int i = 1; i < publishTasks.size(); i++) {
			publishTasks[i].configure {
				mustRunAfter(publishTasks[i - 1])
			}
		}

		dependsOn publishTasks

		doFirst {
			println "Publishing all versions:"
			publishTasks.each { t ->
				def p = t.get().project
				println " - ${p.path} (${p.property("minecraft_version")})"
			}
		}
	} else {
		description = "Builds and uploads the mod to Modrinth."
		dependsOn tasks.build, tasks.modrinth
	}
}