build.gradle

buildscript {
	repositories {
		maven { url = 'https://files.minecraftforge.net/maven' }
		maven { url = 'https://maven.parchmentmc.org' }
		mavenCentral()
	}
	dependencies {
		classpath group: 'net.minecraftforge.gradle', name: 'ForgeGradle', version: '5.1.+', changing: true
		classpath 'org.parchmentmc:librarian:1.+'
		classpath "org.jfrog.buildinfo:build-info-extractor-gradle:4+"
		classpath 'org.spongepowered:mixingradle:0.7.+'
	}
}

plugins {
	id 'java'
	id 'eclipse'
	id 'idea'
	id 'maven-publish'
	id "com.modrinth.minotaur" version "2.+"
	id 'com.matthewprenger.cursegradle' version '1.4.0'
}
apply plugin: 'net.minecraftforge.gradle'
apply plugin: 'org.parchmentmc.librarian.forgegradle'
apply plugin: "com.jfrog.artifactory"
apply plugin: "org.spongepowered.mixin"

//adds the build number to the end of the version string if on a build server
String build_number = System.getenv().BUILD_NUMBER
if (build_number == null) {
	build_number = 'CUSTOM'
}

String semver = "${mod_version_massive}.${mod_version_major}.${mod_version_minor}"

// these two are required for the java plugin to generate jar files with a version
version = "${project.mc_version}-${semver}-${build_number}"
group = 'me.desht.pneumaticcraft' // http://maven.apache.org/guides/mini/guide-naming-conventions.html
archivesBaseName = "pneumaticcraft-repressurized"

ext.releaseTag = System.getenv('TAG') ?: ""
ext.isAlpha = ext.releaseTag.contains("alpha")
ext.isBeta = ext.releaseTag.contains("beta")

// All jar files from this folder will be added automatically as runtime mod dependencies
String extraModsDir = "extra-mods-${project.mc_version}"

sourceSets {
	api
	main {
		compileClasspath += sourceSets.api.output
		runtimeClasspath += sourceSets.api.output
		resources {
			srcDir 'src/generated/resources'
		}
	}
	test {
		compileClasspath += sourceSets.api.output
		runtimeClasspath += sourceSets.api.output
	}
}

configurations {
//	apiImplementation.extendsFrom(implementation)
//	apiRuntimeOnly.extendsFrom(runtimeOnly)
	apiImplementation.extendsFrom(minecraft)
}

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

repositories {
	mavenCentral()
	flatDir {
		name "extra-mods"
		dir file(extraModsDir)
	}
	maven {
		name "JEI"
		url "https://dvs1.progwml6.com/files/maven"
	}
	maven {
		name 'CC: Tweaked'
		url 'https://squiddev.cc/maven/'
	}
	maven {
		name 'Crafttweaker/Patchouli/Botania/Immersive Engineering/Gamestages'
		url 'https://maven.blamejared.com/'
	}
	maven {
		name 'Curios'
		url "https://maven.theillusivec4.top/"
	}
	maven {
		name "K-4u Mod maven"
		url "https://modmaven.dev/"
	}
	maven {
		url "https://www.cursemaven.com"
		content {
			includeGroup "curse.maven"
		}
	}
}

