yarn/build.gradle

341 lines
9.8 KiB
Groovy
Raw Normal View History

2016-08-17 15:23:28 -04:00
buildscript {
repositories {
jcenter()
maven {
2017-11-22 08:56:07 -05:00
name "Modmuss50 Repository"
url 'https://maven.modmuss50.me'
}
}
dependencies {
classpath "net.fabricmc:weave:0.2.0.+"
classpath "net.fabricmc:stitch:0.1.0.+"
classpath "commons-io:commons-io:1.4"
classpath "com.google.guava:guava:19.0"
classpath 'de.undercouch:gradle-download-task:3.4.3'
classpath 'net.fabricmc:tiny-remapper:+'
}
2016-08-17 15:23:28 -04:00
}
apply plugin: 'de.undercouch.download'
2018-10-26 06:51:01 -04:00
def minecraft_version = "18w43c"
2016-09-09 08:47:32 -04:00
def pomfVersion = "${minecraft_version}"
def ENV = System.getenv()
if (ENV.BUILD_NUMBER) {
pomfVersion = pomfVersion + "." + "${System.getenv().BUILD_NUMBER}"
2016-09-09 08:47:32 -04:00
}
2016-08-17 15:23:28 -04:00
def mappingsDir = file("mappings")
def cacheFilesMinecraft = file(".gradle/minecraft")
def mergedFile = file("${minecraft_version}-merged.jar")
def mappedFile = file("${minecraft_version}-mapped.jar")
def versionFile = new File(cacheFilesMinecraft, "${minecraft_version}.json")
def clientJar = new File(cacheFilesMinecraft, "${minecraft_version}-client.jar")
def serverJar = new File(cacheFilesMinecraft, "${minecraft_version}-server.jar")
def libraries = new File(cacheFilesMinecraft, "${minecraft_version}-libraries")
2016-08-17 15:23:28 -04:00
import groovy.json.JsonSlurper
import org.apache.commons.io.FileUtils
import com.google.common.hash.HashCode
import com.google.common.hash.Hashing
import com.google.common.io.Files
import net.fabricmc.stitch.merge.JarMerger
import net.fabricmc.tinyremapper.OutputConsumerPath
import net.fabricmc.tinyremapper.TinyRemapper
import net.fabricmc.tinyremapper.TinyUtils
import net.fabricmc.weave.CommandTinyify
import net.fabricmc.weave.CommandFindMappingErrors
2016-08-17 15:23:28 -04:00
import groovy.util.XmlSlurper
import groovy.io.FileType
2016-09-21 08:52:54 -04:00
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.zip.GZIPOutputStream;
import java.io.File;
import java.nio.file.Paths;
2016-08-17 15:23:28 -04:00
boolean validateChecksum(File file, String checksum) {
if (file != null) {
def hash = Files.hash(file, Hashing.sha1())
def builder = new StringBuilder()
hash.asBytes().each {
builder.append(Integer.toString((it & 0xFF) + 0x100, 16).substring(1))
}
return builder.toString().equals(checksum)
}
return false
}
task downloadVersionsManifest {
//inputs.property "mc_ver", minecraft_version
inputs.property "currenttime", new Date()
def manifestFile = new File(cacheFilesMinecraft, "version_manifest.json")
outputs.file(manifestFile)
doLast {
logger.lifecycle(":downloading minecraft versions manifest")
FileUtils.copyURLToFile(new URL("https://launchermeta.mojang.com/mc/game/version_manifest.json"), manifestFile)
}
}
def getManifestVersion(File manifestFile, String minecraft_version) {
def manifest = manifestFile.exists() ? new JsonSlurper().parseText(FileUtils.readFileToString(manifestFile)) : null
return manifest != null ? manifest.versions.stream().filter({it.id.equals(minecraft_version)}).findFirst() : java.util.Optional.empty()
}
task downloadWantedVersionManifest(dependsOn: downloadVersionsManifest) {
def manifestFile = downloadVersionsManifest.outputs.files.singleFile
def manifestVersion = getManifestVersion(manifestFile, minecraft_version)
//have to grab the release time as there's a current timestamp on each element?!
inputs.property "releaseTime", manifestVersion.isPresent() ? manifestVersion.get().releaseTime : -1
outputs.file versionFile
doLast {
manifestVersion = getManifestVersion(manifestFile, minecraft_version) //nb need to re-read here in case it didn't exist before
if (manifestVersion.isPresent() || versionFile.exists()) {
if (manifestVersion.isPresent()) {
FileUtils.copyURLToFile(new URL(manifestVersion.get().url), versionFile)
}
} else {
throw new RuntimeException("No version data for Minecraft version ${minecraft_version}")
}
}
}
2016-08-17 15:23:28 -04:00
task downloadMcJars(dependsOn: downloadWantedVersionManifest) {
2016-08-17 15:23:28 -04:00
inputs.files versionFile
2016-08-17 15:23:28 -04:00
outputs.files(clientJar, serverJar)
2016-08-17 15:23:28 -04:00
outputs.upToDateWhen {
2016-08-17 15:23:28 -04:00
def version = new JsonSlurper().parseText(FileUtils.readFileToString(versionFile))
return clientJar.exists() && serverJar.exists() && validateChecksum(clientJar, version.downloads.client.sha1) && validateChecksum(serverJar, version.downloads.server.sha1)
}
doLast {
if (!versionFile.exists()) {
throw new RuntimeException("Can't download the jars without the ${versionFile.name} file!")
}
2016-08-17 15:23:28 -04:00
//reload in case it changed
def version = new JsonSlurper().parseText(FileUtils.readFileToString(versionFile))
logger.lifecycle(":downloading minecraft jars")
2016-08-17 15:23:28 -04:00
if (!clientJar.exists() || !validateChecksum(clientJar, version.downloads.client.sha1)) {
logger.lifecycle(":downloading minecraft client")
FileUtils.copyURLToFile(new URL(version.downloads.client.url), clientJar)
}
if (!serverJar.exists() || !validateChecksum(serverJar, version.downloads.server.sha1)) {
logger.lifecycle(":downloading minecraft server")
FileUtils.copyURLToFile(new URL(version.downloads.server.url), serverJar)
}
}
}
task mergeJars(dependsOn: downloadMcJars) {
inputs.files downloadMcJars.outputs.files.files
outputs.file(mergedFile)
2016-08-17 15:23:28 -04:00
doLast {
logger.lifecycle(":merging jars")
def client = new FileInputStream(inputs.files.files.find {it.name.endsWith("-client.jar")})
def server = new FileInputStream(inputs.files.files.find {it.name.endsWith("-server.jar")})
2016-08-17 15:23:28 -04:00
def merged = new FileOutputStream(mergedFile)
def jarMerger = new JarMerger(client, server, merged)
jarMerger.merge()
jarMerger.close()
client.close()
server.close()
merged.close()
}
}
task setupPomf(dependsOn: mergeJars) {
2016-08-17 15:23:28 -04:00
}
task pomf(dependsOn: setupPomf) {
doLast {
def cacheFilesEnigma = new File(".gradle/enigma")
if (!cacheFilesEnigma.exists()) {
cacheFilesEnigma.mkdirs()
}
2016-08-17 15:23:28 -04:00
def mavenMetadata = new File(cacheFilesEnigma, "maven-metadata.xml")
def localEnigmaVersion = mavenMetadata.exists() ? new XmlSlurper().parseText(FileUtils.readFileToString(mavenMetadata)).versioning.release : ""
2016-08-17 15:23:28 -04:00
logger.lifecycle(":downloading enigma metadata")
FileUtils.copyURLToFile(new URL("http://maven.modmuss50.me/cuchaz/enigma/maven-metadata.xml"), mavenMetadata)
def metadata = new XmlSlurper().parseText(FileUtils.readFileToString(mavenMetadata))
def enigmaVersion = metadata.versioning.release
2016-08-17 15:23:28 -04:00
def enigma = new File(cacheFilesEnigma, "${enigmaVersion}.jar")
2016-08-17 15:23:28 -04:00
if (localEnigmaVersion != enigmaVersion || !enigma.exists()) {
logger.lifecycle(":downloading enigma")
FileUtils.copyURLToFile(new URL("http://maven.modmuss50.me/cuchaz/enigma/${enigmaVersion}/enigma-${enigmaVersion}-all.jar"), enigma)
} else {
logger.lifecycle(":skipping enigma download")
}
2016-08-17 15:23:28 -04:00
logger.lifecycle(":launching enigma")
ant.java(jar: enigma.getAbsolutePath(), fork: true, spawn: true) {
arg(value: mergedFile.getAbsolutePath())
arg(value: mappingsDir.getAbsolutePath())
}
2016-08-17 15:23:28 -04:00
}
}
2016-09-08 18:42:45 -04:00
task build(type: Zip) {
from mappingsDir
2016-09-08 18:42:45 -04:00
include "**/*"
2016-09-09 08:47:32 -04:00
archiveName "pomf-enigma-${pomfVersion}.zip"
2016-09-08 18:42:45 -04:00
destinationDir(file("build/libs"))
2016-09-09 08:47:32 -04:00
}
2016-09-21 08:52:54 -04:00
task checkMappings {
inputs.dir mappingsDir
doLast {
logger.lifecycle(":checking mappings")
String[] args = [
mergedFile.getAbsolutePath(),
mappingsDir.getAbsolutePath()
]
new CommandFindMappingErrors().run(args)
}
}
task buildTiny(dependsOn: "mergeJars") {
inputs.dir mappingsDir
def libs = new File("build/libs/")
if (!libs.exists()) {
libs.mkdirs()
}
def outputFile = new File(libs, "pomf-tiny-${pomfVersion}.gz")
outputs.file(outputFile)
doLast {
logger.lifecycle(":generating tiny mappings")
String[] args = [
mergedFile.getAbsolutePath(),
mappingsDir.getAbsolutePath(),
"mappings.tiny",
"mojang",
"pomf"
]
new CommandTinyify().run(args)
logger.lifecycle(":compressing tiny mappings")
def buffer = new byte[1024]
def fileOutputStream = new FileOutputStream(outputFile)
def outputStream = new GZIPOutputStream(fileOutputStream)
def inputFile = new File("mappings.tiny")
def fileInputStream = new FileInputStream(inputFile)
def length
while ((length = fileInputStream.read(buffer)) > 0) {
outputStream.write(buffer, 0, length)
}
fileInputStream.close()
outputStream.finish()
outputStream.close()
inputFile.delete()
}
}
2016-09-21 08:52:54 -04:00
tasks.build.dependsOn "buildTiny"
task downloadMcLibs(dependsOn: downloadWantedVersionManifest) {
inputs.files versionFile
2016-09-21 08:52:54 -04:00
outputs.file(libraries)
2016-09-21 08:52:54 -04:00
outputs.upToDateWhen {
return true
}
2016-09-21 08:52:54 -04:00
doLast {
if (!versionFile.exists()) {
throw new RuntimeException("Can't download the jars without the ${versionFile.name} file!")
}
def version = new JsonSlurper().parseText(FileUtils.readFileToString(versionFile))
logger.lifecycle(":downloading minecraft libraries")
if (!libraries.exists()) {
libraries.mkdirs()
}
version.libraries.each {
def downloadUrl = it.downloads.artifact.url
download {
src downloadUrl
dest new File(libraries, downloadUrl.substring(downloadUrl.lastIndexOf("/") + 1))
overwrite false
}
}
}
2016-09-21 08:52:54 -04:00
}
task mapJar(dependsOn: [downloadMcLibs, build]) {
inputs.files downloadMcLibs.outputs.files.files
outputs.file(mappedFile)
2018-10-27 10:37:37 -04:00
//Force the task to always run
outputs.upToDateWhen {
return true
}
doLast {
logger.lifecycle(":mapping minecraft")
if (mappedFile.exists()) {
mappedFile.delete()
}
def tinyInput = new File("build/libs/pomf-tiny-${pomfVersion}.gz").toPath()
def remapper = TinyRemapper.newRemapper()
.withMappings(TinyUtils.createTinyMappingProvider(tinyInput, "mojang", "pomf"))
.build()
try {
def outputConsumer = new OutputConsumerPath(mappedFile.toPath())
outputConsumer.addNonClassFiles(mergedFile.toPath())
remapper.read(mergedFile.toPath())
libraries.eachFileRecurse(FileType.FILES) {file ->
remapper.read(file.toPath())
}
remapper.apply(mergedFile.toPath(), outputConsumer)
outputConsumer.finish()
remapper.finish()
} catch (Exception e) {
remapper.finish();
throw new RuntimeException("Failed to remap jar", e);
}
}
}