build.gradle

buildscript {
	repositories {
		//jcenter()
		maven {
			name "Modmuss50 Repository"
			url 'https://maven.modmuss50.me'
		}
		maven {
			name "Jitpack"
			url 'https://jitpack.io/'
		}
	}
	dependencies {
		classpath "commons-io:commons-io:2.6"
		classpath "org.apache.commons:commons-compress:1.19"
		classpath "com.google.guava:guava:28.0-jre"
		classpath 'de.undercouch:gradle-download-task:3.4.3'
		classpath "cuchaz:enigma-cli:0.27.1"
		classpath 'net.fabricmc:tiny-remapper:0.1.0.40' //Newer versions will need createMappingsProvider updating
		classpath 'com.github.Chocohead:Stitch:8befa96d4b'
		classpath 'com.github.Chocohead:tiny-mappings-parser:337c8b6'
	}
}

plugins {
	id 'java'
	id 'de.undercouch.download' version '4.1.1'
	id 'maven-publish'
}

def minecraft_version = "b1.7.3"

def ENV = System.getenv()
def build_number = 22

def plasmaVersion = "${minecraft_version}-build.$build_number"


repositories {
	mavenCentral()
	maven {
		name "Modmuss50 Repository"
		url 'https://maven.modmuss50.me'
	}
	maven {
		name "Jitpack"
		url 'https://jitpack.io/'
	}
}

configurations {
	enigmaRuntime {
		resolutionStrategy {
			cacheDynamicVersionsFor 0, "seconds"
			cacheChangingModulesFor 0, "seconds"
		}
	}
}

dependencies {
	enigmaRuntime "cuchaz:enigma-swing:0.27.1"
	enigmaRuntime 'com.github.Chocohead:Stitch:8befa96d4b'
}

def mappingsDir = file("mappings")
def cacheFilesMinecraft = file(".gradle/minecraft")
def tempDir = file(".gradle/temp")
def mergedJar = file("${minecraft_version}-merged.jar")
def clientIntermediaryJar = new File(cacheFilesMinecraft, "${minecraft_version}-client-intermediary.jar")
def serverIntermediaryJar = new File(cacheFilesMinecraft, "${minecraft_version}-server-intermediary.jar")
def namedJar = file("${minecraft_version}-named.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")
def libs = new File(buildDir, "libs")

import groovy.io.FileType
import groovy.json.JsonSlurper

import org.apache.commons.compress.archivers.zip.ZipArchiveEntry;
import org.apache.commons.compress.archivers.zip.ZipArchiveInputStream;
import org.apache.commons.io.FileUtils

import com.google.common.hash.Hashing
import com.google.common.io.Files

import cuchaz.enigma.command.CheckMappingsCommand
import cuchaz.enigma.command.ConvertMappingsCommand
import cuchaz.enigma.command.MapSpecializedMethodsCommand

import net.fabricmc.stitch.commands.CommandCorrectMappingUnions
import net.fabricmc.stitch.commands.CommandFixNesting
import net.fabricmc.stitch.commands.CommandMergeTiny
import net.fabricmc.stitch.commands.CommandRewriteIntermediary
import net.fabricmc.stitch.merge.JarMerger
import net.fabricmc.tinyremapper.OutputConsumerPath
import net.fabricmc.tinyremapper.TinyRemapper
import net.fabricmc.tinyremapper.TinyUtils
import net.fabricmc.mappings.ClassEntry
import net.fabricmc.mappings.MethodEntry
import net.fabricmc.mappings.FieldEntry
import net.fabricmc.mappings.EntryTriple
import net.fabricmc.mappings.Mappings
import net.fabricmc.mappings.MappingsProvider
import net.fabricmc.tinyremapper.IMappingProvider
import net.fabricmc.tinyremapper.MemberInstance

import java.util.concurrent.TimeUnit
import java.util.zip.GZIPOutputStream

