build.gradle

import io.github.redrain0o0.legacyskins.buildscript.ModLoader

import java.nio.file.Files
import java.nio.file.StandardCopyOption

import static io.github.redrain0o0.legacyskins.buildscript.ModLoader.*
import io.github.redrain0o0.legacyskins.buildscript.ProjectInfo
plugins {
	id 'maven-publish'
	id 'me.modmuss50.mod-publish-plugin' version '0.7.2'
}

ProjectInfo info = ProjectInfo.from(project)
String minecraftVersion = info.minecraftVersion()
int minecraftIntVersion
{
	String[] split = minecraftVersion.split("\\.")
	if (split.length == 2) split = [split[0], split[1], 0]
	minecraftIntVersion = split[0].toInteger() * 10000 + split[1].toInteger() * 100 + split[2].toInteger()
}
int javaVersion = minecraftIntVersion >= 12006 ? 21 : 17
System.out.println(minecraftIntVersion)
ModLoader loader = info.loader()

project.ext["loom.platform"] = loader.friendlyName

version = project.mod_version + "+" + loader.friendlyName + "+" + minecraftVersion
group = project.maven_group

apply plugin: 'dev.architectury.loom'
stonecutter.const("fabric", loader == FABRIC)
stonecutter.const("forge", loader == FORGE)
stonecutter.const("neoforge", loader == NEOFORGE)
stonecutter.const("eventbusupdates", loader == NEOFORGE)
stonecutter.const("multientrypoints", loader == NEOFORGE && minecraftIntVersion >= 1_20_06)
stonecutter.const("constructorargs", loader == NEOFORGE && minecraftIntVersion >= 1_20_02)
stonecutter.const("yacl", project.yacl_version != "[VERSIONED]")
stonecutter.const("clothconfig", project.clothconfig_version != "[VERSIONED]")

base {
	archivesName = project.archives_base_name
}

def packageJar = tasks.create("packageJar", Copy.class) {
	into("${rootProject.layout.buildDirectory.get()}/libs/$mod_version")
}

repositories {
	mavenCentral()
	maven {
		name = "Terraformers"
		url = "https://maven.terraformersmc.com/"
	}
	maven {
		name = "tom5454 maven"
		url = "https://raw.githubusercontent.com/tom5454/maven/main"
	}
	// libsdl4j + YACL
	maven {
		url "https://maven.isxander.dev/releases"
	}
	if (loader == NEOFORGE) {
		maven {
			url "https://maven.neoforged.net/releases"
		}
	}
	maven {
		url "https://maven.minecraftforge.net/"
	}
	// Architectury + other shedaniel
	maven {
		url "https://maven.shedaniel.me/"
	}
	exclusiveContent {
		forRepository {
			maven {
				url "https://thedarkcolour.github.io/KotlinForForge/"
			}
		}
		filter {
			includeGroup "thedarkcolour"
		}
	}
	exclusiveContent {
		forRepository {
			maven {
				name = "Modrinth"
				url = "https://api.modrinth.com/maven"
			}
		}
		filter {
			includeGroup "maven.modrinth"
		}
	}
}

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

	// Fabric API. This is technically optional, but you probably want it anyway.
	compileOnly "com.tom5454.cpm:CustomPlayerModels-API:${project.cpm_api_version}"
	modImplementation "com.tom5454.cpm:CustomPlayerModels${loader == FORGE ? "" : "-" /* ... */}${loader == NEOFORGE ? "" : "${project.cpm_loader}-"}${project.cpm_mc_version}:${project.cpm_runtime_version}"
	modImplementation "maven.modrinth:legacy4j:${project.legacy4j_version}"
	api "dev.isxander:libsdl4j:${project.libsdl4j_version}"
	if (loader.isForgeLike()) {
		 forgeRuntimeLibrary "dev.isxander:libsdl4j:${project.libsdl4j_version}"
	}

	if (project.yacl_version != "[VERSIONED]") {
		// Attempt to fix NeoForge crash
		modCompileOnly "dev.isxander:yet-another-config-lib:${project.yacl_version}", {
			exclude group: "net.fabricmc.fabric-api"
		}
//		if (stonecutter.current.isActive && loader.isForgeLike()) {
//			forgeRuntimeLibrary "org.quiltmc.parsers:gson:0.2.1"
//			forgeRuntimeLibrary "org.quiltmc.parsers:json:0.2.1"
//		}
	}

	if (project.clothconfig_version != "[VERSIONED]") {
		modImplementation "me.shedaniel.cloth:cloth-config-${loader.friendlyName}:${project.clothconfig_version}", {
			exclude group: "net.fabricmc.fabric-api"
		}
	}

	// Fabric exclusive dependencies:
	if (loader == FABRIC) {
		modImplementation "net.fabricmc:fabric-loader:${project.loader_version}"
		modCompileOnly "com.terraformersmc:modmenu:7.2.2", {
			transitive false
		}
		//implementation include("io.github.llamalad7:mixinextras-fabric:${project.mixinextras_version}")
		testImplementation "net.fabricmc:fabric-loader-junit:${project.loader_version}"
		// Save download time by only depending on Fabric API when it's needed, otherwise just depending on a few modules required to compile Legacy Skins. {
		if (stonecutter.current.isActive) {
			modLocalRuntime("net.fabricmc.fabric-api:fabric-api:$project.fabric_api_version")
		} else {
			modLocalRuntime "net.fabricmc.fabric-api:fabric-api:$project.fabric_api_version", {
				transitive = false
			}
		}
		for (String module in project.properties.fabric_api_modules.split(",") as String[]) {
			modApi fabricApi.module(module, "$project.properties.fabric_api_version")
		}
		// }
	} else if (loader == NEOFORGE) {
		neoForge "net.neoforged:neoforge:$project.properties.neoforge_version"
	} else if (loader == FORGE) {
		forge "net.minecraftforge:forge:$project.properties.forge_version"
	}
}

