fully working double break and fast break. No delays for blocks that take longer than 6 ticks to break

Author: beanbag44

src/main/kotlin/com/lambda/interaction/managers/breaking/BreakInfo.kt

@@ -18,6 +18,7 @@
 package com.lambda.interaction.managers.breaking
 
 import com.lambda.config.blocks.BreakConfig
+import com.lambda.config.blocks.BreakConfig.BreakMode
 import com.lambda.context.SafeContext
 import com.lambda.interaction.construction.simulation.context.BreakContext
 import com.lambda.interaction.handlers.breaking.RebreakHandler
@@ -35,6 +36,7 @@ import net.minecraft.item.ItemStack
 import net.minecraft.network.packet.c2s.play.PlayerActionC2SPacket
 import net.minecraft.network.packet.c2s.play.PlayerActionC2SPacket.Action
 import net.minecraft.util.math.BlockPos
+import net.minecraft.world.attribute.EnvironmentAttributeModifier.override
 
 /**
  * A data class that holds all the information required to process and continue a break.
@@ -66,6 +68,7 @@ data class BreakInfo(
 	var soundsCooldown = 0f
 	var vanillaInstantBreakable = false
 	val rebreakable get() = !vanillaInstantBreakable && type == Primary
+	var bypassedDelay = breakConfig.breakMode != BreakMode.OldGrim
 
 	enum class BreakType(
 		override val displayName: String,
@@ -161,5 +164,7 @@ data class BreakInfo(
 			}
 		}
 
+	fun getBreakDelay() = if (!bypassedDelay) 6 else breakConfig.breakDelay
+
 	override fun toString() = "$type, ${context.cachedState}, ${context.blockPos}"
 }

src/main/kotlin/com/lambda/interaction/managers/breaking/BreakManager.kt

@@ -154,7 +154,7 @@ object BreakManager : Manager<BreakRequest>(
 	private var rotationRequest: RotationRequest? = null
 	private val rotated get() = rotationRequest?.done != false
 
-	private var breakCooldown = 0
+	private var breakDelay = 0
 	var breaksThisTick = 0
 	private var maxBreaksThisTick = 0
 
@@ -166,19 +166,15 @@ object BreakManager : Manager<BreakRequest>(
 			field = value
 		}
 
-	const val OLD_GRIM_Y_OFFSET = 2000
+	const val OLD_GRIM_Y_OFFSET = 955
 
 	override fun load(): String {
 		super.load()
 
-		listen<TickEvent.Pre>({ Int.MAX_VALUE }) {
-			if (activeInfos.isEmpty() && breaks.isEmpty()) return@listen
-		}
-
 		listen<TickEvent.Post>({ Int.MIN_VALUE }) {
 			if (primaryBreak?.breaking == false) primaryBreak = null
 			breakInfos.forEach { it?.tickChecks() }
-			if (breakCooldown > 0) breakCooldown--
+			if (breakDelay > 0) breakDelay--
 			activeRequest = null
 			breaks = mutableListOf()
 			breaksThisTick = 0
@@ -231,7 +227,7 @@ object BreakManager : Manager<BreakRequest>(
 		listenUnsafe<ConnectionEvent.Connect.Pre>({ Int.MIN_VALUE }) {
 			primaryBreak = null
 			secondaryBreak = null
-			breakCooldown = 0
+			breakDelay = 0
 		}
 
 		immediateRenderer("BreakManager Immediate Renderer") {
@@ -474,6 +470,7 @@ object BreakManager : Manager<BreakRequest>(
 	private fun SafeContext.processNewBreak(request: BreakRequest): Boolean =
 		request.runSafeAutomated {
 			if (tickStage !in request.breakConfig.tickStageMask) return false
+			if (breakDelay > 0) return false
 
 			breaks.forEach { ctx ->
 				if (breaksThisTick >= maxBreaksThisTick) return false
@@ -505,8 +502,6 @@ object BreakManager : Manager<BreakRequest>(
 		requestCtx: BreakContext,
 		request: BreakRequest
 	): BreakInfo? {
-		if (breakCooldown > 0) return null
-
 		val breakInfo = BreakInfo(requestCtx, Primary, request)
 		primaryBreak?.let { primaryInfo ->
 			if (tickStage !in primaryInfo.breakConfig.tickStageMask) return null
@@ -622,6 +617,7 @@ object BreakManager : Manager<BreakRequest>(
 			}
 		}
 		breaksThisTick++
+		if (info.type == Primary) breakDelay = info.getBreakDelay()
 		info.nullify()
 	}
 
@@ -705,7 +701,7 @@ object BreakManager : Manager<BreakRequest>(
 
 			if (gamemode.isCreative && world.worldBorder.contains(ctx.blockPos)) {
 				if (!PacketLimitHandler.canSendPackets(1, PacketType.PlayerAction)) return
-				breakCooldown = breakConfig.breakDelay
+				breakDelay = info.getBreakDelay()
 				lastPosStarted = ctx.blockPos
 				onBlockBreak(info)
 				info.startBreakPacket()
@@ -723,6 +719,13 @@ object BreakManager : Manager<BreakRequest>(
 
 			if (breakConfig.swapMode == BreakConfig.SwapMode.Constant && !swapped) return
 
+			val requiresDelayBypassing = info.type == Primary && breakConfig.breakMode == BreakMode.OldGrim && !info.bypassedDelay
+			if (requiresDelayBypassing && PacketLimitHandler.canSendPackets(22, PacketType.PlayerAction) && info.breakingTicks >= 6) {
+				repeat(22) { info.startBreakPacket(OLD_GRIM_Y_OFFSET) }
+				PacketLimitHandler.sentPackets(22, PacketType.PlayerAction)
+				info.bypassedDelay = true
+			}
+
 			info.breakingTicks++
 			val breakDelta = blockState.calcBreakDelta(ctx.blockPos)
 			val progress = breakDelta * (info.breakingTicks - breakConfig.fudgeFactor)
@@ -750,15 +753,18 @@ object BreakManager : Manager<BreakRequest>(
 			val swing = breakConfig.swing
 			if (progress >= info.getBreakThreshold()) {
 				if (info.swapInfo.swap && !swapped) return
-				if (info.type == Primary && !PacketLimitHandler.canSendPackets(1, PacketType.PlayerAction)) return
+
+				if (info.type == Primary) {
+					if (breakConfig.breakMode == BreakMode.OldGrim && info.breakingTicks < 6) return
+					if (!PacketLimitHandler.canSendPackets(1, PacketType.PlayerAction)) return
+				}
 
 				onBlockBreak(info)
 				if (info.type == Primary) {
 					info.stopBreakPacket()
 					PacketLimitHandler.sentPackets(1, PacketType.PlayerAction)
 				}
 				if (swing.isEnabled() && swing != BreakConfig.SwingMode.Start) swingHand(breakConfig.swingType, Hand.MAIN_HAND)
-				breakCooldown = breakConfig.breakDelay
 			} else {
 				if (swing == BreakConfig.SwingMode.Constant) swingHand(breakConfig.swingType, Hand.MAIN_HAND)
 			}
@@ -809,7 +815,7 @@ object BreakManager : Manager<BreakRequest>(
 			onBlockBreak(info)
 			info.startBreakPacket()
 			PacketLimitHandler.sentPackets(1, PacketType.PlayerAction)
-			breakCooldown = breakConfig.breakDelay
+			breakDelay = info.getBreakDelay()
 			if (breakConfig.swing.isEnabled()) swingHand(breakConfig.swingType, Hand.MAIN_HAND)
 			return true
 		}
@@ -821,9 +827,12 @@ object BreakManager : Manager<BreakRequest>(
 
 		var packetCount = 1
 		info.vanillaInstantBreakable = progress >= 1
-		val oldGrim = breakConfig.breakMode == BreakMode.OldGrim && !info.vanillaInstantBreakable
-		if (breakConfig.breakMode == BreakMode.Grim || oldGrim) packetCount++
-		val requiresSecondStop = info.type == Secondary || (instantBreakable && !info.vanillaInstantBreakable)
+		val isGrim = breakConfig.breakMode == BreakMode.Grim
+		val oldGrim = breakConfig.breakMode == BreakMode.OldGrim
+		val requiresSecondStop = instantBreakable && !info.vanillaInstantBreakable
+
+		if (isGrim) packetCount++
+		else if (oldGrim) packetCount++
 		if (requiresSecondStop) packetCount++
 
 		if (!PacketLimitHandler.canSendPackets(packetCount, PacketType.PlayerAction)) return false
@@ -838,8 +847,7 @@ object BreakManager : Manager<BreakRequest>(
 
 		if (instantBreakable) {
 			onBlockBreak(info)
-			val breakDelay = breakConfig.breakDelay
-			if (!info.vanillaInstantBreakable) breakCooldown = if (breakDelay == 0) 0 else breakDelay + 1
+			if (!info.vanillaInstantBreakable) breakDelay = info.getBreakDelay()
 		} else {
 			info.apply {
 				breaking = true
@@ -849,7 +857,7 @@ object BreakManager : Manager<BreakRequest>(
 			}
 		}
 
-		if (breakConfig.breakMode == BreakMode.Grim) info.stopBreakPacket()
+		if (isGrim) info.stopBreakPacket()
 		info.startBreakPacket()
 		if (oldGrim) info.startBreakPacket(OLD_GRIM_Y_OFFSET)
 		if (requiresSecondStop) info.stopBreakPacket()