boolean validateChecksum(File file, String checksum) {
	if (file != null) {
		def hash = Files.asByteSource(file).hash(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")
	logger.info(manifestFile.absolutePath)
	outputs.file(manifestFile)
	doLast {
		logger.lifecycle(":downloading minecraft versions manifest")
		if (manifestFile.exists()) {
			if (FileUtils.isFileOlder(manifestFile, System.currentTimeMillis() - TimeUnit.MILLISECONDS.convert(1, TimeUnit.DAYS))) {
				logger.info("Manifest was more than than 1 day old, redownloading.")
				FileUtils.copyURLToFile(new URL("https://launchermeta.mojang.com/mc/game/version_manifest.json"), manifestFile)
			} else {
				logger.info("Manifest already existed, and is up to date enough.")
			}
		} else {
			logger.info("Manifest did not exist, downloading.")
			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}")
		}
	}
}

task downloadMcJars(dependsOn: downloadWantedVersionManifest) {

	inputs.files versionFile

	outputs.files(clientJar, serverJar)

	outputs.upToDateWhen {
		def version = new JsonSlurper().parseText(FileUtils.readFileToString(versionFile))
		return clientJar.exists() && serverJar.exists() && validateChecksum(clientJar, version.downloads.client.sha1) && validateChecksum(serverJar, "2f90dc1cb5ca7e9d71786801b307390a67fcf954")
	}

	doLast {
		if (!versionFile.exists()) {
			throw new RuntimeException("Can't download the jars without the ${versionFile.name} file!")
		}

		//reload in case it changed
		def version = new JsonSlurper().parseText(FileUtils.readFileToString(versionFile))

		logger.lifecycle(":downloading minecraft jars")

		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 1server")
//			FileUtils.copyURLToFile(new URL(version.downloads.server.url), serverJar)
//		}
		if (!serverJar.exists() || !validateChecksum(serverJar, "2f90dc1cb5ca7e9d71786801b307390a67fcf954")) {
			logger.lifecycle(":downloading minecraft server")
			URL url = new URL("https://cdn.discordapp.com/attachments/369990015096455168/500081541196546049/b1.7.3.zip");

			HttpURLConnection connection = (HttpURLConnection) url.openConnection();
			connection.setRequestProperty("User-Agent", "Mozilla/5.0"); //Discord wants some kind of user agent before it lets you download things

			new ZipArchiveInputStream(connection.getInputStream()).with {stream ->
				ZipArchiveEntry entry;
				while ((entry = stream.getNextZipEntry()) != null) {
					if ("b1.7.3/minecraft_server.jar".equals(entry.getName())) {
						FileUtils.copyToFile(stream, serverJar);
						break;
					}
				}
			}
		}
	}
}

task downloadMcLibs(dependsOn: downloadWantedVersionManifest) {
	inputs.files versionFile

	outputs.dir(libraries)

	outputs.upToDateWhen {
		return false
	}

	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
			if (downloadUrl == null) return

			download {
				src downloadUrl
				dest new File(libraries, downloadUrl.substring(downloadUrl.lastIndexOf("/") + 1))
				overwrite false
			}
		}
	}
}

task downloadIntermediary(type: Download) {
	//TODO: Don't hardcode me to just these Intermediaries
	def url = "https://gist.githubusercontent.com/Chocohead/b7ea04058776495a93ed2d13f34d697a/raw/Beta 1.7.3 Merge.tiny"
	src url.replaceAll(" ", "%20")
	dest new File(cacheFilesMinecraft, "${minecraft_version}-intermediary.tiny")
}

task remapClientJar(dependsOn: [downloadMcJars, downloadMcLibs, downloadIntermediary]) {
	inputs.file clientJar
	inputs.files downloadMcLibs.outputs.files.files
	outputs.file clientIntermediaryJar

	doLast {
		logger.lifecycle(":mapping client to intermediary")
		mapJar(clientIntermediaryJar, clientJar, downloadIntermediary.dest, libraries, "client", "intermediary")
	}
}

