build.gradle

plugins {
	id "fabric-loom" version "1.3-SNAPSHOT"
	id "io.github.juuxel.loom-quiltflower" version "1.10.0" // Quiltflower, a better decompiler
//	id "io.github.p03w.machete" version "1.+" // automatic jar compressing on build
	id "maven-publish"
}

sourceCompatibility = JavaVersion.VERSION_17
targetCompatibility = JavaVersion.VERSION_17

def moduleDependencies(project, List<String> depNames) {
	def deps = depNames.iterator().collect { project.dependencies.project(path: ":$it", configuration: 'namedElements') }

	project.dependencies {
		deps.each {
			api it
		}
	}

	// As we manually handle the maven artifacts, we need to also manually specify the deps.
	project.publishing {
		publications {
			if (project.archivesBaseName == "jello" || project.archivesBaseName == "gelatin") return

			mavenJava(MavenPublication) {
				pom.withXml {
					def depsNode = asNode().appendNode("dependencies")
					deps.each {
						def depNode = depsNode.appendNode("dependency")
						depNode.appendNode("groupId", it.group)
						depNode.appendNode("artifactId", it.name)
						depNode.appendNode("version", it.version)
						depNode.appendNode("scope", "compile")
					}
				}
			}
		}
	}
}

moduleDependencies(project, [
		"common",
		"dye-registry",
		"dye-entries",
		"dye-entities",
		"dye-cauldron"
])

