various setting changes

Author: emyfops

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

@@ -44,13 +44,18 @@ import com.lambda.config.settings.numeric.LongSetting
 import com.lambda.util.Communication.logError
 import com.lambda.util.KeyCode
 import com.lambda.util.Nameable
+import com.lambda.util.reflections.getInstancesImplementingWithParameters
 import imgui.flag.ImGuiInputTextFlags
+import io.github.classgraph.ClassInfoList
 import net.minecraft.block.Block
 import net.minecraft.item.Item
+import net.minecraft.network.listener.ClientPlayPacketListener
+import net.minecraft.network.packet.Packet
 import net.minecraft.registry.Registries
 import net.minecraft.util.math.BlockPos
 import net.minecraft.util.math.Vec3d
 import java.awt.Color
+import kotlin.reflect.KClass
 
 /**
  * Represents a set of [AbstractSetting]s that are associated with the [name] of the [Configurable].
@@ -132,11 +137,12 @@ abstract class Configurable(
     fun setting(
         name: String,
         defaultValue: Collection<Block>,
+        immutableCollection: Collection<Block> = Registries.BLOCK.toList(),
         description: String = "",
         visibility: () -> Boolean = { true },
     ) = BlockCollectionSetting(
         name,
-        Registries.BLOCK.toList(),
+        immutableCollection,
         defaultValue.toMutableList(),
         description,
         visibility,
@@ -145,37 +151,38 @@ abstract class Configurable(
     fun setting(
         name: String,
         defaultValue: Collection<Item>,
+        immutableCollection: Collection<Item> = Registries.ITEM.toList(),
         description: String = "",
         visibility: () -> Boolean = { true },
     ) = ItemCollectionSetting(
         name,
-        Registries.ITEM.toList(),
+        immutableCollection,
         defaultValue.toMutableList(),
         description,
         visibility,
     ).register()
 
     inline fun <reified T : Comparable<T>> setting(
         name: String,
-        immutableList: Collection<T>,
-        defaultValue: Collection<T> = immutableList,
+        defaultValue: Collection<T>,
+        immutableList: Collection<T> = defaultValue,
         description: String = "",
         noinline visibility: () -> Boolean = { true },
     ) = CollectionSetting(
         name,
-        immutableList,
         defaultValue.toMutableList(),
+        immutableList,
         TypeToken.getParameterized(Collection::class.java, T::class.java).type,
         description,
         visibility,
     ).register()
 
     inline fun <reified T : Any> setting(
-        name: String,
-        immutableList: Collection<T>,
-        defaultValue: Collection<T> = immutableList,
-        description: String = "",
-        noinline visibility: () -> Boolean = { true },
+	    name: String,
+	    defaultValue: Collection<T>,
+	    immutableList: Collection<T> = defaultValue,
+	    description: String = "",
+	    noinline visibility: () -> Boolean = { true },
     ) = ClassCollectionSetting(
         name,
         immutableList,

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

@@ -21,7 +21,7 @@ import com.lambda.config.configurations.UserAutomationConfigs
 import com.lambda.module.ModuleRegistry.moduleNameMap
 
 class UserAutomationConfig(override val name: String) : AutomationConfig(name, UserAutomationConfigs) {
-    val linkedModules = setting<String>("Linked Modules", moduleNameMap.filter { it.value.defaultAutomationConfig != Companion.DEFAULT }.keys, emptySet())
+    val linkedModules = setting<String>("Linked Modules", emptySet(), moduleNameMap.filter { it.value.defaultAutomationConfig != Companion.DEFAULT }.keys)
         .onSelect { module -> moduleNameMap[module]?.automationConfig = this@UserAutomationConfig }
         .onDeselect { module ->
             moduleNameMap[module]?.let { module ->

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

@@ -57,7 +57,7 @@ open class BreakSettings(
     override val breakDelay by c.setting("Break Delay", 0, 0..6, 1, "The delay between breaking blocks", " tick(s)").group(baseGroup, Group.General).index()
 
     // Timing
-    override val tickStageMask by c.setting("Break Stage Mask", ALL_STAGES.toSet(), setOf(TickEvent.Input.Post), description = "The sub-tick timing at which break actions can be performed").group(baseGroup, Group.General).index()
+    override val tickStageMask by c.setting("Break Stage Mask", setOf(TickEvent.Input.Post), ALL_STAGES.toSet(), description = "The sub-tick timing at which break actions can be performed").group(baseGroup, Group.General).index()
 
     // Swap
     override val swapMode by c.setting("Swap Mode", BreakConfig.SwapMode.End, "Decides when to swap to the best suited tool when breaking a block").group(baseGroup, Group.General).index()

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

@@ -20,7 +20,6 @@ package com.lambda.config.groups
 import com.lambda.config.Configurable
 import com.lambda.config.SettingGroup
 import com.lambda.util.NamedEnum
-import net.minecraft.item.Item
 import net.minecraft.item.Items
 
 class EatSettings(
@@ -35,13 +34,13 @@ class EatSettings(
     override val eatOnHunger by c.setting("Eat On Hunger", true, "Whether to eat when hungry").group(baseGroup).index()
     override val minFoodLevel by c.setting("Minimum Food Level", 6, 0..20, 1, "The minimum food level to eat food", " food level") { eatOnHunger }.group(baseGroup).index()
     override val saturated by c.setting("Saturated", EatConfig.Saturation.EatSmart, "When to stop eating") { eatOnHunger }.group(baseGroup).index()
-    override val nutritiousFood by c.setting("Nutritious Food", nutritiousFoodDefaults, description = "Items that are be considered nutritious") { eatOnHunger }.group(baseGroup).index()
+    override val nutritiousFood by c.setting("Nutritious Food", nutritiousFoodDefaults, nutritiousFoodDefaults, "Items that are be considered nutritious") { eatOnHunger }.group(baseGroup).index()
     override val selectionPriority by c.setting("Selection Priority", EatConfig.SelectionPriority.MostNutritious, "The priority for selecting food items") { eatOnHunger }.group(baseGroup).index()
     override val eatOnFire by c.setting("Eat On Fire", true, "Whether to eat when on fire").group(baseGroup).index()
-    override val resistanceFood by c.setting("Resistance Food", resistanceFoodDefaults, description = "Items that give Fire Resistance") { eatOnFire }.group(baseGroup).index()
+    override val resistanceFood by c.setting("Resistance Food", resistanceFoodDefaults, resistanceFoodDefaults, "Items that give Fire Resistance") { eatOnFire }.group(baseGroup).index()
     override val eatOnDamage by c.setting("Eat On Damage", true, "Whether to eat when damaged").group(baseGroup).index()
     override val minDamage by c.setting("Minimum Damage", 10, 0..20, 1, "The minimum damage threshold to trigger eating") { eatOnDamage }.group(baseGroup).index()
-    override val regenerationFood by c.setting("Regeneration Food", regenerationFoodDefaults, description = "Items that give Regeneration") { eatOnDamage }.group(baseGroup).index()
+    override val regenerationFood by c.setting("Regeneration Food", regenerationFoodDefaults, regenerationFoodDefaults, "Items that give Regeneration") { eatOnDamage }.group(baseGroup).index()
     override val ignoreBadFood by c.setting("Ignore Bad Food", true, "Whether to eat when the food is bad").group(baseGroup).index()
-    override val badFood by c.setting("Bad Food", negativeFoodDefaults, description = "Items that are considered bad food") { ignoreBadFood }.group(baseGroup).index()
+    override val badFood by c.setting("Bad Food", negativeFoodDefaults, negativeFoodDefaults, "Items that are considered bad food") { ignoreBadFood }.group(baseGroup).index()
 }

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

@@ -32,5 +32,5 @@ class HotbarSettings(
     override val swapDelay by c.setting("Swap Delay", 0, 0..3, 1, "The number of ticks delay before allowing another hotbar selection swap", " ticks").group(baseGroup).index()
     override val swapsPerTick by c.setting("Swaps Per Tick", 3, 1..10, 1, "The number of hotbar selection swaps that can take place each tick") { swapDelay <= 0 }.group(baseGroup).index()
     override val swapPause by c.setting("Swap Pause", 0, 0..20, 1, "The delay in ticks to pause actions after switching to the slot", " ticks").group(baseGroup).index()
-    override val tickStageMask by c.setting("Hotbar Stage Mask", ALL_STAGES.toSet(), setOf(TickEvent.Input.Post), description = "The sub-tick timing at which hotbar actions are performed").group(baseGroup).index()
+    override val tickStageMask by c.setting("Hotbar Stage Mask", setOf(TickEvent.Input.Post), ALL_STAGES.toSet(), description = "The sub-tick timing at which hotbar actions are performed").group(baseGroup).index()
 }

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

@@ -31,7 +31,7 @@ class InteractSettings(
     override val rotate by c.setting("Rotate For Interact", true, "Rotates the player to look at the block when interacting").group(baseGroup).index()
     override val sorter by c.setting("Interact Sorter", ActionConfig.SortMode.Tool, "The order in which interactions are performed").group(baseGroup).index()
     override val swingHand by c.setting("Swing On Interact", true, "Swings the players hand after interacting").group(baseGroup).index()
-    override val tickStageMask by c.setting("Interact Stage Mask", ALL_STAGES.toSet(), setOf(TickEvent.Input.Post), description = "The sub-tick timing at which interact actions are performed").group(baseGroup).index()
+    override val tickStageMask by c.setting("Interact Stage Mask", setOf(TickEvent.Input.Post), ALL_STAGES.toSet(), description = "The sub-tick timing at which interact actions are performed").group(baseGroup).index()
     override val interactSwingType by c.setting("Interact Swing Type", BuildConfig.SwingType.Vanilla, "The style of swing") { swingHand }.group(baseGroup).index()
     override val interactConfirmationMode by c.setting("Interact Confirmation Mode", InteractConfig.InteractConfirmationMode.InteractThenAwait, "The style of confirmation for interactions").group(baseGroup).index()
 }

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

@@ -34,7 +34,7 @@ class PlaceSettings(
     override val airPlace by c.setting("Air Place", AirPlaceMode.None, "Allows for placing blocks without adjacent faces").group(baseGroup).index()
     override val axisRotateSetting by c.setting("Axis Rotate", true, "Overrides the Rotate For Place setting and rotates the player on each axis to air place rotational blocks") { airPlace.isEnabled }.group(baseGroup).index()
     override val sorter by c.setting("Place Sorter", ActionConfig.SortMode.Tool, "The order in which placements are performed").group(baseGroup).index()
-    override val tickStageMask by c.setting("Place Stage Mask", ALL_STAGES.toSet(), setOf(TickEvent.Input.Post),  description = "The sub-tick timing at which place actions are performed").group(baseGroup).index()
+    override val tickStageMask by c.setting("Place Stage Mask", setOf(TickEvent.Input.Post), ALL_STAGES.toSet(), description = "The sub-tick timing at which place actions are performed").group(baseGroup).index()
     override val placeConfirmationMode by c.setting("Place Confirmation", PlaceConfirmationMode.PlaceThenAwait, "Wait for block placement confirmation").group(baseGroup).index()
     override val maxPendingPlacements by c.setting("Max Pending Placements", 5, 0..30, 1, "The maximum amount of pending placements").group(baseGroup).index()
     override val placementsPerTick by c.setting("Places Per Tick", 1, 1..30, 1, "Maximum instant block places per tick").group(baseGroup).index()

src/main/kotlin/com/lambda/config/settings/collections/BlockCollectionSetting.kt

@@ -22,6 +22,9 @@ import com.google.gson.reflect.TypeToken
 import com.lambda.Lambda.gson
 import com.lambda.config.serializer.BlockCodec
 import com.lambda.gui.dsl.ImGuiBuilder
+import com.lambda.util.StringUtils.levenshteinDistance
+import imgui.ImGuiListClipper
+import imgui.flag.ImGuiChildFlags
 import imgui.flag.ImGuiSelectableFlags.DontClosePopups
 import net.minecraft.block.Block
 
@@ -33,40 +36,46 @@ class BlockCollectionSetting(
 	visibility: () -> Boolean,
 ) : CollectionSetting<Block>(
 	name,
-	immutableCollection,
 	defaultValue,
+	immutableCollection,
 	TypeToken.getParameterized(Collection::class.java, Block::class.java).type,
 	description,
 	visibility,
 ) {
+	private var searchFilter = ""
+
 	override fun ImGuiBuilder.buildLayout() {
 		val text = if (value.size == 1) "block" else "blocks"
 
 		combo("##$name", "$name: ${value.size} $text") {
-			value.toMutableList() // Copy the list instead of iterating the immutable one
-				.forEach {
-					selectable(
-						label = BlockCodec.stringify(it),
-						selected = true,
-						flags = DontClosePopups
-					) { value.remove(it) }
-				}
-		}
+			inputText("##$name-SearchBox", ::searchFilter)
 
-		button("Add") { openPopup("Blocks") }
+			child(
+				strId = "##$name-ComboOptionsChild",
+				childFlags = ImGuiChildFlags.AutoResizeY or ImGuiChildFlags.AlwaysAutoResize,
+			) {
+				val list = immutableCollection
+					.filter { searchFilter == "" || searchFilter.levenshteinDistance(BlockCodec.stringify(it)) < 3 }
 
-		popup("Blocks") {
-			filter("Search for blocks") { filter ->
-				immutableCollection
-					.filter {
-						//filter.inputBuffer.levenshteinDistance(ItemCodec.stringify(it)) < 3 &&
-						!value.contains(it)
-					}
-					.forEach {
-						text(BlockCodec.stringify(it))
-						sameLine()
-						button("Add") { value.add(it) }
+				ImGuiListClipper.forEach { // not actually iterating
+					it.begin(list.size)
+
+					while (it.step()) {
+						for (i in it.displayStart..it.displayEnd) {
+							val v = list.getOrNull(i) ?: continue
+							val selected = value.contains(v)
+
+							selectable(
+								label = BlockCodec.stringify(v),
+								selected = selected,
+								flags = DontClosePopups
+							) {
+								if (selected) value.remove(v)
+								else value.add(v)
+							}
+						}
 					}
+				}
 			}
 		}
 	}

src/main/kotlin/com/lambda/config/settings/collections/ClassCollectionSetting.kt

@@ -21,10 +21,14 @@ import com.google.gson.JsonElement
 import com.google.gson.reflect.TypeToken
 import com.lambda.Lambda.gson
 import com.lambda.gui.dsl.ImGuiBuilder
+import com.lambda.util.StringUtils.levenshteinDistance
+import com.lambda.util.reflections.className
+import imgui.ImGuiListClipper
+import imgui.flag.ImGuiChildFlags
 import imgui.flag.ImGuiSelectableFlags.DontClosePopups
 
 /**
- * @see [com.lambda.config.settings.collections.CollectionSettings]
+ * @see [com.lambda.config.settings.collections.CollectionSetting]
  * @see [com.lambda.config.Configurable]
  */
 class ClassCollectionSetting<T : Any>(
@@ -35,34 +39,50 @@ class ClassCollectionSetting<T : Any>(
 	visibility: () -> Boolean,
 ) : CollectionSetting<T>(
 	name,
-	immutableCollection,
 	defaultValue,
+	immutableCollection,
 	TypeToken.getParameterized(Collection::class.java, Any::class.java).type,
 	description,
 	visibility,
 ) {
+	private var searchFilter = ""
+
 	override fun ImGuiBuilder.buildLayout() {
-		combo("##$name", "$name: ${value.size} item(s)") {
-			immutableCollection
-				.forEach {
-					val isSelected = value.contains(it)
+		val text = if (value.size == 1) "item" else "items"
+
+		combo("##$name", "$name: ${value.size} $text") {
+			inputText("##$name-SearchBox", ::searchFilter)
 
-					selectable(
-						label = it.className,
-						selected = isSelected,
-						flags = DontClosePopups,
-					) {
-						if (isSelected) value.remove(it)
-						else value.add(it)
+			child(
+				strId = "##$name-ComboOptionsChild",
+				childFlags = ImGuiChildFlags.AutoResizeY or ImGuiChildFlags.AlwaysAutoResize,
+			) {
+				val list = immutableCollection
+					.filter { searchFilter == "" || searchFilter.levenshteinDistance(it.className) < 3 }
+
+				ImGuiListClipper.forEach { // not actually iterating
+					it.begin(list.size)
+
+					while (it.step()) {
+						for (i in it.displayStart..it.displayEnd) {
+							val v = list.getOrNull(i) ?: continue
+							val selected = value.contains(v)
+
+							selectable(
+								label = v.className,
+								selected = selected,
+								flags = DontClosePopups
+							) {
+								if (selected) value.remove(v)
+								else value.add(v)
+							}
+						}
 					}
 				}
+			}
 		}
 	}
 
-	val Any.className: String get() = this::class.java.name
-		.substringAfter("${this::class.java.packageName}.")
-		.replace('$', '.')
-
 	// When serializing the list to json we do not want to serialize the elements' classes, but their stringified representation.
 	// If we do serialize the classes we'll run into missing type adapters errors by Gson.
 	// This is intended behaviour. If you wish your collection settings to display something else then you must extend this class.

src/main/kotlin/com/lambda/config/settings/collections/CollectionSetting.kt

@@ -25,6 +25,9 @@ import com.lambda.config.SettingEditorDsl
 import com.lambda.config.SettingGroupEditor
 import com.lambda.context.SafeContext
 import com.lambda.gui.dsl.ImGuiBuilder
+import com.lambda.util.StringUtils.levenshteinDistance
+import imgui.ImGuiListClipper
+import imgui.flag.ImGuiChildFlags
 import imgui.flag.ImGuiSelectableFlags.DontClosePopups
 import java.lang.reflect.Type
 
@@ -40,8 +43,8 @@ import java.lang.reflect.Type
  */
 open class CollectionSetting<T : Any>(
     override var name: String,
-    private var immutableCollection: Collection<T>,
     defaultValue: MutableCollection<T>,
+    private var immutableCollection: Collection<T>,
     type: Type,
     description: String,
     visibility: () -> Boolean,
@@ -52,6 +55,7 @@ open class CollectionSetting<T : Any>(
     description,
     visibility
 ) {
+    private var searchFilter = ""
     private val strListType =
         TypeToken.getParameterized(Collection::class.java, String::class.java).type
 
@@ -67,20 +71,38 @@ open class CollectionSetting<T : Any>(
     }
 
     override fun ImGuiBuilder.buildLayout() {
-        combo("##$name", "$name: ${value.size} item(s)") {
-            immutableCollection
-                .forEach {
-                    val isSelected = value.contains(it)
-
-                    selectable(
-                        label = it.toString(),
-                        selected = isSelected,
-                        flags = DontClosePopups,
-                    ) {
-                        if (isSelected) value.remove(it)
-                        else value.add(it)
+        val text = if (value.size == 1) "item" else "items"
+
+        combo("##$name", "$name: ${value.size} $text") {
+            inputText("##$name-SearchBox", ::searchFilter)
+
+            child(
+                strId = "##$name-ComboOptionsChild",
+                childFlags = ImGuiChildFlags.AutoResizeY or ImGuiChildFlags.AlwaysAutoResize,
+            ) {
+                val list = immutableCollection
+                    .filter { searchFilter == "" || searchFilter.levenshteinDistance(it.toString()) < 3 }
+
+                ImGuiListClipper.forEach { // not actually iterating
+                    it.begin(list.size)
+
+                    while (it.step()) {
+                        for (i in it.displayStart..it.displayEnd) {
+                            val v = list.getOrNull(i) ?: continue
+                            val selected = value.contains(v)
+
+                            selectable(
+                                label = v.toString(),
+                                selected = selected,
+                                flags = DontClosePopups
+                            ) {
+                                if (selected) value.remove(v)
+                                else value.add(v)
+                            }
+                        }
                     }
                 }
+            }
         }
     }