fix preprocessing bug causing some state processing issues

beanbag44 · beanbag44 · commit d75b9ee60755 · 2026-03-02T08:20:33.000Z
diff --git a/src/main/kotlin/com/lambda/interaction/construction/simulation/processing/ProcessorRegistry.kt b/src/main/kotlin/com/lambda/interaction/construction/simulation/processing/ProcessorRegistry.kt
@@ -147,26 +147,29 @@ object ProcessorRegistry : Loadable {
 	context(safeContext: SafeContext)
 	private fun preProcess(pos: BlockPos, state: BlockState, targetState: BlockState, itemStack: ItemStack) =
 		PreProcessingInfoAccumulator(targetState, itemStack.item).run {
+			var stateProcessing = false
 			stateProcessors.forEach { processor ->
 				if (processor.acceptsState(state, targetState)) {
 					with(processor) { preProcess(state, targetState, pos) }
+					stateProcessing = true
 				}
 			}
 			if (!omitInteraction) {
 				if (state.block != expectedState.block) {
-					if (!state.isReplaceable) return@run null
-					propertyPreProcessors.forEach { processor ->
-						if (processor.acceptsState(state, expectedState)) {
-							with(processor) { preProcess(state, expectedState, pos) }
+					if (state.isReplaceable)  {
+						propertyPreProcessors.forEach { processor ->
+							if (processor.acceptsState(state, expectedState)) {
+								with(processor) { preProcess(state, expectedState, pos) }
+							}
 						}
-					}
+					} else if (!stateProcessing) return@run null
 				} else {
 					propertyPostProcessors.forEach { processor ->
 						if (processor.acceptsState(state, expectedState)) {
 							with(processor) { preProcess(state, expectedState, pos) }
 						}
 					}
-					if (!state.matches(expectedState, ignore)) return@run null
+					if (!state.matches(expectedState, ignore) && !stateProcessing) return@run null
 				}
 			}
 			complete()
diff --git a/src/main/kotlin/com/lambda/interaction/construction/simulation/processing/preprocessors/state/BambooStateProcessor.kt b/src/main/kotlin/com/lambda/interaction/construction/simulation/processing/preprocessors/state/BambooStateProcessor.kt
@@ -29,7 +29,7 @@ import net.minecraft.util.math.BlockPos
 
 // Collected using reflections and then accessed from a collection in ProcessorRegistry
 @Suppress("unused")
-object BambooPreProcessor : StateProcessor {
+object BambooStateProcessor : StateProcessor {
 	override fun acceptsState(state: BlockState, targetState: BlockState) =
 		(state.isReplaceable || state.block == Blocks.BAMBOO_SAPLING) && targetState.block == Blocks.BAMBOO
 
diff --git a/src/main/kotlin/com/lambda/interaction/construction/simulation/processing/preprocessors/state/FireStateProcessor.kt b/src/main/kotlin/com/lambda/interaction/construction/simulation/processing/preprocessors/state/FireStateProcessor.kt
@@ -27,7 +27,7 @@ import net.minecraft.util.math.BlockPos
 
 // Collected using reflections and then accessed from a collection in ProcessorRegistry
 @Suppress("unused")
-object FirePreProcessor : StateProcessor {
+object FireStateProcessor : StateProcessor {
 	override fun acceptsState(state: BlockState, targetState: BlockState) =
 		state.isReplaceable && targetState.block == Blocks.FIRE
 
diff --git a/src/main/kotlin/com/lambda/interaction/construction/simulation/processing/preprocessors/state/FlowerPotStateProcessor.kt b/src/main/kotlin/com/lambda/interaction/construction/simulation/processing/preprocessors/state/FlowerPotStateProcessor.kt
@@ -28,7 +28,7 @@ import net.minecraft.util.math.BlockPos
 
 // Collected using reflections and then accessed from a collection in ProcessorRegistry
 @Suppress("unused")
-object FlowerPotPreProcessor : StateProcessor {
+object FlowerPotStateProcessor : StateProcessor {
 	override fun acceptsState(state: BlockState, targetState: BlockState) =
 		(state.isReplaceable || state.block == Blocks.FLOWER_POT) &&
 				(targetState.block is FlowerPotBlock && targetState.block != Blocks.FLOWER_POT)
diff --git a/src/main/kotlin/com/lambda/interaction/managers/breaking/BreakManager.kt b/src/main/kotlin/com/lambda/interaction/managers/breaking/BreakManager.kt
@@ -799,8 +799,9 @@ object BreakManager : Manager<BreakRequest>(
 		if (instantBreakable) {
 			info.vanillaInstantBreakable = progress >= 1
 			onBlockBreak(info)
+			val breakDelay = breakConfig.breakDelay
 			if (!info.vanillaInstantBreakable)
-				breakCooldown = if (breakConfig.breakDelay == 0) 0 else breakConfig.breakDelay + 1
+				breakCooldown = if (breakDelay == 0) 0 else breakDelay + 1
 		} else {
 			info.apply {
 				breaking = true
diff --git a/src/main/kotlin/com/lambda/interaction/managers/interacting/InteractManager.kt b/src/main/kotlin/com/lambda/interaction/managers/interacting/InteractManager.kt
@@ -48,6 +48,7 @@ import com.lambda.util.player.gamemode
 import com.lambda.util.player.isItemOnCooldown
 import com.lambda.util.player.swingHand
 import net.minecraft.block.BlockState
+import net.minecraft.block.SculkVeinBlock.place
 import net.minecraft.block.pattern.CachedBlockPosition
 import net.minecraft.client.network.ClientPlayerEntity
 import net.minecraft.item.BlockItem
@@ -139,8 +140,7 @@ object InteractManager : Manager<InteractRequest>(
 
 		val iterator = potentialPlacements.iterator()
 		while (iterator.hasNext()) {
-			if (interactCooldown > 0) break
-			if (placementsThisTick + 1 > maxPlacementsThisTick) break
+			if (!canInteractThisTick()) break
 			val ctx = iterator.next()
 
 			shouldSneak = ctx.sneak
@@ -152,7 +152,7 @@ object InteractManager : Manager<InteractRequest>(
 			fun doAction() {
 				val hand = if (interactConfig.airPlace == AirPlaceMode.Grim) Hand.OFF_HAND else Hand.MAIN_HAND
 				actionResult = if (ctx.preProcessingInfo.placing) placeBlock(ctx, request, hand)
-				else interaction.interactBlock(player, Hand.MAIN_HAND, ctx.hitResult)
+				else interaction.interactBlock(player, if (ctx.preProcessingInfo.item != null) hand else Hand.MAIN_HAND, ctx.hitResult)
 			}
 
 			//ToDo: Once we add 30bps placements we will need to move the air place bypass logic out of the loop to avoid excess packet spam
@@ -174,7 +174,8 @@ object InteractManager : Manager<InteractRequest>(
 					mc.gameRenderer.firstPersonRenderer.resetEquipProgress(Hand.MAIN_HAND)
 				}
 			}
-			interactCooldown = ctx.interactConfig.interactDelay + 1
+			val interactDelay = ctx.interactConfig.interactDelay
+			interactCooldown = if (interactDelay == 0) 0 else interactDelay + 1
 			placementsThisTick++
 			iterator.remove()
 		}
@@ -183,6 +184,9 @@ object InteractManager : Manager<InteractRequest>(
 		}
 	}
 
+	fun canInteractThisTick() =
+		interactCooldown <= 0 && placementsThisTick < maxPlacementsThisTick
+
 	/**
 	 * Filters the [request]'s [InteractContext]s, placing them into the [potentialPlacements] collection, and
 	 * setting other configurations.

Original file line number	Diff line number	Diff line change
`@@ -147,26 +147,29 @@ object ProcessorRegistry : Loadable {`
`147`	`147`	`context(safeContext: SafeContext)`
`148`	`148`	`private fun preProcess(pos: BlockPos, state: BlockState, targetState: BlockState, itemStack: ItemStack) =`
`149`	`149`	`PreProcessingInfoAccumulator(targetState, itemStack.item).run {`
	`150`	`+ var stateProcessing = false`
`150`	`151`	`stateProcessors.forEach { processor ->`
`151`	`152`	`if (processor.acceptsState(state, targetState)) {`
`152`	`153`	`with(processor) { preProcess(state, targetState, pos) }`
	`154`	`+ stateProcessing = true`
`153`	`155`	`}`
`154`	`156`	`}`
`155`	`157`	`if (!omitInteraction) {`
`156`	`158`	`if (state.block != expectedState.block) {`
`157`		`- if (!state.isReplaceable) return@run null`
`158`		`- propertyPreProcessors.forEach { processor ->`
`159`		`- if (processor.acceptsState(state, expectedState)) {`
`160`		`- with(processor) { preProcess(state, expectedState, pos) }`
	`159`	`+ if (state.isReplaceable) {`
	`160`	`+ propertyPreProcessors.forEach { processor ->`
	`161`	`+ if (processor.acceptsState(state, expectedState)) {`
	`162`	`+ with(processor) { preProcess(state, expectedState, pos) }`
	`163`	`+ }`
`161`	`164`	`}`
`162`		`- }`
	`165`	`+ } else if (!stateProcessing) return@run null`
`163`	`166`	`} else {`
`164`	`167`	`propertyPostProcessors.forEach { processor ->`
`165`	`168`	`if (processor.acceptsState(state, expectedState)) {`
`166`	`169`	`with(processor) { preProcess(state, expectedState, pos) }`
`167`	`170`	`}`
`168`	`171`	`}`
`169`		`- if (!state.matches(expectedState, ignore)) return@run null`
	`172`	`+ if (!state.matches(expectedState, ignore) && !stateProcessing) return@run null`
`170`	`173`	`}`
`171`	`174`	`}`
`172`	`175`	`complete()`