use server rotation when placing and add chest post processing to ignore unfinished double chests

beanbag44 · beanbag44 · commit 8a115e7122d2 · 2026-01-25T13:02:41.000Z
diff --git a/src/main/java/com/lambda/mixin/entity/EntityMixin.java b/src/main/java/com/lambda/mixin/entity/EntityMixin.java
@@ -17,7 +17,6 @@
 
 package com.lambda.mixin.entity;
 
-import com.lambda.Lambda;
 import com.lambda.event.EventFlow;
 import com.lambda.event.events.EntityEvent;
 import com.lambda.event.events.PlayerEvent;
@@ -42,6 +41,8 @@
 import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
 import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;
 
+import static com.lambda.Lambda.getMc;
+
 @Mixin(Entity.class)
 public abstract class EntityMixin {
     @Shadow
@@ -56,7 +57,7 @@ public void move(MovementType movementType, Vec3d movement) {
      */
     @WrapOperation(method = "updateVelocity", at = @At(value = "INVOKE", target = "Lnet/minecraft/entity/Entity;getYaw()F"))
     public float velocityYaw(Entity entity, Operation<Float> original) {
-        if ((Object) this != Lambda.getMc().player) return original.call(entity);
+        if ((Object) this != getMc().player) return original.call(entity);
 
         Float y = RotationManager.getMovementYaw();
         if (y == null) return original.call(entity);
@@ -75,7 +76,7 @@ public float velocityYaw(Entity entity, Operation<Float> original) {
     @WrapOperation(method = "getRotationVec", at = @At(value = "INVOKE", target = "Lnet/minecraft/entity/Entity;getYaw(F)F"))
     float fixDirectionYaw(Entity entity, float tickDelta, Operation<Float> original) {
         Vec2d rot = RotationManager.getRotationForVector(tickDelta);
-        if (entity != Lambda.getMc().player || rot == null) return original.call(entity, tickDelta);
+        if (entity != getMc().player || rot == null) return original.call(entity, tickDelta);
 
         return (float) rot.getX();
     }
@@ -91,7 +92,7 @@ float fixDirectionYaw(Entity entity, float tickDelta, Operation<Float> original)
     @WrapOperation(method = "getRotationVec", at = @At(value = "INVOKE", target = "Lnet/minecraft/entity/Entity;getPitch(F)F"))
     float fixDirectionPitch(Entity entity, float tickDelta, Operation<Float> original) {
         Vec2d rot = RotationManager.getRotationForVector(tickDelta);
-        if (entity != Lambda.getMc().player || rot == null) return original.call(entity, tickDelta);
+        if (entity != getMc().player || rot == null) return original.call(entity, tickDelta);
 
         return (float) rot.getY();
     }
@@ -107,7 +108,7 @@ float fixDirectionPitch(Entity entity, float tickDelta, Operation<Float> origina
     @WrapOperation(method = "getRotationVector()Lnet/minecraft/util/math/Vec3d;", at = @At(value = "INVOKE", target = "Lnet/minecraft/entity/Entity;getYaw()F"))
     float fixDirectionYaw2(Entity entity, Operation<Float> original) {
         Vec2d rot = RotationManager.getRotationForVector(1.0);
-        if (entity != Lambda.getMc().player || rot == null) return original.call(entity);
+        if (entity != getMc().player || rot == null) return original.call(entity);
 
         return (float) rot.getX();
     }
@@ -123,7 +124,7 @@ float fixDirectionYaw2(Entity entity, Operation<Float> original) {
     @WrapOperation(method = "getRotationVector()Lnet/minecraft/util/math/Vec3d;", at = @At(value = "INVOKE", target = "Lnet/minecraft/entity/Entity;getPitch()F"))
     float fixDirectionPitch2(Entity entity, Operation<Float> original) {
         Vec2d rot = RotationManager.getRotationForVector(1.0);
-        if (entity != Lambda.getMc().player || rot == null) return original.call(entity);
+        if (entity != getMc().player || rot == null) return original.call(entity);
 
         return (float) rot.getY();
     }
@@ -161,8 +162,8 @@ private boolean wrapSetPitch(Entity instance, float yaw) {
 
     @Inject(method = "isSprinting()Z", at = @At("HEAD"), cancellable = true)
     private void injectIsSprinting(CallbackInfoReturnable<Boolean> cir) {
-        var player = Lambda.getMc().player;
-        if ((Object) this != Lambda.getMc().player) return;
+        var player = getMc().player;
+        if ((Object) this != getMc().player) return;
         if (ElytraFly.INSTANCE.isEnabled() && ElytraFly.getMode() == ElytraFly.FlyMode.Bounce && player.isGliding()) cir.setReturnValue(true);
     }
 
@@ -172,4 +173,9 @@ private void injectGetPose(CallbackInfoReturnable<EntityPose> cir) {
         if (!(entity instanceof ClientPlayerEntity player)) return;
         if (ElytraFly.INSTANCE.isEnabled() && ElytraFly.getMode() == ElytraFly.FlyMode.Bounce && player.isGliding()) cir.setReturnValue(EntityPose.GLIDING);
     }
+
+    @ModifyExpressionValue(method = "getHorizontalFacing", at = @At(value = "INVOKE", target = "Lnet/minecraft/entity/Entity;getYaw()F"))
+    private float modifyGetYaw(float original) {
+        return (Object) this == getMc().player ? RotationManager.getServerRotation().getYawF() : original;
+    }
 }
diff --git a/src/main/java/com/lambda/mixin/world/DirectionMixin.java b/src/main/java/com/lambda/mixin/world/DirectionMixin.java
@@ -0,0 +1,40 @@
+/*
+ * Copyright 2026 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.mixin.world;
+
+import com.lambda.interaction.managers.rotating.RotationManager;
+import com.llamalad7.mixinextras.injector.ModifyExpressionValue;
+import net.minecraft.entity.Entity;
+import net.minecraft.util.math.Direction;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.injection.At;
+
+import static com.lambda.Lambda.getMc;
+
+@Mixin(Direction.class)
+public class DirectionMixin {
+    @ModifyExpressionValue(method = "getEntityFacingOrder", at = @At(value = "INVOKE", target = "Lnet/minecraft/entity/Entity;getYaw(F)F"))
+    private static float modifyGetYaw(float original, Entity entity) {
+        return entity == getMc().player ? RotationManager.getServerRotation().getYawF() : original;
+    }
+
+    @ModifyExpressionValue(method = "getEntityFacingOrder", at = @At(value = "INVOKE", target = "Lnet/minecraft/entity/Entity;getPitch(F)F"))
+    private static float modifyGetPitch(float original, Entity entity) {
+        return entity == getMc().player ? RotationManager.getServerRotation().getPitchF() : original;
+    }
+}
diff --git a/src/main/kotlin/com/lambda/interaction/construction/simulation/processing/PlacementProcessor.kt b/src/main/kotlin/com/lambda/interaction/construction/simulation/processing/PlacementProcessor.kt
@@ -34,13 +34,15 @@ interface StateProcessor {
 }
 
 interface PropertyPreProcessor {
-	fun acceptsState(targetState: BlockState): Boolean
+	fun acceptsState(state: BlockState, targetState: BlockState): Boolean
 
 	context(safeContext: SafeContext)
 	fun PreProcessingInfoAccumulator.preProcess(state: BlockState, targetState: BlockState, pos: BlockPos)
 }
 
 interface PropertyPostProcessor {
 	fun acceptsState(state: BlockState, targetState: BlockState): Boolean
-	fun PreProcessingInfoAccumulator.preProcess(state: BlockState, targetState: BlockState)
+
+	context(safeContext: SafeContext)
+	fun PreProcessingInfoAccumulator.preProcess(state: BlockState, targetState: BlockState, pos: BlockPos)
 }
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,26 @@ object ProcessorRegistry : Loadable {
 	context(safeContext: SafeContext)
 	private fun preProcess(pos: BlockPos, state: BlockState, targetState: BlockState, itemStack: ItemStack) =
 		PreProcessingInfoAccumulator(targetState, itemStack.item).run {
-			val stateProcessing = stateProcessors.any { processor ->
-				processor.acceptsState(state, targetState).also { accepted ->
-					if (accepted)
-						with(processor) { preProcess(state, targetState, pos) }
+			stateProcessors.forEach { processor ->
+				if (processor.acceptsState(state, targetState)) {
+					with(processor) { preProcess(state, targetState, pos) }
 				}
 			}
-			if (!stateProcessing && !omitInteraction) {
+			if (!omitInteraction) {
 				if (state.block != expectedState.block) {
 					if (!state.isReplaceable) return@run null
 					propertyPreProcessors.forEach { processor ->
-						if (processor.acceptsState(targetState))
+						if (processor.acceptsState(state, expectedState)) {
 							with(processor) { preProcess(state, expectedState, pos) }
+						}
 					}
 				} else {
 					propertyPostProcessors.forEach { processor ->
 						if (processor.acceptsState(state, expectedState)) {
-							with(processor) { preProcess(state, expectedState) }
+							with(processor) { preProcess(state, expectedState, pos) }
 						}
 					}
-					if (!state.matches(targetState, ignore)) return@run null
+					if (!state.matches(expectedState, ignore)) return@run null
 				}
 			}
 			complete()
diff --git a/src/main/kotlin/com/lambda/interaction/construction/simulation/processing/preprocessors/property/placement/post/ChestPostProcessor.kt b/src/main/kotlin/com/lambda/interaction/construction/simulation/processing/preprocessors/property/placement/post/ChestPostProcessor.kt
@@ -0,0 +1,54 @@
+/*
+ * Copyright 2026 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.interaction.construction.simulation.processing.preprocessors.property.placement.post
+
+import com.lambda.context.SafeContext
+import com.lambda.interaction.construction.simulation.processing.PreProcessingInfoAccumulator
+import com.lambda.interaction.construction.simulation.processing.PropertyPostProcessor
+import com.lambda.util.BlockUtils.blockState
+import net.minecraft.block.BlockState
+import net.minecraft.block.ChestBlock
+import net.minecraft.block.enums.ChestType
+import net.minecraft.state.property.Properties
+import net.minecraft.util.math.BlockPos
+
+// Collected using reflections and then accessed from a collection in ProcessorRegistry
+@Suppress("unused")
+object ChestPostProcessor : PropertyPostProcessor {
+	override fun acceptsState(state: BlockState, targetState: BlockState) =
+		state.block is ChestBlock && state.block === targetState.block &&
+				Properties.CHEST_TYPE in state && Properties.HORIZONTAL_FACING in state &&
+				state.get(Properties.HORIZONTAL_FACING) == targetState.get(Properties.HORIZONTAL_FACING) &&
+				state.get(Properties.CHEST_TYPE) != targetState.get(Properties.CHEST_TYPE)
+
+	context(safeContext: SafeContext)
+	override fun PreProcessingInfoAccumulator.preProcess(state: BlockState, targetState: BlockState, pos: BlockPos) {
+		noCaching()
+		val targetType = targetState.get(Properties.CHEST_TYPE)
+		val currentType = state.get(Properties.CHEST_TYPE)
+		if (currentType != ChestType.SINGLE) return
+		val currentFacing = state.get(Properties.HORIZONTAL_FACING)
+		val otherChestDirection = when(targetType) {
+			ChestType.LEFT -> currentFacing.rotateYClockwise()
+			else -> currentFacing.rotateYCounterclockwise()
+		}
+		val otherChest = safeContext.blockState(pos.offset(otherChestDirection))
+		if (otherChest.block !is ChestBlock || otherChest.get(Properties.CHEST_TYPE) != ChestType.SINGLE)
+			addIgnores(Properties.CHEST_TYPE)
+	}
+}
diff --git a/src/main/kotlin/com/lambda/interaction/construction/simulation/processing/preprocessors/property/placement/post/StandardInteractPostProcessor.kt b/src/main/kotlin/com/lambda/interaction/construction/simulation/processing/preprocessors/property/placement/post/StandardInteractPostProcessor.kt
@@ -17,10 +17,12 @@
 
 package com.lambda.interaction.construction.simulation.processing.preprocessors.property.placement.post
 
+import com.lambda.context.SafeContext
 import com.lambda.interaction.construction.simulation.processing.PreProcessingInfoAccumulator
 import com.lambda.interaction.construction.simulation.processing.ProcessorRegistry.standardInteractProperties
 import com.lambda.interaction.construction.simulation.processing.PropertyPostProcessor
 import net.minecraft.block.BlockState
+import net.minecraft.util.math.BlockPos
 
 // Collected using reflections and then accessed from a collection in ProcessorRegistry
 @Suppress("unused")
@@ -30,7 +32,8 @@ object StandardInteractPostProcessor : PropertyPostProcessor {
 			it in targetState && state.get(it) != targetState.get(it)
 		}
 
-	override fun PreProcessingInfoAccumulator.preProcess(state: BlockState, targetState: BlockState) {
+	context(safeContext: SafeContext)
+	override fun PreProcessingInfoAccumulator.preProcess(state: BlockState, targetState: BlockState, pos: BlockPos) {
 		setItem(null)
 		setPlacing(false)
 	}
diff --git a/src/main/kotlin/com/lambda/interaction/construction/simulation/processing/preprocessors/property/placement/pre/AttachmentPreProcessor.kt b/src/main/kotlin/com/lambda/interaction/construction/simulation/processing/preprocessors/property/placement/pre/AttachmentPreProcessor.kt
@@ -29,7 +29,7 @@ import net.minecraft.util.math.Direction
 // Collected using reflections and then accessed from a collection in ProcessorRegistry
 @Suppress("unused")
 object AttachmentPreProcessor : PropertyPreProcessor {
-    override fun acceptsState(targetState: BlockState) =
+    override fun acceptsState(state: BlockState, targetState: BlockState) =
         Properties.ATTACHMENT in targetState
 
 	context(safeContext: SafeContext)
diff --git a/src/main/kotlin/com/lambda/interaction/construction/simulation/processing/preprocessors/property/placement/pre/AxisPreProcessor.kt b/src/main/kotlin/com/lambda/interaction/construction/simulation/processing/preprocessors/property/placement/pre/AxisPreProcessor.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 AxisPreProcessor : PropertyPreProcessor {
-    override fun acceptsState(targetState: BlockState) =
+    override fun acceptsState(state: BlockState, targetState: BlockState) =
         Properties.AXIS in targetState
 
     context(safeContext: SafeContext)
diff --git a/src/main/kotlin/com/lambda/interaction/construction/simulation/processing/preprocessors/property/placement/pre/BlockFacePreProcessor.kt b/src/main/kotlin/com/lambda/interaction/construction/simulation/processing/preprocessors/property/placement/pre/BlockFacePreProcessor.kt
@@ -29,7 +29,7 @@ import net.minecraft.util.math.Direction
 // Collected using reflections and then accessed from a collection in ProcessorRegistry
 @Suppress("unused")
 object BlockFacePreProcessor : PropertyPreProcessor {
-    override fun acceptsState(targetState: BlockState) =
+    override fun acceptsState(state: BlockState, targetState: BlockState) =
         Properties.BLOCK_FACE in targetState
 
 	context(safeContext: SafeContext)
diff --git a/src/main/kotlin/com/lambda/interaction/construction/simulation/processing/preprocessors/property/placement/pre/BlockHalfPreProcessor.kt b/src/main/kotlin/com/lambda/interaction/construction/simulation/processing/preprocessors/property/placement/pre/BlockHalfPreProcessor.kt
@@ -31,7 +31,7 @@ import net.minecraft.util.math.Direction
 // Collected using reflections and then accessed from a collection in ProcessorRegistry
 @Suppress("unused")
 object BlockHalfPreProcessor : PropertyPreProcessor {
-    override fun acceptsState(targetState: BlockState) =
+    override fun acceptsState(state: BlockState, targetState: BlockState) =
         Properties.BLOCK_HALF in targetState
 
     context(safeContext: SafeContext)
diff --git a/src/main/kotlin/com/lambda/interaction/construction/simulation/processing/preprocessors/property/placement/pre/ChestPreProcessor.kt b/src/main/kotlin/com/lambda/interaction/construction/simulation/processing/preprocessors/property/placement/pre/ChestPreProcessor.kt
@@ -20,7 +20,6 @@ package com.lambda.interaction.construction.simulation.processing.preprocessors.
 import com.lambda.context.SafeContext
 import com.lambda.interaction.construction.simulation.processing.PreProcessingInfoAccumulator
 import com.lambda.interaction.construction.simulation.processing.PropertyPreProcessor
-import com.lambda.threading.runSafe
 import net.minecraft.block.BlockState
 import net.minecraft.block.ChestBlock
 import net.minecraft.block.enums.ChestType
@@ -30,28 +29,26 @@ import net.minecraft.util.math.BlockPos
 // Collected using reflections and then accessed from a collection in ProcessorRegistry
 @Suppress("unused")
 object ChestPreProcessor : PropertyPreProcessor {
-	override fun acceptsState(targetState: BlockState) =
+	override fun acceptsState(state: BlockState, targetState: BlockState) =
 		targetState.block is ChestBlock && Properties.CHEST_TYPE in targetState && Properties.HORIZONTAL_FACING in targetState
 
 	context(safeContext: SafeContext)
 	override fun PreProcessingInfoAccumulator.preProcess(state: BlockState, targetState: BlockState, pos: BlockPos) {
 		noCaching()
-		runSafe {
-			val chestBlock = targetState.block as? ChestBlock ?: return
-			val targetType = targetState.get(Properties.CHEST_TYPE)
-			val targetFacing = targetState.get(Properties.HORIZONTAL_FACING)
-			val placeType = chestBlock.getChestType(world, pos, targetFacing)
-			if (placeType == targetType) return
-			if (targetType != ChestType.SINGLE) {
-				if (placeType == ChestType.SINGLE) addIgnores(Properties.CHEST_TYPE)
-				else {
-					val canPlaceWithTypeRight = targetFacing == chestBlock.getNeighborChestDirection(world, pos, targetFacing.rotateYCounterclockwise())
-					if (targetType != ChestType.RIGHT || !canPlaceWithTypeRight) {
-						setExpectedState(targetState.with(Properties.CHEST_TYPE, ChestType.SINGLE))
-						setSneak(true)
-					}
+		val chestBlock = targetState.block as? ChestBlock ?: return
+		val targetType = targetState.get(Properties.CHEST_TYPE)
+		val targetFacing = targetState.get(Properties.HORIZONTAL_FACING)
+		val placeType = chestBlock.getChestType(safeContext.world, pos, targetFacing)
+		if (placeType == targetType) return
+		if (targetType != ChestType.SINGLE) {
+			if (placeType == ChestType.SINGLE) addIgnores(Properties.CHEST_TYPE)
+			else {
+				val canPlaceWithTypeRight = targetFacing == chestBlock.getNeighborChestDirection(safeContext.world, pos, targetFacing.rotateYCounterclockwise())
+				if (targetType != ChestType.RIGHT || !canPlaceWithTypeRight) {
+					setExpectedState(targetState.with(Properties.CHEST_TYPE, ChestType.SINGLE))
+					setSneak(true)
 				}
-			} else setSneak(true)
-		}
+			}
+		} else setSneak(true)
 	}
 }
diff --git a/src/main/kotlin/com/lambda/interaction/construction/simulation/processing/preprocessors/property/placement/pre/DoorHingePreProcessor.kt b/src/main/kotlin/com/lambda/interaction/construction/simulation/processing/preprocessors/property/placement/pre/DoorHingePreProcessor.kt
@@ -31,7 +31,7 @@ import net.minecraft.util.math.Direction
 // Collected using reflections and then accessed from a collection in ProcessorRegistry
 @Suppress("unused")
 object DoorHingePreProcessor : PropertyPreProcessor {
-    override fun acceptsState(targetState: BlockState) =
+    override fun acceptsState(state: BlockState, targetState: BlockState) =
         Properties.DOOR_HINGE in targetState
 
 	context(safeContext: SafeContext)
diff --git a/src/main/kotlin/com/lambda/interaction/construction/simulation/processing/preprocessors/property/placement/pre/HopperFacingPreProcessor.kt b/src/main/kotlin/com/lambda/interaction/construction/simulation/processing/preprocessors/property/placement/pre/HopperFacingPreProcessor.kt
@@ -28,15 +28,15 @@ import net.minecraft.util.math.Direction
 // Collected using reflections and then accessed from a collection in ProcessorRegistry
 @Suppress("unused")
 object HopperFacingPreProcessor : PropertyPreProcessor {
-    override fun acceptsState(targetState: BlockState) =
+    override fun acceptsState(state: BlockState, targetState: BlockState) =
         Properties.HOPPER_FACING in targetState
 
     context(safeContext: SafeContext)
     override fun PreProcessingInfoAccumulator.preProcess(state: BlockState, targetState: BlockState, pos: BlockPos) {
         val facing = targetState.get(Properties.HOPPER_FACING) ?: return
         when {
             facing.axis == Direction.Axis.Y -> retainSides { it.axis == Direction.Axis.Y }
-            else -> retainSides(facing)
+            else -> retainSides(facing, facing.opposite)
         }
     }
 }
diff --git a/src/main/kotlin/com/lambda/interaction/construction/simulation/processing/preprocessors/property/placement/pre/SlabPreProcessor.kt b/src/main/kotlin/com/lambda/interaction/construction/simulation/processing/preprocessors/property/placement/pre/SlabPreProcessor.kt
@@ -32,7 +32,7 @@ import net.minecraft.util.math.Direction
 // Collected using reflections and then accessed from a collection in ProcessorRegistry
 @Suppress("unused")
 object SlabPreProcessor : PropertyPreProcessor {
-    override fun acceptsState(targetState: BlockState) = targetState.block is SlabBlock
+    override fun acceptsState(state: BlockState, targetState: BlockState) = targetState.block is SlabBlock
 
     context(safeContext: SafeContext)
     override fun PreProcessingInfoAccumulator.preProcess(state: BlockState, targetState: BlockState, pos: BlockPos) {
diff --git a/src/main/kotlin/com/lambda/util/BlockUtils.kt b/src/main/kotlin/com/lambda/util/BlockUtils.kt
@@ -53,6 +53,7 @@ import net.minecraft.block.DecoratedPotBlock
 import net.minecraft.block.DispenserBlock
 import net.minecraft.block.DoorBlock
 import net.minecraft.block.DragonEggBlock
+import net.minecraft.block.DropperBlock
 import net.minecraft.block.EnchantingTableBlock
 import net.minecraft.block.EnderChestBlock
 import net.minecraft.block.FenceBlock
@@ -226,6 +227,7 @@ object BlockUtils {
         DaylightDetectorBlock::class,
         DecoratedPotBlock::class,
         DispenserBlock::class,
+        DropperBlock::class,
         DoorBlock::class,
         DragonEggBlock::class,
         EnchantingTableBlock::class,
diff --git a/src/main/resources/lambda.mixins.json b/src/main/resources/lambda.mixins.json

Original file line number	Diff line number	Diff line change
`@@ -34,13 +34,15 @@ interface StateProcessor {`
`34`	`34`	`}`
`35`	`35`
`36`	`36`	`interface PropertyPreProcessor {`
`37`		`- fun acceptsState(targetState: BlockState): Boolean`
	`37`	`+ fun acceptsState(state: BlockState, targetState: BlockState): Boolean`
`38`	`38`
`39`	`39`	`context(safeContext: SafeContext)`
`40`	`40`	`fun PreProcessingInfoAccumulator.preProcess(state: BlockState, targetState: BlockState, pos: BlockPos)`
`41`	`41`	`}`
`42`	`42`
`43`	`43`	`interface PropertyPostProcessor {`
`44`	`44`	`fun acceptsState(state: BlockState, targetState: BlockState): Boolean`
`45`		`- fun PreProcessingInfoAccumulator.preProcess(state: BlockState, targetState: BlockState)`
	`45`	`+`
	`46`	`+ context(safeContext: SafeContext)`
	`47`	`+ fun PreProcessingInfoAccumulator.preProcess(state: BlockState, targetState: BlockState, pos: BlockPos)`
`46`	`48`	`}`
Original file line number	Diff line number	Diff line change
`@@ -147,26 +147,26 @@ 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`		`- val stateProcessing = stateProcessors.any { processor ->`
`151`		`- processor.acceptsState(state, targetState).also { accepted ->`
`152`		`- if (accepted)`
`153`		`- with(processor) { preProcess(state, targetState, pos) }`
	`150`	`+ stateProcessors.forEach { processor ->`
	`151`	`+ if (processor.acceptsState(state, targetState)) {`
	`152`	`+ with(processor) { preProcess(state, targetState, pos) }`
`154`	`153`	`}`
`155`	`154`	`}`
`156`		`- if (!stateProcessing && !omitInteraction) {`
	`155`	`+ if (!omitInteraction) {`
`157`	`156`	`if (state.block != expectedState.block) {`
`158`	`157`	`if (!state.isReplaceable) return@run null`
`159`	`158`	`propertyPreProcessors.forEach { processor ->`
`160`		`- if (processor.acceptsState(targetState))`
	`159`	`+ if (processor.acceptsState(state, expectedState)) {`
`161`	`160`	`with(processor) { preProcess(state, expectedState, pos) }`
	`161`	`+ }`
`162`	`162`	`}`
`163`	`163`	`} else {`
`164`	`164`	`propertyPostProcessors.forEach { processor ->`
`165`	`165`	`if (processor.acceptsState(state, expectedState)) {`
`166`		`- with(processor) { preProcess(state, expectedState) }`
	`166`	`+ with(processor) { preProcess(state, expectedState, pos) }`
`167`	`167`	`}`
`168`	`168`	`}`
`169`		`- if (!state.matches(targetState, ignore)) return@run null`
	`169`	`+ if (!state.matches(expectedState, ignore)) return@run null`
`170`	`170`	`}`
`171`	`171`	`}`
`172`	`172`	`complete()`