Relative structure paths support

Avanatiker · Avanatiker · commit a0ade28c5ba5 · 2024-11-10T05:18:56.000+01:00
diff --git a/common/src/main/kotlin/com/lambda/command/commands/BuildCommand.kt b/common/src/main/kotlin/com/lambda/command/commands/BuildCommand.kt
@@ -1,10 +1,7 @@
 package com.lambda.command.commands
 
 import com.lambda.brigadier.CommandResult
-import com.lambda.brigadier.argument.boolean
-import com.lambda.brigadier.argument.literal
-import com.lambda.brigadier.argument.string
-import com.lambda.brigadier.argument.value
+import com.lambda.brigadier.argument.*
 import com.lambda.brigadier.executeWithResult
 import com.lambda.brigadier.optional
 import com.lambda.brigadier.required
@@ -17,6 +14,9 @@ import com.lambda.threading.runSafe
 import com.lambda.util.Communication.info
 import com.lambda.util.extension.CommandBuilder
 import com.lambda.util.extension.move
+import java.nio.file.InvalidPathException
+import java.nio.file.NoSuchFileException
+import java.nio.file.Path
 
 object BuildCommand : LambdaCommand(
     name = "Build",
@@ -25,33 +25,40 @@ object BuildCommand : LambdaCommand(
 ) {
     override fun CommandBuilder.create() {
         required(literal("place")) {
-            required(string("structure")) { structure ->
+            required(greedyString("structure")) { structure ->
                 suggests { _, builder ->
-                    StructureRegistry
-                        .forEach { key, _ -> builder.suggest(key) }
+                    StructureRegistry.forEach { key, _ -> builder.suggest(key) }
 
                     builder.buildFuture()
                 }
                 optional(boolean("pathing")) { pathing ->
                     executeWithResult {
-                        val id = structure().value()
-                        val path = if (pathing != null) pathing().value() else false
+                        val pathString = structure().value()
+                        val doPathing = if (pathing != null) pathing().value() else false
                         runSafe<Unit> {
-                            StructureRegistry
-                                .loadStructureByName(id)
-                                ?.let { template ->
-                                    info("Building structure $id with dimensions ${template.size.toShortString()} created by ${template.author}")
-                                    template.toStructure()
-                                        .move(player.blockPos)
-                                        .toBlueprint()
-                                        .build(pathing = path)
-                                        .start(null)
+                            try {
+                                StructureRegistry
+                                    .loadStructureByRelativePath(Path.of(pathString))
+                                    ?.let { template ->
+                                        info("Building structure $pathString with dimensions ${template.size.toShortString()} created by ${template.author}")
+                                        template.toStructure()
+                                            .move(player.blockPos)
+                                            .toBlueprint()
+                                            .build(pathing = doPathing)
+                                            .start(null)
 
-                                    return@executeWithResult CommandResult.success()
-                                }
+                                        return@executeWithResult CommandResult.success()
+                                    }
+                            } catch (e: InvalidPathException) {
+                                return@executeWithResult CommandResult.failure("Invalid path $pathString")
+                            } catch (e: NoSuchFileException) {
+                                return@executeWithResult CommandResult.failure("Structure $pathString not found")
+                            } catch (e: Exception) {
+                                return@executeWithResult CommandResult.failure(e.message ?: "Failed to load structure $pathString")
+                            }
                         }
 
-                        CommandResult.failure("Structure $id not found")
+                        CommandResult.failure("Structure $pathString not found")
                     }
                 }
             }
diff --git a/common/src/main/kotlin/com/lambda/command/commands/ReplayCommand.kt b/common/src/main/kotlin/com/lambda/command/commands/ReplayCommand.kt
@@ -13,6 +13,7 @@ import com.lambda.module.modules.player.Replay
 import com.lambda.util.FolderRegister
 import com.lambda.util.FolderRegister.listRecursive
 import com.lambda.util.extension.CommandBuilder
+import kotlin.io.path.exists
 
 object ReplayCommand : LambdaCommand(
     name = "replay",
@@ -31,7 +32,7 @@ object ReplayCommand : LambdaCommand(
         required(literal("load")) {
             required(greedyString("replay filepath")) { replayName ->
                 suggests { _, builder ->
-                    val dir = FolderRegister.replay
+                    val dir = FolderRegister.replay.toFile()
                     dir.listRecursive { it.isFile }.forEach {
                         builder.suggest(it.relativeTo(dir).path)
                     }
@@ -46,7 +47,7 @@ object ReplayCommand : LambdaCommand(
                     }
 
                     try {
-                        Replay.loadRecording(replayFile)
+                        Replay.loadRecording(replayFile.toFile())
                     } catch (e: JsonSyntaxException) {
                         return@executeWithResult CommandResult.failure("Failed to load replay file: ${e.message}")
                     }
diff --git a/common/src/main/kotlin/com/lambda/config/configurations/FriendConfig.kt b/common/src/main/kotlin/com/lambda/config/configurations/FriendConfig.kt
@@ -2,8 +2,9 @@ package com.lambda.config.configurations
 
 import com.lambda.config.Configuration
 import com.lambda.util.FolderRegister
+import java.io.File
 
 object FriendConfig : Configuration() {
     override val configName get() = "friends"
-    override val primary = FolderRegister.config.resolve("$configName.json")
+    override val primary: File = FolderRegister.config.resolve("$configName.json").toFile()
 }
diff --git a/common/src/main/kotlin/com/lambda/config/configurations/GuiConfig.kt b/common/src/main/kotlin/com/lambda/config/configurations/GuiConfig.kt
@@ -2,8 +2,9 @@ package com.lambda.config.configurations
 
 import com.lambda.config.Configuration
 import com.lambda.util.FolderRegister
+import java.io.File
 
 object GuiConfig : Configuration() {
     override val configName get() = "gui"
-    override val primary = FolderRegister.config.resolve("$configName.json")
+    override val primary: File = FolderRegister.config.resolve("$configName.json").toFile()
 }
diff --git a/common/src/main/kotlin/com/lambda/config/configurations/LambdaConfig.kt b/common/src/main/kotlin/com/lambda/config/configurations/LambdaConfig.kt
@@ -2,8 +2,9 @@ package com.lambda.config.configurations
 
 import com.lambda.config.Configuration
 import com.lambda.util.FolderRegister
+import java.io.File
 
 object LambdaConfig : Configuration() {
     override val configName get() = "lambda"
-    override val primary = FolderRegister.config.resolve("$configName.json")
+    override val primary: File = FolderRegister.config.resolve("$configName.json").toFile()
 }
diff --git a/common/src/main/kotlin/com/lambda/config/configurations/ModuleConfig.kt b/common/src/main/kotlin/com/lambda/config/configurations/ModuleConfig.kt
@@ -4,6 +4,7 @@ import com.lambda.config.Configuration
 import com.lambda.config.configurations.ModuleConfig.configName
 import com.lambda.config.configurations.ModuleConfig.primary
 import com.lambda.util.FolderRegister
+import java.io.File
 
 
 /**
@@ -16,5 +17,5 @@ import com.lambda.util.FolderRegister
  */
 object ModuleConfig : Configuration() {
     override val configName get() = "modules"
-    override val primary = FolderRegister.config.resolve("$configName.json")
+    override val primary: File = FolderRegister.config.resolve("$configName.json").toFile()
 }
diff --git a/common/src/main/kotlin/com/lambda/core/Loader.kt b/common/src/main/kotlin/com/lambda/core/Loader.kt
@@ -15,6 +15,7 @@ import com.lambda.interaction.material.ContainerManager
 import com.lambda.module.ModuleRegistry
 import com.lambda.sound.SoundRegistry
 import com.lambda.util.Communication.ascii
+import com.lambda.util.FolderRegister
 import kotlin.system.measureTimeMillis
 import kotlin.time.DurationUnit
 import kotlin.time.toDuration
@@ -26,6 +27,7 @@ object Loader {
         get() = "${(System.currentTimeMillis() - started).toDuration(DurationUnit.MILLISECONDS)}"
 
     private val loadables = listOf(
+        FolderRegister,
         ModuleRegistry,
         CommandRegistry,
         RotationManager,
diff --git a/common/src/main/kotlin/com/lambda/http/Request.kt b/common/src/main/kotlin/com/lambda/http/Request.kt
@@ -37,7 +37,7 @@ data class Request(
      * @param maxAge The maximum age of the cached resource. Default is 4 days.
      */
     fun maybeDownload(name: String, maxAge: Duration = 7.days): File {
-        val file = cache.resolve(name).createIfNotExists()
+        val file = cache.resolve(name).toFile().createIfNotExists()
 
         if (
             System.currentTimeMillis() - file.lastModified() < maxAge.inWholeMilliseconds
diff --git a/common/src/main/kotlin/com/lambda/interaction/construction/StructureRegistry.kt b/common/src/main/kotlin/com/lambda/interaction/construction/StructureRegistry.kt
@@ -1,5 +1,6 @@
 package com.lambda.interaction.construction
 
+import com.lambda.Lambda.LOG
 import com.lambda.Lambda.mc
 import com.lambda.core.Loadable
 import com.lambda.util.Communication.logError
@@ -14,12 +15,10 @@ import net.minecraft.nbt.NbtSizeTracker
 import net.minecraft.registry.Registries
 import net.minecraft.structure.StructureTemplate
 import net.minecraft.util.WorldSavePath
-import java.io.File
 import java.nio.file.*
 import java.nio.file.StandardWatchEventKinds.ENTRY_CREATE
 import java.nio.file.StandardWatchEventKinds.ENTRY_DELETE
 import java.util.concurrent.ConcurrentHashMap
-import kotlin.io.inputStream
 import kotlin.io.path.*
 
 /**
@@ -30,8 +29,7 @@ import kotlin.io.path.*
 @OptIn(ExperimentalPathApi::class)
 @Suppress("JavaIoSerializableObjectMustHaveReadResolve")
 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 structurePath = FolderRegister.structure
     private val pathWatcher = FileSystems.getDefault().newWatchService()
         .apply { structurePath.register(this, ENTRY_CREATE, ENTRY_DELETE) }
 
@@ -48,56 +46,51 @@ object StructureRegistry : ConcurrentHashMap<String, StructureTemplate?>(), Load
     )
 
     /**
-     * Searches for a structure file by name, trying all supported extensions.
-     *
-     * @param name The name of the structure file without the extension.
-     * @return The corresponding [File] if found, or null otherwise.
-     */
-    private fun findStructureByName(name: String): File? =
-        serializers
-            .keys
-            .firstNotNullOfOrNull { extension ->
-                structurePath
-                    .resolve("$name.$extension")
-                    .toFile()
-                    .takeIf { it.isFile && it.exists() }
-            }
-
-    /**
-     * Loads a structure by name, will attempt a discovery sequence if the structure could not be found
+     * Loads a structure by relative path, will attempt a discovery sequence if the structure could not be found
      * and performs format conversions if necessary
      *
-     * @param name The name of the structure to load (without extension).
+     * @param relativePath The name of the structure to load (without extension).
      * @param convert Whether to replace the file after converting it.
      * @return The loaded [StructureTemplate], or null if the structure is not found.
      */
-    fun loadStructureByName(
-        name: String,
+    fun loadStructureByRelativePath(
+        relativePath: Path,
         convert: Boolean = true,
     ): StructureTemplate? {
         if (!structurePath.isDirectory()) {
             logError(
-                "Invalid structure template: $name",
+                "Invalid structure template: $relativePath",
                 "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
+        updateFileWatcher()
+
+        return computeIfAbsent(relativePath.pathString.lowercase()) {
+            loadFileAndCreate(relativePath, convert)?.also {
+                LOG.info("Loaded structure template $relativePath by ${it.author} with dimensions ${it.size.toShortString()}")
+            }
+        }
+    }
+
+    /**
+     * 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.
+     */
+    private fun updateFileWatcher() {
         pathWatcher.poll()?.let { key ->
             key.pollEvents()
                 ?.filterIsInstance<WatchEvent<Path>>()
                 ?.forEach { event ->
-                    val path = event.context()
-                    val nameNoExt = path.nameWithoutExtension
+                    val newPath = event.context()
 
                     when (event.kind()) {
-                        ENTRY_DELETE -> remove(nameNoExt)
+                        ENTRY_DELETE -> remove(newPath.pathString)
                         ENTRY_CREATE -> {
-                            if (!contains(nameNoExt) && nameNoExt != name) {
-                                loadStructureByName(path.nameWithoutExtension, convert = true)
+                            computeIfAbsent(newPath.pathString) {
+                                loadStructureByRelativePath(newPath, convert = true)
                             }
                         }
                     }
@@ -108,42 +101,36 @@ object StructureRegistry : ConcurrentHashMap<String, StructureTemplate?>(), Load
                     if (!key.reset()) return@forEach
                 }
         }
-
-        return computeIfAbsent(name.lowercase()) { loadFileAndCreate(name, convert) }
     }
 
     /**
      * 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) }
-                    }
+    private fun loadFileAndCreate(path: Path, convert: Boolean) =
+        structurePath.resolve(path).inputStream().use { templateStream ->
+            val compound = NbtIo.readCompressed(templateStream, NbtSizeTracker.ofUnlimitedBytes())
+            val extension = path.extension
+            val template = createStructure(compound, extension)
+
+            if (convert && extension != "nbt") {
+                template?.let { saveStructure(path.pathString, 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
-                    }
-                }
+            // Verify the structure integrity after it had been
+            // converted to a regular structure template
+            if (compound.isValidStructureTemplate()) {
+                template
+            } else {
+                logError(
+                    "Invalid structure template: $path",
+                    "File does not match template format, it might have been corrupted",
+                )
+                null
             }
+        }
 
     /**
      * Creates a [StructureTemplate] from the provided NBT data.
@@ -164,14 +151,14 @@ object StructureRegistry : ConcurrentHashMap<String, StructureTemplate?>(), Load
     /**
      * Saves the provided [structure] to disk under the specified [name].
      *
-     * @param name The name of the structure file (without the extension).
+     * @param relativePath The relative path of the structure to save.
      * @param structure The [StructureTemplate] to save.
      */
-    private fun saveStructure(name: String, structure: StructureTemplate) {
-        val path = structurePath.resolve("$name.nbt")
+    private fun saveStructure(relativePath: String, structure: StructureTemplate) {
+        val path = structurePath.resolve("$relativePath.nbt")
         val compound = structure.writeNbt(NbtCompound())
 
-        Files.createDirectories(path.parent) // Ensure parent directories exist
+        Files.createDirectories(path.parent)
         path.outputStream().use { output ->
             NbtIo.writeCompressed(compound, output)
         }
@@ -189,7 +176,7 @@ object StructureRegistry : ConcurrentHashMap<String, StructureTemplate?>(), Load
     override fun load(): String {
         structurePath.walk()
             .filter { it.extension in serializers.keys }
-            .forEach { path -> loadStructureByName(path.nameWithoutExtension) }
+            .forEach { loadStructureByRelativePath(structurePath.relativize(it)) }
 
         return "Loaded $size structure templates"
     }
diff --git a/common/src/main/kotlin/com/lambda/module/modules/network/PacketLogger.kt b/common/src/main/kotlin/com/lambda/module/modules/network/PacketLogger.kt
@@ -79,7 +79,7 @@ object PacketLogger : Module(
             val fileName = "packet-log-${getTime(fileFormatter)}.txt"
 
             // ToDo: Organize files with FolderRegister.worldBoundDirectory
-            file = FolderRegister.packetLogs.resolve(fileName).apply {
+            file = FolderRegister.packetLogs.resolve(fileName).toFile().apply {
                 if (!parentFile.exists()) {
                     parentFile.mkdirs()
                 }
diff --git a/common/src/main/kotlin/com/lambda/module/modules/player/Replay.kt b/common/src/main/kotlin/com/lambda/module/modules/player/Replay.kt
@@ -412,7 +412,7 @@ object Replay : Module(
             this@Replay.warn("Recording too short. Minimum length: 5 ticks.")
             return
         }
-        val file = FolderRegister.replay.locationBoundDirectory().resolve("$name.json")
+        val file = FolderRegister.replay.toFile().locationBoundDirectory().resolve("$name.json")
 
         lambdaScope.launch(Dispatchers.IO) {
             file.writeText(gsonCompact.toJson(recording))
diff --git a/common/src/main/kotlin/com/lambda/util/FolderRegister.kt b/common/src/main/kotlin/com/lambda/util/FolderRegister.kt

Original file line number	Diff line number	Diff line change
`@@ -2,8 +2,9 @@ package com.lambda.config.configurations`
`2`	`2`
`3`	`3`	`import com.lambda.config.Configuration`
`4`	`4`	`import com.lambda.util.FolderRegister`
	`5`	`+import java.io.File`
`5`	`6`
`6`	`7`	`object FriendConfig : Configuration() {`
`7`	`8`	`override val configName get() = "friends"`
`8`		`- override val primary = FolderRegister.config.resolve("$configName.json")`
	`9`	`+ override val primary: File = FolderRegister.config.resolve("$configName.json").toFile()`
`9`	`10`	`}`
Original file line number	Diff line number	Diff line change
`@@ -79,7 +79,7 @@ object PacketLogger : Module(`
`79`	`79`	`val fileName = "packet-log-${getTime(fileFormatter)}.txt"`
`80`	`80`
`81`	`81`	`// ToDo: Organize files with FolderRegister.worldBoundDirectory`
`82`		`- file = FolderRegister.packetLogs.resolve(fileName).apply {`
	`82`	`+ file = FolderRegister.packetLogs.resolve(fileName).toFile().apply {`
`83`	`83`	`if (!parentFile.exists()) {`
`84`	`84`	`parentFile.mkdirs()`
`85`	`85`	`}`