dependencies {
	minecraft([
			group  : "net.minecraftforge",
			name   : 'forge',
			version: "${project.mc_version}-${project.forge_version}"
	])

	annotationProcessor 'org.spongepowered:mixin:0.8.5:processor'

	testImplementation "org.junit.jupiter:junit-jupiter-api:5.7.2"
	testRuntimeOnly "org.junit.jupiter:junit-jupiter-engine:5.7.2"

	implementation fg.deobf("mcjty.theoneprobe:theoneprobe:${top_version}") {
		exclude group: "net.minecraftforge", module: "forge"
	}
	// compile against the JEI API but do not include it at runtime
	compileOnly fg.deobf("mezz.jei:jei-${mc_version}-common-api:${jei_version}")
	compileOnly fg.deobf("mezz.jei:jei-${mc_version}-forge-api:${jei_version}")
	// at runtime, use the full JEI
	runtimeOnly fg.deobf("mezz.jei:jei-${mc_version}-common:${jei_version}")
	runtimeOnly fg.deobf("mezz.jei:jei-${mc_version}-forge:${jei_version}")
	compileOnly fg.deobf("top.theillusivec4.curios:curios-forge:${curios_version}:api")
	runtimeOnly fg.deobf("top.theillusivec4.curios:curios-forge:${curios_version}")
	compileOnly fg.deobf("vazkii.botania:Botania:${botania_version}-FORGE:api")
	runtimeOnly fg.deobf("vazkii.botania:Botania:${botania_version}-FORGE")
	compileOnly fg.deobf("vazkii.patchouli:Patchouli:${patchouli_version}:api")
	runtimeOnly fg.deobf("vazkii.patchouli:Patchouli:${patchouli_version}")
	implementation fg.deobf("org.squiddev:cc-tweaked-${project.mc_version}:${cc_tweaked_version}")
	compileOnly fg.deobf("blusunrize.immersiveengineering:ImmersiveEngineering:${immersive_engineering_version}")
	compileOnly fg.deobf("mekanism:Mekanism:${mekanism_version}:api")
	runtimeOnly fg.deobf("mekanism:Mekanism:${mekanism_version}")
	implementation fg.deobf("com.simibubi.create:create-${project.mc_version}:${create_version}:slim") { transitive = false }
	implementation fg.deobf("com.jozufozu.flywheel:flywheel-forge-${project.mc_version}:${flywheel_version}")
	implementation fg.deobf("com.tterrag.registrate:Registrate:${registrate_version}")
//	implementation fg.deobf("curse.maven:create-328085:${create_curse_id}")
	implementation fg.deobf("curse.maven:jade-324717:${jade_curse_id}")
	implementation fg.deobf("curse.maven:cofh_core-69162:${cofh_core_curse_id}")
 	implementation fg.deobf("curse.maven:thermal_cultivation-271835:${thermal_cultivation_curse_id}")
	implementation fg.deobf("curse.maven:thermal_expansion-69163:${thermal_expansion_curse_id}")
	implementation fg.deobf("curse.maven:thermal_foundation-222880:${thermal_foundation_curse_id}")
	implementation fg.deobf("curse.maven:thermal_innovation-291737:${thermal_innovation_curse_id}")
	implementation fg.deobf("curse.maven:thermal_locomotion-406959:${thermal_locomotion_curse_id}")

	implementation fg.deobf("com.blamejared.crafttweaker:CraftTweaker-forge-1.19.2:${crafttweaker_version}")
	compileOnly fg.deobf("net.darkhax.gamestages:GameStages-Forge-${project.mc_version}:${gamestages_version}")

	//compileOnly fg.deobf("appeng:appliedenergistics2:${ae2_version}:api")
	//runtimeOnly fg.deobf("appeng:appliedenergistics2:${ae2_version}")
	//compileOnly fg.deobf("team.chisel.ctm:CTM:MC1.16.1-${ctm_version}")
	//runtimeOnly fg.deobf("team.chisel.ctm:CTM:MC1.16.1-${ctm_version}")

	// Locally sourced extra mods for runtime (i.e. testing) - thanks AE2 for this idea
	for (extraModJar in fileTree(dir: extraModsDir, include: '*.jar')) {
		def basename = extraModJar.name.substring(0, extraModJar.name.length() - ".jar".length())
		def versionSep = basename.lastIndexOf('-')
		assert versionSep != -1
		def artifactId = basename.substring(0, versionSep)
		def version = basename.substring(versionSep + 1)
		runtimeOnly fg.deobf("extra-mods:$artifactId:$version")
	}

//    compileOnly "li.cil.oc:OpenComputers:MC1.12.2-${oc_version}:api"
//    compileOnly "net.industrial-craft:industrialcraft-2:2.8.27-ex112:api"
//    compileOnly "thaumcraft:Thaumcraft:${thaumcraft_version}"
//    compileOnly "team.chisel.ctm:CTM:${ctm_version}:api"
}

