build.gradle

import org.groovymc.modsdotgroovy.types.core.Platform

plugins {
    id 'maven-publish'
    id 'signing'
    id 'java-library'
    alias libs.plugins.managedversioning
    alias libs.plugins.modsdotgroovy
}

managedVersioning {
    versionFile.set project.file('version.properties')
    metadataVersion.set libs.versions.minecraft
    versionPRs()
    versionSnapshots()

    gitHubActions {
        snapshot {
            prettyName.set 'Snapshot'
            workflowDispatch.set(true)
            onBranches.add '1.*'
            gradleJob {
                buildCache()
                name.set 'build'
				javaVersion.set '21'
                gradlew 'Build', 'build'
                gradlew 'Publish', 'publish'
                mavenSnapshot('github')
            }
        }
        release {
            prettyName.set 'Release'
            workflowDispatch.set(true)
            gradleJob {
                buildCache()
                name.set 'build'
				javaVersion.set '21'
                step {
                    setupGitUser()
                }
                readOnly.set false
                gradlew 'Tag Release', 'tagRelease'
                gradlew 'Build', 'build'
                step {
                    run.set 'git push && git push --tags'
                }
                recordVersion 'Record Version', 'version'
            }
            gradleJob {
                buildCache()
                name.set 'publish'
				javaVersion.set '21'
                needs.add('build')
                tag.set('${{needs.build.outputs.version}}')
                gradlew 'Publish', 'publish', 'closeAndReleaseSonatypeStagingRepository'
                mavenCentral()
				mavenStaging('github')
                sign()
            }
        }
        build_pr {
            prettyName.set 'Build PR'
            pullRequest.set(true)
            gradleJob {
                name.set 'build'
				javaVersion.set '21'
                gradlew 'Build', 'build'
                gradlew 'Publish', 'publish'
                pullRequestArtifact()
            }
        }
        publish_pr {
            prettyName.set 'Publish PR'
            publishPullRequestAction(
                'github',
				"${project.group.replace('.', '/')}/${project.name}",
                'Build PR'
            )
        }
    }
}

managedVersioning.apply()

println "Building: $version"

modsDotGroovy {
    multiplatform.expose()
    gather {
        projectProperty('mod_id')
        projectProperty('mod_name')
        projectProperty('description')
    }
}

sourceSets.neoforge.modsDotGroovy {
    platform = Platform.NEOFORGE
    inferGather.set false
    multiplatform.from(':', 'main')
    gather {
        minecraftVersion = libs.versions.minecraft.get()
        platformVersion = libs.versions.neoforge.get()
    }
    enable()
}

sourceSets.fabric.modsDotGroovy {
    platform = Platform.FABRIC
    inferGather.set false
    multiplatform.from(':', 'main')
    gather {
        minecraftVersion = libs.versions.minecraft.get()
        platformVersion = libs.versions.fabric.loader.get()
    }
    enable()
}

dependencies {
    compileOnly cLibs.bundles.compileonly
    annotationProcessor cLibs.bundles.annotationprocessor
    compileOnly libs.fabric.mixin

    fabricCompileOnly cLibs.bundles.compileonly
    fabricAnnotationProcessor cLibs.bundles.annotationprocessor
    modFabricImplementation libs.fabric.loader
    modFabricImplementation libs.fabric.api

    neoforgeCompileOnly cLibs.bundles.compileonly
    neoforgeAnnotationProcessor cLibs.bundles.annotationprocessor
}

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

java {
    withSourcesJar()
    withJavadocJar()
    registerFeature("neoforge") {
        usingSourceSet sourceSets.neoforge
        capability(project.group as String, project.name, project.version as String)
        capability(project.group as String, "$project.name-neoforge", project.version as String)
        withSourcesJar()
        withJavadocJar()
    }
    registerFeature("fabric") {
        usingSourceSet sourceSets.fabric
        capability(project.group as String, project.name, project.version as String)
        capability(project.group as String, "$project.name-fabric", project.version as String)
        withSourcesJar()
        withJavadocJar()
    }
}

managedVersioning.publishing.mavenCentral()
managedVersioning.publishing.mavenStaging(publishing)
managedVersioning.publishing.mavenPullRequest(publishing)
managedVersioning.publishing.mavenSnapshot(publishing)

publishing {
    publications {
        mavenJava(MavenPublication) {
            from components.java
            managedVersioning.publishing.sign(signing, it)
            managedVersioning.publishing.pom(it, github_repo, license)
            pom {
                name = mod_name
                description = project.description
            }
        }
    }
}

['sourcesJar', 'fabricSourcesJar', 'neoforgeSourcesJar'].each {
	tasks.named(it, Jar) {
		from(files("LICENSE")) {
			rename { "${it}_${project.name}" }
		}
	}
}

['jar', 'fabricJar', 'neoforgeJar'].each {
	tasks.named(it, Jar) {
		from(files("LICENSE")) {
			rename { "${it}_${project.name}" }
		}

		manifest {
			attributes([
				'Specification-Title'     : mod_name,
				'Specification-Vendor'    : mod_author,
				'Specification-Version'   : project.version,
				'Implementation-Title'    : "$mod_name - ${project.name}",
				'Implementation-Version'  : project.version,
				'Implementation-Vendor'   : mod_author,
				'Built-On-Minecraft'      : libs.versions.minecraft.get(),
				'Implementation-Commit-Time': managedVersioning.timestamp.get(),
				'Implementation-Commit': managedVersioning.hash.get()
			])
		}
	}
}