diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
index e585d866..59a44dc5 100644
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -18,7 +18,7 @@ jobs:
uses: actions/setup-java@v3.0.0
with:
distribution: adopt
- java-version: 11
+ java-version: 17
- name: Build LimboAPI
run: ./gradlew build
- name: Upload LimboAPI
diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
index f2fbbd0c..59ccb97b 100644
--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@@ -14,7 +14,7 @@ jobs:
uses: actions/setup-java@v3.0.0
with:
distribution: adopt
- java-version: 11
+ java-version: 17
- name: Build LimboAPI
run: ./gradlew build
- name: Upload LimboAPI
diff --git a/README.md b/README.md
index 2c6ba1d7..57263656 100644
--- a/README.md
+++ b/README.md
@@ -53,7 +53,7 @@ Test server: [``ely.su``](https://hotmc.ru/minecraft-server-203216)
net.elytrium.limboapi
api
- 1.1.16
+ 1.1.17
provided
@@ -70,7 +70,7 @@ Test server: [``ely.su``](https://hotmc.ru/minecraft-server-203216)
}
dependencies {
- compileOnly("net.elytrium.limboapi:api:1.1.16")
+ compileOnly("net.elytrium.limboapi:api:1.1.17")
}
```
diff --git a/VERSION b/VERSION
index 63b283b2..cbb8cbae 100644
--- a/VERSION
+++ b/VERSION
@@ -1 +1 @@
-1.1.16
+1.1.17
diff --git a/api/build.gradle b/api/build.gradle
index 2242a7aa..b7e412d8 100644
--- a/api/build.gradle
+++ b/api/build.gradle
@@ -5,7 +5,12 @@ plugins {
id("maven-publish")
}
-dependencies {
+compileJava() {
+ getOptions().getRelease().set(11)
+ getOptions().setEncoding("UTF-8")
+}
+
+dependencies() {
compileOnly("com.velocitypowered:velocity-api:$velocityVersion")
api("net.elytrium.commons:config:$elytriumCommonsVersion")
api("net.elytrium.commons:utils:$elytriumCommonsVersion")
@@ -14,44 +19,41 @@ dependencies {
api("net.kyori:adventure-nbt:$adventureVersion")
compileOnly("com.github.spotbugs:spotbugs-annotations:$spotbugsVersion")
+
+ annotationProcessor("net.java.dev.jna:jna-platform:5.13.0")
+ annotationProcessor("com.github.bsideup.jabel:jabel-javac-plugin:1.0.0")
}
-license {
+license() {
matching(includes: ["**/mcprotocollib/**"]) {
- setHeader(getRootProject().file("HEADER_MCPROTOCOLLIB.txt"))
+ header = rootProject.file("HEADER_MCPROTOCOLLIB.txt")
}
- setHeader(file("HEADER.txt"))
-}
-
-task javadocJar(type: Jar) {
- getArchiveClassifier().set("javadoc")
- from(javadoc)
+ header = file("HEADER.txt")
}
-javadoc {
- MinimalJavadocOptions options = getOptions()
+javadoc() {
options.setEncoding("UTF-8")
- options.setCharSet("UTF-8")
- // Mark sources as Java 11 source compatible.
options.setSource("11")
- options.links("https://docs.oracle.com/en/java/javase/11/docs/api/", "https://jd.adventure.kyori.net/nbt/4.11.0/")
-
+ options.links("https://docs.oracle.com/en/java/javase/11/docs/api/")
options.addStringOption("Xdoclint:none", "-quiet")
-
- // Remove "undefined" from search paths when generating javadoc for a non-modular project. (JDK-8215291)
- if (JavaVersion.current() == JavaVersion.VERSION_11) {
+ if (JavaVersion.current() >= JavaVersion.VERSION_1_9 && JavaVersion.current() < JavaVersion.VERSION_12) {
options.addBooleanOption("-no-module-directories", true)
}
}
-task sourcesJar(type: Jar) {
- getArchiveClassifier().set("sources")
+tasks.register("sourcesJar", Jar) {
+ archiveClassifier = "sources"
from(sourceSets.main.getAllSource())
}
-publishing {
- repositories {
+tasks.register("javadocJar", Jar) {
+ archiveClassifier = "javadoc"
+ from(javadoc)
+}
+
+publishing() {
+ repositories() {
maven {
credentials {
setUsername(System.getenv("PUBLISH_USERNAME"))
@@ -63,22 +65,20 @@ publishing {
}
}
- publications {
- maven(MavenPublication) {
- from(components.java)
+ publications.create("publication", MavenPublication) {
+ from(components.java)
- artifact(javadocJar)
- artifact(sourcesJar)
- }
+ artifact(javadocJar)
+ artifact(sourcesJar)
}
}
-artifacts {
+artifacts() {
archives(javadocJar)
archives(sourcesJar)
}
-sourceSets.main.getJava().srcDir(
+sourceSets.main.java.srcDir(
getTasks().register("generateTemplates", Copy) {
task -> {
String version = getVersion().contains("-") ? "${getVersion()} (git-${getCurrentShortRevision()})" : getVersion()
diff --git a/api/src/main/java/net/elytrium/limboapi/api/LimboFactory.java b/api/src/main/java/net/elytrium/limboapi/api/LimboFactory.java
index b4e64d52..a8b733a0 100644
--- a/api/src/main/java/net/elytrium/limboapi/api/LimboFactory.java
+++ b/api/src/main/java/net/elytrium/limboapi/api/LimboFactory.java
@@ -189,6 +189,23 @@ public interface LimboFactory {
*/
PreparedPacket createPreparedPacket(ProtocolVersion minVersion, ProtocolVersion maxVersion);
+ /**
+ * Creates new prepared packet builder for the CONFIG state.
+ *
+ * @return new prepared packet.
+ */
+ PreparedPacket createConfigPreparedPacket();
+
+ /**
+ * Creates new prepared packet builder for the CONFIG state.
+ *
+ * @param minVersion Minimum version to prepare.
+ * @param maxVersion Maximum version to prepare.
+ *
+ * @return new prepared packet.
+ */
+ PreparedPacket createConfigPreparedPacket(ProtocolVersion minVersion, ProtocolVersion maxVersion);
+
/**
* Registers self-made packet.
*
diff --git a/api/src/main/java/net/elytrium/limboapi/api/LimboSessionHandler.java b/api/src/main/java/net/elytrium/limboapi/api/LimboSessionHandler.java
index f7afa636..bbc8f387 100644
--- a/api/src/main/java/net/elytrium/limboapi/api/LimboSessionHandler.java
+++ b/api/src/main/java/net/elytrium/limboapi/api/LimboSessionHandler.java
@@ -15,6 +15,10 @@ default void onSpawn(Limbo server, LimboPlayer player) {
}
+ default void onConfig(Limbo server, LimboPlayer player) {
+
+ }
+
default void onMove(double posX, double posY, double posZ) {
}
diff --git a/build.gradle b/build.gradle
index 143bc2c7..f213d2f9 100644
--- a/build.gradle
+++ b/build.gradle
@@ -1,60 +1,55 @@
//file:noinspection GroovyAssignabilityCheck
-plugins {
+plugins() {
id("java")
+
id("checkstyle")
- id("com.github.spotbugs").version("5.0.7").apply(false)
+ id("com.github.spotbugs").version("5.0.14").apply(false)
id("org.cadixdev.licenser").version("0.6.1").apply(false)
}
-allprojects {
+allprojects() {
apply(plugin: "checkstyle")
apply(plugin: "com.github.spotbugs")
apply(plugin: "org.cadixdev.licenser")
setGroup("net.elytrium.limboapi")
- setVersion("1.1.17-SNAPSHOT")
-
- compileJava {
- getOptions().setEncoding("UTF-8")
- }
+ setVersion("1.1.17")
- java {
- setSourceCompatibility(JavaVersion.VERSION_11)
- setTargetCompatibility(JavaVersion.VERSION_11)
+ compileJava() {
+ sourceCompatibility = JavaVersion.VERSION_17
+ targetCompatibility = JavaVersion.VERSION_17
}
- repositories {
+ repositories() {
mavenCentral()
- maven {
+ maven() {
setName("elytrium-repo")
setUrl("https://maven.elytrium.net/repo/")
}
- maven {
+ maven() {
setName("papermc-repo")
setUrl("https://papermc.io/repo/repository/maven-public/")
}
}
- checkstyle {
- setToolVersion("10.3")
- setConfigFile(file("${this.getRootDir()}/config/checkstyle/checkstyle.xml"))
- setConfigProperties("configDirectory": "${this.getRootDir()}/config/checkstyle")
- setMaxErrors(0)
- setMaxWarnings(0)
+ checkstyle() {
+ toolVersion = "10.12.1"
+ configFile = file("$rootDir/config/checkstyle/checkstyle.xml")
+ configProperties = ["configDirectory": "$rootDir/config/checkstyle"]
+ maxErrors = 0
+ maxWarnings = 0
}
- spotbugs {
- setExcludeFilter(file("${this.getRootDir()}/config/spotbugs/suppressions.xml"))
- }
+ spotbugs() {
+ excludeFilter = file("${this.getRootDir()}/config/spotbugs/suppressions.xml")
- spotbugsMain {
- reports {
- html {
- getRequired().set(true)
- getOutputLocation().set(file("${this.getBuildDir()}/reports/spotbugs/main/spotbugs.html"))
- setStylesheet("fancy-hist.xsl")
+ if (this.project != rootProject) {
+ reports.register("html") {
+ required = true
+ outputLocation.value(layout.buildDirectory.file("reports/spotbugs/main/spotbugs.html"))
+ stylesheet = "fancy-hist.xsl"
}
}
}
diff --git a/gradle.properties b/gradle.properties
index 7447910e..fdcd975b 100644
--- a/gradle.properties
+++ b/gradle.properties
@@ -1,4 +1,5 @@
-fastPrepareVersion=1.0.7
+org.gradle.jvmargs=-Xmx4096m
+fastPrepareVersion=1.0.8
velocityVersion=3.2.0-SNAPSHOT
nettyVersion=4.1.86.Final
fastutilVersion=8.5.11
@@ -6,3 +7,4 @@ bstatsVersion=3.0.0
spotbugsVersion=4.7.3
elytriumCommonsVersion=1.2.3
adventureVersion=4.12.0
+manifestUrl=https://launchermeta.mojang.com/mc/game/version_manifest.json
\ No newline at end of file
diff --git a/plugin/build.gradle b/plugin/build.gradle
index e4a2991c..0aa7627a 100644
--- a/plugin/build.gradle
+++ b/plugin/build.gradle
@@ -1,11 +1,23 @@
//file:noinspection GroovyAssignabilityCheck
-plugins {
+buildscript() {
+ dependencies() {
+ classpath("commons-io:commons-io:2.6")
+ classpath("com.google.guava:guava:28.0-jre")
+ }
+}
+
+plugins() {
id("java")
id("com.github.johnrengelman.shadow").version("7.1.2")
}
-dependencies {
+compileJava() {
+ getOptions().getRelease().set(11)
+ getOptions().setEncoding("UTF-8")
+}
+
+dependencies() {
implementation(project(":api"))
implementation("net.elytrium.commons:config:$elytriumCommonsVersion")
implementation("net.elytrium.commons:utils:$elytriumCommonsVersion")
@@ -26,11 +38,14 @@ dependencies {
implementation("org.bstats:bstats-velocity:$bstatsVersion")
compileOnly("com.github.spotbugs:spotbugs-annotations:$spotbugsVersion")
+
+ annotationProcessor("net.java.dev.jna:jna-platform:5.13.0")
+ annotationProcessor("com.github.bsideup.jabel:jabel-javac-plugin:1.0.0")
}
-shadowJar {
+shadowJar() {
getArchiveClassifier().set("")
- setArchiveFileName("limboapi-${version}.${extension}")
+ setArchiveFileName("limboapi-${project.version}.jar")
exclude("META-INF/versions/**")
exclude("net/kyori/**")
@@ -42,7 +57,7 @@ shadowJar {
relocate("net.elytrium.commons.config", "net.elytrium.limboapi.thirdparty.commons.config")
}
-license {
+license() {
matching(includes: ["**/mcprotocollib/**"]) {
setHeader(getRootProject().file("HEADER_MCPROTOCOLLIB.txt"))
}
@@ -53,11 +68,602 @@ license {
setHeader(getRootProject().file("HEADER.txt"))
}
-task finalize {
+tasks.register("finalize") {
doLast {
- file("build/libs/${this.getName()}-${this.getVersion()}.jar").delete()
+ file("build/libs/${project.name}-${project.version}.jar").delete()
}
}
assemble.dependsOn(shadowJar)
build.finalizedBy(finalize)
+
+import groovy.io.FileType
+import groovy.json.JsonOutput
+import groovy.json.JsonSlurper
+import org.apache.commons.io.FilenameUtils
+import org.apache.commons.io.FileUtils
+import com.google.common.hash.Hashing
+import com.google.common.io.Files
+
+import java.nio.file.Path
+import java.util.function.Function
+import java.util.stream.Collectors
+
+enum MinecraftVersion {
+ MINECRAFT_1_7_2(4),
+ MINECRAFT_1_7_6(5),
+ MINECRAFT_1_8(47),
+ MINECRAFT_1_9(107),
+ MINECRAFT_1_9_1(108),
+ MINECRAFT_1_9_2(109),
+ MINECRAFT_1_9_4(110),
+ MINECRAFT_1_10(210),
+ MINECRAFT_1_11(315),
+ MINECRAFT_1_11_1(316),
+ MINECRAFT_1_12(335),
+ MINECRAFT_1_12_1(338),
+ MINECRAFT_1_12_2(340),
+ MINECRAFT_1_13(393),
+ MINECRAFT_1_13_1(401),
+ MINECRAFT_1_13_2(404),
+ MINECRAFT_1_14(477),
+ MINECRAFT_1_14_1(480),
+ MINECRAFT_1_14_2(485),
+ MINECRAFT_1_14_3(490),
+ MINECRAFT_1_14_4(498),
+ MINECRAFT_1_15(573),
+ MINECRAFT_1_15_1(575),
+ MINECRAFT_1_15_2(578),
+ MINECRAFT_1_16(735),
+ MINECRAFT_1_16_1(736),
+ MINECRAFT_1_16_2(751),
+ MINECRAFT_1_16_3(753),
+ MINECRAFT_1_16_4(754),
+ MINECRAFT_1_17(755),
+ MINECRAFT_1_17_1(756),
+ MINECRAFT_1_18(757),
+ MINECRAFT_1_18_2(758),
+ MINECRAFT_1_19(759),
+ MINECRAFT_1_19_1(760),
+ MINECRAFT_1_19_3(761),
+ MINECRAFT_1_19_4(762),
+ MINECRAFT_1_20(763),
+ MINECRAFT_1_20_2(764)
+
+ public static final List WORLD_VERSIONS = List.of(
+ MINECRAFT_1_13,
+ MINECRAFT_1_13_2,
+ MINECRAFT_1_14,
+ MINECRAFT_1_15,
+ MINECRAFT_1_16,
+ MINECRAFT_1_16_2,
+ MINECRAFT_1_17,
+ MINECRAFT_1_19,
+ MINECRAFT_1_19_3,
+ MINECRAFT_1_19_4,
+ MINECRAFT_1_20
+ )
+
+ public static final MinecraftVersion MINIMUM_VERSION = MINECRAFT_1_7_2
+ public static final MinecraftVersion MAXIMUM_VERSION = values()[values().length - 1]
+
+ private static final Map PVN_MAP = new HashMap<>()
+
+ static {
+ int pvn = MINIMUM_VERSION.getProtocolVersion()
+
+ for (MinecraftVersion version : values()) {
+ for (; pvn <= version.getProtocolVersion(); pvn++) {
+ PVN_MAP.put(pvn, version)
+ }
+ }
+ }
+
+ static MinecraftVersion fromPVN(int pvn) {
+ return PVN_MAP.getOrDefault(pvn)
+ }
+
+ static MinecraftVersion fromVersionName(String name) {
+ return valueOf("MINECRAFT_" + name.replace('.', '_'))
+ }
+
+ final int protocolVersion
+
+ MinecraftVersion(int protocolVersion) {
+ this.protocolVersion = protocolVersion
+ }
+
+ int getProtocolVersion() {
+ return this.protocolVersion
+ }
+
+ String getVersionName() {
+ return this.toString().substring(10).replace('_', '.')
+ }
+}
+
+project.ext.dataDirectory = new File(this.getBuildDir(), "minecraft")
+project.ext.manifestDir = new File(dataDirectory, "manifest.json")
+project.ext.generatedDir = new File(this.getBuildDir(), "generated/minecraft")
+
+sourceSets {
+ main {
+ resources {
+ srcDirs += generatedDir
+ }
+ }
+}
+
+tasks.register("downloadManifest") {
+ this.println("> Downloading version manifest...")
+ manifestDir.getParentFile().mkdirs()
+ FileUtils.copyURLToFile(new URL(manifestUrl), manifestDir)
+}
+
+File downloadVersionManifest(String version) {
+ this.println("> Downloading ${version} manifest...")
+
+ Object manifest = new JsonSlurper().parse(manifestDir)
+ def optional = manifest.versions.stream().filter({it.id == version}).findFirst()
+ if (optional.empty()) {
+ throw new RuntimeException("Couldn't find version: ${version}")
+ }
+
+ File output = new File(dataDirectory, "${version}/manifest.json")
+ output.getParentFile().mkdirs()
+ FileUtils.copyURLToFile(new URL(optional.get().url), output)
+ return output
+}
+
+File getGeneratedCache(MinecraftVersion version) {
+ File generated = new File(dataDirectory, "${version.getVersionName()}/generated")
+ return new File(generated, "reports/blocks.json").exists()
+ && new File(generated, "reports/${version >= MinecraftVersion.MINECRAFT_1_14 ? "registries" : "items"}.json").exists()
+ && new File(generated, "data/minecraft/tags").exists()
+ ? generated : null
+}
+
+static boolean validateServer(File file, String expected) {
+ if (file == null || !file.exists()) {
+ return false
+ }
+
+ def hash = Files.asByteSource(file).hash(Hashing.sha1())
+ StringBuilder hashBuilder = new StringBuilder()
+ hash.asBytes().each({hashBuilder.append(Integer.toString((it & 0xFF) + 0x100, 16).substring(1))})
+ return hashBuilder.toString() == expected
+}
+
+File getServerJar(String version) {
+ File manifestFile = this.downloadVersionManifest(version)
+ Object manifest = new JsonSlurper().parse(manifestFile)
+
+ File jarFile = new File(dataDirectory, "${version}/server.jar")
+ if (!validateServer(jarFile, manifest.downloads.server.sha1)) {
+ this.println("> Downloading ${version} server...")
+ jarFile.getParentFile().mkdirs()
+ FileUtils.copyURLToFile(new URL(manifest.downloads.server.url), jarFile)
+ }
+
+ return jarFile
+}
+
+File generateData(MinecraftVersion version) {
+ File cache = getGeneratedCache(version)
+ if (cache != null) {
+ return cache;
+ }
+
+ File jarFile = this.getServerJar(version.getVersionName())
+ File targetDir = new File(jarFile.getParentFile(), "generated")
+
+ try {
+ FileUtils.deleteDirectory(targetDir)
+ } catch (IOException ignored) {
+ // Ignored.
+ }
+
+ String command
+ if (version >= MinecraftVersion.MINECRAFT_1_18) {
+ command = "\"%s\" -DbundlerMainClass=net.minecraft.data.Main -jar \"${jarFile.getAbsolutePath()}\" --reports --server"
+ } else {
+ command = "\"%s\" -cp \"${jarFile.getAbsolutePath()}\" net.minecraft.data.Main --reports --server"
+ }
+
+ exec {
+ if (System.getProperty("os.name").toLowerCase().contains("win")) {
+ File java = new File(System.getProperty("java.home"), "bin/java.exe")
+ commandLine("cmd", "/c", String.format(command, java))
+ } else {
+ File java = new File(System.getProperty("java.home"), "bin/java")
+ commandLine("bash", "-c", String.format(command, java))
+ }
+
+ workingDir(jarFile.getParentFile())
+ }
+
+ return targetDir
+}
+
+static Map> getDefaultProperties(Object data) {
+ Map> defaultProperties = new HashMap<>()
+
+ data.forEach({ key, block ->
+ if (!block.containsKey("properties")) {
+ return
+ }
+
+ for (Object blockState : block.states) {
+ if (!blockState.containsKey("default") || !blockState.default) {
+ continue
+ }
+
+ Map properties = blockState["properties"]
+ defaultProperties.put(key, properties)
+ break
+ }
+ })
+
+ return defaultProperties
+}
+
+static Map> loadFallbackMapping(File file) {
+ Object map = new JsonSlurper().parse(file)
+ return MinecraftVersion.values().collectEntries({ version ->
+ [version, map.getOrDefault(version.toString(), Collections.emptyMap())]
+ })
+}
+
+static Map> loadLegacyMapping(File file) {
+ return new JsonSlurper().parse(file).collectEntries({ version, mapping ->
+ [MinecraftVersion.valueOf(version), mapping.collectEntries({ block, id ->
+ [block, Integer.parseInt(id)]
+ })]
+ })
+}
+
+static int getBlockID(String block,
+ Map> mappings,
+ Map>> properties,
+ Map> fallback,
+ MinecraftVersion version) {
+ Map> defaultProperties
+ if (version >= MinecraftVersion.MINECRAFT_1_13) {
+ defaultProperties = properties[version]
+ } else {
+ defaultProperties = properties[MinecraftVersion.MINECRAFT_1_18_2]
+ }
+
+ String[] split = block.split("\\[")
+ String noArgBlock = split[0]
+
+ MinecraftVersion fallbackVersion = MinecraftVersion.MAXIMUM_VERSION
+ while (fallbackVersion != version) {
+ --fallbackVersion
+ noArgBlock = fallback[fallbackVersion].getOrDefault(noArgBlock, noArgBlock)
+ }
+
+ Map blockProperties = defaultProperties[noArgBlock]
+ String targetBlockID
+ if (blockProperties == null) {
+ targetBlockID = noArgBlock
+ } else {
+ Map currentProperties = new TreeMap<>(blockProperties)
+ if (split.length > 1) {
+ String[] args = split[1].split(",")
+ Map input = Arrays.stream(args)
+ .map(arg -> arg.replace("]", "").split("="))
+ .collect(Collectors.toMap(parts -> parts[0], parts -> parts[1]))
+
+ input.forEach({ key, value ->
+ if (currentProperties.containsKey(key)) {
+ currentProperties.put(key, value)
+ }
+ })
+ }
+
+ targetBlockID = noArgBlock + Arrays.toString(
+ currentProperties.collect({ k, v -> k + "=" + v }).toArray()
+ ).replace(" ", "")
+ }
+
+ Integer id = mappings[version][targetBlockID]
+ if (id == null && blockProperties != null) {
+ targetBlockID = noArgBlock + Arrays.toString(
+ new TreeMap<>(blockProperties).collect({ k, v -> k + "=" + v }).toArray()
+ ).replace(" ", "")
+ id = mappings[version][targetBlockID]
+ }
+
+ if (id == null) {
+ System.err.println("No ${version.getVersionName()} fallback data for ${noArgBlock}, replacing with minecraft:stone")
+ id = 1
+ }
+
+ return id
+}
+
+static Map getBlockMappings(Object data, Map> defaultPropertiesMap) {
+ Map mapping = new HashMap<>()
+
+ data.forEach({ blockID, blockData ->
+ for (Object blockState : blockData.states) {
+ int protocolID = blockState.id
+
+ if (blockState.containsKey("properties")) {
+ Map stateProperties = blockState["properties"]
+ Map properties = new TreeMap<>(
+ defaultPropertiesMap.getOrDefault(blockID, Collections.emptyMap()))
+
+ properties.putAll(stateProperties)
+
+ String stateID = blockID + Arrays.toString(
+ properties.collect({ k, v -> k + "=" + v }).toArray()
+ ).replace(" ", "")
+
+ mapping.put(stateID, protocolID)
+ } else {
+ mapping.put(blockID, protocolID)
+ }
+ }
+ })
+
+ return mapping
+}
+
+void generateBlockMappings(File targetDir, Map blockReports) {
+ this.println("> Generating default block properties...")
+
+ Map>> defaultProperties =
+ blockReports.collectEntries({ version, report ->
+ [version, getDefaultProperties(report)]
+ })
+
+ new File(targetDir, "defaultblockproperties.json").write(JsonOutput.prettyPrint(
+ JsonOutput.toJson(defaultProperties[MinecraftVersion.MAXIMUM_VERSION].sort())), "UTF-8")
+
+ this.println("> Generating blockstates...")
+
+ Map> mappings = loadLegacyMapping(
+ new File(this.getProjectDir(), "mapping/legacyblockmapping.json"))
+
+ blockReports.forEach({ version, report ->
+ mappings.put(version, getBlockMappings(report, defaultProperties[version]))
+ })
+
+ Map blocks = mappings[MinecraftVersion.MAXIMUM_VERSION]
+
+ new File(targetDir, "blockstates.json").write(
+ JsonOutput.prettyPrint(JsonOutput.toJson(
+ blocks.sort(Map.Entry::getValue)
+ .collectEntries({ k, v -> [k, String.valueOf(v)] })
+ )), "UTF-8")
+
+ this.println("> Generating blockstates mapping...")
+
+ Map> fallbackMapping = loadFallbackMapping(
+ new File(this.getProjectDir(), "mapping/fallbackdata.json"))
+
+ Map> blockstateMapping = new LinkedHashMap<>()
+ blocks.sort(Map.Entry::getValue)
+ .forEach({ block, modernID ->
+ Map blockMapping = new LinkedHashMap<>()
+
+ int lastID = -1
+ for (MinecraftVersion version : MinecraftVersion.values()) {
+ int id = getBlockID(block, mappings, defaultProperties, fallbackMapping, version)
+ if (lastID != id) {
+ blockMapping.put(version.getVersionName(), String.valueOf(lastID = id))
+ }
+ }
+
+ blockstateMapping.put(String.valueOf(modernID), blockMapping)
+ })
+
+ new File(targetDir, "blockstates_mapping.json").write(
+ JsonOutput.prettyPrint(JsonOutput.toJson(blockstateMapping)), "UTF-8")
+
+ this.println("> Generating legacy blocks...")
+
+ Map legacyData = new JsonSlurper().parse(
+ new File(this.getProjectDir(), "mapping/legacyblocks.json"))
+
+ legacyData = legacyData.collectEntries({ legacy, modern ->
+ [legacy, String.valueOf(getBlockID(modern, mappings, defaultProperties, fallbackMapping, MinecraftVersion.MAXIMUM_VERSION))]
+ })
+
+ new File(targetDir, "legacyblocks.json").write(
+ JsonOutput.prettyPrint(JsonOutput.toJson(legacyData)), "UTF-8")
+}
+
+static Map> sortRegistryMapping(Map> mapping) {
+ return mapping.collectEntries({ modernID, map ->
+ [modernID, map.sort({
+ if (it.getKey().contains(".")) {
+ return MinecraftVersion.fromVersionName(it.getKey())
+ } else {
+ return MinecraftVersion.MINIMUM_VERSION
+ }
+ })]
+ }).sort()
+}
+
+void generateRegistryMapping(String target, File targetDir, Map registriesReports) {
+ this.println("> Generating ${target}s...")
+
+ Map> idMap =
+ registriesReports.collectEntries({ version, registry ->
+ Object entries = registry["minecraft:${target}"].entries
+ return [version, entries.collectEntries({ name, id -> [name, String.valueOf(id["protocol_id"])] })]
+ })
+
+ Map modernIDs = Collections.max(idMap.entrySet(), Map.Entry.comparingByKey()).getValue()
+
+ new File(targetDir, "${target}s.json").write(JsonOutput.prettyPrint(
+ JsonOutput.toJson(modernIDs.sort({Integer.parseInt(it.getValue()) }))), "UTF-8")
+
+ this.println("> Generating ${target}s mapping...")
+
+ Map> mapping = new JsonSlurper()
+ .parse(new File(this.getProjectDir(), "mapping/legacy_${target}s_mapping.json"))
+ .collectEntries({ key, value -> [modernIDs[key], value] })
+
+ idMap.forEach({ version, ids ->
+ ids.forEach({ key, id ->
+ if (!modernIDs.containsKey(key)) {
+ return
+ }
+
+ mapping.computeIfAbsent(modernIDs[key], _ -> new LinkedHashMap<>()).put(version.getVersionName(), id)
+ })
+ })
+
+ mapping = sortRegistryMapping(mapping)
+ new File(targetDir, "${target}s_mapping.json").write(JsonOutput.prettyPrint(
+ JsonOutput.toJson(mapping.sort({ Integer.parseInt(it.getKey()) }))), "UTF-8")
+}
+
+void generateRegistryMappings(File targetDir, Map registriesReports) {
+ this.generateRegistryMapping("item", targetDir, registriesReports
+ .findAll({ e -> MinecraftVersion.WORLD_VERSIONS.contains(e.getKey()) }))
+ this.generateRegistryMapping("block", targetDir, registriesReports)
+
+ this.println("> Generating blockentities mapping...")
+
+ Map> blockentities = new JsonSlurper()
+ .parse(new File(this.getProjectDir(), "mapping/legacy_blockentities_mapping.json"))
+
+ registriesReports.forEach({ version, registries ->
+ if (version < MinecraftVersion.MINECRAFT_1_19) {
+ return
+ }
+
+ registries["minecraft:block_entity_type"].entries.forEach({ key, value ->
+ int id = value.protocol_id
+ blockentities.computeIfAbsent(key, _ -> new LinkedHashMap<>())
+ .put(version.getVersionName(), String.valueOf(id))
+ })
+ })
+
+ blockentities = sortRegistryMapping(blockentities)
+ new File(targetDir, "blockentities_mapping.json").write(
+ JsonOutput.prettyPrint(JsonOutput.toJson(blockentities)), "UTF-8")
+}
+
+static Map>> getTags(File tagDir, Map tagTypes) {
+ Map>> tags = new LinkedHashMap<>()
+
+ tagTypes.forEach({ directory, key ->
+ File directoryFile = new File(tagDir, directory)
+ if (!directoryFile.exists()) {
+ return
+ }
+
+ Map> typeTags = new HashMap<>()
+ Map> tempTags = new HashMap<>()
+
+ directoryFile.eachFileRecurse(FileType.FILES, { file ->
+ List values = new JsonSlurper().parse(file).values
+ Path relativePath = directoryFile.toPath().relativize(file.toPath())
+ String name = FilenameUtils.removeExtension(relativePath.toString()).replace(File.pathSeparator, "/")
+ typeTags.put("minecraft:" + name, values)
+ })
+
+ boolean flatten = false
+ while (!flatten) {
+ flatten = true
+
+ typeTags.forEach({ name, currentTags ->
+ List newTags = new ArrayList<>()
+ currentTags.forEach({ currentTag ->
+ if (currentTag.startsWith("#")) {
+ newTags.addAll(typeTags.get(currentTag.substring(1)))
+ flatten = false
+ } else {
+ newTags.add(currentTag)
+ }
+ })
+
+ tempTags.put(name, newTags)
+ })
+
+ typeTags = tempTags
+ tempTags = new HashMap<>()
+ }
+
+ tags.put(key, typeTags)
+ })
+
+ return tags
+}
+
+void generateTags(File targetDir, Map tagDirs) {
+ this.println("> Generating tags...")
+
+ Map tagTypes = new JsonSlurper().parse(new File(getProjectDir(), "mapping/tag_types.json"))
+
+ Map>>> allTags =
+ tagDirs.collectEntries({ version, dir ->
+ [version, getTags(dir, tagTypes.tag_types)]
+ })
+
+ Map>> mergedTags = new LinkedHashMap<>()
+
+ allTags.forEach({ version, tags ->
+ tags.forEach({ type, typeTags -> {
+ Map> mergedTypeTags = mergedTags.computeIfAbsent(type, _ -> new HashMap<>())
+ typeTags.forEach({ name, values ->
+ Set mergedValues = mergedTypeTags.computeIfAbsent(name, _ -> new HashSet<>())
+ if (!tagTypes.supported_tag_types.contains(type)) {
+ return
+ }
+
+ mergedValues.addAll(values)
+ })
+ }})
+ })
+
+ mergedTags = mergedTags.collectEntries({ type, typeTags ->
+ [type, typeTags.collectEntries({ name, values ->
+ [name, values.sort()]
+ }).sort()]
+ })
+
+ new File(targetDir, "tags.json").write(JsonOutput.prettyPrint(JsonOutput.toJson(mergedTags)), "UTF-8")
+}
+
+tasks.register("generateMappings") {
+ dependsOn(downloadManifest)
+
+ File targetDir = new File(generatedDir, "mapping")
+ targetDir.mkdirs()
+
+ this.println("> Generating Minecraft data...")
+
+ Map generated = Arrays.stream(MinecraftVersion.values())
+ .dropWhile({ it < MinecraftVersion.MINECRAFT_1_13 })
+ .collect(Collectors.toMap(Function.identity(), this::generateData))
+
+ Map blockReports = generated.collectEntries({ version, directory ->
+ [version, new JsonSlurper().parse(new File(directory, "reports/blocks.json"))]
+ })
+
+ this.generateBlockMappings(targetDir, blockReports)
+
+ Map registriesReports = generated
+ .findAll({ it.getKey() >= MinecraftVersion.MINECRAFT_1_14 })
+ .collectEntries({ version, directory ->
+ [version, new JsonSlurper().parse(new File(directory, "reports/registries.json"))]
+ })
+
+ this.generateRegistryMappings(targetDir, registriesReports)
+
+ Map