use index's instead of doubleBreakBlock booleans

Author: beanbag44

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

@@ -278,13 +278,13 @@ object PacketMine : Module(
                                 runBetweenHandlers(ProgressStage.EndPre, ProgressStage.EndPost, pos, { lastValidBestTool }) {
                                     packetStopBreak(pos)
 
-                                    onBlockBreak(doubleBreakBlock = false)
+                                    onBlockBreak(index = 0)
                                 }
                                 return@forEach
                             }
 
                             doubleBreakSwapTo(bestTool)
-                            onBlockBreak(doubleBreakBlock = true)
+                            onBlockBreak(index = 1)
                         }
 
                         BreakState.ReBreaking -> {
@@ -294,7 +294,7 @@ object PacketMine : Module(
                             }
 
                             if (isOutOfRange(pos.toCenterPos()) || !reBreak.isEnabled()) {
-                                nullifyCurrentBreakingBlock(false)
+                                nullifyCurrentBreakingBlock(0)
                                 return@forEach
                             }
 
@@ -324,22 +324,22 @@ object PacketMine : Module(
                                 if (breakType == BreakType.Primary) {
                                     runHandlers(ProgressStage.EndPost, pos, lastValidBestTool)
                                 }
-                                onBlockBreak(doubleBreakBlock = breakType == BreakType.Double)
+                                onBlockBreak(index = breakType.index)
                                 return@forEach
                             }
 
                             if (System.currentTimeMillis() - timeCompleted < timeoutDelay * 1000) return@forEach
 
                             val primary = breakType == BreakType.Primary
 
-                            if (!primary) nullifyCurrentBreakingBlock(true)
+                            if (!primary) nullifyCurrentBreakingBlock(1)
                             if (breakNextQueueBlock()) return@forEach
 
                             if (primary) {
                                 runHandlers(ProgressStage.TimedOut, pos, lastValidBestTool)
                             }
 
-                            nullifyCurrentBreakingBlock(breakType == BreakType.Double)
+                            nullifyCurrentBreakingBlock(breakType.index)
                         }
                     }
                 }
@@ -365,7 +365,7 @@ object PacketMine : Module(
                         }
                     }
 
-                    onBlockBreak(packetReceiveBreak = true, doubleBreakBlock = breakType == BreakType.Double)
+                    onBlockBreak(packetReceiveBreak = true, index = breakType.index)
                 }
             }
         }
