build.gradle

import me.modmuss50.mpp.ReleaseType

buildscript {
	dependencies {
		classpath 'org.parchmentmc:librarian:1.+'
		classpath "org.jfrog.buildinfo:build-info-extractor-gradle:4+"
	}
}

plugins {
    id 'java-library'
    id 'eclipse'
    id 'idea'
    id 'maven-publish'
	id 'net.neoforged.moddev' version '1.0.11'
    id "me.modmuss50.mod-publish-plugin" version "0.7.2"
}

ext {
	releaseTag = providers.environmentVariable("TAG").orElse("").get()
	isAlpha = ext.releaseTag.contains("alpha")
	isBeta = ext.releaseTag.contains("beta")
}

// All jar files from this folder will be added automatically as runtime-only mod dependencies
def extraModsDir = "extra-mods-${minecraft_version}"

repositories {
	mavenLocal()
	mavenCentral()
	flatDir {
		name "extra-mods"
		dir file(extraModsDir)
		content {
			includeGroup "extra-mods"
		}
	}
	maven {
		url "https://www.cursemaven.com"
		content {
			includeGroup "curse.maven"
		}
	}
	maven {
		name 'CC: Tweaked'
		url 'https://squiddev.cc/maven/'
		content {
			includeGroup("cc.tweaked")
		}
	}
	maven {
		name 'Crafttweaker/Patchouli/Botania/Immersive Engineering/Gamestages'
		url 'https://maven.blamejared.com/'
		content {
			includeGroup "vazkii.patchouli"
			includeGroup "vazkii.botania"
			includeGroup "mezz.jei"
			includeGroup "blusunrize.immersiveengineering"
			includeGroup "com.blamejared.crafttweaker"
			includeGroup "net.darkhax.gamestages"
			includeGroup "net.darkhax.bookshelf"
			includeGroup "org.openzen.zencode"
		}
	}
	maven {
		name = "OctoStudios"
		url = uri("https://maven.octo-studios.com/releases")
	}
	maven {
		name "K-4u Mod maven"
		url "https://modmaven.dev/"
		content {
			includeGroup "com.simibubi.create"
			includeGroup "mekanism"
			includeGroup "mcjty.theoneprobe"
		}
	}
	maven {
		name "FTB Maven"
		url "https://maven.ftb.dev/releases/"
		content {
			includeGroup "dev.ftb.mods"
		}
	}
}

base {
    archivesName = "${archive_base_name}-${mod_version}+mc${minecraft_version}"
}

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

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

neoForge {
	version = "${neo_version}"

	parchment {
		mappingsVersion = project.parchment_mappings_version
		minecraftVersion = project.parchment_minecraft_version
	}

	addModdingDependenciesTo(sourceSets.api)

	validateAccessTransformers = true

	runs {
		client {
			client()
			jvmArgument("-Xmx4G")
			gameDirectory = project.file('runs/client')
		}
		data {
			data()
			jvmArgument("-Xmx4G")
			gameDirectory = project.file('runs/data')
			programArguments = [ '--mod', project.mod_id, '--all', '--output', file('src/generated/resources/').getAbsolutePath(), '--existing', file('src/main/resources/').getAbsolutePath() ]
		}
		server {
			server()
			programArgument("-nogui")
			jvmArgument("-Xmx4G")
			gameDirectory = project.file('runs/server')
		}
	}

	mods {
		pneumaticcraft {
			sourceSet sourceSets.main
			sourceSet sourceSets.api
		}
	}
}

configurations {
	compileClasspath.extendsFrom localImplementation
	runtimeClasspath.extendsFrom localImplementation
	runtimeClasspath.extendsFrom localRuntime
}

