treat double slab placements like actual placements rather than interactions, and more build sim cleanup

Author: beanbag44

common/src/main/kotlin/com/lambda/interaction/construction/processing/PlacementProcessor.kt

@@ -18,8 +18,9 @@
 package com.lambda.interaction.construction.processing
 
 import net.minecraft.block.BlockState
+import net.minecraft.util.math.BlockPos
 
 abstract class PlacementProcessor {
     abstract fun acceptsState(state: BlockState): Boolean
-    abstract fun preProcess(state: BlockState, accumulator: PreProcessingInfoAccumulator)
+    abstract fun preProcess(state: BlockState, pos: BlockPos, accumulator: PreProcessingInfoAccumulator)
 }

common/src/main/kotlin/com/lambda/interaction/construction/processing/ProcessorRegistry.kt

@@ -21,7 +21,10 @@ import com.lambda.core.Loadable
 import com.lambda.interaction.construction.verify.TargetState
 import com.lambda.util.reflections.getInstances
 import net.minecraft.block.BlockState
+import net.minecraft.block.SlabBlock
+import net.minecraft.block.enums.SlabType
 import net.minecraft.state.property.Properties
+import net.minecraft.util.math.BlockPos
 
 object ProcessorRegistry : Loadable {
     private val processors = getInstances<PlacementProcessor>()
@@ -104,17 +107,23 @@ object ProcessorRegistry : Loadable {
 
     override fun load() = "Loaded ${processors.size} pre processors"
 
-    fun TargetState.getProcessingInfo(): PreProcessingInfo =
+    fun TargetState.getProcessingInfo(pos: BlockPos): PreProcessingInfo =
         (this as? TargetState.State)?.let { state ->
-            processorCache.getOrPut(state.blockState) {
+            val get: () -> PreProcessingInfo = {
+
                 val infoAccumulator = PreProcessingInfoAccumulator()
 
                 processors.forEach {
                     if (!it.acceptsState(state.blockState)) return@forEach
-                    it.preProcess(state.blockState, infoAccumulator)
+                    it.preProcess(state.blockState, pos, infoAccumulator)
                 }
 
                 infoAccumulator.complete()
             }
+            if (isExemptFromCache(state)) get()
+            else processorCache.getOrPut(state.blockState, get)
         } ?: PreProcessingInfo.DEFAULT
+
+    private fun isExemptFromCache(state: TargetState.State) =
+        state.blockState.block is SlabBlock && state.blockState.get(Properties.SLAB_TYPE) == SlabType.DOUBLE
 }

common/src/main/kotlin/com/lambda/interaction/construction/processing/preprocessors/AttachmentPreProcessor.kt

@@ -22,6 +22,7 @@ import com.lambda.interaction.construction.processing.PreProcessingInfoAccumulat
 import net.minecraft.block.BlockState
 import net.minecraft.block.enums.Attachment
 import net.minecraft.state.property.Properties
+import net.minecraft.util.math.BlockPos
 import net.minecraft.util.math.Direction
 
 // Collected using reflections and then accessed from a collection in ProcessorRegistry
@@ -30,7 +31,7 @@ object AttachmentPreProcessor : PlacementProcessor() {
     override fun acceptsState(state: BlockState) =
         state.properties.contains(Properties.ATTACHMENT)
 
-    override fun preProcess(state: BlockState, accumulator: PreProcessingInfoAccumulator) {
+    override fun preProcess(state: BlockState, pos: BlockPos, accumulator: PreProcessingInfoAccumulator) {
         val attachment = state.get(Properties.ATTACHMENT) ?: return
         with (accumulator) {
             when (attachment) {

common/src/main/kotlin/com/lambda/interaction/construction/processing/preprocessors/AxisPreProcessor.kt

@@ -21,14 +21,15 @@ import com.lambda.interaction.construction.processing.PlacementProcessor
 import com.lambda.interaction.construction.processing.PreProcessingInfoAccumulator
 import net.minecraft.block.BlockState
 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 AxisPreProcessor : PlacementProcessor() {
     override fun acceptsState(state: BlockState) =
         state.getOrEmpty(Properties.AXIS).isPresent
 
-    override fun preProcess(state: BlockState, accumulator: PreProcessingInfoAccumulator) {
+    override fun preProcess(state: BlockState, pos: BlockPos, accumulator: PreProcessingInfoAccumulator) {
         val axis = state.get(Properties.AXIS)
         accumulator.retainSides { side ->
             side.axis == axis

common/src/main/kotlin/com/lambda/interaction/construction/processing/preprocessors/BlockFacePreProcessor.kt

@@ -22,6 +22,7 @@ import com.lambda.interaction.construction.processing.PreProcessingInfoAccumulat
 import net.minecraft.block.BlockState
 import net.minecraft.block.enums.BlockFace
 import net.minecraft.state.property.Properties
+import net.minecraft.util.math.BlockPos
 import net.minecraft.util.math.Direction
 
 // Collected using reflections and then accessed from a collection in ProcessorRegistry
@@ -30,7 +31,7 @@ object BlockFacePreProcessor : PlacementProcessor() {
     override fun acceptsState(state: BlockState) =
         state.getOrEmpty(Properties.BLOCK_FACE).isPresent
 
-    override fun preProcess(state: BlockState, accumulator: PreProcessingInfoAccumulator) {
+    override fun preProcess(state: BlockState, pos: BlockPos, accumulator: PreProcessingInfoAccumulator) {
         val property = state.get(Properties.BLOCK_FACE) ?: return
         with (accumulator) {
             when (property) {

common/src/main/kotlin/com/lambda/interaction/construction/processing/preprocessors/BlockHalfPreProcessor.kt

@@ -24,6 +24,7 @@ import com.lambda.interaction.construction.verify.SurfaceScan
 import net.minecraft.block.BlockState
 import net.minecraft.block.enums.BlockHalf
 import net.minecraft.state.property.Properties
+import net.minecraft.util.math.BlockPos
 import net.minecraft.util.math.Direction
 
 // Collected using reflections and then accessed from a collection in ProcessorRegistry
@@ -32,7 +33,7 @@ object BlockHalfPreProcessor : PlacementProcessor() {
     override fun acceptsState(state: BlockState) =
         state.getOrEmpty(Properties.BLOCK_HALF).isPresent
 
-    override fun preProcess(state: BlockState, accumulator: PreProcessingInfoAccumulator) {
+    override fun preProcess(state: BlockState, pos: BlockPos, accumulator: PreProcessingInfoAccumulator) {
         val slab = state.get(Properties.BLOCK_HALF) ?: return
 
         val surfaceScan = when (slab) {

common/src/main/kotlin/com/lambda/interaction/construction/processing/preprocessors/DoorHingePreProcessor.kt

@@ -25,6 +25,7 @@ import com.lambda.threading.runSafe
 import net.minecraft.block.BlockState
 import net.minecraft.block.enums.DoorHinge
 import net.minecraft.state.property.Properties
+import net.minecraft.util.math.BlockPos
 import net.minecraft.util.math.Direction
 
 // Collected using reflections and then accessed from a collection in ProcessorRegistry
@@ -33,7 +34,7 @@ object DoorHingePreProcessor : PlacementProcessor() {
     override fun acceptsState(state: BlockState) =
         state.properties.contains(Properties.DOOR_HINGE)
 
-    override fun preProcess(state: BlockState, accumulator: PreProcessingInfoAccumulator) =
+    override fun preProcess(state: BlockState, pos: BlockPos, accumulator: PreProcessingInfoAccumulator) =
         runSafe {
             val side = state.get(Properties.DOOR_HINGE) ?: return@runSafe
             val scanner = when (state.get(Properties.HORIZONTAL_FACING) ?: return@runSafe) {

common/src/main/kotlin/com/lambda/interaction/construction/processing/preprocessors/HopperFacingPreProcessor.kt

@@ -21,6 +21,7 @@ import com.lambda.interaction.construction.processing.PlacementProcessor
 import com.lambda.interaction.construction.processing.PreProcessingInfoAccumulator
 import net.minecraft.block.BlockState
 import net.minecraft.state.property.Properties
+import net.minecraft.util.math.BlockPos
 import net.minecraft.util.math.Direction
 
 // Collected using reflections and then accessed from a collection in ProcessorRegistry
@@ -29,7 +30,7 @@ object HopperFacingPreProcessor : PlacementProcessor() {
     override fun acceptsState(state: BlockState) =
         state.properties.contains(Properties.HOPPER_FACING)
 
-    override fun preProcess(state: BlockState, accumulator: PreProcessingInfoAccumulator) {
+    override fun preProcess(state: BlockState, pos: BlockPos, accumulator: PreProcessingInfoAccumulator) {
         val facing = state.get(Properties.HOPPER_FACING) ?: return
         when {
             facing.axis == Direction.Axis.Y -> accumulator.retainSides { it.axis == Direction.Axis.Y }

common/src/main/kotlin/com/lambda/interaction/construction/processing/preprocessors/SlabPreProcessor.kt

@@ -21,26 +21,34 @@ import com.lambda.interaction.construction.processing.PlacementProcessor
 import com.lambda.interaction.construction.processing.PreProcessingInfoAccumulator
 import com.lambda.interaction.construction.verify.ScanMode
 import com.lambda.interaction.construction.verify.SurfaceScan
+import com.lambda.threading.runSafe
+import com.lambda.util.BlockUtils.blockState
 import net.minecraft.block.BlockState
 import net.minecraft.block.SlabBlock
 import net.minecraft.block.enums.SlabType
 import net.minecraft.state.property.Properties
+import net.minecraft.util.math.BlockPos
 import net.minecraft.util.math.Direction
 
 // Collected using reflections and then accessed from a collection in ProcessorRegistry
 @Suppress("unused")
 object SlabPreProcessor : PlacementProcessor() {
     override fun acceptsState(state: BlockState) = state.block is SlabBlock
 
-    override fun preProcess(state: BlockState, accumulator: PreProcessingInfoAccumulator) {
+    override fun preProcess(state: BlockState, pos: BlockPos, accumulator: PreProcessingInfoAccumulator) {
         val slab = state.get(Properties.SLAB_TYPE) ?: return
+        val currentState = runSafe { blockState(pos) } ?: return
 
         val surfaceScan = when (slab) {
              SlabType.BOTTOM -> SurfaceScan(ScanMode.LESSER_BLOCK_HALF, Direction.Axis.Y)
              SlabType.TOP -> SurfaceScan(ScanMode.GREATER_BLOCK_HALF, Direction.Axis.Y)
              SlabType.DOUBLE -> {
                  accumulator.addIgnores(Properties.SLAB_TYPE)
-                 SurfaceScan(ScanMode.FULL, Direction.Axis.Y)
+                 if (currentState.block !is SlabBlock) SurfaceScan.DEFAULT
+                 else when (currentState.get(Properties.SLAB_TYPE)) {
+                     SlabType.BOTTOM -> SurfaceScan(ScanMode.GREATER_BLOCK_HALF, Direction.Axis.Y)
+                     else -> SurfaceScan(ScanMode.LESSER_BLOCK_HALF, Direction.Axis.Y)
+                 }
              }
         }