allprojects {
	apply plugin: "fabric-loom"
	apply plugin: "maven-publish"
	apply plugin: "io.github.juuxel.loom-quiltflower"

	group = project.maven_group
	version = ("${project.mod_version}+${project.minecraft_version}")
	archivesBaseName = project.archives_base_name

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

	java {
		withSourcesJar()
	}

	repositories {
		maven { url "https://maven.wispforest.io" }
		maven { url "https://maven.shedaniel.me/" }
		maven { url "https://jitpack.io"}
		maven { name = "Modrinth"
			url "https://api.modrinth.com/maven"
			content {includeGroup "maven.modrinth" }
		}
		maven {
			url "https://cursemaven.com"
			content {includeGroup "curse.maven" }
		}
		maven {
			url "https://maven.terraformersmc.com/releases/"
			content {includeGroup "com.terraformersmc" }
		}
		maven { url = "https://ueaj.dev/maven/" }
		maven { url = "https://maven.gegy.dev/" }
		mavenLocal()
		mavenCentral()
	}

//	publishing {
//		if (project.archivesBaseName == "jello") return
//
//		setupRepositories(repositories)
//	}

	dependencies {
		minecraft("com.mojang:minecraft:${project.minecraft_version}")
		mappings("net.fabricmc:yarn:${project.yarn_mappings}:v2")
		modImplementation("net.fabricmc:fabric-loader:${project.loader_version}")

		modCompileOnly('com.google.code.findbugs:jsr305:3.0.2')
		modImplementation("net.fabricmc.fabric-api:fabric-api:${project.fabric_version}")

		//-----------------

		implementation("org.atteo:evo-inflector:1.3")

		if(project.archivesBaseName == "jello"){
			annotationProcessor modImplementation ("io.wispforest:owo-lib:${project.owo_version}", {
				exclude group: "net.fabricmc.fabric-api"
			})
		} else {
			if(project.archivesBaseName == "gelatin"){
				annotationProcessor ("io.wispforest:owo-lib:${project.owo_version}", {
					exclude group: "net.fabricmc.fabric-api"
				})
			}

			modCompileOnly /*modLocalRuntime*/ ("io.wispforest:owo-lib:${project.owo_version}", {
				exclude group: "net.fabricmc.fabric-api"
			})
		}

		modCompileOnly modLocalRuntime("me.shedaniel:RoughlyEnoughItems-api-fabric:${project.rei}"){
			exclude group: "net.fabricmc.fabric-api"
			exclude group: "com.terraformersmc"
		}

		modCompileOnly modLocalRuntime("me.shedaniel:RoughlyEnoughItems-fabric:${project.rei}"){
			exclude group: "net.fabricmc.fabric-api"
			exclude group: "com.terraformersmc"
		}

		modLocalRuntime("maven.modrinth:better-beds:${project.better_beds}")

		modCompileOnly modLocalRuntime("io.wispforest:condensed_creative-fabric:${project.cc}", {
			exclude group: "net.fabricmc.fabric-api"
			exclude group: "io.wispforest"
		})

		modCompileOnly modLocalRuntime("com.terraformersmc:modmenu:${project.modmenu}")

		//modImplementation modLocalRuntime("maven.modrinth:carpet:${project.carpet}")

		//modImplementation modLocalRuntime("maven.modrinth:ebe:${project.ebe}")
		//modLocalRuntime("net.devtech:arrp:0.6.7")

		//modLocalRuntime("maven.modrinth:diagonal-windows:v8.0.1-1.20.1-Fabric")
		//modLocalRuntime("maven.modrinth:puzzles-lib:v8.0.24-1.20.1-Fabric")
		//modLocalRuntime("maven.modrinth:forge-config-api-port:v8.0.0-1.20.1-Fabric")

		//-----------------
		// Local Mods

		modLocalRuntime("maven.modrinth:ferrite-core:${project.ferrite_core}-fabric")

//    modLocalRuntime("maven.modrinth:lithium:${project.lithium}")

		modCompileOnly modLocalRuntime ("maven.modrinth:sodium:${project.sodium}")
		modCompileOnly modLocalRuntime ("maven.modrinth:indium:${project.indium}")
		modCompileOnly modLocalRuntime('org.joml:joml:1.10.2')

		modLocalRuntime("maven.modrinth:starlight:${project.starlight}")

		modLocalRuntime("maven.modrinth:lazydfu:${project.lazydfu}")
	}

	allprojects.each { p ->
		loom.mods.register(p.name) {
			sourceSet p.sourceSets.main
		}
	}

	loom {
		accessWidenerPath = file("src/main/resources/${project.name}.accesswidener") // globalAccessWidener

		runtimeOnlyLog4j = true

		sourceSets {
			main {
				resources {
					srcDir(project.file("src/generated/resources"))
					exclude(project.file("src/generated/resources/.cache").toString())
				}
			}
		}

		runs {
			if(project.archivesBaseName == "jello" || project.archivesBaseName == "gelatin") {

				client {
					client()
					ideConfigGenerated true
					name = "[${project.archivesBaseName}] Client"
					source sourceSets.main
				}
				server {
					server()
					ideConfigGenerated true
					name = "[${project.archivesBaseName}] Server"
					source sourceSets.main
				}

				if (project.archivesBaseName == "jello") {
					datagen {
						client()
						ideConfigGenerated true

						name "[${project.archivesBaseName}] Data Generation"
						vmArg "-Dfabric-api.datagen"
						vmArg "-Dfabric-api.datagen.output-dir=${project.file("src/generated/resources")}"
						vmArg "-Dfabric-api.datagen.modid=jello"

						runDir "build/datagen"
					}
					client_renderDoc {
						client()
						ideConfigGenerated true
						name = "[${project.archivesBaseName}] Client - (RenderDoc)"
						source sourceSets.main
						vmArg "-Dowo.renderdocPath=${System.getenv('renderDocPath')}"
						//"C:\Program Files\RenderDoc\renderdoc.dll"
					}
					client_mixin {
						client()
						ideConfigGenerated true
						name = "[${project.archivesBaseName}] Client - (Mixin Swap)"
						source sourceSets.main
						vmArg "-Dmixin.debug.export=true"

						try {
							afterEvaluate {
								def mixinDep = this.configurations.compileClasspath
										.allDependencies
										.findAll { it.name == "sponge-mixin" }
										.first()

								if (mixin != null) {
									def mixinPath = this.configurations.compileClasspath.files(mixinDep).first().path;

									println(mixinPath)

									vmArg("-javaagent:\"${mixinPath}\"")

									println("[Info]: Mixin Hotswap Run should be working")
								} else {
									println("[Warning]: Unable to locate file path for Mixin Jar, HotSwap Run will not work!!!")
								}
							}
						} catch (Exception e) {
							println("[Error]: MixinHotswap Run had a issue!")
							e.printStackTrace()
						}
					}
				}
			}
		}
	}

	tasks.withType(ProcessResources).configureEach { proccess ->
		inputs.property "version", project.version

		filesMatching("fabric.mod.json") { expand "version": project.version }
	}

	tasks.withType(AbstractArchiveTask) {
		preserveFileTimestamps = true
		reproducibleFileOrder = true
	}

	tasks.withType(JavaCompile).configureEach {
		it.options.release = Integer.parseInt(sourceCompatibility)
	}

	jar {
		from("LICENSE") {
			rename { "${it}_${project.archivesBaseName}" }
		}
	}
}

