mirror of
https://github.com/GTNewHorizons/CraftTweaker.git
synced 2026-11-13 16:54:05 +00:00
Glease
38c46d61d9
Class Registries are merged together into one. All subprojects are also merged into one. It's probably possible to split stuff into multiple source sets and not merging the registries, but I'm just too lazy for that.
748 lines
25 KiB
Groovy
748 lines
25 KiB
Groovy
//version: 1646409286
|
|
/*
|
|
DO NOT CHANGE THIS FILE!
|
|
|
|
Also, you may replace this file at any time if there is an update available.
|
|
Please check https://github.com/GTNewHorizons/ExampleMod1.7.10/blob/main/build.gradle for updates.
|
|
*/
|
|
|
|
|
|
import com.github.jengelman.gradle.plugins.shadow.tasks.ConfigureShadowRelocation
|
|
import com.github.jengelman.gradle.plugins.shadow.tasks.ShadowJar
|
|
import org.gradle.internal.logging.text.StyledTextOutput.Style
|
|
import org.gradle.internal.logging.text.StyledTextOutputFactory
|
|
|
|
import java.util.concurrent.TimeUnit
|
|
|
|
buildscript {
|
|
repositories {
|
|
maven {
|
|
name 'forge'
|
|
url 'https://maven.minecraftforge.net'
|
|
}
|
|
maven {
|
|
name 'sonatype'
|
|
url 'https://oss.sonatype.org/content/repositories/snapshots/'
|
|
}
|
|
maven {
|
|
name 'Scala CI dependencies'
|
|
url 'https://repo1.maven.org/maven2/'
|
|
}
|
|
maven {
|
|
name 'jitpack'
|
|
url 'https://jitpack.io'
|
|
}
|
|
}
|
|
dependencies {
|
|
classpath 'com.github.GTNewHorizons:ForgeGradle:1.2.7'
|
|
}
|
|
}
|
|
|
|
plugins {
|
|
id 'java-library'
|
|
id 'idea'
|
|
id 'eclipse'
|
|
id 'scala'
|
|
id 'maven-publish'
|
|
id 'org.jetbrains.kotlin.jvm' version '1.5.30' apply false
|
|
id 'org.jetbrains.kotlin.kapt' version '1.5.30' apply false
|
|
id 'org.ajoberstar.grgit' version '4.1.1'
|
|
id 'com.github.johnrengelman.shadow' version '4.0.4'
|
|
id 'com.palantir.git-version' version '0.13.0' apply false
|
|
id 'de.undercouch.download' version '5.0.1'
|
|
id 'com.github.gmazzo.buildconfig' version '3.0.3' apply false
|
|
}
|
|
|
|
if (project.file('.git/HEAD').isFile()) {
|
|
apply plugin: 'com.palantir.git-version'
|
|
}
|
|
|
|
def out = services.get(StyledTextOutputFactory).create('an-output')
|
|
|
|
apply plugin: 'forge'
|
|
|
|
def projectJavaVersion = JavaLanguageVersion.of(8)
|
|
|
|
java {
|
|
toolchain {
|
|
languageVersion.set(projectJavaVersion)
|
|
}
|
|
}
|
|
|
|
idea {
|
|
module {
|
|
inheritOutputDirs = true
|
|
downloadJavadoc = true
|
|
downloadSources = true
|
|
}
|
|
}
|
|
|
|
if(JavaVersion.current() != JavaVersion.VERSION_1_8) {
|
|
throw new GradleException("This project requires Java 8, but it's running on " + JavaVersion.current())
|
|
}
|
|
|
|
checkPropertyExists("modName")
|
|
checkPropertyExists("modId")
|
|
checkPropertyExists("modGroup")
|
|
checkPropertyExists("autoUpdateBuildScript")
|
|
checkPropertyExists("minecraftVersion")
|
|
checkPropertyExists("forgeVersion")
|
|
checkPropertyExists("replaceGradleTokenInFile")
|
|
checkPropertyExists("gradleTokenModId")
|
|
checkPropertyExists("gradleTokenModName")
|
|
checkPropertyExists("gradleTokenVersion")
|
|
checkPropertyExists("gradleTokenGroupName")
|
|
checkPropertyExists("apiPackage")
|
|
checkPropertyExists("accessTransformersFile")
|
|
checkPropertyExists("usesMixins")
|
|
checkPropertyExists("mixinPlugin")
|
|
checkPropertyExists("mixinsPackage")
|
|
checkPropertyExists("coreModClass")
|
|
checkPropertyExists("containsMixinsAndOrCoreModOnly")
|
|
checkPropertyExists("usesShadowedDependencies")
|
|
checkPropertyExists("developmentEnvironmentUserName")
|
|
|
|
boolean noPublishedSources = project.findProperty("noPublishedSources") ? project.noPublishedSources.toBoolean() : false
|
|
boolean usesMixinDebug = project.findProperty('usesMixinDebug') ?: project.usesMixins.toBoolean()
|
|
|
|
String javaSourceDir = "src/main/java/"
|
|
String scalaSourceDir = "src/main/scala/"
|
|
String kotlinSourceDir = "src/main/kotlin/"
|
|
|
|
String targetPackageJava = javaSourceDir + modGroup.toString().replaceAll("\\.", "/")
|
|
String targetPackageScala = scalaSourceDir + modGroup.toString().replaceAll("\\.", "/")
|
|
String targetPackageKotlin = kotlinSourceDir + modGroup.toString().replaceAll("\\.", "/")
|
|
if(!(getFile(targetPackageJava).exists() || getFile(targetPackageScala).exists() || getFile(targetPackageKotlin).exists())) {
|
|
throw new GradleException("Could not resolve \"modGroup\"! Could not find " + targetPackageJava + " or " + targetPackageScala + " or " + targetPackageKotlin)
|
|
}
|
|
|
|
if(apiPackage) {
|
|
targetPackageJava = javaSourceDir + modGroup.toString().replaceAll("\\.", "/") + "/" + apiPackage.toString().replaceAll("\\.", "/")
|
|
targetPackageScala = scalaSourceDir + modGroup.toString().replaceAll("\\.", "/") + "/" + apiPackage.toString().replaceAll("\\.", "/")
|
|
targetPackageKotlin = kotlinSourceDir + modGroup.toString().replaceAll("\\.", "/") + "/" + apiPackage.toString().replaceAll("\\.", "/")
|
|
if(!(getFile(targetPackageJava).exists() || getFile(targetPackageScala).exists() || getFile(targetPackageKotlin).exists())) {
|
|
throw new GradleException("Could not resolve \"apiPackage\"! Could not find " + targetPackageJava + " or " + targetPackageScala + " or " + targetPackageKotlin)
|
|
}
|
|
}
|
|
|
|
if(accessTransformersFile) {
|
|
String targetFile = "src/main/resources/META-INF/" + accessTransformersFile
|
|
if(!getFile(targetFile).exists()) {
|
|
throw new GradleException("Could not resolve \"accessTransformersFile\"! Could not find " + targetFile)
|
|
}
|
|
}
|
|
|
|
if(usesMixins.toBoolean()) {
|
|
if(mixinsPackage.isEmpty() || mixinPlugin.isEmpty()) {
|
|
throw new GradleException("\"mixinPlugin\" requires \"mixinsPackage\" and \"mixinPlugin\" to be set!")
|
|
}
|
|
|
|
targetPackageJava = javaSourceDir + modGroup.toString().replaceAll("\\.", "/") + "/" + mixinsPackage.toString().replaceAll("\\.", "/")
|
|
targetPackageScala = scalaSourceDir + modGroup.toString().replaceAll("\\.", "/") + "/" + mixinsPackage.toString().replaceAll("\\.", "/")
|
|
targetPackageKotlin = kotlinSourceDir + modGroup.toString().replaceAll("\\.", "/") + "/" + mixinsPackage.toString().replaceAll("\\.", "/")
|
|
if(!(getFile(targetPackageJava).exists() || getFile(targetPackageScala).exists() || getFile(targetPackageKotlin).exists())) {
|
|
throw new GradleException("Could not resolve \"mixinsPackage\"! Could not find " + targetPackageJava + " or " + targetPackageScala + " or " + targetPackageKotlin)
|
|
}
|
|
|
|
String targetFileJava = javaSourceDir + modGroup.toString().replaceAll("\\.", "/") + "/" + mixinPlugin.toString().replaceAll("\\.", "/") + ".java"
|
|
String targetFileScala = scalaSourceDir + modGroup.toString().replaceAll("\\.", "/") + "/" + mixinPlugin.toString().replaceAll("\\.", "/") + ".scala"
|
|
String targetFileScalaJava = scalaSourceDir + modGroup.toString().replaceAll("\\.", "/") + "/" + mixinPlugin.toString().replaceAll("\\.", "/") + ".java"
|
|
String targetFileKotlin = kotlinSourceDir + modGroup.toString().replaceAll("\\.", "/") + "/" + mixinPlugin.toString().replaceAll("\\.", "/") + ".kt"
|
|
if(!(getFile(targetFileJava).exists() || getFile(targetFileScala).exists() || getFile(targetFileScalaJava).exists() || getFile(targetFileKotlin).exists())) {
|
|
throw new GradleException("Could not resolve \"mixinPlugin\"! Could not find " + targetFileJava + " or " + targetFileScala + " or " + targetFileScalaJava + " or " + targetFileKotlin)
|
|
}
|
|
}
|
|
|
|
if(coreModClass) {
|
|
String targetFileJava = javaSourceDir + modGroup.toString().replaceAll("\\.", "/") + "/" + coreModClass.toString().replaceAll("\\.", "/") + ".java"
|
|
String targetFileScala = scalaSourceDir + modGroup.toString().replaceAll("\\.", "/") + "/" + coreModClass.toString().replaceAll("\\.", "/") + ".scala"
|
|
String targetFileScalaJava = scalaSourceDir + modGroup.toString().replaceAll("\\.", "/") + "/" + coreModClass.toString().replaceAll("\\.", "/") + ".java"
|
|
String targetFileKotlin = kotlinSourceDir + modGroup.toString().replaceAll("\\.", "/") + "/" + coreModClass.toString().replaceAll("\\.", "/") + ".kt"
|
|
if(!(getFile(targetFileJava).exists() || getFile(targetFileScala).exists() || getFile(targetFileScalaJava).exists() || getFile(targetFileKotlin).exists())) {
|
|
throw new GradleException("Could not resolve \"coreModClass\"! Could not find " + targetFileJava + " or " + targetFileScala + " or " + targetFileScalaJava + " or " + targetFileKotlin)
|
|
}
|
|
}
|
|
|
|
configurations.all {
|
|
resolutionStrategy.cacheChangingModulesFor(0, TimeUnit.SECONDS)
|
|
|
|
// Make sure GregTech build won't time out
|
|
System.setProperty("org.gradle.internal.http.connectionTimeout", 120000 as String)
|
|
System.setProperty("org.gradle.internal.http.socketTimeout", 120000 as String)
|
|
}
|
|
|
|
// Fix Jenkins' Git: chmod a file should not be detected as a change and append a '.dirty' to the version
|
|
try {
|
|
'git config core.fileMode false'.execute()
|
|
}
|
|
catch (Exception ignored) {
|
|
out.style(Style.Failure).println("git isn't installed at all")
|
|
}
|
|
|
|
// Pulls version first from the VERSION env and then git tag
|
|
String identifiedVersion
|
|
String versionOverride = System.getenv("VERSION") ?: null
|
|
try {
|
|
identifiedVersion = versionOverride == null ? gitVersion() : versionOverride
|
|
}
|
|
catch (Exception ignored) {
|
|
out.style(Style.Failure).text(
|
|
'This mod must be version controlled by Git AND the repository must provide at least one tag,\n' +
|
|
'or the VERSION override must be set! ').style(Style.SuccessHeader).text('(Do NOT download from GitHub using the ZIP option, instead\n' +
|
|
'clone the repository, see ').style(Style.Info).text('https://gtnh.miraheze.org/wiki/Development').style(Style.SuccessHeader).println(' for details.)'
|
|
)
|
|
versionOverride = 'NO-GIT-TAG-SET'
|
|
identifiedVersion = versionOverride
|
|
}
|
|
version = minecraftVersion + '-' + identifiedVersion
|
|
ext {
|
|
modVersion = identifiedVersion
|
|
}
|
|
|
|
if(identifiedVersion == versionOverride) {
|
|
out.style(Style.Failure).text('Override version to ').style(Style.Identifier).text(modVersion).style(Style.Failure).println('!\7')
|
|
}
|
|
|
|
group = modGroup
|
|
if(project.hasProperty("customArchiveBaseName") && customArchiveBaseName) {
|
|
archivesBaseName = customArchiveBaseName
|
|
}
|
|
else {
|
|
archivesBaseName = modId
|
|
}
|
|
|
|
def arguments = []
|
|
def jvmArguments = []
|
|
|
|
if (usesMixins.toBoolean()) {
|
|
arguments += [
|
|
"--tweakClass org.spongepowered.asm.launch.MixinTweaker"
|
|
]
|
|
if (usesMixinDebug.toBoolean()) {
|
|
jvmArguments += [
|
|
"-Dmixin.debug.countInjections=true",
|
|
"-Dmixin.debug.verbose=true",
|
|
"-Dmixin.debug.export=true"
|
|
]
|
|
}
|
|
}
|
|
|
|
minecraft {
|
|
version = minecraftVersion + '-' + forgeVersion + '-' + minecraftVersion
|
|
runDir = 'run'
|
|
|
|
if (replaceGradleTokenInFile) {
|
|
replaceIn replaceGradleTokenInFile
|
|
if(gradleTokenModId) {
|
|
replace gradleTokenModId, modId
|
|
}
|
|
if(gradleTokenModName) {
|
|
replace gradleTokenModName, modName
|
|
}
|
|
if(gradleTokenVersion) {
|
|
replace gradleTokenVersion, modVersion
|
|
}
|
|
if(gradleTokenGroupName) {
|
|
replace gradleTokenGroupName, modGroup
|
|
}
|
|
}
|
|
|
|
clientIntellijRun {
|
|
args(arguments)
|
|
jvmArgs(jvmArguments)
|
|
|
|
if(developmentEnvironmentUserName) {
|
|
args("--username", developmentEnvironmentUserName)
|
|
}
|
|
}
|
|
|
|
serverIntellijRun {
|
|
args(arguments)
|
|
jvmArgs(jvmArguments)
|
|
}
|
|
}
|
|
|
|
if(file('addon.gradle').exists()) {
|
|
apply from: 'addon.gradle'
|
|
}
|
|
|
|
apply from: 'repositories.gradle'
|
|
|
|
configurations {
|
|
implementation.extendsFrom(shadowImplementation) // TODO: remove after all uses are refactored
|
|
implementation.extendsFrom(shadowCompile)
|
|
implementation.extendsFrom(shadeCompile)
|
|
}
|
|
|
|
repositories {
|
|
maven {
|
|
name 'Overmind forge repo mirror'
|
|
url 'https://gregtech.overminddl1.com/'
|
|
}
|
|
if(usesMixins.toBoolean()) {
|
|
maven {
|
|
name 'sponge'
|
|
url 'https://repo.spongepowered.org/repository/maven-public'
|
|
}
|
|
maven {
|
|
url 'https://jitpack.io'
|
|
}
|
|
}
|
|
}
|
|
|
|
dependencies {
|
|
if(usesMixins.toBoolean()) {
|
|
annotationProcessor('org.ow2.asm:asm-debug-all:5.0.3')
|
|
annotationProcessor('com.google.guava:guava:24.1.1-jre')
|
|
annotationProcessor('com.google.code.gson:gson:2.8.6')
|
|
annotationProcessor('org.spongepowered:mixin:0.8-SNAPSHOT')
|
|
// using 0.8 to workaround a issue in 0.7 which fails mixin application
|
|
compile('com.github.GTNewHorizons:SpongePoweredMixin:0.7.12-GTNH') {
|
|
// Mixin includes a lot of dependencies that are too up-to-date
|
|
exclude module: 'launchwrapper'
|
|
exclude module: 'guava'
|
|
exclude module: 'gson'
|
|
exclude module: 'commons-io'
|
|
exclude module: 'log4j-core'
|
|
}
|
|
compile('com.github.GTNewHorizons:SpongeMixins:1.5.0')
|
|
}
|
|
}
|
|
|
|
apply from: 'dependencies.gradle'
|
|
|
|
def mixingConfigRefMap = 'mixins.' + modId + '.refmap.json'
|
|
def refMap = "${tasks.compileJava.temporaryDir}" + File.separator + mixingConfigRefMap
|
|
def mixinSrg = "${tasks.reobf.temporaryDir}" + File.separator + "mixins.srg"
|
|
|
|
task generateAssets {
|
|
if (usesMixins.toBoolean()) {
|
|
def mixinConfigFile = getFile("/src/main/resources/mixins." + modId + ".json");
|
|
if (!mixinConfigFile.exists()) {
|
|
mixinConfigFile.text = """{
|
|
"required": true,
|
|
"minVersion": "0.7.11",
|
|
"package": "${modGroup}.${mixinsPackage}",
|
|
"plugin": "${modGroup}.${mixinPlugin}",
|
|
"refmap": "${mixingConfigRefMap}",
|
|
"target": "@env(DEFAULT)",
|
|
"compatibilityLevel": "JAVA_8",
|
|
"mixins": [],
|
|
"client": [],
|
|
"server": []
|
|
}
|
|
"""
|
|
}
|
|
}
|
|
}
|
|
|
|
task relocateShadowJar(type: ConfigureShadowRelocation) {
|
|
target = tasks.shadowJar
|
|
prefix = modGroup + ".shadow"
|
|
}
|
|
|
|
shadowJar {
|
|
project.configurations.shadeCompile.each { dep ->
|
|
from(project.zipTree(dep)) {
|
|
exclude 'META-INF', 'META-INF/**'
|
|
}
|
|
}
|
|
|
|
manifest {
|
|
attributes(getManifestAttributes())
|
|
}
|
|
|
|
minimize() // This will only allow shading for actually used classes
|
|
configurations = [project.configurations.shadowImplementation, project.configurations.shadowCompile]
|
|
dependsOn(relocateShadowJar)
|
|
}
|
|
|
|
jar {
|
|
project.configurations.shadeCompile.each { dep ->
|
|
from(project.zipTree(dep)) {
|
|
exclude 'META-INF', 'META-INF/**'
|
|
}
|
|
}
|
|
|
|
manifest {
|
|
attributes(getManifestAttributes())
|
|
}
|
|
|
|
if(usesShadowedDependencies.toBoolean()) {
|
|
dependsOn(shadowJar)
|
|
enabled = false
|
|
}
|
|
}
|
|
|
|
reobf {
|
|
if(usesMixins.toBoolean()) {
|
|
addExtraSrgFile mixinSrg
|
|
}
|
|
}
|
|
|
|
afterEvaluate {
|
|
if(usesMixins.toBoolean()) {
|
|
tasks.compileJava {
|
|
options.compilerArgs += [
|
|
"-AreobfSrgFile=${tasks.reobf.srg}",
|
|
"-AoutSrgFile=${mixinSrg}",
|
|
"-AoutRefMapFile=${refMap}",
|
|
// Elan: from what I understand they are just some linter configs so you get some warning on how to properly code
|
|
"-XDenableSunApiLintControl",
|
|
"-XDignore.symbol.file"
|
|
]
|
|
}
|
|
}
|
|
}
|
|
|
|
runClient {
|
|
if(developmentEnvironmentUserName) {
|
|
arguments += [
|
|
"--username",
|
|
developmentEnvironmentUserName
|
|
]
|
|
}
|
|
|
|
args(arguments)
|
|
jvmArgs(jvmArguments)
|
|
}
|
|
|
|
runServer {
|
|
args(arguments)
|
|
jvmArgs(jvmArguments)
|
|
}
|
|
|
|
tasks.withType(JavaExec).configureEach {
|
|
javaLauncher.set(
|
|
javaToolchains.launcherFor {
|
|
languageVersion = projectJavaVersion
|
|
}
|
|
)
|
|
}
|
|
|
|
processResources {
|
|
// this will ensure that this task is redone when the versions change.
|
|
inputs.property "version", project.version
|
|
inputs.property "mcversion", project.minecraft.version
|
|
|
|
// replace stuff in mcmod.info, nothing else
|
|
from(sourceSets.main.resources.srcDirs) {
|
|
include 'mcmod.info'
|
|
|
|
// replace modVersion and minecraftVersion
|
|
expand "minecraftVersion": project.minecraft.version,
|
|
"modVersion": modVersion,
|
|
"modId": modId,
|
|
"modName": modName
|
|
}
|
|
|
|
if(usesMixins.toBoolean()) {
|
|
from refMap
|
|
}
|
|
|
|
// copy everything else that's not the mcmod.info
|
|
from(sourceSets.main.resources.srcDirs) {
|
|
exclude 'mcmod.info'
|
|
}
|
|
}
|
|
|
|
def getManifestAttributes() {
|
|
def manifestAttributes = [:]
|
|
if(!containsMixinsAndOrCoreModOnly.toBoolean() && (usesMixins.toBoolean() || coreModClass)) {
|
|
manifestAttributes += ["FMLCorePluginContainsFMLMod": true]
|
|
}
|
|
|
|
if(accessTransformersFile) {
|
|
manifestAttributes += ["FMLAT" : accessTransformersFile.toString()]
|
|
}
|
|
|
|
if(coreModClass) {
|
|
manifestAttributes += ["FMLCorePlugin": modGroup + "." + coreModClass]
|
|
}
|
|
|
|
if(usesMixins.toBoolean()) {
|
|
manifestAttributes += [
|
|
"TweakClass" : "org.spongepowered.asm.launch.MixinTweaker",
|
|
"MixinConfigs" : "mixins." + modId + ".json",
|
|
"ForceLoadAsMod" : !containsMixinsAndOrCoreModOnly.toBoolean()
|
|
]
|
|
}
|
|
return manifestAttributes
|
|
}
|
|
|
|
task sourcesJar(type: Jar) {
|
|
from (sourceSets.main.allSource)
|
|
from (file("$projectDir/LICENSE"))
|
|
getArchiveClassifier().set('sources')
|
|
}
|
|
|
|
task shadowDevJar(type: ShadowJar) {
|
|
project.configurations.shadeCompile.each { dep ->
|
|
from(project.zipTree(dep)) {
|
|
exclude 'META-INF', 'META-INF/**'
|
|
}
|
|
}
|
|
|
|
from sourceSets.main.output
|
|
getArchiveClassifier().set("dev")
|
|
|
|
manifest {
|
|
attributes(getManifestAttributes())
|
|
}
|
|
|
|
minimize() // This will only allow shading for actually used classes
|
|
configurations = [project.configurations.shadowImplementation, project.configurations.shadowCompile]
|
|
}
|
|
|
|
task relocateShadowDevJar(type: ConfigureShadowRelocation) {
|
|
target = tasks.shadowDevJar
|
|
prefix = modGroup + ".shadow"
|
|
}
|
|
|
|
task circularResolverJar(type: Jar) {
|
|
dependsOn(relocateShadowDevJar)
|
|
dependsOn(shadowDevJar)
|
|
enabled = false
|
|
}
|
|
|
|
task devJar(type: Jar) {
|
|
project.configurations.shadeCompile.each { dep ->
|
|
from(project.zipTree(dep)) {
|
|
exclude 'META-INF', 'META-INF/**'
|
|
}
|
|
}
|
|
|
|
from sourceSets.main.output
|
|
getArchiveClassifier().set("dev")
|
|
|
|
manifest {
|
|
attributes(getManifestAttributes())
|
|
}
|
|
|
|
if(usesShadowedDependencies.toBoolean()) {
|
|
dependsOn(circularResolverJar)
|
|
enabled = false
|
|
}
|
|
}
|
|
|
|
task apiJar(type: Jar) {
|
|
from (sourceSets.main.allSource) {
|
|
include modGroup.toString().replaceAll("\\.", "/") + "/" + apiPackage.toString().replaceAll("\\.", "/") + '/**'
|
|
}
|
|
|
|
from (sourceSets.main.output) {
|
|
include modGroup.toString().replaceAll("\\.", "/") + "/" + apiPackage.toString().replaceAll("\\.", "/") + '/**'
|
|
}
|
|
|
|
from (sourceSets.main.resources.srcDirs) {
|
|
include("LICENSE")
|
|
}
|
|
|
|
getArchiveClassifier().set('api')
|
|
}
|
|
|
|
artifacts {
|
|
if(!noPublishedSources) {
|
|
archives sourcesJar
|
|
}
|
|
archives devJar
|
|
if(apiPackage) {
|
|
archives apiJar
|
|
}
|
|
}
|
|
|
|
// The gradle metadata includes all of the additional deps that we disabled from POM generation (including forgeBin with no groupID),
|
|
// and isn't strictly needed with the POM so just disable it.
|
|
tasks.withType(GenerateModuleMetadata) {
|
|
enabled = false
|
|
}
|
|
|
|
// workaround variable hiding in pom processing
|
|
def projectConfigs = project.configurations
|
|
|
|
publishing {
|
|
publications {
|
|
maven(MavenPublication) {
|
|
from components.java
|
|
if(usesShadowedDependencies.toBoolean()) {
|
|
artifact source: shadowJar, classifier: ""
|
|
}
|
|
if(!noPublishedSources) {
|
|
artifact source: sourcesJar, classifier: "src"
|
|
}
|
|
artifact source: usesShadowedDependencies.toBoolean() ? shadowDevJar : devJar, classifier: "dev"
|
|
if (apiPackage) {
|
|
artifact source: apiJar, classifier: "api"
|
|
}
|
|
|
|
groupId = System.getenv("ARTIFACT_GROUP_ID") ?: "com.github.GTNewHorizons"
|
|
artifactId = System.getenv("ARTIFACT_ID") ?: project.name
|
|
// Using the identified version, not project.version as it has the prepended 1.7.10
|
|
version = System.getenv("RELEASE_VERSION") ?: identifiedVersion
|
|
|
|
// remove extra garbage from minecraft and minecraftDeps configuration
|
|
pom.withXml {
|
|
def badArtifacts = [:].withDefault {[] as Set<String>}
|
|
for (configuration in [projectConfigs.minecraft, projectConfigs.minecraftDeps]) {
|
|
for (dependency in configuration.allDependencies) {
|
|
badArtifacts[dependency.group == null ? "" : dependency.group] += dependency.name
|
|
}
|
|
}
|
|
// example for specifying extra stuff to ignore
|
|
// badArtifacts["org.example.group"] += "artifactName"
|
|
|
|
Node pomNode = asNode()
|
|
pomNode.dependencies.'*'.findAll() {
|
|
badArtifacts[it.groupId.text()].contains(it.artifactId.text())
|
|
}.each() {
|
|
it.parent().remove(it)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
repositories {
|
|
maven {
|
|
url = "http://jenkins.usrv.eu:8081/nexus/content/repositories/releases"
|
|
credentials {
|
|
username = System.getenv("MAVEN_USER") ?: "NONE"
|
|
password = System.getenv("MAVEN_PASSWORD") ?: "NONE"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Updating
|
|
task updateBuildScript {
|
|
doLast {
|
|
if (performBuildScriptUpdate(projectDir.toString())) return
|
|
|
|
print("Build script already up-to-date!")
|
|
}
|
|
}
|
|
|
|
if (isNewBuildScriptVersionAvailable(projectDir.toString())) {
|
|
if (autoUpdateBuildScript.toBoolean()) {
|
|
performBuildScriptUpdate(projectDir.toString())
|
|
} else {
|
|
out.style(Style.SuccessHeader).println("Build script update available! Run 'gradle updateBuildScript'")
|
|
}
|
|
}
|
|
|
|
static URL availableBuildScriptUrl() {
|
|
new URL("https://raw.githubusercontent.com/GTNewHorizons/ExampleMod1.7.10/main/build.gradle")
|
|
}
|
|
|
|
boolean performBuildScriptUpdate(String projectDir) {
|
|
if (isNewBuildScriptVersionAvailable(projectDir)) {
|
|
def buildscriptFile = getFile("build.gradle")
|
|
availableBuildScriptUrl().withInputStream { i -> buildscriptFile.withOutputStream { it << i } }
|
|
out.style(Style.Success).print("Build script updated. Please REIMPORT the project or RESTART your IDE!")
|
|
return true
|
|
}
|
|
return false
|
|
}
|
|
|
|
boolean isNewBuildScriptVersionAvailable(String projectDir) {
|
|
Map parameters = ["connectTimeout": 2000, "readTimeout": 2000]
|
|
|
|
String currentBuildScript = getFile("build.gradle").getText()
|
|
String currentBuildScriptHash = getVersionHash(currentBuildScript)
|
|
String availableBuildScript = availableBuildScriptUrl().newInputStream(parameters).getText()
|
|
String availableBuildScriptHash = getVersionHash(availableBuildScript)
|
|
|
|
boolean isUpToDate = currentBuildScriptHash.empty || availableBuildScriptHash.empty || currentBuildScriptHash == availableBuildScriptHash
|
|
return !isUpToDate
|
|
}
|
|
|
|
static String getVersionHash(String buildScriptContent) {
|
|
String versionLine = buildScriptContent.find("^//version: [a-z0-9]*")
|
|
if(versionLine != null) {
|
|
return versionLine.split(": ").last()
|
|
}
|
|
return ""
|
|
}
|
|
|
|
configure(updateBuildScript) {
|
|
group = 'forgegradle'
|
|
description = 'Updates the build script to the latest version'
|
|
}
|
|
|
|
// Deobfuscation
|
|
|
|
def deobf(String sourceURL) {
|
|
try {
|
|
URL url = new URL(sourceURL)
|
|
String fileName = url.getFile()
|
|
|
|
//get rid of directories:
|
|
int lastSlash = fileName.lastIndexOf("/")
|
|
if(lastSlash > 0) {
|
|
fileName = fileName.substring(lastSlash + 1)
|
|
}
|
|
//get rid of extension:
|
|
if(fileName.endsWith(".jar")) {
|
|
fileName = fileName.substring(0, fileName.lastIndexOf("."))
|
|
}
|
|
|
|
String hostName = url.getHost()
|
|
if(hostName.startsWith("www.")) {
|
|
hostName = hostName.substring(4)
|
|
}
|
|
List parts = Arrays.asList(hostName.split("\\."))
|
|
Collections.reverse(parts)
|
|
hostName = String.join(".", parts)
|
|
|
|
return deobf(sourceURL, hostName + "/" + fileName)
|
|
} catch(Exception e) {
|
|
return deobf(sourceURL, "deobf/" + String.valueOf(sourceURL.hashCode()))
|
|
}
|
|
}
|
|
|
|
// The method above is to be preferred. Use this method if the filename is not at the end of the URL.
|
|
def deobf(String sourceURL, String fileName) {
|
|
String cacheDir = System.getProperty("user.home") + "/.gradle/caches/"
|
|
String bon2Dir = cacheDir + "forge_gradle/deobf"
|
|
String bon2File = bon2Dir + "/BON2-2.5.0.jar"
|
|
String obfFile = cacheDir + "modules-2/files-2.1/" + fileName + ".jar"
|
|
String deobfFile = cacheDir + "modules-2/files-2.1/" + fileName + "-deobf.jar"
|
|
|
|
if(file(deobfFile).exists()) {
|
|
return files(deobfFile)
|
|
}
|
|
|
|
download.run {
|
|
src 'https://github.com/GTNewHorizons/BON2/releases/download/2.5.0/BON2-2.5.0.CUSTOM-all.jar'
|
|
dest bon2File
|
|
quiet true
|
|
overwrite false
|
|
}
|
|
|
|
download.run {
|
|
src sourceURL
|
|
dest obfFile
|
|
quiet true
|
|
overwrite false
|
|
}
|
|
|
|
exec {
|
|
commandLine 'java', '-jar', bon2File, '--inputJar', obfFile, '--outputJar', deobfFile, '--mcVer', '1.7.10', '--mappingsVer', 'stable_12', '--notch'
|
|
workingDir bon2Dir
|
|
standardOutput = new ByteArrayOutputStream()
|
|
}
|
|
|
|
return files(deobfFile)
|
|
}
|
|
|
|
// Helper methods
|
|
|
|
def checkPropertyExists(String propertyName) {
|
|
if (!project.hasProperty(propertyName)) {
|
|
throw new GradleException("This project requires a property \"" + propertyName + "\"! Please add it your \"gradle.properties\". You can find all properties and their description here: https://github.com/GTNewHorizons/ExampleMod1.7.10/blob/main/gradle.properties")
|
|
}
|
|
}
|
|
|
|
def getFile(String relativePath) {
|
|
return new File(projectDir, relativePath)
|
|
}
|