start to re break implementation. Need to fix issue with managers calling other managers in onOpen before they have opened

Author: beanbag44

common/src/main/kotlin/com/lambda/config/groups/BreakSettings.kt

@@ -29,6 +29,7 @@ class BreakSettings(
     vis: () -> Boolean = { true }
 ) : BreakConfig(priority) {
     override val breakMode by c.setting("Break Mode", BreakMode.Packet) { vis() }
+    override val reBreak = ReBreakSettings(c, vis)
     override val unsafeCancels by c.setting("Unsafe Cancels", true, "Allows cancelling block breaking even if the server might continue breaking sever side, potentially causing unexpected state changes") { vis() }
     override val breakThreshold by c.setting("Break Threshold", 0.7f, 0.1f..1.0f, 0.02f, "The break amount at which the block is considered broken") { vis() }
     override val doubleBreak by c.setting("Double Break", true, "Allows breaking two blocks at once") { vis() }

common/src/main/kotlin/com/lambda/config/groups/ReBreakSettings.kt

@@ -0,0 +1,36 @@
+/*
+ * 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.config.groups
+
+import com.lambda.config.Configurable
+
+class ReBreakSettings(
+    c: Configurable,
+    vis: () -> Boolean = { true }
+) {
+    val mode by c.setting("ReBreak Mode", Mode.Manual, "The method used to re-break blocks after they've been broken once", vis)
+
+    enum class Mode {
+        None,
+        Manual,
+        Auto,
+        AutoConstant;
+
+        fun isEnabled() = this != None
+    }
+}

common/src/main/kotlin/com/lambda/event/events/TickEvent.kt

@@ -37,7 +37,7 @@ import com.lambda.event.Event
  *
  * @see net.minecraft.client.MinecraftClient.tick
  */
-sealed class TickEvent {
+sealed class TickEvent : Event {
     /**
      * Triggered before each iteration of the game loop.
      *
@@ -47,12 +47,12 @@ sealed class TickEvent {
      * 2. Steps world tick manager
      * 3. Decrements item use cooldown
      */
-    data object Pre : Event
+    data object Pre : TickEvent()
 
     /**
      * Triggered after each iteration of the game loop.
      */
-    data object Post : Event
+    data object Post : TickEvent()
 
     /**
      * Triggered during the network tick stage only
@@ -69,8 +69,8 @@ sealed class TickEvent {
      * @see net.minecraft.client.network.ClientPlayerInteractionManager.tick
      */
     sealed class Network {
-        data object Pre : Event
-        data object Post : Event
+        data object Pre : TickEvent()
+        data object Post : TickEvent()
     }
 
     /**
@@ -87,8 +87,8 @@ sealed class TickEvent {
      * @see net.minecraft.client.MinecraftClient.handleInputEvents
      */
     sealed class Input {
-        data object Pre : Event
-        data object Post : Event
+        data object Pre : TickEvent()
+        data object Post : TickEvent()
     }
 
     /**
@@ -97,8 +97,8 @@ sealed class TickEvent {
      * @see net.minecraft.client.render.WorldRenderer.tick
      */
     sealed class WorldRender {
-        data object Pre : Event
-        data object Post : Event
+        data object Pre : TickEvent()
+        data object Post : TickEvent()
     }
 
     /**
@@ -107,8 +107,8 @@ sealed class TickEvent {
      * @see net.minecraft.client.sound.SoundManager.tick
      */
     sealed class Sound {
-        data object Pre : Event
-        data object Post : Event
+        data object Pre : TickEvent()
+        data object Post : TickEvent()
     }
 
     /**
@@ -128,12 +128,12 @@ sealed class TickEvent {
         /**
          * Triggered before each render tick ([TickEvent.Render]) of the game loop.
          */
-        data object Pre : Event
+        data object Pre : TickEvent()
 
         /**
          * Triggered after each render tick ([TickEvent.Render]) of the game loop.
          */
-        data object Post : Event
+        data object Post : TickEvent()
     }
 
     /**
@@ -152,11 +152,11 @@ sealed class TickEvent {
         /**
          * Triggered before each player tick ([TickEvent.Player]).
          */
-        data object Pre : Event
+        data object Pre : TickEvent()
 
         /**
          * Triggered after each player tick ([TickEvent.Player]).
          */
-        data object Post : Event
+        data object Post : TickEvent()
     }
 }

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

