Open collection settings for typed collections

Author: emyfops

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

@@ -24,7 +24,9 @@ import com.lambda.Lambda.LOG
 import com.lambda.config.settings.CharSetting
 import com.lambda.config.settings.FunctionSetting
 import com.lambda.config.settings.StringSetting
+import com.lambda.config.settings.collections.BlockCollectionSetting
 import com.lambda.config.settings.collections.CollectionSettings
+import com.lambda.config.settings.collections.ItemCollectionSetting
 import com.lambda.config.settings.collections.MapSetting
 import com.lambda.config.settings.comparable.BooleanSetting
 import com.lambda.config.settings.comparable.EnumSetting
@@ -43,6 +45,8 @@ import com.lambda.util.KeyCode
 import com.lambda.util.Nameable
 import imgui.flag.ImGuiInputTextFlags
 import net.minecraft.block.Block
+import net.minecraft.item.Item
+import net.minecraft.registry.Registries
 import net.minecraft.util.math.BlockPos
 import net.minecraft.util.math.Vec3d
 import java.awt.Color
@@ -122,20 +126,30 @@ abstract class Configurable(
         visibility: () -> Boolean = { true },
     ) = StringSetting(name, defaultValue, multiline, flags, description, visibility).register()
 
-    inline fun <reified T : Any> setting(
-	    name: String,
-	    immutableList: Collection<T>,
-	    defaultValue: Collection<T> = immutableList,
-	    description: String = "",
-	    serializer: Stringifiable<T>,
-	    noinline visibility: () -> Boolean = { true },
-    ) = CollectionSettings(
+
+    fun setting(
+        name: String,
+        defaultValue: Collection<Block>,
+        description: String = "",
+        visibility: () -> Boolean = { true },
+    ) = BlockCollectionSetting(
         name,
-        immutableList,
+        Registries.BLOCK.toList(),
+        defaultValue.toMutableList(),
+        description,
+        visibility,
+    ).register()
+
+    fun setting(
+        name: String,
+        defaultValue: Collection<Item>,
+        description: String = "",
+        visibility: () -> Boolean = { true },
+    ) = ItemCollectionSetting(
+        name,
+        Registries.ITEM.toList(),
         defaultValue.toMutableList(),
-        TypeToken.getParameterized(MutableList::class.java, T::class.java).type,
         description,
-        serializer,
         visibility,
     ).register()
 
@@ -144,15 +158,13 @@ abstract class Configurable(
         immutableList: Collection<T>,
         defaultValue: Collection<T> = immutableList,
         description: String = "",
-        crossinline serializer: (T) -> String = { if (it::class.java.isPrimitive) it.toString() else it::class.java.simpleName },
         noinline visibility: () -> Boolean = { true },
     ) = CollectionSettings(
         name,
         immutableList,
         defaultValue.toMutableList(),
         TypeToken.getParameterized(Collection::class.java, T::class.java).type,
         description,
-        object : Stringifiable<T> { override fun stringify(value: T) = serializer(value) },
         visibility,
     ).register()
 

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

@@ -100,7 +100,7 @@ abstract class Configuration : Jsonable, Loadable {
     private fun save() = runCatching {
         primary.createIfNotExists()
             .let {
-                it.writeText(gson.toJson(toJson()))
+                it.writeText(toJson().toString())
                 it.copyTo(backup, true)
             }
     }

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

@@ -18,12 +18,10 @@
 package com.lambda.config
 
 import com.lambda.config.configurations.UserAutomationConfigs
-import com.lambda.config.serializer.ItemCodec
-import com.lambda.module.Module
 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(), serializer = { it })
+    val linkedModules = setting<String>("Linked Modules", moduleNameMap.filter { it.value.defaultAutomationConfig != Companion.DEFAULT }.keys, emptySet())
         .onSelect { module -> moduleNameMap[module]?.automationConfig = this@UserAutomationConfig }
         .onDeselect { module ->
             moduleNameMap[module]?.let { module ->

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

@@ -19,7 +19,6 @@ package com.lambda.config.groups
 
 import com.lambda.config.Configurable
 import com.lambda.config.SettingGroup
-import com.lambda.config.serializer.ItemCodec
 import com.lambda.util.NamedEnum
 import net.minecraft.item.Item
 import net.minecraft.item.Items
@@ -36,13 +35,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<Item>("Nutritious Food", nutritiousFoodDefaults, nutritiousFoodDefaults, "Items that are be considered nutritious", ItemCodec) { 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 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<Item>("Resistance Food", resistanceFoodDefaults, resistanceFoodDefaults, "Items that give Fire Resistance", ItemCodec) { eatOnFire }.group(baseGroup).index()
+    override val resistanceFood by c.setting("Resistance Food", resistanceFoodDefaults, description = "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<Item>("Regeneration Food", regenerationFoodDefaults, regenerationFoodDefaults, "Items that give Regeneration", ItemCodec) { eatOnDamage }.group(baseGroup).index()
+    override val regenerationFood by c.setting("Regeneration Food", regenerationFoodDefaults, description = "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<Item>("Bad Food", negativeFoodDefaults, negativeFoodDefaults, "Items that are considered bad food", ItemCodec) { ignoreBadFood }.group(baseGroup).index()
+    override val badFood by c.setting("Bad Food", negativeFoodDefaults, description = "Items that are considered bad food") { ignoreBadFood }.group(baseGroup).index()
 }

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

@@ -36,7 +36,7 @@ class InventorySettings(
 
     override val actionsPerSecond by c.setting("Actions Per Second", 100, 0..100, 1, "How many inventory actions can be performed per tick").group(baseGroup, Group.General).index()
     override val tickStageMask by c.setting("Inventory Stage Mask", setOf(TickEvent.Pre, TickEvent.Input.Pre, TickEvent.Input.Post, TickEvent.Player.Post), description = "The sub-tick timing at which inventory actions are performed").group(baseGroup, Group.General).index()
-    override val disposables by c.setting("Disposables", ItemUtils.defaultDisposables, ItemUtils.defaultDisposables, "Items that will be ignored when checking for a free slot").group(baseGroup, Group.Container).index()
+    override val disposables by c.setting("Disposables", ItemUtils.defaultDisposables, description = "Items that will be ignored when checking for a free slot").group(baseGroup, Group.Container).index()
     override val swapWithDisposables by c.setting("Swap With Disposables", true, "Swap items with disposable ones").group(baseGroup, Group.Container).index()
     override val providerPriority by c.setting("Provider Priority", InventoryConfig.Priority.WithMinItems, "What container to prefer when retrieving the item from").group(baseGroup, Group.Container).index()
     override val storePriority by c.setting("Store Priority", InventoryConfig.Priority.WithMinItems, "What container to prefer when storing the item to").group(baseGroup, Group.Container).index()

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

@@ -0,0 +1,70 @@
+/*
+ * 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.config.settings.collections
+
+import com.lambda.config.serializer.BlockCodec
+import com.lambda.gui.dsl.ImGuiBuilder
+import imgui.flag.ImGuiSelectableFlags.DontClosePopups
+import net.minecraft.block.Block
+
+class BlockCollectionSetting(
+	override var name: String,
+	private val immutableCollection: Collection<Block>,
+	defaultValue: MutableCollection<Block>,
+	description: String,
+	visibility: () -> Boolean,
+) : CollectionSettings<Block>(
+	name,
+	immutableCollection,
+	defaultValue,
+	Block::class.java,
+	description,
+	visibility,
+) {
+	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) }
+				}
+		}
+
+		button("Add") { openPopup("Blocks") }
+
+		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) }
+					}
+			}
+		}
+	}
+}

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

@@ -21,23 +21,20 @@ import com.google.gson.JsonElement
 import com.lambda.Lambda.gson
 import com.lambda.config.AbstractSetting
 import com.lambda.config.AutomationConfig
-import com.lambda.config.Stringifiable
 import com.lambda.context.SafeContext
 import com.lambda.gui.dsl.ImGuiBuilder
-import com.lambda.threading.runSafe
 import imgui.flag.ImGuiSelectableFlags.DontClosePopups
 import java.lang.reflect.Type
 
 /**
  * @see [com.lambda.config.Configurable]
  */
-class CollectionSettings<T : Any>(
+open class CollectionSettings<T : Any>(
     override var name: String,
     private var immutableCollection: Collection<T>,
     defaultValue: MutableCollection<T>,
     type: Type,
     description: String,
-    private val serializer: Stringifiable<T>,
     visibility: () -> Boolean,
 ) : AbstractSetting<MutableCollection<T>>(
     name,
@@ -49,43 +46,37 @@ class CollectionSettings<T : Any>(
     private val selectListeners = mutableListOf<SafeContext.(T) -> Unit>()
     private val deselectListeners = mutableListOf<SafeContext.(T) -> Unit>()
 
+    fun onSelect(block: SafeContext.(T) -> Unit) = apply {
+        selectListeners.add(block)
+    }
+
+    fun onDeselect(block: SafeContext.(T) -> Unit) = apply {
+        deselectListeners.add(block)
+    }
+
     override fun ImGuiBuilder.buildLayout() {
         combo("##$name", "$name: ${value.size} item(s)") {
             immutableCollection
                 .forEach {
                     val isSelected = value.contains(it)
 
                     selectable(
-                        serializer.stringify(it), isSelected,
-                        flags = DontClosePopups
+                        label = it.toString(),
+                        selected = isSelected,
+                        flags = DontClosePopups,
                     ) {
-                        if (isSelected) {
-                            value.remove(it)
-                            runSafe { deselectListeners.forEach { listener -> listener(it) } }
-                        } else {
-                            value.add(it)
-                            runSafe { selectListeners.forEach { listener -> listener(it) } }
-                        }
+                        if (isSelected) value.remove(it)
+                        else value.add(it)
                     }
                 }
         }
     }
 
-    override fun toJson(): JsonElement = gson.toJsonTree(value)
-
     override fun loadFromJson(serialized: JsonElement) {
-        value = gson.fromJson<MutableList<T>>(serialized, type)
+        value = gson.fromJson<Collection<T>>(serialized, type)
             .toMutableList()
     }
 
-    fun onSelect(block: SafeContext.(T) -> Unit) = apply {
-        selectListeners.add(block)
-    }
-
-    fun onDeselect(block: SafeContext.(T) -> Unit) = apply {
-        deselectListeners.add(block)
-    }
-
     companion object {
         @AutomationConfig.SettingEditorDsl
         @Suppress("unchecked_cast")

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

@@ -0,0 +1,70 @@
+/*
+ * 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.config.settings.collections
+
+import com.lambda.config.serializer.ItemCodec
+import com.lambda.gui.dsl.ImGuiBuilder
+import imgui.flag.ImGuiSelectableFlags.DontClosePopups
+import net.minecraft.item.Item
+
+class ItemCollectionSetting(
+	override var name: String,
+	private val immutableCollection: Collection<Item>,
+	defaultValue: MutableCollection<Item>,
+	description: String,
+	visibility: () -> Boolean,
+) : CollectionSettings<Item>(
+	name,
+	immutableCollection,
+	defaultValue,
+	Item::class.java,
+	description,
+	visibility,
+) {
+	override fun ImGuiBuilder.buildLayout() {
+		val text = if (value.size == 1) "item" else "items"
+
+		combo("##$name", "$name: ${value.size} $text") {
+			value.toMutableList() // Copy the list instead of iterating the immutable one
+				.forEach {
+					selectable(
+						label = ItemCodec.stringify(it),
+						selected = true,
+						flags = DontClosePopups
+					) { value.remove(it) }
+				}
+		}
+
+		button("Add") { openPopup("Items") }
+
+		popup("Items") {
+			filter("Search for items") { filter ->
+				immutableCollection
+					.filter {
+						//filter.inputBuffer.levenshteinDistance(ItemCodec.stringify(it)) < 3 &&
+								!value.contains(it)
+					}
+					.forEach {
+						text(ItemCodec.stringify(it))
+						sameLine()
+						button("Add") { value.add(it) }
+					}
+			}
+		}
+	}
+}

src/main/kotlin/com/lambda/friend/FriendManager.kt

@@ -42,7 +42,7 @@ import java.util.*
 //  - Improve save file structure.
 object FriendManager : Configurable(FriendConfig), Loadable {
     override val name = "friends"
-    val friends by setting("friends", emptySet(), setOf(), serializer = GameProfileCodec)
+    val friends by setting("friends", emptySet<GameProfile>())
 
     fun befriend(profile: GameProfile) = friends.add(profile)
     fun unfriend(profile: GameProfile): Boolean = friends.remove(profile)

src/main/kotlin/com/lambda/gui/dsl/ImGuiBuilder.kt

@@ -1583,15 +1583,19 @@ object ImGuiBuilder {
         lambdaTooltip(description())
     }
 
+    @ImGuiDsl
+    fun openPopup(strId: String, flags: Int = ImGuiPopupFlags.None) =
+        ImGui.openPopup(strId, flags)
+
     /**
-     * Creates a popup.
+     * Creates a popup. You must first call [openPopup] with the same [strId]
      *
      * @param strId Unique identifier
      * @param flags Popup flags
      * @param block Content of the popup
      */
     @ImGuiDsl
-    inline fun popup(strId: String, flags: Int = ImGuiPopupFlags.None, block: ProcedureBlock) {
+    inline fun popup(strId: String, flags: Int = ImGuiPopupFlags.AnyPopup, block: ProcedureBlock) {
         if (beginPopup(strId, flags)) {
             block()
             endPopup()