@@ -861,12 +861,10 @@ object PacketMine : Module(
     private fun SafeContext.isOutOfRange(vec: Vec3d) =
         player.eyePos.distanceTo(vec) > range
 
-    private fun SafeContext.onBlockBreak(packetReceiveBreak: Boolean = false, doubleBreakBlock: Boolean = false) {
-        val block = if (doubleBreakBlock) 1 else 0
-
-        currentMiningBlock[block]?.apply {
+    private fun SafeContext.onBlockBreak(packetReceiveBreak: Boolean = false, index: Int = 0) {
+        currentMiningBlock[index]?.apply {
             if (!isOutOfRange(pos.toCenterPos()) || packetReceiveBreak) {
-                checkClientSideBreak(packetReceiveBreak, pos, doubleBreakBlock = doubleBreakBlock)
+                checkClientSideBreak(packetReceiveBreak, pos, index = index)
             }
 
             if (timeCompleted == -1L) {
@@ -879,13 +877,13 @@ object PacketMine : Module(
             }
 
             if (breakType == BreakType.Double && (breakState == BreakState.AwaitingResponse || !validateBreak)) {
-                nullifyCurrentBreakingBlock(true)
+                nullifyCurrentBreakingBlock(1)
             }
 
             breaksPerTickCounter++
 
             queueBreakStartCounter = queueBreakDelay
-            if (breakNextQueueBlock(doubleBreakBlock = doubleBreakBlock)) return
+            if (breakNextQueueBlock(index = index)) return
 
             if (reBreak.isEnabled() && !isOutOfRange(pos.toCenterPos()) && breakType == BreakType.Primary) {
                 if (breakState != BreakState.ReBreaking) {
@@ -896,45 +894,39 @@ object PacketMine : Module(
                 return
             }
 
-            nullifyCurrentBreakingBlock(doubleBreakBlock)
+            nullifyCurrentBreakingBlock(index)
         }
     }
 
-    private fun SafeContext.nullifyCurrentBreakingBlock(doubleBreakBlock: Boolean) {
-        val block = if (doubleBreakBlock) 1 else 0
-
-        if (!doubleBreakBlock) {
-            currentMiningBlock[block]?.apply {
+    private fun SafeContext.nullifyCurrentBreakingBlock(index: Int) {
+        if (index == 0) {
+            currentMiningBlock[index]?.apply {
                 if (breakingAnimation) world.setBlockBreakingInfo(player.id, pos, -1)
                 runHandlers(ProgressStage.TimedOut, pos, lastValidBestTool)
             }
         }
 
-        currentMiningBlock[block] = null
+        currentMiningBlock[index] = null
     }
 
-    private fun isStateBroken(previousState: BlockState?, activeState: BlockState): Boolean {
-        previousState?.let { previous ->
-            if (isStateEmpty(previous)) return false
+    private fun isStateBroken(previousState: BlockState, newState: BlockState): Boolean {
+        if (isStateEmpty(previousState)) return false
 
-            return activeState.isAir || (
-                    activeState.fluidState.fluid is WaterFluid
-                            && !activeState.properties.contains(Properties.WATERLOGGED)
-                            && previous.properties.contains(Properties.WATERLOGGED)
-                            && previous.get(Properties.WATERLOGGED)
-                    )
-        } ?: return false
+        return (newState.isAir && previousState.fluidState.isEmpty)
+                || (
+                !newState.fluidState.isEmpty
+                        && !previousState.fluidState.isEmpty
+                )
     }
 
     private fun isStateEmpty(state: BlockState) =
         state.isAir || (
-                (!state.properties.contains(Properties.WATERLOGGED)
-                        || !state.get(Properties.WATERLOGGED))
+                !state.properties.contains(Properties.WATERLOGGED)
                         && !state.fluidState.isEmpty
                 )
 
-    private fun SafeContext.checkClientSideBreak(packetReceiveBreak: Boolean, pos: BlockPos, doubleBreakBlock: Boolean = false) {
-        if (packetReceiveBreak || (!validateBreak && !doubleBreakBlock)) {
+    private fun SafeContext.checkClientSideBreak(packetReceiveBreak: Boolean, pos: BlockPos, index: Int = 0) {
+        if (packetReceiveBreak || (!validateBreak && index == 0)) {
             interaction.breakBlock(pos)
         }
     }
@@ -963,18 +955,18 @@ object PacketMine : Module(
                 && currentMiningBlock[1]?.pos != pos
                 && !blockQueue.contains(pos)
 
-    private fun SafeContext.breakNextQueueBlock(doubleBreakBlock: Boolean = false): Boolean {
+    private fun SafeContext.breakNextQueueBlock(index: Int = 0): Boolean {
         if (!queueBlocks || currentMiningBlock.any { it?.timeCompleted == -1L }) return false
 
         var startedBreakingAtLeastOne = false
 
         while (true) {
             filterBlockQueueUntilNextPossible()?.let { block ->
-                currentMiningBlock[1]?.run {
+                if (currentMiningBlock[1] != null) {
                     return startedBreakingAtLeastOne
                 }
 
-                val requiresAnotherTickDelay = doubleBreakBlock && !validateBreak && queueBreakDelay <= 0 && doubleBreak
+                val requiresAnotherTickDelay = index == 1 && !validateBreak && queueBreakDelay <= 0 && doubleBreak
 
                 if (queueBreakStartCounter > 0 || breaksPerTickCounter >= 1 || requiresAnotherTickDelay) {
                     if (requiresAnotherTickDelay) queueBreakStartCounter++
@@ -1369,7 +1361,7 @@ object PacketMine : Module(
         Breaking, ReBreaking, AwaitingResponse
     }
 
-    private enum class BreakType {
-        Primary, Double;
+    private enum class BreakType(val index: Int) {
+        Primary(0), Double(1);
     }
 }