Merge branch 'master' into feature/combat

Author: Avanatiker

common/src/main/kotlin/com/lambda/command/commands/BuildCommand.kt

@@ -18,6 +18,8 @@
 package com.lambda.command.commands
 
 import com.lambda.brigadier.CommandResult
+import com.lambda.brigadier.CommandResult.Companion.failure
+import com.lambda.brigadier.CommandResult.Companion.success
 import com.lambda.brigadier.argument.greedyString
 import com.lambda.brigadier.argument.literal
 import com.lambda.brigadier.argument.value
@@ -28,6 +30,7 @@ import com.lambda.interaction.construction.StructureRegistry
 import com.lambda.interaction.construction.blueprint.Blueprint.Companion.toStructure
 import com.lambda.interaction.construction.blueprint.StaticBlueprint.Companion.toBlueprint
 import com.lambda.task.TaskFlow.run
+import com.lambda.task.tasks.BuildTask
 import com.lambda.task.tasks.BuildTask.Companion.build
 import com.lambda.threading.runSafe
 import com.lambda.util.Communication.info
@@ -42,6 +45,8 @@ object BuildCommand : LambdaCommand(
     description = "Builds a structure",
     usage = "build <structure>"
 ) {
+    private var lastBuildTask: BuildTask? = null
+
     override fun CommandBuilder.create() {
         required(literal("place")) {
             required(greedyString("structure")) { structure ->
@@ -57,27 +62,38 @@ object BuildCommand : LambdaCommand(
                                 .loadStructureByRelativePath(Path.of(pathString))
                                 ?.let { template ->
                                     info("Building structure $pathString with dimensions ${template.size.toShortString()} created by ${template.author}")
-                                    template.toStructure()
+                                    lastBuildTask = template.toStructure()
                                         .move(player.blockPos)
                                         .toBlueprint()
                                         .build()
                                         .run()
 
-                                    return@executeWithResult CommandResult.success()
+                                    return@executeWithResult success()
                                 }
                         } catch (e: InvalidPathException) {
-                            return@executeWithResult CommandResult.failure("Invalid path $pathString")
+                            return@executeWithResult failure("Invalid path $pathString")
                         } catch (e: NoSuchFileException) {
-                            return@executeWithResult CommandResult.failure("Structure $pathString not found")
+                            return@executeWithResult failure("Structure $pathString not found")
                         } catch (e: Exception) {
-                            return@executeWithResult CommandResult.failure(
+                            return@executeWithResult failure(
                                 e.message ?: "Failed to load structure $pathString"
                             )
                         }
                     }
 
-                    CommandResult.failure("Structure $pathString not found")
+                    failure("Structure $pathString not found")
+                }
+            }
+        }
+
+        required(literal("cancel")) {
+            executeWithResult {
+                lastBuildTask?.cancel() ?: run {
+                    return@executeWithResult failure("No build task to cancel")
                 }
+                this@BuildCommand.info("$lastBuildTask cancelled")
+                lastBuildTask = null
+                success()
             }
         }
     }

common/src/main/kotlin/com/lambda/command/commands/ConfigCommand.kt

@@ -17,8 +17,14 @@
 
 package com.lambda.command.commands
 
+import com.google.gson.JsonParser
+import com.lambda.brigadier.CommandResult
+import com.lambda.brigadier.CommandResult.Companion.failure
 import com.lambda.brigadier.CommandResult.Companion.success
 import com.lambda.brigadier.argument.literal
+import com.lambda.brigadier.argument.string
+import com.lambda.brigadier.argument.value
+import com.lambda.brigadier.argument.word
 import com.lambda.brigadier.executeWithResult
 import com.lambda.brigadier.required
 import com.lambda.command.LambdaCommand
