build.gradle

buildscript {
	dependencies {
		classpath "org.kohsuke:github-api:1.330"
	}
}

plugins {
	id "net.fabricmc.fabric-loom" version "${loom_version}"
	id "com.diffplug.spotless" version "8.10.3"
	id "net.wimods.github-compile-summary" version "0.1.1"
}

version = project.mod_version
group = project.maven_group

base {
	archivesName = project.archives_base_name
}

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.
	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}"
	implementation "net.fabricmc:fabric-loader:${project.loader_version}"
	
	// Fabric API. This is technically optional, but you probably want it anyway.
	implementation "net.fabricmc.fabric-api:fabric-api:${project.fabric_api_version}"
}

fabricApi.configureTests {
	createSourceSet = true
	enableGameTests = false
	enableClientGameTests = true
	modId = "wurst_testmod"
	username = "Wurst-Bot"
}

loom {
	accessWidenerPath = file("src/main/resources/wurst.accesswidener")
	
	runs {
		clientWithMods {
			inherit client
		}
		
		clientGameTestWithMods {
			inherit client
			source = sourceSets.gametest
			runDir = "build/run/clientGameTestWithMods"
			jvmArguments.add("-Dfabric.client.gametest")
			programArguments.add("--username=Wurst-Bot")
		}
	}
}

configurations {
	testMods {
		transitive = false
	}
}

def optionalCompatMods = [
	sodium: [artifact: "sodium", property: "sodium_version"],
	lootr: [artifact: "lootr", property: "lootr_version"],
	better_block_entities: [
		artifact: "better-block-entities",
		property: "better_block_entities_version"
	],
	badoptimizations: [
		artifact: "badoptimizations",
		property: "badoptimizations_version"
	],
	shoulder_surfing: [
		artifact: "shoulder-surfing-reloaded",
		property: "shoulder_surfing_version"
	],
	forge_config_api_port: [
		artifact: "forge-config-api-port",
		property: "forge_config_api_port_version"
	]
]

def compatModVersions = optionalCompatMods.collectEntries { id, mod ->
	[(id): providers.gradleProperty(mod.property).orElse("")]
}

dependencies {
	optionalCompatMods.each { id, mod ->
		def version = compatModVersions[id].get().trim()
		if(!version.isEmpty())
			testMods "maven.modrinth:${mod.artifact}:${version}"
	}
}

def hasCompatMods = providers.provider {
	compatModVersions.values().any { !it.get().trim().isEmpty() }
}

def cleanClientWithMods = tasks.register("cleanClientWithMods", Delete) {
	delete "run/mods"
}

def prepareClientWithMods = tasks.register("prepareClientWithMods", Sync) {
	from configurations.testMods
	into "run/mods"
}

tasks.named("runClientWithMods") {
	onlyIf { hasCompatMods.get() }
	dependsOn prepareClientWithMods
	finalizedBy cleanClientWithMods
}

def cleanClientGameTestWithMods = tasks.register("cleanClientGameTestWithMods", Delete) {
	delete layout.buildDirectory.dir("run/clientGameTestWithMods")
}

def prepareClientGameTestWithMods = tasks.register("prepareClientGameTestWithMods", Sync) {
	dependsOn cleanClientGameTestWithMods
	from configurations.testMods
	into layout.buildDirectory.dir("run/clientGameTestWithMods/mods")
}

tasks.named("runClientGameTestWithMods") {
	onlyIf { hasCompatMods.get() }
	dependsOn prepareClientGameTestWithMods
}

processResources {
	def modVersion = project.version.substring(1)
	inputs.property("version", modVersion)
	
	filesMatching("fabric.mod.json") {
		expand(version: modVersion)
	}
}

tasks.withType(JavaCompile).configureEach {
	// Minecraft 26.1 (26.1-snapshot-1) upwards uses Java 25.
	it.options.release = 25
}

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()
	
	sourceCompatibility = JavaVersion.VERSION_25
	targetCompatibility = JavaVersion.VERSION_25
}

jar {
	def archivesName = project.base.archivesName
	inputs.property("archivesName", archivesName)
	
	from("LICENSE.txt") {
		rename { "LICENSE-${archivesName.get()}.txt" }
	}
	
	exclude("intentionally_untranslated.json")
}

