build.gradle

plugins {
	id 'java'

	// Plugin to put dependencies inside our final jar
	id 'com.github.johnrengelman.shadow' version '8.1.1' apply false

	// Plugin to create merged jars
	id 'io.github.pacifistmc.forgix' version '1.2.9'

	// Manifold preprocessor
	id 'systems.manifold.manifold-gradle-plugin' version '0.0.2-alpha'

	// Architectury is used here only as a replacement for forge's own loom
	id 'dev.architectury.loom' version '1.6.396' apply false
}

/**
 * Creates a list of values of Minecraft versions for the Manifold preprocessors.
 * Source: https://gitlab.com/jeseibel/distant-horizons/-/blob/870c0f68d3faf6aa7c76a1c094d19c802f59f06b/build.gradle
 *
 * @param mcVersions array of all MC versions
 * @param targetMinecraftIndex array index of the currently active MC version
 */
def writeBuildGradlePredefine(List<String> mcVersions, int targetMinecraftIndex)
{
	StringBuilder sb = new StringBuilder()
	sb.append("# DON'T TOUCH THIS FILE, This is handled by the build script\n")
	for (int i = 0; i < mcVersions.size(); i++) {
		String verStr = mcVersions[i].replace(".", "_")
		sb.append("MC_" + verStr + "=" + i.toString() + "\n")
		if (targetMinecraftIndex == i) {
			sb.append("MC_VER=" + i.toString() + "\n")
		}
	}
	new File(projectDir, "build.properties").text = sb.toString()
}

// Transfers the values set in settings.gradle to the rest of the project
project.gradle.ext.getProperties().each { prop ->
	rootProject.ext.set(prop.key, prop.value)
	println "Added prop [key:" + prop.key + ", value:" + prop.value + "]"
}
// Sets up manifold stuff
writeBuildGradlePredefine(rootProject.targetMinecraftVersions, rootProject.targetMinecraftVersionIndex)

rootProject.versionStr = rootProject.mod_version + '-' + rootProject.minecraft_version
rootProject.group = mod_group_id

forgix {
	group = rootProject.group
	mergedJarName = "${rootProject.mod_id}-${rootProject.versionStr}.jar"

	if (findProject(':forge')) {
		forge {
			jarLocation = "build/libs/${rootProject.mod_id}-forge-${rootProject.versionStr}.jar"
		}
	}

	if (findProject(':fabric')) {
		fabric {
			jarLocation = "build/libs/${rootProject.mod_id}-fabric-${rootProject.versionStr}.jar"
		}
	}

	// TODO removeDuplicates causes a ClassNotFoundException with Forge.
	//		forge can't seem to find the common package when this is enabled.
	//		it would be good if we could use it since it downsizes the output .jar file quite a bit.
	// removeDuplicate 'nl.nielspoldervaart.gdmc'
}


subprojects { p ->

	def isMinecraftSubProject = p != project(':common')

	apply plugin: 'java'
	apply plugin: 'com.github.johnrengelman.shadow'
	apply plugin: 'systems.manifold.manifold-gradle-plugin'

	if (
		(findProject(':forge') && p == project(':forge')) ||
		(findProject(':neoforge') && p == project(':neoforge'))
	) {
		apply plugin: 'dev.architectury.loom'
	}

	configurations {
		shadowMe
		implementation.extendsFrom(shadowMe)

		if (isMinecraftSubProject) {
			common
			shadowCommon
			shadowMe.extendsFrom(common)
			compileClasspath.extendsFrom(common)
			runtimeClasspath.extendsFrom(common)

			if (findProject(':forge')) {
				developmentForge.extendsFrom(common)
			}
			if (findProject(':fabric') && p != project(':fabric')) {
				fabric
				shadowFabric
				compileClasspath.extendsFrom(fabric)
				runtimeClasspath.extendsFrom(fabric)
			}
		}
	}

	dependencies {
		annotationProcessor 'systems.manifold:manifold-preprocessor:2024.1.0'

		if (isMinecraftSubProject) {
			common(project(':common')) { transitive false }
			shadowCommon(project(':common')) { transitive false }

			if (findProject(':fabric') && p != project(':fabric')) {
				fabric(project(path: ':fabric')) { transitive false }
				shadowFabric(project(path: ':fabric')) { transitive false }
			}
		}
	}

	shadowJar {
		configurations = [project.configurations.shadowMe]

		mergeServiceFiles()
	}

	jar.dependsOn(shadowJar)

	processResources {
		def resourceTargets = [
			// For Forge
			"META-INF/mods.toml",
			"fabric.mod.json",
		]
		def intoTargets = ["$buildDir/resources/main/"]

		def replaceProperties = [
			minecraft_version: rootProject.minecraft_version,
			minecraft_version_range: rootProject.minecraft_version_range,
			forge_version: rootProject.forge_version,
			forge_version_range: rootProject.forge_version_range,
			forge_loader_version_range: rootProject.forge_loader_version_range,
			fabric_version: rootProject.fabric_version,
			fabric_loader_version: rootProject.fabric_loader_version,
			mod_id: rootProject.mod_id,
			mod_name: rootProject.mod_name,
			mod_license: rootProject.mod_license,
			mod_version: rootProject.versionStr,
			mod_authors: rootProject.mod_authors,
			mod_description: rootProject.mod_description,
			java_version: rootProject.java_version,
		]
		inputs.properties replaceProperties
		replaceProperties.put 'project', project
		filesMatching(resourceTargets) {
			expand replaceProperties + [project: project]
		}

		intoTargets.each { target -> {
			if (file(target).exists()) {
				copy {
					from(sourceSets.main.resources) {
						include resourceTargets
						expand replaceProperties
					}
					into target
				}
			}
		}}
	}

	jar {
		manifest {
			attributes(
				'Specification-Title'     : rootProject.mod_id,
				'Specification-Vendor'    : rootProject.mod_authors,
				'Specification-Version'   : '1', // We are version 1 of ourselves
				'Implementation-Title'    : project.name,
				'Implementation-Version'  : rootProject.versionStr,
				'Implementation-Vendor'   : rootProject.mod_authors,
				'Implementation-Timestamp': new Date().format("yyyy-MM-dd'T'HH:mm:ssZ")
			)
		}
	}
}

allprojects { p -> {

	apply plugin: 'java'
	apply plugin: 'maven-publish'

	archivesBaseName = rootProject.mod_id
	version = project.name + '-' + rootProject.versionStr
	group = rootProject.group

	repositories {
		mavenCentral()

		// VanillaGradle and Mixins in common
		maven {
			url 'https://repo.spongepowered.org/maven/'
		}

		// For Architectury API
		maven {
			url 'https://maven.architectury.dev'
		}

		// Manifold
		maven {
			url 'https://oss.sonatype.org/content/repositories/snapshots/'
		}
	}

	task copyCommonResources(type: Copy) {
		from project(":common").file("src/main/resources")
		into(file(p.file("build/resources/main")))
	}

	tasks.withType(JavaCompile).configureEach {
		options.release = rootProject.java_version as Integer
		options.encoding = 'UTF-8' // Use the UTF-8 charset for Java compilation
		options.compilerArgs += ['-Xplugin:Manifold']
	}

	java {
		withSourcesJar()
	}

}}

// Delete the merged folder when running clean
task cleanMergedJars() {
	def mergedFolder = file('Merged')
	if (mergedFolder.exists()) {
		delete(mergedFolder)
	}
}
// add cleanMergedJars to the end of the "clean" task
tasks['clean'].finalizedBy(cleanMergedJars)