player trap module

Author: beanbag44

src/main/kotlin/com/lambda/module/modules/combat/PlayerTrap.kt

@@ -0,0 +1,120 @@
+/*
+ * 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.module.modules.combat
+
+import com.lambda.config.AutomationConfig.Companion.setDefaultAutomationConfig
+import com.lambda.config.applyEdits
+import com.lambda.context.SafeContext
+import com.lambda.friend.FriendManager.isFriend
+import com.lambda.interaction.construction.blueprint.TickingBlueprint.Companion.tickingBlueprint
+import com.lambda.interaction.construction.verify.TargetState
+import com.lambda.interaction.managers.interacting.InteractConfig
+import com.lambda.module.Module
+import com.lambda.module.tag.ModuleTag
+import com.lambda.task.RootTask.run
+import com.lambda.task.Task
+import com.lambda.task.tasks.BuildTask.Companion.build
+import com.lambda.util.BlockUtils.blockState
+import com.lambda.util.item.ItemUtils.block
+import com.lambda.util.math.flooredBlockPos
+import com.lambda.util.player.SlotUtils.hotbarAndStorage
+import com.lambda.util.world.entitySearch
+import net.minecraft.block.Blocks
+import net.minecraft.client.network.OtherClientPlayerEntity
+import net.minecraft.entity.player.PlayerEntity
+import net.minecraft.item.BlockItem
+import net.minecraft.util.math.BlockPos
+import kotlin.jvm.optionals.getOrNull
+
+object PlayerTrap : Module(
+	name = "PlayerTrap",
+	description = "Surrounds players with any given block",
+	tag = ModuleTag.COMBAT
+) {
+	private val blocks by setting("Blocks", setOf(Blocks.OBSIDIAN, Blocks.ENDER_CHEST, Blocks.CRYING_OBSIDIAN))
+	private val friends by setting("Friends", false)
+	private val self by setting("Self", false)
+
+	private var task: Task<*>? = null
+
+	init {
+		setDefaultAutomationConfig {
+			applyEdits {
+				buildConfig.apply {
+					editTyped(
+						::pathing,
+						::stayInRange,
+						::spleefEntities,
+						::collectDrops
+					) { defaultValue(false); hide() }
+					::checkSideVisibility.edit { defaultValue(false) }
+				}
+				interactConfig.apply {
+					::airPlace.edit { defaultValue(InteractConfig.AirPlaceMode.Grim) }
+				}
+				hideGroup(eatConfig)
+			}
+		}
+
+		onEnable {
+			task = tickingBlueprint {
+				val block = player.hotbarAndStorage.firstOrNull {
+					it.item is BlockItem && blocks.contains(it.item.block)
+				}?.item?.block ?: return@tickingBlueprint emptyMap()
+				val targetPlayer = if (self) player
+				else entitySearch<OtherClientPlayerEntity>(
+					buildConfig.interactReach,
+					player.eyePos.flooredBlockPos
+				).firstOrNull { friends || !isFriend(it.gameProfile) } ?: return@tickingBlueprint emptyMap()
+				getTrapPositions(targetPlayer).associateWith { TargetState.Block(block) }
+			}.build(finishOnDone = false).run()
+		}
+
+		onDisable { task?.cancel(); task = null }
+	}
+
+	fun SafeContext.getTrapPositions(player: PlayerEntity): Set<BlockPos> {
+		val min = player.boundingBox.minPos.add(0.001, 0.001, 0.001).flooredBlockPos.add(-1, -1, -1)
+		val max = player.boundingBox.maxPos.add(-0.001, -0.001, -0.001).flooredBlockPos.add(1, 1, 1)
+
+		return buildSet {
+			(min.x + 1..<max.x).forEach { x ->
+				(min.y + 1..<max.y).forEach { y ->
+					add(BlockPos(x, y, min.z))
+					add(BlockPos(x, y, max.z))
+				}
+			}
+
+			(min.z + 1..<max.z).forEach { z ->
+				(min.y + 1..<max.y).forEach { y ->
+					add(BlockPos(min.x, y, z))
+					add(BlockPos(max.x, y, z))
+				}
+			}
+
+			(min.x + 1..<max.x).forEach { x ->
+				(min.z + 1..<max.z).forEach { z ->
+					BlockPos(x, min.y, z).let { pos ->
+						if (pos == player.supportingBlockPos.getOrNull() && blockState(pos).isReplaceable) add(pos)
+					}
+					add(BlockPos(x, max.y, z))
+				}
+			}
+		}
+	}
+}

src/main/kotlin/com/lambda/module/modules/player/FastBreak.kt

@@ -34,7 +34,7 @@ object FastBreak : Module(
     description = "Break blocks faster.",
     tag = ModuleTag.PLAYER,
 ) {
-    private val pendingInteractions = ConcurrentLinkedQueue<BuildContext>()
+    private val pendingActions = ConcurrentLinkedQueue<BuildContext>()
 
     init {
 		setDefaultAutomationConfig {
@@ -80,7 +80,7 @@ object FastBreak : Module(
         listen<PlayerEvent.Breaking.Update> { event ->
             event.cancel()
 	        runSafeAutomated {
-				breakRequest(listOf(event.pos), pendingInteractions)?.submit()
+				breakRequest(listOf(event.pos), pendingActions)?.submit()
 			}
         }
     }

src/main/kotlin/com/lambda/module/modules/player/PacketMine.kt

@@ -72,7 +72,7 @@ object PacketMine : Module(
     private val startColor by setting("Start Color", Color(255, 255, 0, 60), "The color of the start (closest to breaking) of the queue") { renderQueue && dynamicColor }.group(Group.Renders)
     private val endColor by setting("End Color", Color(255, 0, 0, 60), "The color of the end (farthest from breaking) of the queue") { renderQueue && dynamicColor }.group(Group.Renders)
 
-    private val pendingInteractions = ConcurrentLinkedQueue<BuildContext>()
+    private val pendingActions = ConcurrentLinkedQueue<BuildContext>()
 
     private var breaks = 0
     private var itemDrops = 0
@@ -219,7 +219,7 @@ object PacketMine : Module(
         if (!reBreaking) {
             queuePositions.retainAllPositions(breakContexts)
         }
-        breakRequest(breakContexts, pendingInteractions) {
+        breakRequest(breakContexts, pendingActions) {
             onStart { onProgress(it) }
             onUpdate { onProgress(it) }
             onStop { removeBreak(it); breaks++ }

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

@@ -47,13 +47,13 @@ object Scaffold : Module(
     private val descend by setting("Descend", KeyCode.Unbound, "Lower the place position by one to allow the player to lower y level")
     private val descendAmount by setting("Descend Amount", 1, 1..5, 1, "The amount to lower the place position by when descending", unit = " blocks") { descend != Bind.EMPTY }
 
-    private val pendingInteractions = ConcurrentLinkedQueue<BuildContext>()
+    private val pendingActions = ConcurrentLinkedQueue<BuildContext>()
 
     init {
 		setDefaultAutomationConfig {
 			applyEdits {
 				buildConfig.apply {
-					editTyped(::pathing, ::stayInRange, ::collectDrops) {
+					editTyped(::pathing, ::stayInRange, ::collectDrops, ::spleefEntities) {
 						defaultValue(false)
 						hide()
 					}
@@ -77,7 +77,7 @@ object Scaffold : Module(
 						::accessStashes
 					)
 				}
-				hideAllGroupsExcept(interactConfig, rotationConfig, hotbarConfig, inventoryConfig)
+				hideAllGroupsExcept(buildConfig, interactConfig, rotationConfig, hotbarConfig, inventoryConfig)
 			}
 		}
 
@@ -91,7 +91,7 @@ object Scaffold : Module(
                 scaffoldPositions(beneath)
                     .associateWith { TargetState.Solid(emptySet()) }
                     .simulate()
-                    .interactRequest(pendingInteractions)
+                    .interactRequest(pendingActions)
 	                ?.submit()
             }
         }