task remapServerJar(dependsOn: [downloadMcJars, downloadMcLibs, downloadIntermediary]) {
	inputs.file serverJar
	inputs.files downloadMcLibs.outputs.files.files
	outputs.file serverIntermediaryJar

	doLast {
		logger.lifecycle(":mapping server to intermediary")
		mapJar(serverIntermediaryJar, serverJar, downloadIntermediary.dest, libraries, "server", "intermediary")
	}
}

task mergeJars(dependsOn: [remapClientJar, remapServerJar]) {
	inputs.files([clientIntermediaryJar, serverIntermediaryJar])
	outputs.file(mergedJar)

	doLast {
		logger.lifecycle(":merging jars")

		if (mergedJar.exists()) {
			return
		}

		def jarMerger = new JarMerger(clientIntermediaryJar, serverIntermediaryJar, mergedJar)
		jarMerger.merge()
		jarMerger.close()

		CommandFixNesting.run(mergedJar)
	}
}

task setupPlasma(dependsOn: mergeJars) {

}

task plasma(dependsOn: setupPlasma) {
	doLast {
		ant.setLifecycleLogLevel "WARN"
		ant.java(
			classname: 'cuchaz.enigma.gui.Main',
			classpath: configurations.enigmaRuntime.asPath,
			fork: true,
			spawn: true
		) {
			jvmarg(value: "-Xmx2048m")
			arg(value: '-jar')
			arg(value: mergedJar.getAbsolutePath())
			arg(value: '-mappings')
			arg(value: mappingsDir.getAbsolutePath())
			arg(value: '-profile')
			arg(value: 'enigma_profile.json')
		}
	}
}

task buildEnigma(type: Zip) {
	from mappingsDir
	include "**/*"
	archiveName "plasma-enigma-${plasmaVersion}.zip"
	destinationDir(libs)
}

task checkMappings {
	inputs.dir mappingsDir
	doLast {
		logger.lifecycle(":checking mappings")

		String[] args = [
			mergedJar.getAbsolutePath(),
			mappingsDir.getAbsolutePath()
		]

		new CheckMappingsCommand().run(args)
	}
}

task buildYarnTiny(dependsOn: "mergeJars", type: FileOutput) {
	inputs.dir mappingsDir
	if (!libs.exists()) {
		libs.mkdirs()
	}

	def plasmaTiny = new File(tempDir, "plasma-mappings.tiny")
	fileOutput = plasmaTiny

	outputs.upToDateWhen { return false }

	doLast {
		logger.lifecycle(":generating tiny mappings")

		new MapSpecializedMethodsCommand().run(
			mergedJar.getAbsolutePath(),
			'enigma',
			mappingsDir.getAbsolutePath(),
			'tiny:intermediary:named',
			plasmaTiny.getAbsolutePath()
		)
	}
}

task mergeTiny(dependsOn: [downloadIntermediary, buildYarnTiny], type: FileOutput) {
	def plasmaTinyInput = buildYarnTiny.fileOutput

	def outputFile = new File(tempDir, "mappings.tiny")
	outputs.file(outputFile)
	fileOutput = outputFile

	outputs.upToDateWhen { return false }

	doLast {
		logger.lifecycle(":merging plasma and intermediary")
		String[] args = [
			downloadIntermediary.dest.getAbsolutePath(),
			plasmaTinyInput.getAbsolutePath(),
			outputFile.getAbsolutePath()
		]

		new CommandMergeTiny().run(args)
		CommandCorrectMappingUnions.run(outputFile.toPath(), "intermediary", "named")
	}
}

task tinyJar(type: Jar, dependsOn: "mergeTiny") {
	outputs.upToDateWhen { return false }
	archiveName = "plasma-${plasmaVersion}.jar"
	destinationDir(libs)
	classifier = ""
	from(mergeTiny.fileOutput) {
		rename { "mappings/mappings.tiny" }
	}
}

