automatic re-break

Author: beanbag44

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

@@ -43,6 +43,8 @@ data class BreakInfo(
     var breakingTicks = 0
     var soundsCooldown = 0.0f
 
+    var pending = false
+
     var vanillaInstantBreakable = false
     val reBreakable get() = !vanillaInstantBreakable && isPrimary
 

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

@@ -455,7 +455,7 @@ object BreakManager : RequestHandler<BreakRequest>(
      */
     private fun BreakInfo.nullify() {
         type.nullify()
-        if (!broken && !isReBreaking && !isRedundant) internalOnCancel()
+        if (!broken && !pending && !isReBreaking && !isRedundant) internalOnCancel()
     }
 
     /**
@@ -519,7 +519,9 @@ object BreakManager : RequestHandler<BreakRequest>(
                     } ?: false
                 }
                 is ReBreakResult.ReBroke -> {
+                    info.type = ReBreak
                     info.nullify()
+                    info.request.onReBreak?.invoke(info.context.expectedPos)
                     return true
                 }
                 else -> {}

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

@@ -39,6 +39,8 @@ data class BreakRequest(
     val onCancel: ((BlockPos) -> Unit)? = null,
     val onBreak: ((BlockPos) -> Unit)? = null,
     val onItemDrop: ((ItemEntity) -> Unit)? = null,
+    val onReBreakStart: ((BlockPos) -> Unit)? = null,
+    val onReBreak: ((BlockPos) -> Unit)? = null,
     private val prio: Priority = 0
 ) : Request(prio, build.breaking) {
     override val done: Boolean

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

@@ -128,6 +128,7 @@ object BrokenBlockHandler {
      * Adds the [info] to the [BrokenBlockHandler], and requesters, pending interaction collections.
      */
     fun BreakInfo.startPending() {
+        pending = true
         pendingBreaks.add(this)
         pendingInteractions.add(context)
     }

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

@@ -51,6 +51,7 @@ object ReBreakManager {
             type = BreakType.ReBreak
             breaking = true
         }
+        info.request.onReBreakStart?.invoke(info.context.expectedPos)
     }
 
     fun clearReBreak() {

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

@@ -21,6 +21,7 @@ import com.lambda.config.groups.BuildSettings
 import com.lambda.config.groups.HotbarSettings
 import com.lambda.config.groups.InteractionSettings
 import com.lambda.config.groups.InventorySettings
+import com.lambda.config.groups.ReBreakSettings
 import com.lambda.config.groups.RotationSettings
 import com.lambda.context.SafeContext
 import com.lambda.event.events.PlayerEvent
@@ -59,6 +60,7 @@ object PacketMine : Module(
     private var itemDrops = 0
 
     private val breakingPositions = arrayOfNulls<BlockPos>(2)
+    private var reBreakPos: BlockPos? = null
 
     private var requestedThisTick = false
 
@@ -67,6 +69,14 @@ object PacketMine : Module(
             requestedThisTick = false
         }
 
+        //ToDo: run on every tick stage
+        listen<TickEvent.Pre> {
+            val reBreakMode = breakConfig.reBreak.mode
+            if (reBreakMode != ReBreakSettings.Mode.Auto && reBreakMode != ReBreakSettings.Mode.AutoConstant) return@listen
+            val reBreak = reBreakPos ?: return@listen
+            requestBreakManager(listOf(reBreak))
+        }
+
         listen<PlayerEvent.Attack.Block> { it.cancel() }
         listen<PlayerEvent.Breaking.Update> { event ->
             event.cancel()
@@ -76,6 +86,7 @@ object PacketMine : Module(
             }
             breakingPositions[0] = null
             sendBreakRequest(event.pos)
+            requestedThisTick = true
         }
 
         listen<TickEvent.Input.Post> {
@@ -89,18 +100,33 @@ object PacketMine : Module(
             requestPositions.add(pos)
         }
 
+        if (requestPositions.isNotEmpty()) requestBreakManager(requestPositions)
+    }
+
+    private fun SafeContext.requestBreakManager(requestPositions: List<BlockPos>) {
         val request = BreakRequest(
             breakContexts(requestPositions), build, rotation, hotbar, pendingInteractions = pendingInteractionsList,
-            onAccept = { breakingPositions[0] = it },
-            onCancel = { nullifyBreakPos(it) },
-            onBreak = { breaks++; nullifyBreakPos(it) },
+            onAccept = {
+                breakingPositions[0] = it
+                reBreakPos = null
+            },
+            onCancel = { nullifyBreakPos(it, true) },
+            onBreak = {
+                breaks++
+                nullifyBreakPos(it)
+            },
+            onReBreakStart = { reBreakPos = it },
+            onReBreak = { reBreakPos = it },
             onItemDrop = { _ -> itemDrops++ }
         )
         breakConfig.request(request)
-        requestedThisTick = true
     }
 
-    private fun nullifyBreakPos(pos: BlockPos) {
+    private fun nullifyBreakPos(pos: BlockPos, includeReBreak: Boolean = false) {
+        if (includeReBreak && pos == reBreakPos) {
+            reBreakPos = null
+            return
+        }
         breakingPositions.forEachIndexed { index, breakPos ->
             if (breakPos == pos) {
                 breakingPositions[index] = null