Search: New Features and QOL Improvements

src/main/java/com/lambda/mixin/network/MixinNetHandlerPlayClient.java

@@ -0,0 +1,23 @@
+package com.lambda.mixin.network;
+
+import com.lambda.client.event.LambdaEventBus;
+import com.lambda.client.event.events.ChunkDataEvent;
+import net.minecraft.client.multiplayer.WorldClient;
+import net.minecraft.client.network.NetHandlerPlayClient;
+import net.minecraft.network.play.server.SPacketChunkData;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.Shadow;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Inject;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
+
+@Mixin(value = NetHandlerPlayClient.class)
+public class MixinNetHandlerPlayClient {
+
+    @Shadow private WorldClient world;
+
+    @Inject(method = "handleChunkData", at = @At("TAIL"))
+    public void handleChunkData(SPacketChunkData packetIn, CallbackInfo ci) {
+        LambdaEventBus.INSTANCE.post(new ChunkDataEvent(packetIn.isFullChunk(), this.world.getChunk(packetIn.getChunkX(), packetIn.getChunkZ())));
+    }
+}

src/main/kotlin/com/lambda/client/command/Args.kt

@@ -14,6 +14,7 @@ import com.lambda.client.util.*
 import com.lambda.client.util.threads.runSafeR
 import kotlinx.coroutines.Dispatchers
 import net.minecraft.block.Block
+import net.minecraft.entity.EntityList
 import net.minecraft.item.Item
 import net.minecraft.util.math.BlockPos
 import java.io.File
@@ -94,6 +95,21 @@ class BlockArg(
     }
 }
 
