item drop callbacks

Author: beanbag44

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

@@ -21,6 +21,7 @@ import com.lambda.Lambda.mc
 import com.lambda.config.groups.BuildConfig
 import com.lambda.context.SafeContext
 import com.lambda.event.EventFlow.post
+import com.lambda.event.events.EntityEvent
 import com.lambda.event.events.TickEvent
 import com.lambda.event.events.UpdateManagerEvent
 import com.lambda.event.events.WorldEvent
@@ -195,15 +196,19 @@ object BreakManager : RequestHandler<BreakRequest>(), PositionBlocking {
                     if (event.newState.matches(pending.context.checkedState))
                         return@listen
 
-                    pendingBreaks.remove(pending)
                     // return if the block's not broken
-                    if (!matchesTargetState(event.pos, pending.context.targetState, event.newState))
+                    if (!matchesTargetState(event.pos, pending.context.targetState, event.newState)) {
+                        pendingBreaks.remove(pending)
                         return@listen
+                    }
 
                     if (pending.breakConfig.breakConfirmation == BreakConfirmationMode.AwaitThenBreak) {
                         destroyBlock(pending)
                     }
-                    pending.onBreak()
+                    pending.internalOnBreak()
+                    if (pending.callbacksCompleted) {
+                        pendingBreaks.remove(pending)
+                    }
                     return@listen
                 }
 
@@ -218,22 +223,34 @@ object BreakManager : RequestHandler<BreakRequest>(), PositionBlocking {
                         return@listen
                     }
                     destroyBlock(info)
-                    info.onBreak()
+                    info.internalOnBreak()
                     info.nullify()
+                    if (!info.callbacksCompleted) {
+                        pendingBreaks.add(info)
+                    }
                 }
         }
 
-        //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
-//            pendingBreaks
-//                .firstOrNull { info -> matchesBlockItem(info, it.entity) }
-//                ?.onItemDrop?.invoke(it.entity)
-//                ?: breakingInfos
-//                    .filterNotNull()
-//                    .firstOrNull { info -> matchesBlockItem(info, it.entity) }?.onItemDrop?.invoke(it.entity)
-//        }
+        listen<EntityEvent.EntityUpdate> {
+            if (it.entity !is ItemEntity) return@listen
+            pendingBreaks
+                .firstOrNull { info -> matchesBlockItem(info, it.entity) }
+                ?.let { pending ->
+                    pending.internalOnItemDrop(it.entity)
+                    if (pending.callbacksCompleted) {
+                        pendingBreaks.remove(pending)
+                    }
+                    return@listen
+                }
+
+            breakingInfos
+                .filterNotNull()
+                .firstOrNull { info -> matchesBlockItem(info, it.entity) }
+                ?.let { info ->
+                    info.internalOnItemDrop(it.entity)
+                }
+        }
     }
 
     private fun matchesBlockItem(info: BreakInfo, entity: ItemEntity): Boolean {
@@ -509,6 +526,32 @@ object BreakManager : RequestHandler<BreakRequest>(), PositionBlocking {
         var soundsCooldown = 0.0f
         var startedWithSecondary = false
 
+        @Volatile
+        private var broken = false
+        private var item: ItemEntity? = null
+
+        val callbacksCompleted
+            @Synchronized get() = broken && (onItemDrop == null || item != null)
+
+        fun internalOnBreak() {
+            synchronized(this) {
+                broken = true
+                onBreak()
+                item?.let { item ->
+                    onItemDrop?.invoke(item)
+                }
+            }
+        }
+
+        fun internalOnItemDrop(item: ItemEntity) {
+            synchronized(this) {
+                this.item = item
+                if (broken) {
+                    onItemDrop?.invoke(item)
+                }
+            }
+        }
+
         fun requestHotbarSwap() =
             hotbarConfig.request(HotbarRequest(context.hotbarIndex)).done
 

common/src/main/kotlin/com/lambda/module/modules/player/HighwayTools.kt

@@ -119,6 +119,7 @@ object HighwayTools : Module(
                 emptyStructure()
             }
         }.build(
+            collectDrops = build.collectDrops,
             build = build,
             rotation = rotation,
             interact = interact,

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

@@ -24,7 +24,6 @@ import com.lambda.config.groups.InteractionConfig
 import com.lambda.config.groups.InventoryConfig
 import com.lambda.interaction.request.rotation.RotationConfig
 import com.lambda.context.SafeContext
-import com.lambda.event.events.EntityEvent
 import com.lambda.event.events.TickEvent
 import com.lambda.event.listener.SafeListener.Companion.listen
 import com.lambda.interaction.construction.blueprint.Blueprint
@@ -204,46 +203,37 @@ class BuildTask @Ta5kBuilder constructor(
                 return@listen
             }
         }
-
-        // ToDo: Dependent on the tracked data order. When set stack is called after position it wont work
-        listen<EntityEvent.EntityUpdate> {
-            if (!collectDrops) return@listen
-            if (it.entity !is ItemEntity) return@listen
-            pendingInteractions.find { context ->
-                val inRange = context.expectedPos.toCenterPos().isInRange(it.entity.pos, 0.5)
-                val correctMaterial = context.checkedState.block == it.entity.stack.item.block
-                inRange && correctMaterial
-            }?.let { _ ->
-                dropsToCollect.add(it.entity)
-            }
-        }
     }
 
     private fun SafeContext.collectDrops() =
-        dropsToCollect.firstOrNull()?.let { itemDrop ->
-            if (!world.entities.contains(itemDrop)) {
-                dropsToCollect.remove(itemDrop)
-                BaritoneUtils.cancel()
-                return true
-            }
+        dropsToCollect
+            .firstOrNull()
+            ?.let { itemDrop ->
+                if (positionBlockingManagers.any { it.blockedPositions.isNotEmpty() }) return true
+
+                if (!world.entities.contains(itemDrop)) {
+                    dropsToCollect.remove(itemDrop)
+                    BaritoneUtils.cancel()
+                    return true
+                }
 
-            val noInventorySpace = player.hotbarAndStorage.none { it.isEmpty }
-            if (noInventorySpace) {
-                val stackToThrow = player.currentScreenHandler.inventorySlots.firstOrNull {
-                    it.stack.item.block in TaskFlowModule.inventory.disposables
-                } ?: run {
-                    failure("No item in inventory to throw but inventory is full and cant pick up item drop")
+                val noInventorySpace = player.hotbarAndStorage.none { it.isEmpty }
+                if (noInventorySpace) {
+                    val stackToThrow = player.currentScreenHandler.inventorySlots.firstOrNull {
+                        it.stack.item.block in TaskFlowModule.inventory.disposables
+                    } ?: run {
+                        failure("No item in inventory to throw but inventory is full and cant pick up item drop")
+                        return true
+                    }
+                    transfer(player.currentScreenHandler) {
+                        throwStack(stackToThrow.id)
+                    }.execute(this@BuildTask)
                     return true
                 }
-                transfer(player.currentScreenHandler) {
-                    throwStack(stackToThrow.id)
-                }.execute(this@BuildTask)
-                return true
-            }
 
-            BaritoneUtils.setGoalAndPath(GoalBlock(itemDrop.blockPos))
-            return true
-        } ?: false
+                BaritoneUtils.setGoalAndPath(GoalBlock(itemDrop.blockPos))
+                return true
+            } ?: false
 
     companion object {
         @Ta5kBuilder