Setting groups with visual tabs

Author: Avanatiker

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

@@ -34,6 +34,7 @@ import com.lambda.gui.Layout
 import com.lambda.threading.runSafe
 import com.lambda.util.Communication.info
 import com.lambda.util.Nameable
+import com.lambda.util.NamedEnum
 import com.lambda.util.extension.CommandBuilder
 import com.lambda.util.text.ClickEvents
 import com.lambda.util.text.HoverEvents
@@ -99,6 +100,7 @@ abstract class AbstractSetting<T : Any>(
     val visibility: () -> Boolean,
 ) : Jsonable, Nameable, Layout {
     private val listeners = mutableListOf<ValueListener<T>>()
+    val groups: MutableList<List<NamedEnum>> = mutableListOf()
 
     var value by Delegates.observable(defaultValue) { _, from, to ->
         listeners.forEach {
@@ -107,7 +109,6 @@ abstract class AbstractSetting<T : Any>(
         }
     }
 
-    private val isVisible get() = visibility()
     val isModified get() = value != defaultValue
 
     operator fun getValue(thisRef: Any?, property: KProperty<*>) = value
@@ -149,6 +150,10 @@ abstract class AbstractSetting<T : Any>(
         listeners.add(ValueListener(false, block))
     }
 
+    fun group(vararg path: NamedEnum) = apply {
+        groups.add(path.toList())
+    }
+
     fun reset() {
         if (value == defaultValue) {
             ConfigCommand.info(notChangedMessage())

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

@@ -19,35 +19,36 @@ package com.lambda.config.groups
 
 import com.lambda.config.Configurable
 import com.lambda.util.BlockUtils.allSigns
+import com.lambda.util.NamedEnum
 
 class BuildSettings(
     c: Configurable,
+    baseGroup: NamedEnum,
     vis: () -> Boolean = { true }
 ) : BuildConfig {
-    enum class Page {
-        General, Break, Place
+    enum class Group(override val displayName: String) : NamedEnum {
+        General("General"),
+        Break("Break"),
+        Place("Place")
     }
 
-    private val page by c.setting("Build Page", Page.General, "Current page", vis)
-
     // General
-    override val pathing by c.setting("Pathing", true, "Path to blocks") { vis() && page == Page.General }
-    override val stayInRange by c.setting("Stay In Range", true, "Stay in range of blocks") { vis() && page == Page.General && pathing }
-    override val collectDrops by c.setting("Collect All Drops", false, "Collect all drops when breaking blocks") { vis() && page == Page.General }
-    override val maxPendingInteractions by c.setting("Max Pending Interactions", 1, 1..10, 1, "Dont wait for this many interactions for the server response") { vis() && page == Page.General }
+    override val pathing by c.setting("Pathing", true, "Path to blocks", vis).group(baseGroup, Group.General)
+    override val stayInRange by c.setting("Stay In Range", true, "Stay in range of blocks", vis).group(baseGroup, Group.General)
+    override val collectDrops by c.setting("Collect All Drops", false, "Collect all drops when breaking blocks", vis).group(baseGroup, Group.General)
+    override val maxPendingInteractions by c.setting("Max Pending Interactions", 1, 1..10, 1, "Dont wait for this many interactions for the server response", visibility = vis).group(baseGroup, Group.General)
 
     // Breaking
-    override val rotateForBreak by c.setting("Rotate For Break", true, "Rotate towards block while breaking") { vis() && page == Page.Break }
-    override val breakConfirmation by c.setting("Break Confirmation", false, "Wait for block break confirmation") { vis() && page == Page.Break }
-    override val breaksPerTick by c.setting("Instant Breaks Per Tick", 5, 1..30, 1, "Maximum instant block breaks per tick") { vis() && page == Page.Break }
-    override val breakWeakBlocks by c.setting("Break Weak Blocks", false, "Break blocks that dont have structural integrity (e.g: grass)") { vis() && page == Page.Break }
-    override val forceSilkTouch by c.setting("Force Silk Touch", false, "Force silk touch when breaking blocks") { vis() && page == Page.Break }
-    override val ignoredBlocks by c.setting("Ignored Blocks", allSigns, allSigns, "Blocks that wont be broken") { vis() && page == Page.Break }
+    override val rotateForBreak by c.setting("Rotate For Break", true, "Rotate towards block while breaking", vis).group(baseGroup, Group.Break)
+    override val breakConfirmation by c.setting("Break Confirmation", false, "Wait for block break confirmation", vis).group(baseGroup, Group.Break)
+    override val breaksPerTick by c.setting("Instant Breaks Per Tick", 5, 1..30, 1, "Maximum instant block breaks per tick", visibility = vis).group(baseGroup, Group.Break)
+    override val breakWeakBlocks by c.setting("Break Weak Blocks", false, "Break blocks that dont have structural integrity (e.g: grass)", vis).group(baseGroup, Group.Break)
+    override val forceSilkTouch by c.setting("Force Silk Touch", false, "Force silk touch when breaking blocks", vis).group(baseGroup, Group.Break)
+    override val ignoredBlocks by c.setting("Ignored Blocks", allSigns, allSigns, "Blocks that wont be broken", vis).group(baseGroup, Group.Break)
 
     // Placing
-    override val rotateForPlace by c.setting("Rotate For Place", true, "Rotate towards block while placing") { vis() && page == Page.Place }
-    override val placeConfirmation by c.setting("Place Confirmation", true, "Wait for block placement confirmation") { vis() && page == Page.Place }
-    override val placementsPerTick by c.setting("Instant Places Per Tick", 1, 1..30, 1, "Maximum instant block places per tick") { vis() && page == Page.Place }
-
-    override val interactionTimeout by c.setting("Interaction Timeout", 10, 1..30, 1, "Timeout for block breaks in ticks", unit = " ticks") { vis() && (page == Page.Place && placeConfirmation || page == Page.Break && breakConfirmation) }
+    override val rotateForPlace by c.setting("Rotate For Place", true, "Rotate towards block while placing", vis).group(baseGroup, Group.Place)
+    override val placeConfirmation by c.setting("Place Confirmation", true, "Wait for block placement confirmation", vis).group(baseGroup, Group.Place)
+    override val placementsPerTick by c.setting("Instant Places Per Tick", 1, 1..30, 1, "Maximum instant block places per tick", visibility = vis).group(baseGroup, Group.Place)
+    override val interactionTimeout by c.setting("Interaction Timeout", 10, 1..30, 1, "Timeout for block breaks in ticks", unit = " ticks") { vis() && (placeConfirmation || breakConfirmation) }.group(baseGroup, Group.Break).group(baseGroup, Group.Place)
 }

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

@@ -20,12 +20,14 @@ package com.lambda.config.groups
 import com.lambda.config.Configurable
 import com.lambda.interaction.request.Priority
 import com.lambda.interaction.request.hotbar.HotbarConfig
+import com.lambda.util.NamedEnum
 
 class HotbarSettings(
     c: Configurable,
+    baseGroup: NamedEnum,
     priority: Priority = 0,
     vis: () -> Boolean = { true }
 ) : HotbarConfig(priority) {
-    override val keepTicks by c.setting("Keep Ticks", 3, 0..20, 1, "The number of ticks to keep the current hotbar selection active", " ticks", vis)
-    override var switchPause by c.setting("Switch Pause", 0, 0..20, 1, "The delay in ticks to pause actions after switching to the slot", " ticks", vis)
+    override val keepTicks by c.setting("Keep Ticks", 3, 0..20, 1, "The number of ticks to keep the current hotbar selection active", " ticks", vis).group(baseGroup)
+    override var switchPause by c.setting("Switch Pause", 0, 0..20, 1, "The delay in ticks to pause actions after switching to the slot", " ticks", vis).group(baseGroup)
 }

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

@@ -19,18 +19,20 @@ package com.lambda.config.groups
 
 import com.lambda.config.Configurable
 import com.lambda.interaction.request.rotation.visibilty.PointSelection
+import com.lambda.util.NamedEnum
 import com.lambda.util.world.raycast.InteractionMask
 import kotlin.math.max
 
 class InteractionSettings(
     c: Configurable,
+    baseGroup: NamedEnum,
     private val usage: InteractionMask,
     vis: () -> Boolean = { true },
 ) : InteractionConfig {
     // Reach
-    private val useDefaultReach by c.setting("Default Reach", true, "Whether to use vanilla interaction ranges", vis)
-    private val attackReachSetting = if (usage.entity) c.setting("Attack Reach", DEFAULT_ATTACK_REACH, 1.0..10.0, 0.01, "Maximum entity interaction distance") { vis() && !useDefaultReach } else null
-    private val interactReachSetting = if (usage.block) c.setting("Interact Reach", DEFAULT_INTERACT_REACH, 1.0..10.0, 0.01, "Maximum block interaction distance") { vis() && !useDefaultReach } else null
+    private val useDefaultReach by c.setting("Default Reach", true, "Whether to use vanilla interaction ranges", vis).group(baseGroup)
+    private val attackReachSetting = if (usage.entity) c.setting("Attack Reach", DEFAULT_ATTACK_REACH, 1.0..10.0, 0.01, "Maximum entity interaction distance") { vis() && !useDefaultReach }.group(baseGroup) else null
+    private val interactReachSetting = if (usage.block) c.setting("Interact Reach", DEFAULT_INTERACT_REACH, 1.0..10.0, 0.01, "Maximum block interaction distance") { vis() && !useDefaultReach }.group(baseGroup) else null
 
     override val attackReach: Double get() {
         check(usage.entity) {
@@ -55,13 +57,13 @@ class InteractionSettings(
     }
 
     // Point scan
-    override val strictRayCast by c.setting("Strict Raycast", true, "Whether to include the environment to the ray cast context", vis)
-    override val checkSideVisibility by c.setting("Visibility Check", true, "Whether to check if an AABB side is visible", vis)
-    override val resolution by c.setting("Resolution", 5, 1..20, 1, "The amount of grid divisions per surface of the hit box", "", vis)
-    override val pointSelection by c.setting("Point Selection", PointSelection.Optimum, "The strategy to select the best hit point", vis)
+    override val strictRayCast by c.setting("Strict Raycast", true, "Whether to include the environment to the ray cast context", vis).group(baseGroup)
+    override val checkSideVisibility by c.setting("Visibility Check", true, "Whether to check if an AABB side is visible", vis).group(baseGroup)
+    override val resolution by c.setting("Resolution", 5, 1..20, 1, "The amount of grid divisions per surface of the hit box", "", vis).group(baseGroup)
+    override val pointSelection by c.setting("Point Selection", PointSelection.Optimum, "The strategy to select the best hit point", vis).group(baseGroup)
 
     // Swing
-    override val swingHand by c.setting("Swing Hand", true, "Whether to swing hand on interactions", vis)
+    override val swingHand by c.setting("Swing Hand", true, "Whether to swing hand on interactions", vis).group(baseGroup)
 
     companion object {
         const val DEFAULT_ATTACK_REACH = 3.0

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

@@ -18,15 +18,17 @@
 package com.lambda.config.groups
 
 import com.lambda.config.Configurable
+import com.lambda.util.NamedEnum
 import com.lambda.util.item.ItemUtils
 
 class InventorySettings(
     c: Configurable,
+    baseGroup: NamedEnum,
     vis: () -> Boolean = { true },
 ) : InventoryConfig {
-    override val disposables by c.setting("Disposables", ItemUtils.defaultDisposables, ItemUtils.defaultDisposables, "Items that will be ignored when checking for a free slot", vis)
-    override val accessEnderChest by c.setting("Access Ender Chest", false, "Allow access to the player's ender chest", vis)
-    override val swapWithDisposables by c.setting("Swap With Disposables", true, "Swap items with disposable ones", vis)
-    override val providerPriority by c.setting("Provider Priority", InventoryConfig.Priority.WithMinItems, "What container to prefer when retrieving the item from", vis)
-    override val storePriority by c.setting("Store Priority", InventoryConfig.Priority.WithMinItems, "What container to prefer when storing the item to", vis)
+    override val disposables by c.setting("Disposables", ItemUtils.defaultDisposables, ItemUtils.defaultDisposables, "Items that will be ignored when checking for a free slot", vis).group(baseGroup)
+    override val accessEnderChest by c.setting("Access Ender Chest", false, "Allow access to the player's ender chest", vis).group(baseGroup)
+    override val swapWithDisposables by c.setting("Swap With Disposables", true, "Swap items with disposable ones", vis).group(baseGroup)
+    override val providerPriority by c.setting("Provider Priority", InventoryConfig.Priority.WithMinItems, "What container to prefer when retrieving the item from", vis).group(baseGroup)
+    override val storePriority by c.setting("Store Priority", InventoryConfig.Priority.WithMinItems, "What container to prefer when storing the item to", vis).group(baseGroup)
 }

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

@@ -21,6 +21,7 @@ import com.lambda.config.Configurable
 import com.lambda.interaction.request.Priority
 import com.lambda.interaction.request.rotation.RotationConfig
 import com.lambda.interaction.request.rotation.RotationMode
+import com.lambda.util.NamedEnum
 import kotlin.math.PI
 import kotlin.math.abs
 import kotlin.math.cos
@@ -30,31 +31,32 @@ import kotlin.random.Random
 
 class RotationSettings(
     c: Configurable,
+    baseGroup: NamedEnum,
     priority: Priority = 0,
     vis: () -> Boolean = { true }
 ) : RotationConfig(priority) {
-    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)
+    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)
 
     /** How many ticks to keep the rotation before resetting */
-    override val keepTicks by c.setting("Keep Rotation", 3, 0..10, 1, "Ticks to keep rotation", " ticks") { rotate && vis() }
+    override val keepTicks by c.setting("Keep Rotation", 3, 0..10, 1, "Ticks to keep rotation", " ticks") { rotate && vis() }.group(baseGroup)
 
     /** How many ticks to wait before resetting the rotation */
-    override val decayTicks by c.setting("Reset Rotation", 3, 1..10, 1, "Ticks before rotation is reset", " ticks") { rotate && vis() }
+    override val decayTicks by c.setting("Reset Rotation", 3, 1..10, 1, "Ticks before rotation is reset", " ticks") { rotate && vis() }.group(baseGroup)
 
     /** Whether the rotation is instant */
-    var instant by c.setting("Instant Rotation", true, "Instantly rotate") { rotate && vis() }
+    var instant by c.setting("Instant Rotation", true, "Instantly rotate") { rotate && vis() }.group(baseGroup)
 
     /**
      * The mean (average/base) value used to calculate rotation speed.
      * This value represents the center of the distribution.
      */
-    var mean by c.setting("Mean", 40.0, 1.0..120.0, 0.1, "Average rotation speed", unit = "°") { rotate && vis() && !instant }
+    var mean by c.setting("Mean", 40.0, 1.0..120.0, 0.1, "Average rotation speed", unit = "°") { rotate && vis() && !instant }.group(baseGroup)
 
     /**
      * The standard deviation for the Gaussian distribution used to calculate rotation speed.
      * This value represents the spread of rotation speed.
      */
-    var spread by c.setting("Spread", 10.0, 0.0..60.0, 0.1, "Spread of rotation speeds", unit = "°") { rotate && vis() && !instant }
+    var spread by c.setting("Spread", 10.0, 0.0..60.0, 0.1, "Spread of rotation speeds", unit = "°") { rotate && vis() && !instant }.group(baseGroup)
 
     /**
      * We must always provide turn speed to the interpolator because the player's yaw might exceed the -180 to 180 range.

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

@@ -24,6 +24,7 @@ import com.lambda.interaction.request.rotation.Rotation.Companion.dist
 import com.lambda.interaction.request.rotation.Rotation.Companion.rotation
 import com.lambda.interaction.request.rotation.Rotation.Companion.rotationTo
 import com.lambda.threading.runSafe
+import com.lambda.util.NamedEnum
 import com.lambda.util.extension.fullHealth
 import com.lambda.util.math.distSq
 import com.lambda.util.world.fastEntitySearch
@@ -49,6 +50,7 @@ import java.util.*
  */
 abstract class Targeting(
     private val owner: Configurable,
+    private val baseGroup: NamedEnum,
     private val predicate: () -> Boolean = { true },
     private val defaultRange: Double,
     private val maxRange: Double,
@@ -133,20 +135,21 @@ abstract class Targeting(
      */
     class Combat(
         owner: Configurable,
+        baseGroup: NamedEnum,
         defaultRange: Double = 5.0,
         maxRange: Double = 16.0,
         predicate: () -> Boolean = { true },
-    ) : Targeting(owner, predicate, defaultRange, maxRange) {
+    ) : Targeting(owner, baseGroup, predicate, defaultRange, maxRange) {
 
         /**
          * The field of view limit for targeting entities. Configurable between 5 and 180 degrees.
          */
-        val fov by owner.setting("FOV Limit", 180, 5..180, 1) { predicate() }
+        val fov by owner.setting("FOV Limit", 180, 5..180, 1) { predicate() }.group(baseGroup)
 
         /**
          * The priority used to determine which entity is targeted. Configurable with default set to [Priority.DISTANCE].
          */
-        val priority by owner.setting("Priority", Priority.DISTANCE) { predicate() }
+        val priority by owner.setting("Priority", Priority.DISTANCE) { predicate() }.group(baseGroup)
 
         /**
          * Validates whether a given entity is targetable for combat based on the field of view limit and other settings.
@@ -184,8 +187,9 @@ abstract class Targeting(
      */
     class ESP(
         owner: Configurable,
+        baseGroup: NamedEnum,
         predicate: () -> Boolean = { true },
-    ) : Targeting(owner, predicate, 128.0, 1024.0)
+    ) : Targeting(owner, baseGroup, predicate, 128.0, 1024.0)
 
     /**
      * Enum representing the different priority factors used for determining the best target.

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

@@ -26,8 +26,10 @@ 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.NamedEnum
 import com.lambda.util.StringUtils.capitalize
 import com.lambda.util.extension.CommandBuilder
+import com.lambda.util.extension.displayValue
 import imgui.ImColor
 import imgui.ImGui
 import imgui.ImVec2
@@ -60,22 +62,7 @@ class EnumSetting<T : Enum<T>>(
         sameLine()
         helpMarker(description)
 
-        combo("##$name", ::index, value.enumValues.map { it.name.capitalize() }.toTypedArray())
-        slider("##$name#", ::index, 0, value.enumValues.size - 1, format = "", flags = AlwaysClamp)
-
-        val min = ImGui.getItemRectMin()
-        val max = ImGui.getItemRectMax()
-        val textSize = ImGui.calcTextSize(value.name)
-        val center = ImVec2(
-            (min.x + max.x) * 0.5f - textSize.x * 0.5f,
-            (min.y + max.y) * 0.5f - textSize.y * 0.5f
-        )
-
-        windowDrawList.addText(
-            center,
-            ImColor.rgb(Color.WHITE),
-            value.name,
-        )
+        combo("##$name", ::index, value.enumValues.map { it.displayValue }.toTypedArray())
     }
 
     override fun CommandBuilder.buildCommand(registry: CommandRegistryAccess) {