build.gradle

import net.earthcomputer.clientcommands.buildscript.CheckLanguageFilesTask
import net.earthcomputer.clientcommands.buildscript.GenerateBuildInfoTask
import net.fabricmc.loom.task.prod.ClientProductionRunTask

plugins {
	id 'net.fabricmc.fabric-loom' version "${loom_version}"
	id 'maven-publish'
	id 'com.modrinth.minotaur' version '2.+'
	id 'com.github.breadmoirai.github-release' version '2.4.1'
	id 'checkstyle'
}

base {
	archivesName = project.archives_base_name
}

repositories {
	maven {
		url = 'https://maven.seedfinding.com'
	}
	maven {
		url = 'https://maven.latticg.com'
	}
	maven {
		url = 'https://maven.xpple.dev/maven2'
	}
	maven {
		url = "https://pkgs.dev.azure.com/djtheredstoner/DevAuth/_packaging/public/maven/v1"
	}
	maven {
		url = "https://maven.parchmentmc.org"
	}
	maven {
		url = 'https://repo.viaversion.com'
		content {
			includeGroup 'com.viaversion'
		}
	}
}

loom {
	splitEnvironmentSourceSets()
	accessWidenerPath = file('src/main/resources/clientcommands.aw')

	mods {
		clientcommands {
			sourceSet sourceSets.main
			sourceSet sourceSets.client
		}
	}
}

// Loom calls the server-side source set "main" and the client-only source set "client". Since we're primarily a
// client-side mod, the client code lives in src/main and the code that also runs on the server lives in src/common.
// The client code can access the common code, but not vice versa.
// TODO: add customization option to loom to rename the source sets instead
sourceSets {
	main {
		java.srcDirs = ['src/common/java']
		resources.srcDirs = ['src/common/resources']
	}
	client {
		java.srcDirs = ['src/main/java']
		resources.srcDirs = ['src/main/resources']
	}
	codeGen
	// Client gametests that are run against vanilla servers of older versions. These are separate from the regular
	// gametests so that ViaFabricPlus is only installed for these tests.
	oldServerGametest {
		compileClasspath += main.output + client.output
		runtimeClasspath += main.output + client.output
	}
}

configurations {
	includedLibrary
	clientImplementation.extendsFrom includedLibrary
	oldServerGametestCompileClasspath.extendsFrom clientCompileClasspath
	oldServerGametestRuntimeClasspath.extendsFrom clientRuntimeClasspath
	oldServerTestMatrixRuntimeOnly
}

loom {
	mods {
		'clientcommands-old-server-test' {
			sourceSet sourceSets.oldServerGametest
		}
	}
}

fabricApi {
	configureTests {
		modId = "clientcommands-test"
		enableGameTests = false
		enableClientGameTests = true
		createSourceSet = true
	}
}

loom.runs {
	oldServerClientGameTest {
		inherit clientGameTest
		sourceSet = sourceSets.oldServerGametest.name
		runDirectory = file('build/run/oldServerClientGameTest')
		systemProperties.put('fabric.client.gametest.testModResourcesPath', file('src/oldServerGametest/resources').absolutePath)
		// downloaded server jars are kept outside the build directory so that they survive a clean
		systemProperties.put('clientcommands.oldServerTest.cacheDir', new File(gradle.gradleUserHomeDir, 'caches/clientcommands-old-servers').absolutePath)
		if (project.hasProperty('oldServerVersions')) {
			// e.g. -PoldServerVersions=1.8.9,1.12.2 to only test against those versions
			systemProperties.put('clientcommands.oldServerTest.versions', project.property('oldServerVersions').toString())
		}
		// the player name needs to be known, and the servers run in offline mode anyway
		systemProperties.put('devauth.enabled', 'false')
		// logs what fishing manipulation is doing, to diagnose test failures on CI
		systemProperties.put('clientcommands.debugFishing', 'true')
	}
}

loom.runs.configureEach {
    jvmArguments.add("-enableassertions")
    systemProperties.put("fabric.loom.suppressNarratorError", "true")
}

dependencies {
	minecraft "com.mojang:minecraft:${project.minecraft_version}"
	implementation "net.fabricmc:fabric-loader:${project.loader_version}"
	implementation "net.fabricmc.fabric-api:fabric-api:${project.fabric_api_version}"

	include clientImplementation("dev.xpple:clientarguments:${project.clientarguments_version}")
	include implementation("dev.xpple:betterconfig-fabric:${project.betterconfig_version}")
	include clientImplementation("dev.xpple:simplewaypoints:${project.simplewaypoints_version}")

	includedLibrary "com.seedfinding:mc_feature:${project.seedfinding_feature_version}"
	includedLibrary "com.seedfinding:mc_biome:${project.seedfinding_biome_version}"
	includedLibrary "com.seedfinding:mc_core:${project.seedfinding_core_version}"
	includedLibrary "com.seedfinding:mc_seed:${project.seedfinding_seed_version}"

	includedLibrary "com.seedfinding:latticg:${project.latticg_version}:rt"
	codeGenImplementation "com.seedfinding:latticg:${project.latticg_version}"

	codeGenImplementation "org.jspecify:jspecify:1.0.0"

	compileOnly 'com.demonwav.mcdev:annotations:2.0.0'

	clientRuntimeOnly("me.djtheredstoner:DevAuth-fabric:${project.devauth_version}") {
		exclude group: 'net.fabricmc', module: 'fabric-loader'
	}

	codeGenImplementation sourceSets.client.output

	// ViaFabricPlus bundles its dependencies, and its transitive dependencies would otherwise change the versions of
	// Fabric Loader and Fabric API
	oldServerGametestRuntimeOnly("com.viaversion:viafabricplus:${project.viafabricplus_version}") {
		transitive = false
	}
	oldServerGametestCompileOnly("com.viaversion:viafabricplus-api:${project.viafabricplus_version}") {
		transitive = false
	}
	oldServerGametestCompileOnly("com.viaversion:viaversion-api:${project.viaversion_version}") {
		transitive = false
	}
	oldServerGametestImplementation "net.fabricmc:mapping-io:${project.mapping_io_version}"
	// ViaVersion is otherwise only available nested inside ViaFabricPlus, which only works when the game is running
	oldServerTestMatrixRuntimeOnly("com.viaversion:viaversion-api:${project.viaversion_version}") {
		transitive = false
	}

	testImplementation "net.fabricmc:fabric-loader-junit:${project.loader_version}"
	testImplementation "org.junit.jupiter:junit-jupiter:${project.junit_version}"
	testImplementation "com.code-intelligence:jazzer-junit:${project.jazzer_junit_version}"
}

