Describable enum settings and some cleanup

Author: Avanatiker

src/main/kotlin/com/lambda/config/groups/BreakSettings.kt

@@ -42,7 +42,7 @@ class BreakSettings(
     // General
     override val breakMode by c.setting("Break Mode", BreakMode.Packet, visibility = vis).group(groupPath, Group.General)
     override val sorter by c.setting("Sorter", SortMode.Closest, "The order in which breaks are performed", visibility = vis).group(groupPath, Group.General)
-    override val reBreak by c.setting("ReBreak", true, "Re-breaks blocks after they've been broken once", visibility = vis).group(groupPath, Group.General)
+    override val rebreak by c.setting("Rebreak", true, "Re-breaks blocks after they've been broken once", visibility = vis).group(groupPath, Group.General)
 
     // Double break
     override val doubleBreak by c.setting("Double Break", true, "Allows breaking two blocks at once", visibility = vis).group(groupPath, Group.General)

src/main/kotlin/com/lambda/config/groups/BuildConfig.kt

@@ -17,6 +17,9 @@
 
 package com.lambda.config.groups
 
+import com.lambda.util.Describable
+import com.lambda.util.NamedEnum
+
 interface BuildConfig {
     // General
     val pathing: Boolean
@@ -35,9 +38,12 @@ interface BuildConfig {
     // Interacting
     val interacting: InteractSettings
 
-    enum class SwingType {
-        Vanilla,
-        Server,
-        Client
+    enum class SwingType(
+        override val displayName: String,
+        override val description: String
+    ) : NamedEnum, Describable {
+        Vanilla("Vanilla", "Play the hand swing locally and also notify the server (default, looks and works as expected)."),
+        Server("Server", "Only notify the server to swing; local animation may not play unless the server echoes it."),
+        Client("Client", "Only play the local swing animation; does not notify the server (purely visual).")
     }
 }

src/main/kotlin/com/lambda/config/groups/BuildSettings.kt

@@ -54,5 +54,5 @@ class BuildSettings(
         vis() && (placing.placeConfirmationMode != PlaceConfig.PlaceConfirmationMode.None
                 || breaking.breakConfirmation != BreakConfirmationMode.None
                 || interacting.interactConfirmationMode != InteractionConfig.InteractConfirmationMode.None)
-    }.group(*groupPath, Group.Break).group(*groupPath, Group.Place).group(*groupPath, Group.Interact)
+    }.group(*groupPath, Group.Break, BreakSettings.Group.General).group(*groupPath, Group.Place).group(*groupPath, Group.Interact)
 }

src/main/kotlin/com/lambda/config/groups/InteractionConfig.kt

@@ -18,6 +18,8 @@
 package com.lambda.config.groups
 
 import com.lambda.interaction.request.rotating.visibilty.PointSelection
+import com.lambda.util.Describable
+import com.lambda.util.NamedEnum
 
 interface InteractionConfig {
     /**
@@ -59,9 +61,12 @@ interface InteractionConfig {
      */
     val pointSelection: PointSelection
 
-    enum class InteractConfirmationMode {
-        None,
-        InteractThenAwait,
-        AwaitThenInteract
+    enum class InteractConfirmationMode(
+        override val displayName: String,
+        override val description: String
+    ): NamedEnum, Describable {
+        None("No confirmation", "Send the interaction and don’t wait for the server. Lowest latency, but effects may briefly appear if the server rejects it."),
+        InteractThenAwait("Interact now, confirm later", "Show interaction effects immediately, then wait for the server to confirm. Feels instant while still verifying the result."),
+        AwaitThenInteract("Confirm first, then interact", "Wait for the server response before showing any effects. Most accurate and safe, but adds a short delay.")
     }
 }

src/main/kotlin/com/lambda/config/groups/RotationSettings.kt

@@ -33,7 +33,7 @@ class RotationSettings(
     baseGroup: NamedEnum,
     vis: () -> Boolean = { true }
 ) : RotationConfig {
-    override var rotationMode by c.setting("Mode", RotationMode.Sync, "SILENT - server-side rotation, SYNC - server-side rotation; client-side movement, LOCK - Lock camera, NONE - No rotation", vis).group(baseGroup)
+    override var rotationMode by c.setting("Mode", RotationMode.Sync, "How the player is being rotated on interaction", vis).group(baseGroup)
 
     /** How many ticks to keep the rotation before resetting */
     override val keepTicks by c.setting("Keep Rotation", 1, 1..10, 1, "Ticks to keep rotation", " ticks") { rotate && vis() }.group(baseGroup)

src/main/kotlin/com/lambda/config/settings/comparable/BooleanSetting.kt

@@ -44,8 +44,9 @@ class BooleanSetting(
     override fun ImGuiBuilder.buildLayout() {
         checkbox(name, ::value)
 
-        sameLine()
-        helpMarker(description)
+        if (description.isNotEmpty()) {
+            lambdaTooltip(description)
+        }
     }
 
     override fun CommandBuilder.buildCommand(registry: CommandRegistryAccess) {

src/main/kotlin/com/lambda/config/settings/comparable/EnumSetting.kt

@@ -26,6 +26,7 @@ import com.lambda.brigadier.executeWithResult
 import com.lambda.brigadier.required
 import com.lambda.config.AbstractSetting
 import com.lambda.gui.dsl.ImGuiBuilder
+import com.lambda.util.Describable
 import com.lambda.util.NamedEnum
 import com.lambda.util.StringUtils.capitalize
 import com.lambda.util.extension.CommandBuilder
@@ -57,14 +58,28 @@ class EnumSetting<T : Enum<T>>(
     }
 
     override fun ImGuiBuilder.buildLayout() {
-        text(name)
+        val values = value.enumValues
+        val preview = value.displayValue
 
-        sameLine()
-        helpMarker(description)
+        combo("##$name", preview = preview) {
+            values.forEachIndexed { idx, v ->
+                val isSelected = idx == index
+
+                selectable(v.displayValue, isSelected) {
+                    if (!isSelected) index = idx
+                }
 
-        combo("##$name", ::index, value.enumValues.map { it.displayValue }.toTypedArray())
+                (v as? Describable)?.let { lambdaTooltip(it.description) }
+            }
+        }
+
+        (value as? Describable)?.let { lambdaTooltip(it.description) }
+        sameLine()
+        text(name)
+        if (description.isNotBlank()) lambdaTooltip(description)
     }
 
+
     override fun CommandBuilder.buildCommand(registry: CommandRegistryAccess) {
         required(word(name)) { parameter ->
             suggests { _, builder ->

src/main/kotlin/com/lambda/interaction/construction/blueprint/Blueprint.kt

@@ -57,22 +57,11 @@ abstract class Blueprint {
     companion object {
         fun emptyStructure(): Structure = emptyMap()
 
-        fun Box.toStructure(targetState: TargetState): Structure =
-            BlockPos.stream(this)
-                .toList()
-                .associateWith { targetState }
-
         fun BlockBox.toStructure(targetState: TargetState): Structure =
-            BlockPos.stream(this)
-                .toList()
-                .associateWith { targetState }
+            BlockPos.stream(this).toList().associateWith { targetState }
 
         fun BlockPos.toStructure(targetState: TargetState): Structure =
-            setOf(this)
-                .associateWith { targetState }
-
-//        fun Schematic.fromSchematic() =
-//            this.blockMap.map { it.key to TargetState.BlockState(it.value) }.toMap()
+            setOf(this).associateWith { targetState }
 
         fun StructureTemplate.toStructure(): Structure =
             blockInfoLists

src/main/kotlin/com/lambda/interaction/construction/processing/PreProcessingInfo.kt

@@ -17,52 +17,10 @@
 
 package com.lambda.interaction.construction.processing
 
-import com.lambda.interaction.construction.processing.ProcessorRegistry.postProcessedProperties
 import com.lambda.interaction.construction.verify.SurfaceScan
 import net.minecraft.state.property.Property
 import net.minecraft.util.math.Direction
 
-@DslMarker
-private annotation class InfoAccumulator
-
-@InfoAccumulator
-class PreProcessingInfoAccumulator(
-    override var surfaceScan: SurfaceScan = SurfaceScan.DEFAULT,
-    override val ignore: MutableSet<Property<*>> = postProcessedProperties.toMutableSet(),
-    override val sides: MutableSet<Direction> = Direction.entries.toMutableSet(),
-    override var shouldBeOmitted: Boolean = false
-) : PreProcessingInfo {
-    @InfoAccumulator
-    fun offerSurfaceScan(scan: SurfaceScan) {
-        if (scan.mode.priority > surfaceScan.mode.priority) {
-            surfaceScan = scan
-        }
-    }
-
-    @InfoAccumulator
-    fun addIgnores(vararg properties: Property<*>) {
-        ignore.addAll(properties)
-    }
-
-    @InfoAccumulator
-    fun retainSides(predicate: (Direction) -> Boolean) {
-        this.sides.retainAll(predicate)
-    }
-
-    @InfoAccumulator
-    fun retainSides(vararg sides: Direction) {
-        this.sides.retainAll(sides.toSet())
-    }
-
-    @InfoAccumulator
-    fun omitPlacement() {
-        shouldBeOmitted = true
-    }
-
-    @InfoAccumulator
-    fun complete() = this as PreProcessingInfo
-}
-
 interface PreProcessingInfo {
     val surfaceScan: SurfaceScan
     val ignore: Set<Property<*>>

src/main/kotlin/com/lambda/interaction/construction/processing/PreProcessingInfoAccumulator.kt

@@ -0,0 +1,64 @@
+/*
+ * Copyright 2025 Lambda
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package com.lambda.interaction.construction.processing
+
+import com.lambda.interaction.construction.verify.SurfaceScan
+import net.minecraft.state.property.Property
+import net.minecraft.util.math.Direction
+
+class PreProcessingInfoAccumulator(
+    override var surfaceScan: SurfaceScan = SurfaceScan.DEFAULT,
+    override val ignore: MutableSet<Property<*>> = ProcessorRegistry.postProcessedProperties.toMutableSet(),
+    override val sides: MutableSet<Direction> = Direction.entries.toMutableSet(),
+    override var shouldBeOmitted: Boolean = false
+) : PreProcessingInfo {
+    @InfoAccumulator
+    fun offerSurfaceScan(scan: SurfaceScan) {
+        if (scan.mode.priority > surfaceScan.mode.priority) {
+            surfaceScan = scan
+        }
+    }
+
+    @InfoAccumulator
+    fun addIgnores(vararg properties: Property<*>) {
+        ignore.addAll(properties)
+    }
+
+    @InfoAccumulator
+    fun retainSides(predicate: (Direction) -> Boolean) {
+        sides.retainAll(predicate)
+    }
+
+    @InfoAccumulator
+    fun retainSides(vararg sides: Direction) {
+        this.sides.retainAll(sides.toSet())
+    }
+
+    @InfoAccumulator
+    fun omitPlacement() {
+        shouldBeOmitted = true
+    }
+
+    @InfoAccumulator
+    fun complete() = this as PreProcessingInfo
+
+    companion object {
+        @DslMarker
+        private annotation class InfoAccumulator
+    }
+}