build.gradle

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

plugins {
	id "fabric-loom" version "${loom_version}"
	id "com.diffplug.spotless" version "8.1.0"
}

def ENV = System.getenv()

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}"
	mappings loom.officialMojangMappings()
	modImplementation "net.fabricmc:fabric-loader:${project.loader_version}"
	testImplementation "net.fabricmc:fabric-loader-junit:${project.loader_version}"
	
	// Fabric API. This is technically optional, but you probably want it anyway.
	modImplementation "net.fabricmc.fabric-api:fabric-api:${project.fabric_api_version}"
	
	// net.wurstclient.ai.PathPos extends net.minecraft.util.math.BlockPos,
	// which uses javax.annotation.concurrent.Immutable, which is part of
	// the JSR305 library.
	//
	// In other words, Wurst won't compile without this library,
	// even though it's Minecraft that actually uses it.
	modImplementation "com.google.code.findbugs:jsr305:3.0.2"
}

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

loom {
	accessWidenerPath = file("src/main/resources/wurst.accesswidener")
	
	runs {
		clientGameTest {
			vmArgs.add("-Dfabric.client.gametest.disableNetworkSynchronizer=true")
		}
		
		clientWithMods {
			inherit client
		}
		
		clientGameTestWithMods {
			inherit client
			source = sourceSets.gametest
			runDir = "build/run/clientGameTestWithMods"
			vmArgs.add("-Dfabric.client.gametest")
			vmArgs.add("-Dfabric.client.gametest.disableNetworkSynchronizer=true")
			vmArgs.add("-Dwurst.test.withMods=true")
			programArgs.add("--username=Wurst-Bot")
		}
	}
}

configurations {
	testMods {
		transitive = false
	}
}

dependencies {
	testMods "maven.modrinth:sodium:${project.sodium_version}"
}

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

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

tasks.named("runClientWithMods") {
	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")
}

def doModCompatTest = providers.gradleProperty("do_mod_compat_test").map { it.toBoolean() }.orElse(false)
tasks.named("runClientGameTestWithMods") {
	onlyIf { doModCompatTest.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 1.20.5 (24w14a) upwards uses Java 21.
	it.options.release = 21
}

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_21
	targetCompatibility = JavaVersion.VERSION_21
}

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.11.0")
	}
}

test {
	useJUnitPlatform()
}

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

task github(dependsOn: build) {
	onlyIf {
		ENV.GITHUB_TOKEN
	}
	
	doLast {
		def github = GitHub.connectUsingOAuth(ENV.GITHUB_TOKEN as String)
		def repoId = project.mcx_repo_id
		def repository = github.getRepository(repoId)
		def ghVersion = getGhVersion()
		
		def ghRelease = repository.getReleaseByTagName(ghVersion as String)
		if(ghRelease == null) {
			def releaseBuilder = new GHReleaseBuilder(repository, ghVersion as String)
			releaseBuilder.body(getChangelogImage("github.com/${repoId}/releases/tag/${ghVersion}"))
			releaseBuilder.prerelease(ghVersion.contains("pre"))
			ghRelease = releaseBuilder.create()
		}
		
		ghRelease.uploadAsset(remapJar.archiveFile.get().getAsFile(), "application/java-archive")
		ghRelease.uploadAsset(remapSourcesJar.archiveFile.get().getAsFile(), "application/java-archive")
	}
}

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

task closeMilestone {
	onlyIf {
		ENV.GITHUB_TOKEN
	}
	
	doLast {
		def github = GitHub.connectUsingOAuth(ENV.GITHUB_TOKEN as String)
		def repoId = project.gh_repo_id
		def repository = github.getRepository(repoId)
		def ghVersion = getGhVersion()
		
		// 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(getChangelog("GitHub", "github.com/${repoId}/milestone/${ghVersion}"))
			milestone.close()
		}
	}
}