task compressTiny(dependsOn: ["tinyJar", "mergeTiny"], type: FileOutput) {
	def outputFile = new File(libs, "plasma-tiny-${plasmaVersion}.gz")
	outputs.file(outputFile)
	fileOutput = outputFile

	def inputFile = mergeTiny.fileOutput

	outputs.upToDateWhen { return false }

	doLast {
		logger.lifecycle(":compressing tiny mappings")

		def buffer = new byte[1024]
		def fileOutputStream = new FileOutputStream(outputFile)
		def outputStream = new GZIPOutputStream(fileOutputStream)
		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()
	}
}

clean.doFirst {
	delete tempDir, cacheFilesMinecraft
}

tasks.build.dependsOn "compressTiny"
tasks.build.dependsOn "buildEnigma"
tasks.build.dependsOn "tinyJar"

task mapNamedJar(dependsOn: [mergeJars, mergeTiny]) {
	inputs.files downloadMcLibs.outputs.files.files
	outputs.file(namedJar)

	//Force the task to always run
	outputs.upToDateWhen {
		return false
	}

	doLast {
		logger.lifecycle(":mapping minecraft to named")

		mapJar(namedJar, mergedJar, mergeTiny.fileOutput, libraries, "intermediary", "named")
	}
}

publishing {
	publications {
		maven(MavenPublication) {
			groupId 'io.github.minecraft-cursed-legacy'
			artifactId "plasma"
			version plasmaVersion

			artifact(compressTiny.fileOutput) {
				classifier "tiny"
				builtBy compressTiny
			}
			artifact(buildEnigma) {
				classifier "enigma"
			}
			artifact(tinyJar)
		}
	}
	repositories {
		maven {
			def mavenUrl = project.hasProperty('maven_url') ? project.property('maven_url') : ""
			url mavenUrl
			if(mavenUrl.startsWith("http")) {
				credentials {
					username project.hasProperty('maven_username') ? project.property('maven_username') : ""
					password project.hasProperty('maven_password') ? project.property('maven_password') : ""
				}
			}
		}
	}
}

IMappingProvider createMappingsProvider(input, from, to) {
	Mappings mappings = MappingsProvider.readTinyMappings(java.nio.file.Files.newInputStream(input), false)
	return {classMap, fieldMap, methodMap ->
		for (ClassEntry entry : mappings.getClassEntries()) {
			classMap.put(entry.get(from), entry.get(to));
		}

		for (FieldEntry entry : mappings.getFieldEntries()) {
			EntryTriple fromTriple = entry.get(from);
			if (fromTriple == null) continue;
			fieldMap.put(fromTriple.getOwner() + "/" + MemberInstance.getFieldId(fromTriple.getName(), fromTriple.getDesc()), entry.get(to).getName());
		}

		for (MethodEntry entry : mappings.getMethodEntries()) {
			EntryTriple fromTriple = entry.get(from);
			if (fromTriple == null) continue;
			methodMap.put(fromTriple.getOwner() + "/" + MemberInstance.getMethodId(fromTriple.getName(), fromTriple.getDesc()), entry.get(to).getName());
		}
	};
}

void mapJar(File output, File input, File mappings, File libraries, String from, String to) {
	if (output.exists()) {
		output.delete()
	}

	def remapper = TinyRemapper.newRemapper()
		.withMappings(createMappingsProvider(mappings.toPath(), from, to))
		.renameInvalidLocals(true)
		.rebuildSourceFilenames(true)
		.build()

	try {
		def outputConsumer = new OutputConsumerPath(output.toPath())
		outputConsumer.addNonClassFiles(input.toPath())
		remapper.readInputs(input.toPath())

		libraries.eachFileRecurse(FileType.FILES) { file ->
			remapper.readClassPath(file.toPath())
		}
		remapper.apply(outputConsumer)
		outputConsumer.close()
		remapper.finish()
	} catch (Exception e) {
		remapper.finish()
		throw new RuntimeException("Failed to remap jar", e);
	}
}

class FileOutput extends DefaultTask {
	@OutputFile
	File fileOutput
}