packemine refactor and rebreak fixes

beanbag44 · beanbag44 · commit e0a95b2665f6 · 2025-05-07T21:37:09.000+01:00
diff --git a/common/src/main/kotlin/com/lambda/interaction/request/breaking/BreakInfo.kt b/common/src/main/kotlin/com/lambda/interaction/request/breaking/BreakInfo.kt
@@ -62,7 +62,7 @@ data class BreakInfo(
 
     @Synchronized
     fun internalOnBreak() {
-        broken = true
+        if (!isReBreaking) broken = true
         request.onBreak?.invoke(context.expectedPos)
         item?.let { item ->
             request.onItemDrop?.invoke(item)
@@ -71,8 +71,8 @@ data class BreakInfo(
 
     @Synchronized
     fun internalOnItemDrop(item: ItemEntity) {
-        this.item = item
-        if (broken) {
+        if (!isReBreaking) this.item = item
+        if (broken || isReBreaking) {
             request.onItemDrop?.invoke(item)
         }
     }
diff --git a/common/src/main/kotlin/com/lambda/interaction/request/breaking/BreakManager.kt b/common/src/main/kotlin/com/lambda/interaction/request/breaking/BreakManager.kt
@@ -129,12 +129,12 @@ object BreakManager : RequestHandler<BreakRequest>(
         }
 
         listen<WorldEvent.BlockUpdate.Server>(priority = Int.MIN_VALUE) { event ->
+            if (event.pos == ReBreakManager.reBreak?.context?.expectedPos) return@listen
+
             breakInfos
                 .filterNotNull()
                 .firstOrNull { it.context.expectedPos == event.pos }
                 ?.let { info ->
-                    if (event.pos == ReBreakManager.reBreak?.context?.expectedPos) return@listen
-
                     // if not broken
                     if (!isBroken(info.context.checkedState, event.newState)) {
                         this@BreakManager.warn("Break at ${event.pos.toShortString()} was rejected with ${event.newState} instead of ${info.context.checkedState.brokenState}")
@@ -203,8 +203,7 @@ object BreakManager : RequestHandler<BreakRequest>(
 
         if (request.fresh) populateFrom(request)
 
-        if (!atMaxBreakInfos(request.build.breaking)) run processNewBreaks@ {
-            if (!performInstantBreaks(request)) return@processNewBreaks
+        if (performInstantBreaks(request)) {
             processNewBreaks(request)
         }
 
@@ -215,7 +214,7 @@ object BreakManager : RequestHandler<BreakRequest>(
                 .filterNotNull()
                 .filter { !it.isRedundant }
                 .also {
-                    rotationRequest = it.firstOrNull { it.breakConfig.rotateForBreak }
+                    rotationRequest = it.firstOrNull { info -> info.breakConfig.rotateForBreak }
                         ?.let { info ->
                             val rotation = info.context.rotation
                             if (instantBreaks.isEmpty()) info.request.rotation.request(rotation, false) else rotation
@@ -251,7 +250,7 @@ object BreakManager : RequestHandler<BreakRequest>(
     private fun SafeContext.populateFrom(request: BreakRequest) {
         // Sanitize the new breaks
         val newBreaks = request.contexts
-            .filter { ctx -> canAccept(ctx) }
+            .filter { ctx -> canAccept(ctx, request.build.breaking) }
             .toMutableList()
 
         // Update the current break infos or cancel if abandoned
@@ -281,14 +280,16 @@ object BreakManager : RequestHandler<BreakRequest>(
     /**
      * @return if the break context can be accepted.
      */
-    private fun SafeContext.canAccept(ctx: BreakContext): Boolean {
+    private fun SafeContext.canAccept(ctx: BreakContext, breakConfig: BreakConfig): Boolean {
         if (pendingBreaks.any { it.context.expectedPos == ctx.expectedPos }) return false
 
-        breakInfos
-            .firstOrNull { it != null && !it.isRedundant }
-            ?.let { info ->
-                if (ctx.hotbarIndex != info.context.hotbarIndex) return false
-            }
+        if (breakConfig.doubleBreak) {
+            breakInfos
+                .firstOrNull { it != null && !it.isRedundant }
+                ?.let { info ->
+                    if (ctx.hotbarIndex != info.context.hotbarIndex) return false
+                }
+        }
 
         return !blockState(ctx.expectedPos).isAir
     }
@@ -449,27 +450,23 @@ object BreakManager : RequestHandler<BreakRequest>(
             if (isPrimary) {
                 abortBreakPacket(world, interaction)
                 nullify()
-                return@runSafe
-            }
-            if (isSecondary && breakConfig.unsafeCancels) {
+            } else if (isSecondary && breakConfig.unsafeCancels) {
                 makeRedundant()
             }
+
+            internalOnCancel()
         }
 
     /**
      * Nullifies the break. If the block is not broken, the [BreakInfo.internalOnCancel] callback gets triggered
      */
-    private fun BreakInfo.nullify() {
-        type.nullify()
-        if (!broken && !pending && !isReBreaking && !isRedundant) internalOnCancel()
-    }
+    private fun BreakInfo.nullify() = type.nullify()
 
     /**
      * Makes the [BreakInfo] redundant and triggers the [BreakInfo.internalOnCancel] callback
      */
     private fun BreakInfo.makeRedundant() {
         type = BreakType.RedundantSecondary
-        internalOnCancel()
     }
 
     /**
@@ -494,15 +491,15 @@ object BreakManager : RequestHandler<BreakRequest>(
         val ctx = info.context
         val hitResult = ctx.result
 
-        if (gamemode.isCreative && world.worldBorder.contains(ctx.expectedPos)) {
+        if (gamemode.isCreative && world.worldBorder.contains(ctx.expectedPos) && info.breaking) {
             if (info.isRedundant) {
                 onBlockBreak(info)
                 return true
             }
             breakCooldown = info.breakConfig.breakDelay
             lastPosStarted = ctx.expectedPos
+            onBlockBreak(info)
             interaction.sendSequencedPacket(world) { sequence ->
-                onBlockBreak(info)
                 PlayerActionC2SPacket(Action.START_DESTROY_BLOCK, ctx.expectedPos, hitResult.side, sequence)
             }
             val swing = info.breakConfig.swing
@@ -535,6 +532,7 @@ object BreakManager : RequestHandler<BreakRequest>(
             }
             if (!startBreaking(info)) {
                 info.nullify()
+                info.internalOnCancel()
                 return false
             }
             val swing = info.breakConfig.swing
@@ -547,6 +545,7 @@ object BreakManager : RequestHandler<BreakRequest>(
         val blockState = blockState(ctx.expectedPos)
         if (blockState.isAir) {
             info.nullify()
+            info.internalOnCancel()
             return false
         }
 
@@ -595,8 +594,8 @@ object BreakManager : RequestHandler<BreakRequest>(
         val swing = info.breakConfig.swing
         if (overBreakThreshold) {
             if (info.isPrimary) {
+                onBlockBreak(info)
                 interaction.sendSequencedPacket(world) { sequence ->
-                    onBlockBreak(info)
                     PlayerActionC2SPacket(Action.STOP_DESTROY_BLOCK, ctx.expectedPos, hitResult.side, sequence)
                 }
             } else {
@@ -626,8 +625,8 @@ object BreakManager : RequestHandler<BreakRequest>(
 
         if (gamemode.isCreative) {
             lastPosStarted = ctx.expectedPos
+            onBlockBreak(info)
             interaction.sendSequencedPacket(world) { sequence: Int ->
-                onBlockBreak(info)
                 PlayerActionC2SPacket(Action.START_DESTROY_BLOCK, ctx.expectedPos, ctx.result.side, sequence)
             }
             breakCooldown = info.breakConfig.breakDelay
diff --git a/common/src/main/kotlin/com/lambda/interaction/request/breaking/BrokenBlockHandler.kt b/common/src/main/kotlin/com/lambda/interaction/request/breaking/BrokenBlockHandler.kt
@@ -81,8 +81,10 @@ object BrokenBlockHandler {
                 if (!isBroken(pending.context.checkedState, event.newState)) {
                     if (!pending.isReBreaking) {
                         this@BrokenBlockHandler.warn("Broken block at ${event.pos.toShortString()} was rejected with ${event.newState} instead of ${pending.context.checkedState.brokenState}")
+                        pending.stopPending()
+                    } else {
+                        pending.context.checkedState = event.newState
                     }
-                    pending.stopPending()
                     return@listen
                 }
 
@@ -141,8 +143,6 @@ object BrokenBlockHandler {
         if (!isReBreaking) {
             pendingBreaks.remove(this)
             pendingInteractions.remove(context)
-        } else {
-            resetCallbacks()
         }
     }
 
diff --git a/common/src/main/kotlin/com/lambda/interaction/request/breaking/ReBreakManager.kt b/common/src/main/kotlin/com/lambda/interaction/request/breaking/ReBreakManager.kt
@@ -50,6 +50,7 @@ object ReBreakManager {
         reBreak = info.apply {
             type = BreakType.ReBreak
             breaking = true
+            resetCallbacks()
         }
         info.request.onReBreakStart?.invoke(info.context.expectedPos)
     }
@@ -62,11 +63,10 @@ object ReBreakManager {
         runSafe {
             val info = reBreak ?: return@runSafe ReBreakResult.Ignored
 
-            if (info.updatedThisTick) return@runSafe ReBreakResult.ReBroke
-
             if (info.context.expectedPos != ctx.expectedPos || !info.breakConfig.reBreak.mode.isEnabled()) {
                 return@runSafe ReBreakResult.Ignored
             }
+            if (info.updatedThisTick) return@runSafe ReBreakResult.ReBroke
             info.updateInfo(ctx, breakRequest)
 
             val context = info.context
diff --git a/common/src/main/kotlin/com/lambda/module/modules/player/PacketMine.kt b/common/src/main/kotlin/com/lambda/module/modules/player/PacketMine.kt
@@ -62,51 +62,45 @@ object PacketMine : Module(
     private val breakingPositions = arrayOfNulls<BlockPos>(2)
     private var reBreakPos: BlockPos? = null
 
-    private var requestedThisTick = false
+    private var attackedThisTick = false
 
     init {
         listen<TickEvent.Post> {
-            requestedThisTick = false
+            attackedThisTick = 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))
+            requestBreakManager(reBreak)
         }
 
         listen<PlayerEvent.Attack.Block> { it.cancel() }
         listen<PlayerEvent.Breaking.Update> { event ->
             event.cancel()
             if (breakingPositions.any { it == event.pos }) return@listen
-            if (breakConfig.doubleBreak && breakingPositions[1] == null) {
-                breakingPositions[1] = breakingPositions[0]
-            }
-            breakingPositions[0] = null
-            sendBreakRequest(event.pos)
-            requestedThisTick = true
+            val secondary = if (breakConfig.doubleBreak) {
+                breakingPositions[1] ?: breakingPositions[0]
+            } else null
+            requestBreakManager(event.pos, secondary)
+            attackedThisTick = true
         }
 
         listen<TickEvent.Input.Post> {
-            if (!requestedThisTick) sendBreakRequest()
+            if (!attackedThisTick) requestBreakManager(*breakingPositions.toList().toTypedArray())
         }
     }
 
-    private fun SafeContext.sendBreakRequest(hitPos: BlockPos? = null) {
-        val requestPositions = arrayListOf(*breakingPositions.filterNotNull().toTypedArray())
-        hitPos?.let { pos ->
-            requestPositions.add(pos)
-        }
-
-        if (requestPositions.isNotEmpty()) requestBreakManager(requestPositions)
-    }
-
-    private fun SafeContext.requestBreakManager(requestPositions: List<BlockPos>) {
+    private fun SafeContext.requestBreakManager(vararg requestPositions: BlockPos?) {
+        if (requestPositions.isEmpty()) return
         val request = BreakRequest(
-            breakContexts(requestPositions), build, rotation, hotbar, pendingInteractions = pendingInteractionsList,
+            breakContexts(requestPositions.filterNotNull()), build, rotation, hotbar, pendingInteractions = pendingInteractionsList,
             onAccept = {
+                if (breakConfig.doubleBreak && breakingPositions[1] == null) {
+                    breakingPositions[1] = breakingPositions[0]
+                }
                 breakingPositions[0] = it
                 reBreakPos = null
             },
@@ -123,16 +117,15 @@ object PacketMine : Module(
     }
 
     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
-                return
             }
         }
+        if (includeReBreak && pos == reBreakPos) {
+            reBreakPos = null
+            return
+        }
     }
 
     private fun SafeContext.breakContexts(breakPositions: Collection<BlockPos>) =
@@ -152,4 +145,4 @@ object PacketMine : Module(
     enum class Page {
         Build, Rotation, Interaction, Inventory, Hotbar
     }
-}
+}

Original file line number	Diff line number	Diff line change
`@@ -81,8 +81,10 @@ object BrokenBlockHandler {`
`81`	`81`	`if (!isBroken(pending.context.checkedState, event.newState)) {`
`82`	`82`	`if (!pending.isReBreaking) {`
`83`	`83`	`this@BrokenBlockHandler.warn("Broken block at ${event.pos.toShortString()} was rejected with ${event.newState} instead of ${pending.context.checkedState.brokenState}")`
	`84`	`+ pending.stopPending()`
	`85`	`+ } else {`
	`86`	`+ pending.context.checkedState = event.newState`
`84`	`87`	`}`
`85`		`- pending.stopPending()`
`86`	`88`	`return@listen`
`87`	`89`	`}`
`88`	`90`
`@@ -141,8 +143,6 @@ object BrokenBlockHandler {`
`141`	`143`	`if (!isReBreaking) {`
`142`	`144`	`pendingBreaks.remove(this)`
`143`	`145`	`pendingInteractions.remove(context)`
`144`		`- } else {`
`145`		`- resetCallbacks()`
`146`	`146`	`}`
`147`	`147`	`}`
`148`	`148`
Original file line number	Diff line number	Diff line change
`@@ -50,6 +50,7 @@ object ReBreakManager {`
`50`	`50`	`reBreak = info.apply {`
`51`	`51`	`type = BreakType.ReBreak`
`52`	`52`	`breaking = true`
	`53`	`+ resetCallbacks()`
`53`	`54`	`}`
`54`	`55`	`info.request.onReBreakStart?.invoke(info.context.expectedPos)`
`55`	`56`	`}`
`@@ -62,11 +63,10 @@ object ReBreakManager {`
`62`	`63`	`runSafe {`
`63`	`64`	`val info = reBreak ?: return@runSafe ReBreakResult.Ignored`
`64`	`65`
`65`		`- if (info.updatedThisTick) return@runSafe ReBreakResult.ReBroke`
`66`		`-`
`67`	`66`	`if (info.context.expectedPos != ctx.expectedPos \|\| !info.breakConfig.reBreak.mode.isEnabled()) {`
`68`	`67`	`return@runSafe ReBreakResult.Ignored`
`69`	`68`	`}`
	`69`	`+ if (info.updatedThisTick) return@runSafe ReBreakResult.ReBroke`
`70`	`70`	`info.updateInfo(ctx, breakRequest)`
`71`	`71`
`72`	`72`	`val context = info.context`