checkstyle {
	toolVersion = project.checkstyle_version
	configFile = rootProject.file("checkstyle.xml")
	ignoreFailures = false
}

test {
	useJUnitPlatform()
	systemProperty('clientcommands.regressionTestDir', file('regressionTests').absolutePath)
}

jar {
	from(configurations.includedLibrary.collect { it.isDirectory() ? it : zipTree(it) }) {
		include 'com/seedfinding/**'
	}

	from("LICENSE")

	manifest.attributes 'Main-Class': 'net.earthcomputer.clientcommands.DoubleClickMain'
}

tasks.register('deleteOldServerGameTestRunDir', Delete) {
	delete loom.runs.oldServerClientGameTest.runDirectory
}

tasks.named('runOldServerClientGameTest') {
	dependsOn deleteOldServerGameTestRunDir
}

// writes the GitHub Actions matrix that splits the old server gametests between parallel jobs
tasks.register('writeOldServerTestMatrix', JavaExec) {
	classpath = sourceSets.oldServerGametest.runtimeClasspath + configurations.oldServerTestMatrixRuntimeOnly
	mainClass = 'net.earthcomputer.clientcommands.oldservergametest.WriteTestMatrix'
	args file('build/old_server_test_matrix.json').absolutePath
	if (project.hasProperty('oldServerVersions')) {
		systemProperty('clientcommands.oldServerTest.versions', project.property('oldServerVersions').toString())
	}
}

tasks.register('generateBuildInfo', GenerateBuildInfoTask) {
	outputFile = new File(temporaryDir, "build_info.json")
}

processClientResources {
	inputs.property "version", project.version
	inputs.property "mcversion", project.minecraft_version_dependency

	duplicatesStrategy DuplicatesStrategy.WARN

	from(sourceSets.client.resources.srcDirs) {
		include "fabric.mod.json"
		expand "version": project.version, "mcversion": project.minecraft_version_dependency
	}

	from(sourceSets.client.resources.srcDirs) {
		exclude "fabric.mod.json"
	}

	from generateBuildInfo
}

java {
	sourceCompatibility = JavaVersion.VERSION_25
	targetCompatibility = JavaVersion.VERSION_25
}

tasks.withType(JavaCompile).configureEach {
	options.encoding = "UTF-8"
}

tasks.register("prodClient", ClientProductionRunTask) {
	runDir = file("run")

	jvmArgs.add("-Ddevauth.enabled=true")

	javaLauncher = javaToolchains.launcherFor {
		languageVersion = JavaLanguageVersion.of(25)
	}
}

tasks.register('sourcesJar', Jar) {
	dependsOn classes
	archiveClassifier.set("sources")
	from sourceSets.main.allSource
}

tasks.register('codeGen', JavaExec) {
	mainClass = 'net.earthcomputer.clientcommands.codegen.CodeGenerator'
	classpath = sourceSets.codeGen.runtimeClasspath
	args file('src/main/java').absolutePath
	enableAssertions = true
}

tasks.register('checkLanguageFiles', CheckLanguageFilesTask) {
	inputDir.set(file('src/main/resources/assets/clientcommands/lang'))
}
check.dependsOn checkLanguageFiles

// read the changelog from the changelog.txt file, make sure the changelog is recent to avoid accidentally using the previous version's changelog.
def changelogFile = file('changelog.txt')
def changelogText = changelogFile.exists() && System.currentTimeMillis() - changelogFile.lastModified() <= 1000 * 60 * 60 ?
		changelogFile.readLines('UTF-8').join('\n') : ''

modrinth {
	token = project.hasProperty('modrinthKey') ? project.modrinthKey : System.getenv("MODRINTH_TOKEN")
	projectId = 'client-commands'
	uploadFile = jar
	gameVersions.set(project.minecraft_version_list.split('\\s*,\\s*').toList())
	loaders.set(['fabric', 'quilt'])
	changelog = changelogText
	dependencies {
		required.project 'fabric-api'
		embedded.project 'betterconfig'
		embedded.project 'simplewaypoints'
	}
}
tasks.modrinth.onlyIf {
	!changelogText.isBlank()
}

githubRelease {
	token(project.hasProperty('githubKey') ? project.githubKey : (System.getenv("GITHUB_TOKEN") ?: ''))
	owner 'Earthcomputer'
	repo 'clientcommands'
	targetCommitish 'fabric'
	releaseName "Version ${project.version} for Minecraft ${project.minecraft_version_list_presentable}"
	body changelogText
	releaseAssets jar.outputs
}
tasks.githubRelease.onlyIf {
	!changelogText.isBlank()
}

publishing {
	publications {
		mavenJava(MavenPublication) {
			artifact jar
			artifact sourcesJar
		}
	}

	repositories {
		// mavenLocal()
	}
}