Cleanup

Author: Avanatiker

common/src/main/kotlin/com/lambda/interaction/construction/StructureRegistry.kt

@@ -29,8 +29,7 @@ import kotlin.io.path.*
  */
 @OptIn(ExperimentalPathApi::class)
 @Suppress("JavaIoSerializableObjectMustHaveReadResolve")
-object StructureRegistry
-    : ConcurrentHashMap<String, StructureTemplate?>(), Loadable {
+object StructureRegistry : ConcurrentHashMap<String, StructureTemplate?>(), Loadable {
     private val levelSession = mc.levelStorage.createSession(FolderRegister.structure.path)
     private val structurePath = levelSession.getDirectory(WorldSavePath.ROOT).normalize()
     private val pathWatcher = FileSystems.getDefault().newWatchService()
@@ -39,12 +38,12 @@ object StructureRegistry
     /**
      * Map of file suffix to their respective read function
      */
-    val serializers = mapOf(
+    private val serializers = mapOf(
         "nbt" to StructureTemplate::readNbtOrException,
         "schem" to StructureTemplate::readSpongeOrException,
         "litematica" to StructureTemplate::readLitematicaOrException,
 
-        // Not supported, who could guess that converting a format from 14 years ago would be hard ? :clueless:
+        // Not supported, who could guess that converting a format from 14 years ago would be hard? :clueless:
         "schematic" to StructureTemplate::readSchematicOrException,
     )
 
@@ -54,7 +53,7 @@ object StructureRegistry
      * @param name The name of the structure file without the extension.
      * @return The corresponding [File] if found, or null otherwise.
      */
-    fun findStructureByName(name: String): File? =
+    private fun findStructureByName(name: String): File? =
         serializers
             .keys
             .firstNotNullOfOrNull { extension ->
@@ -81,93 +80,94 @@ object StructureRegistry
                 "Invalid structure template: $name",
                 "The structure folder is not a folder"
             )
+            return null
         }
 
         // Poll directory file events to load many structures at once
         // They might not show up in the command suggestion, but they are
         // present in the map
-        pathWatcher.poll()
-            ?.let { key ->
-                key.pollEvents()?.forEach { event ->
-                    @Suppress("UNCHECKED_CAST")
-                    event as WatchEvent<Path>
-
-                    val kind = event.kind()
+        pathWatcher.poll()?.let { key ->
+            key.pollEvents()
+                ?.filterIsInstance<WatchEvent<Path>>()
+                ?.forEach { event ->
                     val path = event.context()
                     val nameNoExt = path.nameWithoutExtension
 
-                    when (kind) {
+                    when (event.kind()) {
                         ENTRY_DELETE -> remove(nameNoExt)
-                        ENTRY_CREATE -> if (!contains(nameNoExt) && nameNoExt != name) loadStructureByName(path.nameWithoutExtension, convert = true)
+                        ENTRY_CREATE -> {
+                            if (!contains(nameNoExt) && nameNoExt != name) {
+                                loadStructureByName(path.nameWithoutExtension, convert = true)
+                            }
+                        }
                     }
 
                     // Reset the key -- this step is critical if you want to
                     // receive further watch events.  If the key is no longer valid,
                     // the directory is inaccessible so exit the loop.
                     if (!key.reset()) return@forEach
                 }
-            }
+        }
 
-        return computeIfAbsent(name.lowercase()) {
-            findStructureByName(name)
-                ?.let { it to it.extension }
-                ?.let { (file, extension) ->
-                    file.inputStream().use { templateStream ->
-                        val compound = NbtIo.readCompressed(templateStream, NbtSizeTracker.ofUnlimitedBytes())
-                        val template = createStructure(compound, extension)
-
-                        // Only delete structure files that aren't NBT
-                        if (convert && extension != "nbt") {
-                            template
-                                ?.let { saveStructure(name, it) }
-                                ?.let { structurePath.resolve("$name.$extension").deleteIfExists() }
-                        }
+        return computeIfAbsent(name.lowercase()) { loadFileAndCreate(name, convert) }
+    }
 
-                        // Verify the structure integrity after it had been
-                        // converted to a regular structure template
-                        if (compound.isValidStructureTemplate()) template
-                        else {
-                            logError(
-                                "Invalid structure template: $it",
-                                "File does not match template format, it might have been corrupted",
-                            )
-                            null
-                        }
+    /**
+     * Loads the structure file and creates a [StructureTemplate].
+     *
+     * @param name The name of the structure file (without extension).
+     * @param convert Whether to replace the file after converting it.
+     * @return The created [StructureTemplate], or null if the structure is not found or invalid.
+     */
+    private fun loadFileAndCreate(name: String, convert: Boolean) =
+        findStructureByName(name)
+            ?.let { it to it.extension }
+            ?.let { (file, extension) ->
+                file.inputStream().use { templateStream ->
+                    val compound = NbtIo.readCompressed(templateStream, NbtSizeTracker.ofUnlimitedBytes())
+                    val template = createStructure(compound, extension)
+
+                    if (convert && extension != "nbt") {
+                        template?.let { saveStructure(name, it) }
+                    }
+
+                    // Verify the structure integrity after it had been
+                    // converted to a regular structure template
+                    if (compound.isValidStructureTemplate()) {
+                        template
+                    } else {
+                        logError(
+                            "Invalid structure template: $name",
+                            "File does not match template format, it might have been corrupted",
+                        )
+                        null
                     }
                 }
-        }
-    }
+            }
 
     /**
      * Creates a [StructureTemplate] from the provided NBT data.
      *
      * @param nbt The [NbtCompound] containing the structure's data.
      * @return The created [StructureTemplate], or null if there was an error.
      */
-    private fun createStructure(nbt: NbtCompound, suffix: String): StructureTemplate? {
-        val template = StructureTemplate()
-
-        serializers[suffix]
-            ?.invoke(
-                template,
-                Registries.BLOCK.readOnlyWrapper,
-                nbt,
-            )
-            ?.let { error ->
-                logError("Could not create structure from file", error.message ?: "")
-                return null
-            }
-
-        return template
-    }
+    private fun createStructure(nbt: NbtCompound, suffix: String): StructureTemplate? =
+        StructureTemplate().apply {
+            serializers[suffix]
+                ?.invoke(this, Registries.BLOCK.readOnlyWrapper, nbt)
+                ?.let { error ->
+                    logError("Could not create structure from file", error.message ?: "")
+                    return null
+                }
+        }
 
     /**
      * Saves the provided [structure] to disk under the specified [name].
      *
      * @param name The name of the structure file (without the extension).
      * @param structure The [StructureTemplate] to save.
      */
-    fun saveStructure(name: String, structure: StructureTemplate) {
+    private fun saveStructure(name: String, structure: StructureTemplate) {
         val path = structurePath.resolve("$name.nbt")
         val compound = structure.writeNbt(NbtCompound())
 
@@ -180,17 +180,16 @@ object StructureRegistry
     /**
      * Verifies that the provided NBT data represents a valid Minecraft structure template.
      *
-     * @param this@isValidStructureTemplate The [NbtCompound] to validate.
+     * @receiver The [NbtCompound] to validate.
      * @return True if the NBT contains valid structure template data, false otherwise.
      */
     private fun NbtCompound.isValidStructureTemplate() =
         contains("DataVersion") && contains("blocks") && contains("palette") && contains("size")
 
     override fun load(): String {
-        structurePath.walk().forEach { path ->
-            if (path.extension in serializers.keys)
-                loadStructureByName(path.nameWithoutExtension)
-        }
+        structurePath.walk()
+            .filter { it.extension in serializers.keys }
+            .forEach { path -> loadStructureByName(path.nameWithoutExtension) }
 
         return "Loaded $size structure templates"
     }

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

@@ -8,6 +8,5 @@ import net.minecraft.nbt.NbtList
  * Puts a list of integer into the component, this is not the same as an int array
  */
 fun NbtCompound.putIntList(key: String, vararg values: Int) {
-    this.put(key, values
-        .fold(NbtList()) { list, value -> list.add(NbtInt.of(value)); list })
+    put(key, values.fold(NbtList()) { list, value -> list.add(NbtInt.of(value)); list })
 }

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

@@ -97,43 +97,41 @@ private fun StructureTemplate.readSpongeV1OrException(
     val paletteMax = nbt.getInt("PaletteMax")
     val palette = nbt.getCompound("Palette")
 
-    if (palette.size != paletteMax)
-        return IllegalStateException("Block palette size does not match the provided size (corrupted?)")
+    check(palette.size == paletteMax) {
+        "Block palette size does not match the provided size (corrupted?)"
+    }
 
     val newPalette = NbtList()
-    val newBlocks = NbtList()
 
     palette.keys.forEach { key ->
         val resource = key.substringBefore('[')
-        val paletteEntry = NbtCompound()
         val blockState = NbtCompound()
 
         // Why ?
         // I know it's supposed to be SNBT, but it cannot be parsed back
-        key
-            .substringAfter('[')
+        key.substringAfter('[')
             .substringBefore(']')
             .takeIf { it != resource }
             ?.split(',')
             ?.associate { it.substringBefore('=') to it.substringAfter('=') }
             ?.forEach { (key, value) -> blockState.putString(key, value) }
 
-        paletteEntry.putString("Name", resource)
-        paletteEntry.put("Properties", blockState)
-
-        newPalette.add(paletteEntry)
+        newPalette.add(NbtCompound().apply {
+            putString("Name", resource)
+            put("Properties", blockState)
+        })
     }
 
+    val newBlocks = NbtList()
     var blockIndex = 0
     VarIntIterator(nbt.getByteArray("BlockData"))
         .forEach { blockId ->
-            val compound = NbtCompound()
             val blockpos = positionFromIndex(width, length, blockIndex++)
 
-            compound.putIntList("pos", blockpos.x, blockpos.y, blockpos.z)
-            compound.putInt("state", blockId.toInt())
-
-            newBlocks.add(compound)
+            newBlocks.add(NbtCompound().apply {
+                putIntList("pos", blockpos.x, blockpos.y, blockpos.z)
+                putInt("state", blockId)
+            })
         }
 
     // Construct a structure compatible nbt compound