minecraft {
	mappings channel: 'parchment', version: "${project.mappings_version}-${project.mc_version}"
//	mappings channel: 'parchment', version: "${project.mappings_version}-${project.mc_version}"
//	mappings channel: 'official', version: "1.19"

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

	runs {
		client {
			property 'forge.logging.console.level', 'debug'
			workingDirectory file('run')
			property 'mixin.env.remapRefMap', 'true'
			property 'mixin.env.refMapRemappingFile', "${projectDir}/build/createSrgToMcp/output.srg"
			ideaModule "${project.name}.main"
			mods {
				pneumaticcraft.sources((SourceSet[]) [sourceSets.main, sourceSets.api])
			}
		}
		server {
			property 'forge.logging.console.level', 'debug'
			workingDirectory file('run')
			property 'mixin.env.remapRefMap', 'true'
			property 'mixin.env.refMapRemappingFile', "${projectDir}/build/createSrgToMcp/output.srg"
			ideaModule "${project.name}.main"
			mods {
				pneumaticcraft.sources((SourceSet[]) [sourceSets.main, sourceSets.api])
			}
		}
		data {
			property 'forge.logging.console.level', 'debug'
			property 'fml.earlyprogresswindow', 'false'
			property 'mixin.env.remapRefMap', 'true'
			property 'mixin.env.refMapRemappingFile', "${projectDir}/build/createSrgToMcp/output.srg"
			workingDirectory file('run')
			ideaModule "${project.name}.main"
			forceExit false
			args '--mod', 'pneumaticcraft', '--all', '--output', file('src/generated/resources/'), '--existing', sourceSets.main.resources.srcDirs[0]
			mods {
				pneumaticcraft.sources((SourceSet[]) [sourceSets.main, sourceSets.api])
			}
		}
	}
}

mixin {
	// Refmaps for each SourceSet
	add sourceSets.main, 'mixins.pneumaticcraft.refmap.json'

	// Configs to add to runs and jars
	config 'mixins.pneumaticcraft.json'

	// Specify options for dev run configs
	debug.verbose = true
	debug.export = true
	dumpTargetOnFailure = true

	// Options for the Annotation Processor
	quiet
}

def replaceResources = tasks.register("replaceResources", Copy) {
	it.outputs.upToDateWhen { false }
	//Copy it into the build dir
	it.from(sourceSets.main.resources) {
		include "META-INF/mods.toml"
		expand 'version': version, 'mc_version': mc_version, 'mc_version_range': minecraft_version_range, 'forge_version_range': forge_version_range
	}
	it.into "$buildDir/resources/main/"
}

processResources {
	duplicatesStrategy(DuplicatesStrategy.FAIL)
	exclude('META-INF/mods.toml')
	configure { finalizedBy(replaceResources) }
}

classes.configure {
	dependsOn(replaceResources)
}

javadoc {
	source = [sourceSets.main.allJava, sourceSets.api.allJava]
	// prevent java 8's strict doclint for javadocs from failing builds
	options.addStringOption('Xdoclint:none', '-quiet')
	(options as StandardJavadocDocletOptions)
			.tags("apiNote:a:API Note:", "implSpec:a:Implementation Requirements:", "implNote:a:Implementation Note:")
}

task getChangelogProperty(type: Exec) {
	standardOutput = new ByteArrayOutputStream()
	commandLine 'bash', './scripts/extract_changes.sh', "${semver}"
	doLast {
		ext.changelog = standardOutput.toString()
    }
}

//task makeChangelog(type: GitChangelogTask) {
//	file = file('changelog.html')
//	untaggedName = "Current release ${project.version}"
//	fromCommit = '2fe051cf727adce1be210a46f778aa8fe031331e'
//	toRef = 'HEAD'
//	templateContent = file('changelog.mustache').getText('UTF-8')
//}

//curseforge {
//	apiKey = project.findProperty('curseforge_apikey') ?: '0'
//	project {
//		id = curse_project_id
//		changelog = file('changelog.html')
//		changelogType = 'html'
//		releaseType = 'beta'
//	}
//}

//afterEvaluate {
//	tasks.curseforge281849.dependsOn makeChangelog
//}