javadoc {
	options {
		source = "17"
		encoding = "UTF-8"
		charSet = "UTF-8"
		memberLevel = JavadocMemberLevel.PACKAGE
		links(
				"https://guava.dev/releases/21.0/api/docs/",
				"https://asm.ow2.io/javadoc/",
				"https://docs.oracle.com/javase/8/docs/api/",
				"http://jenkins.liteloader.com/job/Mixin/javadoc/",
				"https://logging.apache.org/log4j/2.x/log4j-api/apidocs/"
				// Need to add minecraft jd publication etc once there is one available
		)
		// Disable the crazy super-strict doclint tool in Java 8
		addStringOption("Xdoclint:none", "-quiet")
	}

	allprojects.each { project ->
		if(project.archivesBaseName == "jello" || project.archivesBaseName == "gelatin") return

		source(project.sourceSets.main.allJava.srcDirs)
	}

	classpath = files(sourceSets.main.compileClasspath)
	include("**/api/**")
	failOnError false
}

var allowNestedJars = true

publishing {
	setupRepositories(repositories)

	publications {
		mavenJava(MavenPublication) {
			//This is such a jank way of disabling nested jars when publishing Gelatin only without the modules since
			//allowNestedJars = false

			artifact(remapJar) {
				builtBy(remapJar)
			}

			artifact(sourcesJar) {
				builtBy remapSourcesJar
			}

			pom.withXml {
				def depsNode = asNode().appendNode("dependencies")
				subprojects.each {
					if (it.archivesBaseName == "jello" || it.archivesBaseName == "gelatin") return//if(project.archivesBaseName == "jello") return

					def depNode = depsNode.appendNode("dependency")
					depNode.appendNode("groupId", it.group)
					depNode.appendNode("artifactId", it.name)
					depNode.appendNode("version", it.version)
					depNode.appendNode("scope", "compile")
				}
			}
		}
	}
}

void setupRepositories(RepositoryHandler repositories) {
	//repositories.mavenLocal() // uncomment for testing

	def ENV = System.getenv()
	repositories.maven {
		url ENV.MAVEN_URL

		credentials {
			username ENV.MAVEN_USER
			password ENV.MAVEN_PASSWORD
		}
	}
}

subprojects.each {
	if(it.archivesBaseName == "jello") return

	remapJar.dependsOn("${it.path}:remapJar")
}

subprojects {
	publishing {
		if (project.archivesBaseName == "jello") return

		setupRepositories(repositories)

		publications {
			release(MavenPublication) {

				from components.java

				artifactId = project.archivesBaseName
				groupId = project.group
				version = project.version
			}
		}
	}
}

dependencies {
	afterEvaluate {
		subprojects.each {
			if(it.archivesBaseName == "jello") return

			api project(path: "${it.path}", configuration: "namedElements")
		}
	}
}



remapJar {
	afterEvaluate {
		if(!allowNestedJars) return

		subprojects.each {
			if(it.archivesBaseName == "jello") return

			nestedJars.from project("${it.path}").tasks.getByName("remapJar")//project.tasks.getByName("remapJar")
		}
	}
}