dependencies {
	testImplementation 'org.junit.jupiter:junit-jupiter-api:5.11.0-M2'
	testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine:5.11.0-M2'

	localImplementation("mcjty.theoneprobe:theoneprobe:${top_version}")
//			{
//		exclude group: "net.minecraftforge", module: "forge"
//	}

	compileOnly("mezz.jei:jei-1.21.1-common-api:${jei_version}")
	compileOnly("mezz.jei:jei-1.21.1-neoforge-api:${jei_version}")
	localRuntime("mezz.jei:jei-1.21.1-common:${jei_version}")
	localRuntime("mezz.jei:jei-1.21.1-neoforge:${jei_version}")

	compileOnly("top.theillusivec4.curios:curios-neoforge:${curios_version}:api")
	localRuntime("top.theillusivec4.curios:curios-neoforge:${curios_version}")

	compileOnly("vazkii.botania:Botania:${botania_version}:api")
	//runtimeOnly("vazkii.botania:Botania:${botania_version}")

	compileOnly("vazkii.patchouli:Patchouli:${patchouli_version}:api")
	localRuntime("vazkii.patchouli:Patchouli:${patchouli_version}")

	localImplementation("curse.maven:cc-tweaked-282001:${cc_tweaked_curse_id}")

	compileOnly("dev.ftb.mods:ftb-filter-system-neoforge:${ffs_version}") { transitive = false }
	compileOnly("dev.ftb.mods:ftb-teams-neoforge:${ftb_teams_version}") { transitive = false }

	localImplementation("blusunrize.immersiveengineering:ImmersiveEngineering:${immersive_engineering_version}")

	compileOnly("mekanism:Mekanism:${mekanism_version}:api")
	localRuntime("mekanism:Mekanism:${mekanism_version}")

	compileOnly("com.simibubi.create:create-1.20.1:${create_version}:slim") { transitive = false }

	localImplementation("curse.maven:jade-324717:${jade_curse_id}")

	compileOnly("com.blamejared.crafttweaker:CraftTweaker-neoforge-1.21.1:${crafttweaker_version}")

	compileOnly("curse.maven:cofh_core-69162:${cofh_core_curse_id}")
	compileOnly("curse.maven:thermal_cultivation-271835:${thermal_cultivation_curse_id}")
	compileOnly("curse.maven:thermal_expansion-69163:${thermal_expansion_curse_id}")
	compileOnly("curse.maven:thermal_foundation-222880:${thermal_foundation_curse_id}")
	compileOnly("curse.maven:thermal_innovation-291737:${thermal_innovation_curse_id}")
	compileOnly("curse.maven:thermal_locomotion-406959:${thermal_locomotion_curse_id}")

	compileOnly("net.darkhax.gamestages:GameStages-Forge-1.20.1:${gamestages_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)
		localRuntime("extra-mods:$artifactId:$version")
	}
}

tasks.withType(ProcessResources).configureEach {
    var replaceProperties = [
            minecraft_version   : minecraft_version, minecraft_version_range: minecraft_version_range,
            neo_version         : neo_version, neo_version_range: neo_version_range,
            loader_version_range: loader_version_range,
            mod_id              : mod_id, mod_name: mod_name, mod_license: mod_license, mod_version: mod_version,
            mod_authors         : mod_authors, mod_description: mod_description, pack_format_number: pack_format_number,
    ]
    inputs.properties replaceProperties

    filesMatching(['META-INF/neoforge.mods.toml', 'pack.mcmeta']) {
        expand replaceProperties + [project: project]
    }
}

jar {
	from sourceSets.api.output
}

task apiJar(type: Jar, dependsOn: apiClasses) {
	archiveClassifier = 'api'
	from sourceSets.api.output
}

task sourcesJar(type: Jar, dependsOn: classes) {
	archiveClassifier = 'sources'
	from sourceSets.main.allSource
	from sourceSets.api.allSource
}

artifacts {
	archives sourcesJar
	archives apiJar
}

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:")
}

def snapExt = ext.releaseTag == "" ? "-SNAPSHOT" : ""
publishing {
    publications {
        register('mavenJava', MavenPublication) {
			artifactId = archive_base_name
			groupId = mod_group_id
			version = "${mod_version}+mc${minecraft_version}${snapExt}"
            from components.java
			artifact sourcesJar
			artifact apiJar
        }
    }
    repositories {
        maven {
            url "file://${project.projectDir}/repo"
        }
        if (System.getenv("MODMAVEN_USER") != null) {
            maven {
                name = "modmaven"
                credentials {
                    username System.getenv("MODMAVEN_USER")
                    password System.getenv("MODMAVEN_PASSWORD")
                }
                url = "https://modmaven.dev/artifactory/local-releases/"
            }
        }
    }
}

tasks.withType(JavaCompile).configureEach {
    options.encoding = 'UTF-8' // Use the UTF-8 charset for Java compilation
}

def releaseType = ext.isAlpha ? ReleaseType.ALPHA : (ext.isBeta ? ReleaseType.BETA : ReleaseType.STABLE)
publishMods {
    dryRun = providers.environmentVariable("CURSEFORGE_TOKEN").getOrNull() == null
    changelog = providers.environmentVariable("CHANGELOG").orElse("dryrun")
    version = mod_version
    type = releaseType
    file = jar.archiveFile
    displayName = "${mod_name} ${mod_version} MC-${minecraft_version}"
    modLoaders.add("neoforge")

    curseforge {
        projectId = curse_project_id
        accessToken = providers.environmentVariable("CURSEFORGE_TOKEN")
        minecraftVersions.add(minecraft_version)
        projectSlug = "pneumaticcraft-repressurized"
        announcementTitle = "Download from Curseforge"
        optional("patchouli", "ctm")
    }

    modrinth {
        projectId = modrinth_project_id
        accessToken = providers.environmentVariable("MODRINTH_TOKEN")
        minecraftVersions.add(minecraft_version)
        announcementTitle = "Download from Modrinth"
        optional("patchouli")
    }

    discord {
        webhookUrl = providers.environmentVariable("DISCORD_WEBHOOK").orElse("dryrun")
		content = changelog.map { "# ${mod_name} v${mod_version} for MC ${minecraft_version} has been released! \n" + it}.get().take(1999)
    }
}