@@ -18,6 +18,7 @@
 package com.lambda.interaction.request.breaking
 
 import com.lambda.config.groups.BuildConfig
+import com.lambda.config.groups.ReBreakSettings
 import com.lambda.event.Event
 import com.lambda.interaction.request.Priority
 import com.lambda.interaction.request.RequestConfig
@@ -27,6 +28,7 @@ abstract class BreakConfig(
     priority: Priority = 0
 ) : RequestConfig<BreakRequest>(priority) {
     abstract val breakMode: BreakMode
+    abstract val reBreak: ReBreakSettings
     abstract val unsafeCancels: Boolean
     abstract val breakThreshold: Float
     abstract val doubleBreak: Boolean

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

@@ -46,6 +46,7 @@ data class BreakInfo(
     val isPrimary get() = type == BreakType.Primary
     val isSecondary get() = type == BreakType.Secondary
     val isRedundant get() = type == BreakType.RedundantSecondary
+    val isReBreaking get() = type == BreakType.ReBreak
 
     @Volatile
     var broken = false; private set
@@ -84,6 +85,11 @@ data class BreakInfo(
         }
     }
 
+    fun resetCallbacks() {
+        broken = false
+        item = null
+    }
+
     fun setBreakingTextureStage(
         player: ClientPlayerEntity,
         world: ClientWorld,
@@ -123,7 +129,8 @@ data class BreakInfo(
 enum class BreakType(val index: Int) {
     Primary(0),
     Secondary(1),
-    RedundantSecondary(2);
+    RedundantSecondary(2),
+    ReBreak(2);
 
     fun getBreakThreshold(breakConfig: BreakConfig) =
         when (this) {

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

@@ -28,7 +28,6 @@ import com.lambda.event.events.WorldEvent
 import com.lambda.event.listener.SafeListener.Companion.listen
 import com.lambda.event.listener.UnsafeListener.Companion.listenUnsafe
 import com.lambda.interaction.construction.context.BreakContext
-import com.lambda.interaction.construction.verify.TargetState
 import com.lambda.interaction.request.PositionBlocking
 import com.lambda.interaction.request.Priority
 import com.lambda.interaction.request.RequestHandler
@@ -37,7 +36,10 @@ import com.lambda.interaction.request.breaking.BreakConfig.BreakMode
 import com.lambda.interaction.request.breaking.BreakManager.activeRequest
 import com.lambda.interaction.request.breaking.BreakManager.processRequest
 import com.lambda.interaction.request.breaking.BreakType.Primary
+import com.lambda.interaction.request.breaking.BreakType.ReBreak
+import com.lambda.interaction.request.breaking.BrokenBlockHandler.brokenState
 import com.lambda.interaction.request.breaking.BrokenBlockHandler.destroyBlock
+import com.lambda.interaction.request.breaking.BrokenBlockHandler.isBroken
 import com.lambda.interaction.request.breaking.BrokenBlockHandler.pendingBreaks
 import com.lambda.interaction.request.breaking.BrokenBlockHandler.setPendingConfigs
 import com.lambda.interaction.request.breaking.BrokenBlockHandler.startPending
@@ -50,7 +52,6 @@ import com.lambda.util.Communication.warn
 import com.lambda.util.item.ItemUtils.block
 import com.lambda.util.player.gamemode
 import com.lambda.util.player.swingHand
-import net.minecraft.block.BlockState
 import net.minecraft.client.sound.PositionedSoundInstance
 import net.minecraft.client.sound.SoundInstance
 import net.minecraft.entity.ItemEntity
@@ -85,12 +86,14 @@ object BreakManager : RequestHandler<BreakRequest>(
     private val rotated get() = rotationRequest?.done != false
 
     private var breakCooldown = 0
-    private var breaksThisTick = 0
+    var breaksThisTick = 0
     private var maxBreaksThisTick = 0
 
     private var breaks = mutableListOf<BreakContext>()
     private var instantBreaks = mutableListOf<BreakContext>()
 
+    var lastPosStarted: BlockPos? = null
+
     fun Any.onBreak(
         alwaysListen: Boolean = false,
         priority: Priority = 0,
@@ -126,7 +129,8 @@ object BreakManager : RequestHandler<BreakRequest>(
                 .firstOrNull { it.context.expectedPos == event.pos }
                 ?.let { info ->
                     // if not broken
-                    if (!matchesTargetState(event.pos, info.context.targetState, event.newState)) {
+                    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}")
                         // update the checked state
                         info.context.checkedState = event.newState
                         return@listen
@@ -135,6 +139,8 @@ object BreakManager : RequestHandler<BreakRequest>(
                     info.internalOnBreak()
                     if (!info.callbacksCompleted) {
                         info.startPending()
+                    } else if (info.isPrimary) {
+                        ReBreakManager.startReBreak(info)
                     }
                     info.nullify()
                 }
@@ -387,6 +393,8 @@ object BreakManager : RequestHandler<BreakRequest>(
                 info.internalOnBreak()
                 if (!info.callbacksCompleted) {
                     info.startPending()
+                } else if (info.isPrimary) {
+                    ReBreakManager.startReBreak(info)
                 }
             }
             BreakConfirmationMode.BreakThenAwait -> {
@@ -442,7 +450,7 @@ object BreakManager : RequestHandler<BreakRequest>(
      */
     private fun BreakInfo.nullify() {
         type.nullify()
-        if (!broken) internalOnCancel()
+        if (!broken && !isReBreaking && !isRedundant) internalOnCancel()
     }
 
     /**
@@ -458,7 +466,8 @@ object BreakManager : RequestHandler<BreakRequest>(
      */
     private fun BreakType.nullify() =
         when (this) {
-            Primary -> primaryBreak = null
+            Primary,
+            ReBreak -> primaryBreak = null
             else -> secondaryBreak = null
         }
 
@@ -492,10 +501,29 @@ object BreakManager : RequestHandler<BreakRequest>(
         }
 
         if (!info.breaking) {
+            when (val reBreakResult = ReBreakManager.handleUpdate(info.context, info.request)) {
+                is ReBreakResult.StillBreaking -> {
+                    primaryBreak = reBreakResult.breakInfo.apply {
+                        type = Primary
+                        ReBreakManager.clearReBreak()
+                    }
+
+                    primaryBreak?.let { primary ->
+                        updateBreakProgress(primary)
+                    }
+                    return true
+                }
+                is ReBreakResult.ReBroke -> {
+                    info.nullify()
+                    return true
+                }
+                else -> {}
+            }
             if (!startBreaking(info)) {
                 info.nullify()
                 return false
             }
+            ReBreakManager.clearReBreak()
             val swing = info.breakConfig.swing
             if (swing.isEnabled() && swing != BreakConfig.SwingMode.End) {
                 swingHand(info.breakConfig.swingType, Hand.MAIN_HAND)
@@ -616,6 +644,7 @@ object BreakManager : RequestHandler<BreakRequest>(
         if (info.breakConfig.breakMode == BreakMode.Packet) {
             info.stopBreakPacket(world, interaction)
         }
+        lastPosStarted = ctx.expectedPos
         info.startBreakPacket(world, interaction)
         if (info.isSecondary || (breakDelta < 1  && breakDelta >= info.breakConfig.breakThreshold)) {
             info.stopBreakPacket(world, interaction)
@@ -633,17 +662,5 @@ object BreakManager : RequestHandler<BreakRequest>(
         return inRange && correctMaterial
     }
 
-    /**
-     * @return if the [newState] matches the [targetState].
-     *
-     * @see TargetState
-     */
-    fun SafeContext.matchesTargetState(pos: BlockPos, targetState: TargetState, newState: BlockState) =
-        if (targetState.matches(newState, pos, world)) true
-        else {
-            this@BreakManager.warn("Break at ${pos.toShortString()} was rejected with $newState instead of $targetState")
-            false
-        }
-
     override fun preEvent(): Event = UpdateManagerEvent.Break().post()
 }