+class EntityArg(
+    override val name: String
+) : AbstractArg<String>(), AutoComplete by StaticPrefixMatch(allEntityNames) {
+    override suspend fun convertToType(string: String?): String? {
+        if (string == null) return null
+        // checks if a valid entity class is registered with this name
+        return if (EntityList.getClassFromName(string) != null) string else null
+    }
+
+    private companion object {
+        val allEntityNames = EntityList.getEntityNameList().map { it.path }
+    }
+}
+
+
 class BaritoneBlockArg(
     override val name: String
 ) : AbstractArg<Block>(), AutoComplete by StaticPrefixMatch(baritoneBlockNames) {

src/main/kotlin/com/lambda/client/command/ClientCommand.kt

@@ -1,7 +1,6 @@
 package com.lambda.client.command
 
 import com.lambda.client.capeapi.PlayerProfile
-import com.lambda.client.command.CommandBuilder
 import com.lambda.client.command.args.AbstractArg
 import com.lambda.client.command.utils.BuilderBlock
 import com.lambda.client.command.utils.ExecuteBlock
@@ -51,6 +50,14 @@ abstract class ClientCommand(
         arg(BlockArg(name), block)
     }
 
+    @CommandBuilder
+    protected inline fun AbstractArg<*>.entity(
+        name: String,
+        entity: BuilderBlock<String>
+    ) {
+        arg(EntityArg(name), entity)
+    }
+
     @CommandBuilder
     protected inline fun AbstractArg<*>.item(
         name: String,

src/main/kotlin/com/lambda/client/command/commands/SearchCommand.kt

@@ -2,30 +2,59 @@ package com.lambda.client.command.commands
 
 import com.lambda.client.command.ClientCommand
 import com.lambda.client.module.modules.render.Search
+import com.lambda.client.util.items.shulkerList
+import com.lambda.client.util.items.signsList
 import com.lambda.client.util.text.MessageSendHelper
 import com.lambda.client.util.text.formatValue
+import net.minecraft.init.Blocks
 
 // TODO: Remove once GUI has List
 object SearchCommand : ClientCommand(
     name = "search",
     description = "Manage search blocks"
 ) {
-    private val warningBlocks = arrayOf("minecraft:grass", "minecraft:end_stone", "minecraft:lava", "minecraft:bedrock", "minecraft:netherrack", "minecraft:dirt", "minecraft:water", "minecraft:stone")
+    private val warningBlocks = hashSetOf(Blocks.GRASS, Blocks.END_STONE, Blocks.LAVA, Blocks.FLOWING_LAVA,
+        Blocks.BEDROCK, Blocks.NETHERRACK, Blocks.DIRT, Blocks.WATER, Blocks.FLOWING_WATER, Blocks.STONE)
 
     init {
         literal("add", "+") {
+            literal("shulker_box") {
+                execute("Add all shulker box types to search") {
+                    Search.blockSearchList.editValue { searchList -> shulkerList.map { it.registryName.toString() }.forEach { searchList.add(it) } }
+                    MessageSendHelper.sendChatMessage("All shulker boxes have been added to block search")
+                }
+            }
+            literal("sign") {
+                execute("Add all signs to search") {
+                    Search.blockSearchList.editValue { searchList -> signsList.map { it.registryName.toString() }.forEach { searchList.add(it) } }
+                    MessageSendHelper.sendChatMessage("All signs have been added to block search")
+                }
+            }
             block("block") { blockArg ->
                 literal("force") {
                     execute("Force add a block to search list") {
                         val blockName = blockArg.value.registryName.toString()
                         addBlock(blockName)
                     }
                 }
-
+                int("dimension") { dimArg ->
+                    execute("Add a block to dimension filter") {
+                        val blockName = blockArg.value.registryName.toString()
+                        val dim = dimArg.value
+                        val dims = Search.blockSearchDimensionFilter.value.find { dimFilter -> dimFilter.searchKey == blockName }?.dim
+                        if (dims != null && !dims.contains(dim)) {
+                            dims.add(dim)
+                        } else {
+                            Search.blockSearchDimensionFilter.value.add(Search.DimensionFilter(blockName, linkedSetOf(dim)))
+                        }
+                        MessageSendHelper.sendChatMessage("Block search filter added for $blockName in dimension ${dimArg.value}")
+                    }
+                }
                 execute("Add a block to search list") {
+                    val block = blockArg.value
                     val blockName = blockArg.value.registryName.toString()
 
-                    if (warningBlocks.contains(blockName)) {
+                    if (warningBlocks.contains(block)) {
                         MessageSendHelper.sendWarningMessage("Your world contains lots of ${formatValue(blockName)}, " +
                             "it might cause extreme lag to add it. " +
                             "If you are sure you want to add it run ${formatValue("$prefixName add $blockName force")}"
@@ -35,50 +64,148 @@ object SearchCommand : ClientCommand(
                     }
                 }
             }
+            entity("entity") { entityArg ->
+                int("dimension") {dimArg ->
+                    execute("Add an entity to dimension filter") {
+                        val entityName = entityArg.value
+                        val dim = dimArg.value
+                        val dims = Search.entitySearchDimensionFilter.value.find { dimFilter -> dimFilter.searchKey == entityName }?.dim
+                        if (dims != null && !dims.contains(dim)) {
+                            dims.add(dim)
+                        } else {
+                            Search.entitySearchDimensionFilter.value.add(Search.DimensionFilter(entityName, linkedSetOf(dim)))
+                        }
+                        MessageSendHelper.sendChatMessage("Entity search filter added for $entityName in dimension ${dimArg.value}")
+                    }
+                }
+
+                execute("Add an entity to search list") {
+                    val entityName = entityArg.value
+                    if (Search.entitySearchList.contains(entityName)) {
+                        MessageSendHelper.sendChatMessage("$entityName is already added to search list")
+                        return@execute
+                    }
+                    Search.entitySearchList.editValue { it.add(entityName) }
+                    MessageSendHelper.sendChatMessage("$entityName has been added to search list")
+                }
+            }
         }
 
         literal("remove", "-") {
+            literal("shulker_box") {
+                execute("Remove all shulker boxes from search") {
+                    Search.blockSearchList.editValue { searchList -> shulkerList.map { it.registryName.toString() }.forEach { searchList.remove(it) } }
+                    MessageSendHelper.sendChatMessage("Removed all shulker boxes from block search")
+                }
+            }
+            literal("sign") {
+                execute("Remove all signs from search") {
+                    Search.blockSearchList.editValue { searchList -> signsList.map { it.registryName.toString() }.forEach { searchList.remove(it) } }
+                    MessageSendHelper.sendChatMessage("Removed all signs from block search")
+                }
+            }
             block("block") { blockArg ->
+                int("dimension") {dimArg ->
+                    execute("Remove a block from dimension filter") {
+                        val blockName = blockArg.value.registryName.toString()
+                        val dim = dimArg.value
+                        val dims = Search.blockSearchDimensionFilter.value.find { dimFilter -> dimFilter.searchKey == blockName }?.dim
+                        if (dims != null) {
+                            dims.remove(dim)
+                            if (dims.isEmpty()) {
+                                Search.blockSearchDimensionFilter.value.removeIf { it.searchKey == blockName }
+                            }
+                        }
+                        MessageSendHelper.sendChatMessage("Block search filter removed for $blockName in dimension ${dimArg.value}")
+                    }
+                }
                 execute("Remove a block from search list") {
                     val blockName = blockArg.value.registryName.toString()
 
-                    if (!Search.searchList.remove(blockName)) {
+                    if (!Search.blockSearchList.contains(blockName)) {
                         MessageSendHelper.sendErrorMessage("You do not have ${formatValue(blockName)} added to search block list")
                     } else {
+                        Search.blockSearchList.editValue { it.remove(blockName) }
                         MessageSendHelper.sendChatMessage("Removed ${formatValue(blockName)} from search block list")
                     }
                 }
             }
+            entity("entity") {entityArg ->
+                int("dimension") {dimArg ->
+                    execute("Remove an entity from dimension filter") {
+                        val entityName = entityArg.value
+                        val dim = dimArg.value
+                        val dims = Search.entitySearchDimensionFilter.value.find { dimFilter -> dimFilter.searchKey == entityName }?.dim
+                        if (dims != null) {
+                            dims.remove(dim)
+                            if (dims.isEmpty()) {
+                                Search.entitySearchDimensionFilter.value.removeIf { it.searchKey == entityName }
+                            }
+                        }
+                        MessageSendHelper.sendChatMessage("Entity search filter removed for $entityName in dimension ${dimArg.value}")
+                    }
+                }
+                execute("Remove an entity from search list") {
+                    val entityName = entityArg.value
+                    Search.entitySearchList.editValue { it.remove(entityName) }
+                    MessageSendHelper.sendChatMessage("Removed $entityName from search list")
+                }
+            }
         }
 
         literal("set", "=") {
             block("block") { blockArg ->
                 execute("Set the search list to one block") {
                     val blockName = blockArg.value.registryName.toString()
 
-                    Search.searchList.clear()
-                    Search.searchList.add(blockName)
+                    Search.blockSearchList.editValue {
+                        it.clear()
+                        it.add(blockName)
+                    }
                     MessageSendHelper.sendChatMessage("Set the search block list to ${formatValue(blockName)}")
                 }
             }
+            entity("entity") { entityArg ->
+                execute("Sets the search list to one entity") {
+                    val entityName = entityArg.value
+                    Search.entitySearchList.editValue {
+                        it.clear()
+                        it.add(entityName)
+                    }
+                    MessageSendHelper.sendChatMessage("Set the entity search list to $entityName")
+                }
+            }
         }
 
         literal("reset", "default") {
             execute("Reset the search list to defaults") {
-                Search.searchList.resetValue()
-                MessageSendHelper.sendChatMessage("Reset the search block list to defaults")
+                Search.blockSearchList.resetValue()
+                Search.entitySearchList.resetValue()
+                Search.blockSearchDimensionFilter.resetValue()
+                Search.entitySearchDimensionFilter.resetValue()
+                MessageSendHelper.sendChatMessage("Reset the search list to defaults")
             }
         }
 
         literal("list") {
             execute("Print search list") {
-                MessageSendHelper.sendChatMessage(Search.searchList.joinToString())
+                MessageSendHelper.sendChatMessage("Blocks: ${Search.blockSearchList.joinToString()}")
+                if (Search.blockSearchDimensionFilter.value.isNotEmpty()) {
+                    MessageSendHelper.sendChatMessage("Block dimension filter: ${Search.blockSearchDimensionFilter.value}")
+                }
+                MessageSendHelper.sendChatMessage("Entities ${Search.entitySearchList.joinToString()}")
+                if (Search.entitySearchDimensionFilter.value.isNotEmpty()) {
+                    MessageSendHelper.sendChatMessage("Entity dimension filter: ${Search.entitySearchDimensionFilter.value}")
+                }
             }
         }
 
         literal("clear") {
             execute("Set the search list to nothing") {
-                Search.searchList.clear()
+                Search.blockSearchList.editValue { it.clear() }
+                Search.entitySearchList.editValue { it.clear() }
+                Search.blockSearchDimensionFilter.editValue { it.clear() }
+                Search.entitySearchDimensionFilter.editValue { it.clear() }
                 MessageSendHelper.sendChatMessage("Cleared the search block list")
             }
         }
@@ -97,9 +224,10 @@ object SearchCommand : ClientCommand(
             return
         }
 
-        if (!Search.searchList.add(blockName)) {
+        if (Search.blockSearchList.contains(blockName)) {
             MessageSendHelper.sendErrorMessage("${formatValue(blockName)} is already added to the search block list")
         } else {
+            Search.blockSearchList.editValue { it.add(blockName) }
             MessageSendHelper.sendChatMessage("${formatValue(blockName)} has been added to the search block list")
         }
     }

src/main/kotlin/com/lambda/client/event/events/ChunkDataEvent.kt

@@ -0,0 +1,9 @@
+package com.lambda.client.event.events
+
+import com.lambda.client.event.Event
+import net.minecraft.world.chunk.Chunk
+
+/**
+ * Event emitted when chunk data is read
+ */
+class ChunkDataEvent(val isFullChunk: Boolean, val chunk: Chunk): Event

src/main/kotlin/com/lambda/client/module/modules/player/InventoryManager.kt

@@ -47,7 +47,7 @@ object InventoryManager : Module(
     private val pauseMovement by setting("Pause Movement", true)
     private val delay by setting("Delay Ticks", 1, 0..20, 1, unit = " ticks")
     private val helpMend by setting("Help Mend", false, description = "Helps mending items by replacing the offhand item with low HP items of the same type")
-    val ejectList = setting(CollectionSetting("Eject List", defaultEjectList))
+    val ejectList = setting(CollectionSetting("Eject List", defaultEjectList, String::class.java))
 
     enum class State {
         IDLE, SAVING_ITEM, HELPING_MEND, REFILLING_BUILDING, REFILLING, EJECTING

src/main/kotlin/com/lambda/client/module/modules/player/Scaffold.kt

@@ -67,8 +67,8 @@ object Scaffold : Module(
     private val thickness by setting("Outline Thickness", 2f, .25f..4f, .25f, { outline && page == Page.RENDER }, description = "Changes thickness of the outline")
     private val pendingBlockColor by setting("Pending Color", ColorHolder(0, 0, 255), visibility = { page == Page.RENDER })
 
-    val blockSelectionWhitelist = setting(CollectionSetting("BlockWhitelist", linkedSetOf("minecraft:obsidian"), { false }))
-    val blockSelectionBlacklist = setting(CollectionSetting("BlockBlacklist", blockBlacklist.map { it.registryName.toString() }.toMutableSet(), { false }))
+    val blockSelectionWhitelist = setting(CollectionSetting("BlockWhitelist", linkedSetOf("minecraft:obsidian"), String::class.java, { false }))
+    val blockSelectionBlacklist = setting(CollectionSetting("BlockBlacklist", blockBlacklist.map { it.registryName.toString() }.toMutableSet(), String::class.java, { false }))
 
     private enum class Page {
         GENERAL, RENDER