@@ -28,8 +34,8 @@ import com.lambda.util.extension.CommandBuilder
 
 object ConfigCommand : LambdaCommand(
     name = "config",
-    aliases = setOf("cfg"),
-    usage = "config <save | load>",
+    aliases = setOf("cfg", "settings", "setting"),
+    usage = "config <save | load | set> <configurable> <setting> <value>",
     description = "Save or load the configuration files"
 ) {
     override fun CommandBuilder.create() {
@@ -51,5 +57,51 @@ object ConfigCommand : LambdaCommand(
                 return@executeWithResult success()
             }
         }
+        required(literal("set")) {
+            required(string("configurable")) { config ->
+                suggests { _, builder ->
+                    Configuration.configurables.forEach {
+                        builder.suggest("\"${it.name}\"")
+                    }
+                    builder.buildFuture()
+                }
+                required(string("setting")) { setting ->
+                    suggests { ctx, builder ->
+                        val conf = config(ctx).value()
+                        Configuration.configurableByName(conf)?.let { configurable ->
+                            configurable.settings.forEach {
+                                builder.suggest("\"${it.name}\"")
+                            }
+                        }
+                        builder.buildFuture()
+                    }
+                    required(string("value as JSON")) { value ->
+                        executeWithResult {
+                            val valueString = value().value()
+                            val confName = config().value()
+                            val settingName = setting().value()
+                            val conf = Configuration.configurableByName(confName) ?: run {
+                                return@executeWithResult failure("$confName is not a valid configurable.")
+                            }
+                            val set = Configuration.settingByName(conf, settingName) ?: run {
+                                return@executeWithResult failure("$settingName is not a valid setting for $confName.")
+                            }
+                            val parsed = try {
+                                JsonParser.parseString("\"$valueString\"")
+                            } catch (e: Exception) {
+                                return@executeWithResult failure("$valueString is not a valid JSON string.")
+                            }
+                            try {
+                                set.loadFromJson(parsed)
+                            } catch (e: Exception) {
+                                return@executeWithResult failure("Failed to load $valueString as a ${set.type::class.simpleName} for $settingName in $confName.")
+                            }
+                            this@ConfigCommand.info("Set $settingName to ${set.value} for $confName.")
+                            return@executeWithResult success()
+                        }
+                    }
+                }
+            }
+        }
     }
 }

common/src/main/kotlin/com/lambda/command/commands/TransferCommand.kt

@@ -106,7 +106,7 @@ object TransferCommand : LambdaCommand(
                 lastContainerTransfer?.cancel() ?: run {
                     return@executeWithResult failure("No transfer to cancel")
                 }
-                info("$lastContainerTransfer cancelled")
+                this@TransferCommand.info("$lastContainerTransfer cancelled")
                 lastContainerTransfer = null
                 success()
             }

common/src/main/kotlin/com/lambda/config/AbstractSetting.kt

@@ -72,7 +72,7 @@ import kotlin.reflect.KProperty
  */
 abstract class AbstractSetting<T : Any>(
     private val defaultValue: T,
-    protected val type: Type,
+    val type: Type,
     val description: String,
     val visibility: () -> Boolean,
 ) : Jsonable, Nameable {

common/src/main/kotlin/com/lambda/config/Configuration.kt

@@ -156,5 +156,12 @@ abstract class Configuration : Jsonable {
 
     companion object {
         val configurations = mutableSetOf<Configuration>()
+        val configurables: Set<Configurable>
+            get() = configurations.flatMapTo(mutableSetOf()) { it.configurables }
+
+        fun configurableByName(name: String) =
+            configurables.find { it.name == name }
+        fun settingByName(configurable: Configurable, name: String) =
+            configurable.settings.find { it.name == name }
     }
 }

common/src/main/kotlin/com/lambda/task/TaskFlow.kt

@@ -23,7 +23,10 @@ object TaskFlow : Task<Unit>() {
     override val name get() = "TaskFlow"
 
     @Ta5kBuilder
-    fun Task<*>.run() = this.execute(this@TaskFlow)
+    inline fun <reified T : Task<*>> T.run(): T {
+        execute(this@TaskFlow)
+        return this
+    }
 
     @Ta5kBuilder
     fun Task<*>.run(task: TaskGenerator<Unit>) {