build.gradle

buildscript {
	repositories {
		maven { url = "https://files.minecraftforge.net/maven" }
		mavenCentral()
	}

	dependencies {
		classpath group: "net.minecraftforge.gradle", name: "ForgeGradle", version: "5.1.+", changing: true
	}
}

plugins {
	id "maven-publish"
	id "com.matthewprenger.cursegradle" version "1.4.0"
	id "com.modrinth.minotaur" version "1.2.1"
}

apply plugin: "net.minecraftforge.gradle"

group = "net.sengir.forestry"
version = System.getenv("FORESTRY_VERSION") ?: "0.0.0.0"
archivesBaseName = "forestry-$minecraft_version"

repositories {
	maven {
		name "JEI"
		url "https://dvs1.progwml6.com/files/maven"
	}

	maven {
		name "Patchouli"
		url "https://maven.blamejared.com/"
	}
}

dependencies {
	minecraft "net.minecraftforge:forge:$minecraft_version-$forge_version"

	compileOnly fg.deobf("mezz.jei:jei-$minecraft_version:$jei_version:api")
	runtimeOnly fg.deobf("mezz.jei:jei-$minecraft_version:$jei_version")

	compileOnly fg.deobf("vazkii.patchouli:Patchouli:$patchouli_version:api")
	runtimeOnly fg.deobf("vazkii.patchouli:Patchouli:$patchouli_version")
}

java {
	toolchain {
		languageVersion = JavaLanguageVersion.of(17)
	}
}

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

sourceSets {
	main {
		resources {
			srcDir "src/generated/resources"
		}
	}
}

minecraft {
	mappings channel: "official", version: minecraft_version

	accessTransformer = file("src/main/resources/META-INF/accesstransformer.cfg")

	runs {
		def commonRunProperties = {
			workingDirectory project.file("run")

			property "forge.logging.console.level", "debug"
			property "fml.earlyprogresswindow", "false"

			// See https://github.com/Vazkii/Patchouli#mixin-troubleshooting
			property "mixin.env.remapRefMap", "true"
			property "mixin.env.refMapRemappingFile", "$projectDir/build/createSrgToMcp/output.srg"

			mods {
				forestry {
					source sourceSets.main
				}
			}
		}

		client {
			with commonRunProperties
		}

		server {
			with commonRunProperties
		}

		data {
			with commonRunProperties
			forceExit false
			args "--mod", "forestry", "--all", "--output", file("src/generated/resources/"), "--existing", file("src/main/resources/")
		}
	}
}

processResources {
	exclude ".cache"

	filesMatching("META-INF/mods.toml") {
		expand "version": project.version,
				"forge_version_range": forge_version_range,
				"jei_version_range": jei_version_range,
				"patchouli_version_range": patchouli_version_range
	}
}

jar {
	finalizedBy "reobfJar"

	from sourceSets.main.output.classesDirs
	from sourceSets.main.output.resourcesDir

	manifest {
		attributes([
				"Specification-Title"     : "Forestry",
				"Specification-Vendor"    : "SirSengir",
				"Specification-Version"   : "${project.version}",
				"Implementation-Title"    : "${project.name}",
				"Implementation-Version"  : "${project.version}",
				"Implementation-Vendor"   : "SirSengir",
				"Implementation-Timestamp": new Date().format("yyyy-MM-dd'T'HH:mm:ssZ")
		])
	}
}

def publicApiIncludePatterns = {
	include "forestry/api/**"
	include "genetics/api/**"
}

javadoc {
	source = sourceSets.main.allJava
	classpath = sourceSets.main.compileClasspath + sourceSets.main.output

	options.addStringOption("Xdoclint:none", "-quiet")
	options.encoding = "UTF-8"
}

javadoc publicApiIncludePatterns

task javadocJar(type: Jar, dependsOn: javadoc, group: "build") {
	archiveClassifier.set("javadoc")
	from javadoc.destinationDir
}

task sourcesJar(type: Jar) {
	archiveClassifier.set("sources")
	from sourceSets.main.allJava
}

task apiJar(type: Jar, group: "build") {
	archiveClassifier.set("api")
	// api jar ist just a development aid and serves as both a binary and source jar simultaneously
	from sourceSets.main.output
	from sourceSets.main.allJava
}

apiJar publicApiIncludePatterns

artifacts {
	archives javadocJar
	archives sourcesJar
	archives apiJar
}

publishing {
	afterEvaluate {
		publications {
			mavenJava(MavenPublication) {
				groupId = project.group
				artifactId = project.archivesBaseName
				version = project.version

				// ForgeGradle will generate wild dependency definitions, see https://github.com/MinecraftForge/ForgeGradle/issues/584
				// Since we don't actually depend on anything, just remove the entire node.
				pom.withXml {
					asNode().remove(asNode().dependencies)
				}

				from components.java
				artifact sourcesJar
				artifact javadocJar
				artifact apiJar
			}
		}
	}

	repositories {
		maven {
			def releasesRepoUrl = uri("$buildDir/repos/releases")
			def snapshotsRepoUrl = uri("$buildDir/repos/snapshots")

			name = "Project"
			url = version.toString().endsWith("SNAPSHOT") ? snapshotsRepoUrl : releasesRepoUrl
		}

		maven {
			credentials {
				username System.getenv("MODMAVEN_USER")
				password System.getenv("MODMAVEN_PASSWORD")
			}

			name = "Modmaven"
			url = "https://modmaven.dev/artifactory/local-releases/"
		}
	}
}

////////////////
// CurseForge
if (System.getenv("CURSEFORGE")) {
	curseforge {
		apiKey = System.getenv("CURSEFORGE")

		project {
			id = project.curseforge_project
			changelogType = "markdown"
			changelog = "View changelog at [the release page](https://github.com/ForestryMC/ForestryMC/releases/tag/${version})"

			if (version.contains("alpha")) {
				releaseType = "alpha"
			} else if (version.contains("beta")) {
				releaseType = "beta"
			} else {
				releaseType = "release"
			}

			addGameVersion project.minecraft_version
			addGameVersion "Forge"

			mainArtifact(jar.archiveFile) {
				displayName = "${project.version}"
				relations {
					optionalDependency 'jei'
					requiredDependency 'patchouli'
				}
			}
		}
	}
}

////////////////
// Modrinth
import com.modrinth.minotaur.TaskModrinthUpload
import com.modrinth.minotaur.request.VersionType

task publishModrinth(type: TaskModrinthUpload) {
	onlyIf {
		System.getenv("MODRINTH")
	}

	dependsOn jar

	token = System.getenv("MODRINTH")
	changelog = "View changelog at [the release page](https://github.com/ForestryMC/ForestryMC/releases/tag/${version})"
	projectId = project.modrinth_project
	versionName = project.version
	versionNumber = project.version

	if (version.contains("alpha")) {
		versionType = VersionType.ALPHA
	} else if (version.contains("beta")) {
		versionType = VersionType.BETA
	} else {
		versionType = VersionType.RELEASE
	}

	uploadFile = jar
	addGameVersion(project.minecraft_version)
	addLoader("forge")
}