refactors n stuff

Author: beanbag44

common/src/main/kotlin/com/lambda/interaction/request/breaking/BreakManager.kt

@@ -40,12 +40,14 @@ import com.lambda.util.BlockUtils.fluidState
 import com.lambda.util.Communication.info
 import com.lambda.util.Communication.warn
 import com.lambda.util.collections.LimitedDecayQueue
+import com.lambda.util.item.ItemUtils.block
 import com.lambda.util.player.swingHandClient
 import net.minecraft.block.BlockState
 import net.minecraft.block.OperatorBlock
 import net.minecraft.client.sound.PositionedSoundInstance
 import net.minecraft.client.sound.SoundInstance
 import net.minecraft.client.world.ClientWorld
+import net.minecraft.entity.ItemEntity
 import net.minecraft.entity.player.PlayerEntity
 import net.minecraft.item.ItemStack
 import net.minecraft.network.packet.c2s.play.HandSwingC2SPacket
@@ -89,13 +91,12 @@ object BreakManager : RequestHandler<BreakRequest>() {
                         .sortedBy { it.instantBreak }
                         .forEach { requestCtx ->
                             if (!canAccept(requestCtx)) return@forEach
-                            val breakType = handleRequestContext(
-                                requestCtx,
-                                request.onBreak,
-                                request.buildConfig,
-                                request.rotationConfig,
-                                request.hotbarConfig
-                            )
+                            val breakType = with(request) {
+                                handleRequestContext(requestCtx,
+                                    buildConfig, rotationConfig, hotbarConfig,
+                                    onBreak, onItemDrop
+                                )
+                            }
                             if (breakType == BreakType.Null) return@request
                             if (requestCtx.instantBreak && instaBreaks < request.buildConfig.breakSettings.breaksPerTick) {
                                 breakingInfos.getOrNull(breakType.index)?.let { info ->
@@ -154,6 +155,24 @@ object BreakManager : RequestHandler<BreakRequest>() {
                         info.onBreak()
                     }
         }
+
+        //ToDo: drop callback stuff
+//        // ToDo: Dependent on the tracked data order. When set stack is called after position it wont work
+//        listen<EntityEvent.EntityUpdate> {
+//            if (it.entity !is ItemEntity) return@listen
+//            pendingInteractions
+//                .firstOrNull { info -> matchesBlockItem(info, it.entity) }
+//                ?.onItemDrop?.invoke(it.entity)
+//                ?: breakingInfos
+//                    .filterNotNull()
+//                    .firstOrNull { info -> matchesBlockItem(info, it.entity) }?.onItemDrop?.invoke(it.entity)
+//        }
+    }
+
+    private fun matchesBlockItem(info: BreakInfo, entity: ItemEntity): Boolean {
+        val inRange = info.context.expectedPos.toCenterPos().isInRange(entity.pos, 0.5)
+        val correctMaterial = info.context.checkedState.block == entity.stack.item.block
+        return inRange && correctMaterial
     }
 
     private fun SafeContext.matchesTargetState(pos: BlockPos, targetState: TargetState, newState: BlockState) =
@@ -165,52 +184,41 @@ object BreakManager : RequestHandler<BreakRequest>() {
 
     private fun handleRequestContext(
         requestCtx: BreakContext,
-        onBreak: () -> Unit,
         buildConfig: BuildConfig,
         rotationConfig: RotationConfig,
-        hotbarConfig: HotbarConfig
+        hotbarConfig: HotbarConfig,
+        onBreak: () -> Unit,
+        onItemDrop: (ItemEntity) -> Unit
     ): BreakType {
+        val breakInfo = BreakInfo(requestCtx, BreakType.Primary,
+            buildConfig.breakSettings, rotationConfig, hotbarConfig,
+            onBreak, onItemDrop
+        )
         primaryBreakingInfo?.let { primaryInfo ->
             if (!primaryInfo.breakConfig.doubleBreak) return BreakType.Null
             if (primaryInfo.startedWithSecondary) return BreakType.Null
             if (!primaryInfo.breaking) {
-                secondaryBreakingInfo = BreakInfo(
-                    requestCtx,
-                    BreakType.Secondary,
-                    onBreak,
-                    buildConfig.breakSettings,
-                    rotationConfig,
-                    hotbarConfig
-                )
+                secondaryBreakingInfo = breakInfo.apply { type = BreakType.Secondary }
                 return BreakType.Secondary
             } else {
                 primaryInfo.type = BreakType.Secondary
                 secondaryBreakingInfo = primaryInfo
-                primaryBreakingInfo = BreakInfo(
-                    requestCtx,
-                    BreakType.Primary,
-                    onBreak,
-                    buildConfig.breakSettings,
-                    rotationConfig,
-                    hotbarConfig
-                )
+                primaryBreakingInfo = breakInfo
+                setPendingInteractionsLimits(buildConfig)
                 return BreakType.Primary
             }
         } ?: run {
-            primaryBreakingInfo = BreakInfo(
-                requestCtx,
-                BreakType.Primary,
-                onBreak,
-                buildConfig.breakSettings,
-                rotationConfig,
-                hotbarConfig
-            )
-            pendingInteractions.setMaxSize(buildConfig.maxPendingInteractions)
-            pendingInteractions.setDecayTime(buildConfig.interactionTimeout * 50L)
+            primaryBreakingInfo = breakInfo
+            setPendingInteractionsLimits(buildConfig)
             return BreakType.Primary
         }
     }
 
+    private fun setPendingInteractionsLimits(buildConfig: BuildConfig) {
+        pendingInteractions.setMaxSize(buildConfig.maxPendingInteractions)
+        pendingInteractions.setDecayTime(buildConfig.interactionTimeout * 50L)
+    }
+
     private fun SafeContext.canAccept(ctx: BreakContext) =
         pendingInteractions.none { it.context.expectedPos == ctx.expectedPos }
                 && breakingInfos.none { info -> info?.context?.expectedPos == ctx.expectedPos }
@@ -417,10 +425,11 @@ object BreakManager : RequestHandler<BreakRequest>() {
     data class BreakInfo(
         val context: BreakContext,
         var type: BreakType,
-        val onBreak: () -> Unit,
         val breakConfig: BreakConfig,
         val rotationConfig: RotationConfig,
-        val hotbarConfig: HotbarConfig
+        val hotbarConfig: HotbarConfig,
+        val onBreak: () -> Unit,
+        val onItemDrop: (ItemEntity) -> Unit
     ) {
         var breaking = false
         var breakingTicks = 0

common/src/main/kotlin/com/lambda/interaction/request/breaking/BreakRequest.kt

@@ -25,14 +25,16 @@ import com.lambda.interaction.request.hotbar.HotbarConfig
 import com.lambda.interaction.request.rotation.RotationConfig
 import com.lambda.threading.runSafe
 import com.lambda.util.BlockUtils.blockState
+import net.minecraft.entity.ItemEntity
 
 data class BreakRequest(
     val contexts: List<BreakContext>,
     val buildConfig: BuildConfig,
     val rotationConfig: RotationConfig,
     val hotbarConfig: HotbarConfig,
     val prio: Priority = 0,
-    val onBreak: () -> Unit
+    val onBreak: () -> Unit,
+    val onItemDrop: (ItemEntity) -> Unit,
 ) : Request(prio) {
     override val done: Boolean
         get() = runSafe {

common/src/main/kotlin/com/lambda/task/tasks/BuildTask.kt

@@ -46,15 +46,13 @@ import com.lambda.module.modules.client.TaskFlowModule
 import com.lambda.task.Task
 import com.lambda.util.BaritoneUtils
 import com.lambda.util.Communication.info
-import com.lambda.util.Communication.warn
 import com.lambda.util.Formatting.string
 import com.lambda.util.collections.LimitedDecayQueue
 import com.lambda.util.extension.Structure
 import com.lambda.util.extension.inventorySlots
 import com.lambda.util.item.ItemUtils.block
 import com.lambda.util.player.SlotUtils.hotbarAndStorage
 import net.minecraft.entity.ItemEntity
-import net.minecraft.util.Hand
 import net.minecraft.util.math.BlockPos
 
 class BuildTask @Ta5kBuilder constructor(
@@ -72,7 +70,6 @@ class BuildTask @Ta5kBuilder constructor(
     private val pendingInteractions = LimitedDecayQueue<BuildContext>(
         build.maxPendingInteractions, build.interactionTimeout * 50L
     ) { info("${it::class.simpleName} at ${it.expectedPos.toShortString()} timed out") }
-    private var currentInteraction: BuildContext? = null
 
     private var placements = 0
     private var breaks = 0
@@ -110,7 +107,12 @@ class BuildTask @Ta5kBuilder constructor(
                     .take(build.breakSettings.breaksPerTick)
 
                 instantResults.firstOrNull()?.let {
-                    build.breakSettings.request(BreakRequest(instantResults.map { it.context }, build, rotation, hotbar) { breaks++ })
+                    build.breakSettings.request(
+                        BreakRequest(
+                            instantResults.map { it.context }, build, rotation, hotbar,
+                            onBreak = { breaks++ }
+                        ) { item -> if (collectDrops) dropsToCollect.add(item) }
+                    )
                     return@listen
                 }
             }
@@ -149,7 +151,10 @@ class BuildTask @Ta5kBuilder constructor(
                     if (pendingInteractions.size >= build.maxPendingInteractions) return@listen
                     val breakContexts = resultsNotBlocked.filterIsInstance<BreakResult.Break>().map { it.context }
                     if (breakContexts.isNotEmpty()) {
-                        val request = BreakRequest(breakContexts, build, rotation, hotbar) { breaks++ }
+                        val request = BreakRequest(
+                            breakContexts, build, rotation, hotbar,
+                            onBreak = { breaks++ },
+                        ) { item -> if (collectDrops) dropsToCollect.add(item) }
                         build.breakSettings.request(request)
                         return@listen
                     }