test {
	useJUnitPlatform()
}

if (loader == FABRIC) {
	fabricApi {
		configureDataGeneration()
	}
} else if (loader.isForgeLike()) {
	loom {
		afterEvaluate {
			runs {
				datagen {
					data()
					programArg "--mod"
					programArg "legacyskins"
					programArg "--output"
					programArg getProject().file("src/main/generated").toPath().toAbsolutePath().toString()
				}
			}
		}
		sourceSets {
			main {
				resources {
					srcDirs += [getProject().file("src/main/generated")]
				}
			}
		}
	}
}

loom {
	runConfigs.all {
		ideConfigGenerated(true) // Run configurations are not created for subprojects by default
		runDir = "../../run" // Use a shared run folder and just create separate worlds
	}
	if (loader == FORGE) {
		forge {
			mixinConfig "legacyskins.mixins.json"
			mixinConfig "legacyskins-forgedev.mixins.json"
		}
	}
}

processResources {
	def deps = [
			"version": project.version,
	        "minecraft": "~" + project.minecraft_version,
			"java": javaVersion,
			"ml": loader.friendlyName
	]
	inputs.property "version", project.version
	inputs.property "deps", deps

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

	if (loader != NEOFORGE && loader != FORGE) exclude "META-INF/neoforge.mods.toml"
	if (loader != FABRIC) exclude "fabric.mod.json"

	doLast {
		// neoforge.mods.toml should be identical to mods.toml
		fileTree(dir: outputs.files.asPath, include: "META-INF/neoforge.mods.toml").each { File file ->
			Files.copy(file.toPath(), java.nio.file.Path.of(outputs.files.asPath).resolve("META-INF/mods.toml"), StandardCopyOption.REPLACE_EXISTING)
		}
	}
}

tasks.withType(JavaCompile).configureEach {
	it.options.release = javaVersion
}

java {
	// 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()
	withJavadocJar()

	sourceCompatibility = JavaVersion.toVersion(javaVersion)
	targetCompatibility = JavaVersion.toVersion(javaVersion)
}

jar {
	from("LICENSE") {
		rename { "${it}_${project.base.archivesName.get()}"}
	}
}

// configure the maven publication
publishing {
	publications {
		create("mavenJava", MavenPublication) {
			artifactId = project.archives_base_name
			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.
	}
}

afterEvaluate {
	packageJar.dependsOn(remapJar)
	packageJar.from(remapJar.archiveFile)
	build.finalizedBy(packageJar)
	tasks.findByPath("publishMods").doFirst {
		if (rootProject.changelogfor != rootProject.mod_version) throw new Error("Fix the changelog!")
	}
}

publishMods {
	def modrinthToken = System.getenv("MODRINTH_TOKEN")
	def curseforgeToken = System.getenv("CURSEFORGE_TOKEN")
	if (modrinthToken == null || curseforgeToken == null) {
		dryRun = true
	} else {
		// For debugging.
		System.out.println(modrinthToken.hashCode() + curseforgeToken.hashCode())
	}

	type = STABLE
	file = tasks.remapJar.archiveFile
	version = project.version
	displayName = "[$minecraftVersion] ${project.mod_version} for ${loader.formalName}"
	modLoaders.add(loader.friendlyName)
	changelog = rootProject.file("CHANGELOG.md").text
	modrinth {
		accessToken = modrinthToken
		projectId = "4UNJZ4cX"
		if (project.supported_minecraft_versions != "[VERSIONED]") {
			for (final def v in (project.supported_minecraft_versions as String).split(",")) {
				minecraftVersions.add(v)
			}
		} else {
			minecraftVersions.add(minecraftVersion)
		}
		if (loader == FABRIC) {
			requires("fabric-api")
			optional("modmenu")
		}
		if (project.yacl_version) {
			optional("yacl")
		}
		if (project.clothconfig_version) {
			optional("cloth-config")
		}
		requires("legacy4j")
		requires("custom-player-models")
	}

	curseforge {
		accessToken = curseforgeToken
		projectId = "1090749"
		if (project.supported_minecraft_versions != "[VERSIONED]") {
			for (final def v in (project.supported_minecraft_versions as String).split(",")) {
				minecraftVersions.add(v)
			}
		} else {
			minecraftVersions.add(minecraftVersion)
		}
		if (loader == FABRIC) {
			requires("fabric-api")
			optional("modmenu")
		}
		if (project.yacl_version) {
			optional("yacl")
		}
		if (project.clothconfig_version) {
			optional("cloth-config")
		}
		requires("legacy-minecraft")
		requires("custom-player-models")
	}
}