import com.diffplug.spotless.generic.LicenseHeaderStep
spotless {
	lineEndings = "WINDOWS"
	java {
		removeUnusedImports()
		leadingSpacesToTabs()
		trimTrailingWhitespace()
		eclipse().configFile(file("codestyle/formatter.xml"))
	}
	format("licenseHeader") {
		target("src/*/java/**/*.java")
		def header_file = file("codestyle/license_header.txt")
		def delimiter = LicenseHeaderStep.DEFAULT_JAVA_HEADER_DELIMITER
		licenseHeaderFile(header_file, delimiter).updateYearWithLatest(true)
	}
	json {
		target("src/**/*.json", "src/**/*.mcmeta")
		gson().indentWithSpaces(2).version("2.14.0")
	}
}

def getGhVersion() {
	return version.substring(0, version.indexOf("-MC"))
}

def getChangelogLink(String platform, String from) {
	def versionSlug = getGhVersion().substring(1).replace(".", "-")
	def shortURL = "https://www.wurstclient.net/updates/wurst-${versionSlug}/"
	def query = []
	if (platform != "GitHub")
		query.add("mc=${project.minecraft_version}")
	query.add("utm_source=${platform}")
	query.add("utm_medium=" + project.archives_base_name.replace("-", "+"))
	def fullURL = shortURL + (query.isEmpty() ? "" : "?" + query.join("&"))
	def encodedURL = java.net.URLEncoder.encode(fullURL, "UTF-8")
	return "[${shortURL}](https://go.wimods.net/from/${from}?to=${encodedURL})"
}

def getChangelogImage(String from) {
	return "![](https://img.wimods.net/${from})"
}

def getChangelog(String platform, String from) {
	def prefix = platform == "GitHub" ? "" : "A changelog can be found at: "
	def imgQuery = platform == "GitHub" ? "" : "?mc_version=${project.minecraft_version}&mod_loader=${project.mod_loader}"
	return prefix + getChangelogLink(platform, from) + getChangelogImage(from + imgQuery)
}

import org.kohsuke.github.GHReleaseBuilder
import org.kohsuke.github.GitHub

tasks.register("github") {
	dependsOn tasks.named("build")

	def githubToken = providers.environmentVariable("GITHUB_TOKEN")
	def repoId = project.mcx_repo_id
	def ghVersion = getGhVersion()
	def changelogImage = getChangelogImage("github.com/${repoId}/releases/tag/${ghVersion}")
	def jarFile = tasks.named("jar", Jar).flatMap { it.archiveFile }
	def sourcesJarFile = tasks.named("sourcesJar", Jar).flatMap { it.archiveFile }
	inputs.files(jarFile, sourcesJarFile)

	onlyIf {
		!githubToken.getOrElse("").isEmpty()
	}
	
	doLast {
		def github = GitHub.connectUsingOAuth(githubToken.get())
		def repository = github.getRepository(repoId)
		
		def ghRelease = repository.getReleaseByTagName(ghVersion as String)
		if(ghRelease == null) {
			def releaseBuilder = new GHReleaseBuilder(repository, ghVersion as String)
			releaseBuilder.body(changelogImage)
			releaseBuilder.prerelease(ghVersion.contains("pre"))
			ghRelease = releaseBuilder.create()
		}
		
		ghRelease.uploadAsset(jarFile.get().asFile, "application/java-archive")
		ghRelease.uploadAsset(sourcesJarFile.get().asFile, "application/java-archive")
	}
}

import org.kohsuke.github.GHIssueState
import org.kohsuke.github.GHMilestoneState
import java.time.Instant

tasks.register("closeMilestone") {
	def githubToken = providers.environmentVariable("GITHUB_TOKEN")
	def repoId = project.gh_repo_id
	def ghVersion = getGhVersion()
	def changelog = getChangelog("GitHub", "github.com/${repoId}/milestone/${ghVersion}")

	onlyIf {
		!githubToken.getOrElse("").isEmpty()
	}
	
	doLast {
		def github = GitHub.connectUsingOAuth(githubToken.get())
		def repository = github.getRepository(repoId)
		
		// Weird API design: listMilestones() requires GHIssueState while everything else uses GHMilestoneState
		def milestone = repository.listMilestones(GHIssueState.ALL).find { it.title == ghVersion }
		if (milestone == null) {
			milestone = repository.createMilestone(ghVersion, "")
		}
		
		if (milestone.getState() != GHMilestoneState.CLOSED) {
			milestone.setDueOn(Date.from(Instant.now()))
			milestone.setDescription(changelog)
			milestone.close()
		}
	}
}