Sponge v3 and Lite v1-v4 support

Author: emyfops

common/src/main/kotlin/com/lambda/util/extension/Nbt.kt

@@ -29,6 +29,13 @@ fun NbtCompound.putIntList(key: String, vararg values: Int) {
     put(key, values.fold(NbtList()) { list, value -> list.add(NbtInt.of(value)); list })
 }
 
+/**
+ * Deletes all the keys in a compound
+ */
+fun NbtCompound.clear() {
+    keys.forEach { remove(it) }
+}
+
 /**
  * Retrieves a vector from a tuple
  */

common/src/main/kotlin/com/lambda/util/extension/Structures.kt

@@ -19,6 +19,7 @@ package com.lambda.util.extension
 
 import com.lambda.Lambda.mc
 import com.lambda.util.VarIntIterator
+import com.lambda.util.math.MathUtils.logCap
 import com.lambda.util.world.FastVector
 import com.lambda.util.world.fastVectorOf
 import com.lambda.util.world.x
@@ -31,6 +32,7 @@ import net.minecraft.nbt.NbtList
 import net.minecraft.registry.RegistryEntryLookup
 import net.minecraft.structure.StructureTemplate
 import kotlin.experimental.and
+import kotlin.math.abs
 
 private fun positionFromIndex(width: Int, length: Int, index: Int): FastVector {
     val y = index / (width * length)
@@ -49,8 +51,11 @@ fun StructureTemplate.readNbtOrException(
 fun StructureTemplate.readSpongeOrException(
     lookup: RegistryEntryLookup<Block>,
     nbt: NbtCompound,
-): Throwable? = when (nbt.getInt("Version")) {
-    1, 2, 3 -> readSpongeV1OrException(lookup, nbt)
+): Throwable? = when (nbt.getInt("Version") +
+        nbt.getCompound("Schematic").getInt("Version"))
+{
+    1, 2 -> readSpongeV1OrException(lookup, nbt)
+    3 -> readSpongeV3OrException(lookup, nbt)
     else -> IllegalStateException("Invalid sponge schematic version")
 }
 
@@ -86,12 +91,8 @@ private fun StructureTemplate.readSpongeV1OrException(
     //     ?.takeIf { 274945015809L times 16 < it } ?: 0L
 
     val palette = nbt.getCompound("Palette")
-
-    val paletteMax = nbt.getInt("PaletteMax")
     val newPalette = NbtList()
 
-    if (palette.size != paletteMax) return IllegalStateException("Block palette size does not match the provided size (corrupted?)")
-
     palette.keys
         .sortedBy { palette.getInt(it) }
         .forEach { key ->
@@ -143,16 +144,89 @@ private fun StructureTemplate.readSpongeV3OrException(
     lookup: RegistryEntryLookup<Block>,
     nbt: NbtCompound,
 ): Throwable? {
-    // Third revision
-    // - 3D Biome support
-    // - Rename Palette to BlockPalette
-    // - Wordsmithing varint and palette usages
-    nbt.put("Palette", nbt.getCompound("BlockPalette"))
+    val schematic = nbt.getCompound("Schematic")
+    val blocks = schematic.getCompound("Blocks")
+
+    schematic.put("Palette", blocks.getCompound("Palette"))
+    schematic.putByteArray("BlockData", blocks.getByteArray("Data"))
+
+    nbt.clear()
+    nbt.copyFrom(schematic)
 
     return readSpongeV1OrException(lookup, nbt)
 }
 
 fun StructureTemplate.readLitematicaOrException(
     lookup: RegistryEntryLookup<Block>,
     nbt: NbtCompound,
-): Throwable = NotImplementedError("Litematica is not supported, you can help by contributing to the project")
+): Throwable? {
+    val version = nbt.getInt("MinecraftDataVersion")
+
+    val metadata = nbt.getCompound("Metadata")
+    val author = metadata.getString("Author")
+
+    val dimension = metadata.getVector("EnclosingSize")
+
+    val newPalette = NbtList()
+    val newBlocks = NbtList()
+
+    val regions = nbt.getCompound("Regions")
+    regions.keys.map { regions.getCompound(it) }
+        .forEach {
+            val position = it.getVector("Position")
+            val size = it.getVector("Size")
+
+            val xSizeAbs = abs(size.x)
+            val ySizeAbs = abs(size.y)
+            val zSizeAbs = abs(size.z)
+
+            if (size.x < 0) position.x %= size.x + 1
+            if (size.y < 0) position.y %= size.y + 1
+            if (size.z < 0) position.z %= size.z + 1
+
+            // The litematic's block state palette is the same as nbt
+            newPalette.addAll(it.getList("BlockStatePalette", 10))
+
+            val palette = it.getLongArray("BlockStates")
+            val bits = palette.size.logCap(2)
+            val maxEntryValue = (1 shl bits) - 1L
+
+            for (x in 0 until xSizeAbs) {
+                for (y in 0 until ySizeAbs) {
+                    for (z in 0 until zSizeAbs) {
+                        val index = (y * xSizeAbs * zSizeAbs) + z * xSizeAbs + x
+
+                        val startOffset = index * bits
+                        val startArrIndex = startOffset / 64
+                        val endArrIndex = ((index + 1) * bits - 1) / 64
+                        val startBitOffset = startOffset % 64
+
+
+                        val stateId = if (startArrIndex == endArrIndex) {
+                            palette[startArrIndex] ushr startBitOffset and maxEntryValue
+                        } else {
+                            (palette[startArrIndex] ushr startBitOffset or palette[endArrIndex] shl (64 - startBitOffset)) and maxEntryValue
+                        }
+
+                        newBlocks.add(NbtCompound().apply {
+                            putIntList("pos", x, y, z)
+                            putInt("state", stateId.toInt())
+                        })
+                    }
+                }
+            }
+        }
+
+    // Construct a structure compatible nbt compound
+    nbt.putInt("DataVersion", version)
+    nbt.putIntList("size", dimension.x, dimension.y, dimension.z)
+    nbt.put("palette", newPalette)
+    nbt.put("blocks", newBlocks)
+    nbt.putString("author", author)
+
+    // Fix the data for future versions
+    DataFixTypes.STRUCTURE.update(mc.dataFixer, nbt, version)
+
+    // Use the StructureTemplate NBT read utils in order to construct the template
+    return readNbtOrException(lookup, nbt)
+}

common/src/main/kotlin/com/lambda/util/math/MathUtils.kt

@@ -38,6 +38,7 @@ object MathUtils {
 
     fun Double.floorToInt() = floor(this).toInt()
     fun Double.ceilToInt() = ceil(this).toInt()
+    fun Int.logCap(minimum: Int) = max(minimum.toDouble(), ceil(log2(toDouble()))).toInt()
 
     fun <T : Number> T.roundToStep(step: T): T {
         val stepD = step.toDouble()

common/src/main/resources/lambda.accesswidener

@@ -67,6 +67,11 @@ accessible field net/minecraft/network/packet/c2s/login/LoginKeyC2SPacket nonce
 accessible method net/minecraft/network/packet/c2s/play/PlayerInteractEntityC2SPacket <init> (IZLnet/minecraft/network/packet/c2s/play/PlayerInteractEntityC2SPacket$InteractTypeHandler;)V
 accessible field net/minecraft/network/packet/c2s/play/PlayerInteractEntityC2SPacket ATTACK Lnet/minecraft/network/packet/c2s/play/PlayerInteractEntityC2SPacket$InteractTypeHandler;
 
+# Math
+accessible method net/minecraft/util/math/Vec3i setX (I)Lnet/minecraft/util/math/Vec3i;
+accessible method net/minecraft/util/math/Vec3i setY (I)Lnet/minecraft/util/math/Vec3i;
+accessible method net/minecraft/util/math/Vec3i setZ (I)Lnet/minecraft/util/math/Vec3i;
+
 # Other
 accessible field net/minecraft/world/explosion/Explosion behavior Lnet/minecraft/world/explosion/ExplosionBehavior;
 accessible field net/minecraft/structure/StructureTemplate blockInfoLists Ljava/util/List;