jar {
	from sourceSets.main.output
	from sourceSets.api.output

	manifest.attributes([
			'FMLAT': 'accesstransformer.cfg',
			"Specification-Title": "PneumaticCraft: Repressurized",
			"Specification-Vendor": "desht",
			"Specification-Version": "${semver}",
			"Implementation-Title": project.name,
			"Implementation-Version": "${project.version}",
			"Implementation-Vendor" :"desht",
			"Implementation-Timestamp": new Date().format("yyyy-MM-dd'T'HH:mm:ssZ")
	])

	finalizedBy 'reobfJar'
}

task javadocJar(type: Jar, dependsOn: javadoc) {
	duplicatesStrategy(DuplicatesStrategy.FAIL)
	archiveClassifier.set('javadoc')
	from javadoc.destinationDir
}

task sourcesJar(type: Jar) {
	duplicatesStrategy(DuplicatesStrategy.FAIL)
	archiveClassifier.set('sources')
	from sourceSets.main.allJava
	from sourceSets.api.allJava
}

task apiJar(type: Jar, dependsOn: apiClasses) {
	duplicatesStrategy(DuplicatesStrategy.FAIL)
	archiveClassifier.set('api')
	from sourceSets.api.output
	afterEvaluate { finalizedBy reobfApiJar }
}

task deobfJar(type: Jar) {
	duplicatesStrategy(DuplicatesStrategy.FAIL)
	archiveClassifier.set('deobf')
	from sourceSets.main.output
	from sourceSets.api.output
}

artifacts {
	archives javadocJar
	archives sourcesJar
	archives apiJar
	archives deobfJar
}

reobf {
	apiJar { classpath.from(sourceSets.api.compileClasspath) }
	jar { classpath.from(sourceSets.main.compileClasspath) }
}

task reobf {
	dependsOn reobfJar
	dependsOn reobfApiJar
}

tasks.withType(GenerateModuleMetadata) {
	enabled = false
}

// with thanks to AE2
def mavenVer = ext.releaseTag == "" ? "${project.mc_version}-${semver}-SNAPSHOT" : "${project.mc_version}-${semver}"
publishing {
	if (System.getenv("MODMAVEN_USER") != null) {
		publications {
			maven(MavenPublication) {
				groupId = project.group
				artifactId = project.archivesBaseName
				version = mavenVer

				// 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 {
				name = "modmaven"
				credentials {
					username System.getenv("MODMAVEN_USER")
					password System.getenv("MODMAVEN_PASSWORD")
				}
				url = "https://modmaven.dev/artifactory/local-releases/"
			}
		}
	}
}

idea {
	module {
		for (String exclude in ['run', 'out', 'logs']) {
			excludeDirs += file(exclude)
		}
	}
}

def relType = "release"
if (ext.isAlpha) {
	relType = "alpha"
} else if (ext.isBeta) {
	relType = "beta"
}

modrinth {
	token = System.getenv("MODRINTH_TOKEN")
	projectId = "${project.modrinth_project_id}"
	versionNumber = "${project.mc_version}-${semver}"
	versionType = relType
	uploadFile = jar // With Loom, this MUST be set to `remapJar` instead of `jar`!
	additionalFiles = [ apiJar ]
	gameVersions = ["${mc_version}"] // Must be an array, even with only one version
	changelog = System.getenv("CHANGELOG")
	dependencies { // A special DSL for creating dependencies
		// scope.type
		// The scope can be `required`, `optional`, or `incompatible`
		// The type can either be `project` or `version`
		required.project "nU0bVIaL"  // Patchouli
	}
}

if (System.getenv("CURSEFORGE_TOKEN")) {
	curseforge {
		apiKey = System.getenv("CURSEFORGE_TOKEN")
		project {
			id = project.curse_project_id
			changelogType = "markdown"
			changelog = System.getenv("CHANGELOG")
			releaseType = relType
			addGameVersion project.mc_version
			addGameVersion "Forge"
			mainArtifact(jar.archiveFile) {
				displayName = "${project.archivesBaseName} v${project.mc_version}-${semver}"
				relations {
					requiredDependency "patchouli"
				}
			}
			addArtifact(apiJar.archiveFile)
		}
	}
}

//test {
//	useJUnitPlatform()
//	include 'mezz/jei/**'
//	exclude 'mezz/jei/lib/**'
//}