//version: 1644894948 /* 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 org.gradle.internal.logging.text.StyledTextOutput import org.gradle.internal.logging.text.StyledTextOutputFactory import org.gradle.internal.logging.text.StyledTextOutput.Style import com.github.jengelman.gradle.plugins.shadow.tasks.ConfigureShadowRelocation import com.github.jengelman.gradle.plugins.shadow.tasks.ShadowJar 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 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" ] 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()) { getFile("/src/main/resources/mixins." + modId + ".json").text = """{ "required": true, "minVersion": "0.7.11", "package": "${modGroup}.${mixinsPackage}", "plugin": "${modGroup}.${mixinPlugin}", "refmap": "${mixingConfigRefMap}", "target": "@env(DEFAULT)", "compatibilityLevel": "JAVA_8" } """ } } 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.allJava) 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.allJava) { 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} 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) }