handling for blocks that place with a unique item and blocks that transform type after placement. Potted blocks and bamboo for example.

Author: beanbag44

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

@@ -18,11 +18,20 @@
 package com.lambda.interaction.construction.processing
 
 import com.lambda.core.Loadable
+import com.lambda.interaction.construction.processing.ProcessorRegistry.IntermediaryInfo.Companion.intermediaryInfo
 import com.lambda.interaction.construction.verify.TargetState
+import com.lambda.util.BlockUtils
+import com.lambda.util.BlockUtils.item
 import com.lambda.util.reflections.getInstances
+import net.minecraft.block.Block
 import net.minecraft.block.BlockState
+import net.minecraft.block.Blocks
+import net.minecraft.block.FlowerPotBlock
+import net.minecraft.item.Item
+import net.minecraft.item.Items
 import net.minecraft.state.property.Properties
 import net.minecraft.util.math.BlockPos
+import net.minecraft.util.math.Direction
 import java.util.*
 
 object ProcessorRegistry : Loadable {
@@ -108,6 +117,22 @@ object ProcessorRegistry : Loadable {
         Properties.DISTANCE_1_7
     )
 
+    /**
+     * Map of blocks that get placed as a different [Block] type, to then be updated afterward. Bamboo and potted flowers are
+     * two examples.
+     *
+     * @see IntermediaryInfo
+     */
+    val intermediaryBlockMap = buildMap<Block, IntermediaryInfo> {
+        this[Blocks.BAMBOO] = intermediaryInfo(IntermediaryProcess(Blocks.BAMBOO_SAPLING, item = Items.BAMBOO))
+        BlockUtils.pottedBlocks.forEach {
+            this[it] = intermediaryInfo(
+                IntermediaryProcess(Blocks.FLOWER_POT, item = Items.FLOWER_POT),
+                IntermediaryProcess(Blocks.FLOWER_POT, it, (it as FlowerPotBlock).content.item)
+            )
+        }
+    }
+
     override fun load() = "Loaded ${processors.size} pre processors"
 
     /**
@@ -134,4 +159,40 @@ object ProcessorRegistry : Loadable {
             }
             processorCache.getOrPut(blockState, get)
         }
+
+    /**
+     * Contains the starting initial block placement and any subsequent intermediary processes to transform the placement
+     * into the final block.
+     *
+     * @see IntermediaryProcess
+     */
+    data class IntermediaryInfo private constructor(
+        val startBlock: IntermediaryProcess,
+        val intermediaryProcesses: List<IntermediaryProcess> = emptyList(),
+    ) {
+        fun getIntermediaryProcess(state: BlockState) = intermediaryProcesses.firstOrNull { it.block === state.block }
+        fun isIntermediaryBlock(state: BlockState) = intermediaryProcesses.any {
+            it.block === state.block || it.targetBlock === state.block
+        } || startBlock.targetBlock === state.block
+
+        companion object {
+            fun intermediaryInfo(
+                startingBlock: IntermediaryProcess,
+                vararg intermediaryProcesses: IntermediaryProcess
+            ) = IntermediaryInfo(startingBlock, intermediaryProcesses.toList())
+        }
+    }
+
+    /**
+     * Holds the required information for placing a [Block] with more than one placement to achieve its target.
+     *
+     * The use of [Block] instead of [BlockState] here is intentional as we would only have to alter the [Properties]s
+     * if the placement was the correct [BlockState]. This is only used when one [Block] needs to transform into another.
+     */
+    data class IntermediaryProcess(
+        val block: Block,
+        val targetBlock: Block = block,
+        val item: Item,
+        val sides: Set<Direction> = Direction.entries.toSet()
+    )
 }

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

@@ -56,9 +56,7 @@ object BuildSimulator : Sim<PostSimResult>() {
                 structure.forEach { (pos, targetState) ->
                     launch {
                         sim(pos, blockState(pos), targetState, pov, concurrentSet) {
-                            if (targetState is TargetState.State &&
-                                targetState.matches(state, pos, preProcessing.ignore)
-                                ) {
+                            if (targetState is TargetState.State && matchesTarget(complete = false)) {
                                 simPostProcessing()
                                 return@sim
                             }

src/main/kotlin/com/lambda/interaction/construction/simulation/BuildSimulator.kt

@@ -21,6 +21,7 @@ import com.lambda.context.Automated
 import com.lambda.context.AutomatedSafeContext
 import com.lambda.interaction.construction.processing.PreProcessingInfo
 import com.lambda.interaction.construction.processing.ProcessorRegistry.getProcessingInfo
+import com.lambda.interaction.construction.processing.ProcessorRegistry.intermediaryBlockMap
 import com.lambda.interaction.construction.result.BuildResult
 import com.lambda.interaction.construction.simulation.checks.BasicChecker.hasBasicRequirements
 import com.lambda.interaction.construction.verify.TargetState
@@ -42,6 +43,17 @@ interface ISimInfo : Automated {
     val concurrentResults: MutableSet<BuildResult>
     val dependencyStack: Stack<Sim<*>>
 
+    fun AutomatedSafeContext.matchesTarget(state: BlockState = this@ISimInfo.state, complete: Boolean = true): Boolean {
+        if (targetState.matches(state, pos, if (!complete) preProcessing.ignore else emptySet())) return true
+        else if (complete) return false
+
+        intermediaryBlockMap[targetState.getState(pos, state).block]?.let { intermediaryInfo ->
+            return intermediaryInfo.isIntermediaryBlock(state)
+        }
+
+        return false
+    }
+
     companion object {
         /**
          * Creates a [SimInfo], checks its basic requirements, and runs the [simBuilder] block.

src/main/kotlin/com/lambda/interaction/construction/simulation/ISimInfo.kt

@@ -90,7 +90,7 @@ class BreakSim private constructor(simInfo: ISimInfo)
             return
         }
 
-        if (targetState.getState(pos).isAir && !state.fluidState.isEmpty && state.isReplaceable) {
+        if (targetState.getState(pos, state).isAir && !state.fluidState.isEmpty && state.isReplaceable) {
             result(BreakResult.Submerge(pos, state))
             sim(pos, state, TargetState.Solid(emptySet())) { simPlacement() }
             return

src/main/kotlin/com/lambda/interaction/construction/simulation/checks/BreakSim.kt

@@ -123,11 +123,11 @@ class PlaceSim private constructor(simInfo: ISimInfo)
 
         val validHits = scanShape(pov, shape, pos, setOf(side), preProcessing) ?: return
 
-        selectHitPos(validHits, fakePlayer, targetState.getStack(pos).blockItem, supervisorScope)
+        selectHitPos(validHits, fakePlayer, targetState.getStack(this@PlaceSim.pos, state).blockItem, supervisorScope)
     }
 
     private fun AutomatedSafeContext.getSwapStack(): ItemStack? {
-        val optimalStack = targetState.getStack(pos)
+        val optimalStack = targetState.getStack(pos, state)
         val stackSelection = optimalStack.item.select()
         val containerSelection = selectContainer { ofAnyType(MaterialContainer.Rank.Hotbar) }
         val container = stackSelection.containerWithMaterial(containerSelection).firstOrNull() ?: run {
@@ -244,7 +244,7 @@ class PlaceSim private constructor(simInfo: ISimInfo)
                 return PlaceTest(state, PlaceTestResult.BlockedByEntity)
             }
 
-        return if (!targetState.matches(resultState, pos, preProcessing.ignore)) {
+        return if (!matchesTarget(resultState, false)) {
             result(PlaceResult.NoIntegrity(pos, resultState, context, (targetState as? TargetState.State)?.blockState))
             PlaceTest(resultState, PlaceTestResult.NoIntegrity)
         } else PlaceTest(resultState, PlaceTestResult.Success)

src/main/kotlin/com/lambda/interaction/construction/simulation/checks/PlaceSim.kt

@@ -19,6 +19,7 @@ package com.lambda.interaction.construction.simulation.checks
 
 import com.lambda.context.AutomatedSafeContext
 import com.lambda.interaction.construction.context.InteractContext
+import com.lambda.interaction.construction.processing.ProcessorRegistry.intermediaryBlockMap
 import com.lambda.interaction.construction.result.BuildResult
 import com.lambda.interaction.construction.result.results.GenericResult
 import com.lambda.interaction.construction.result.results.InteractResult
@@ -65,6 +66,17 @@ class PostProcessingSim private constructor(simInfo: ISimInfo)
     private suspend fun AutomatedSafeContext.simPostProcessing() {
         val targetState = (targetState as? TargetState.State) ?: return
 
+        intermediaryBlockMap[targetState.getState(pos, state).block]?.let { intermediaryInfo ->
+            intermediaryInfo.getIntermediaryProcess(state)?.let { intermediaryBlock ->
+                simInteraction(
+                    intermediaryBlock.targetBlock.defaultState,
+                    intermediaryBlock.sides,
+                    intermediaryBlock.item
+                )
+            }
+            return
+        }
+
         val mismatchedProperties = state.properties.filter { state.get(it) != targetState.blockState.get(it) }
         mismatchedProperties.forEach { property ->
             when (property) {

src/main/kotlin/com/lambda/interaction/construction/simulation/checks/PostProcessingSim.kt

@@ -33,8 +33,8 @@ interface StateMatcher {
     ): Boolean
 
     context(automatedSafeContext: AutomatedSafeContext)
-    fun getStack(pos: BlockPos): ItemStack
+    fun getStack(pos: BlockPos, state: BlockState): ItemStack
     context(automatedSafeContext: AutomatedSafeContext)
-    fun getState(pos: BlockPos): BlockState
+    fun getState(pos: BlockPos, state: BlockState): BlockState
     fun isEmpty(): Boolean
 }

src/main/kotlin/com/lambda/interaction/construction/verify/StateMatcher.kt

@@ -19,6 +19,7 @@ package com.lambda.interaction.construction.verify
 
 import com.lambda.context.AutomatedSafeContext
 import com.lambda.context.SafeContext
+import com.lambda.interaction.construction.processing.ProcessorRegistry.intermediaryBlockMap
 import com.lambda.interaction.material.container.ContainerManager.findDisposable
 import com.lambda.util.BlockUtils.blockState
 import com.lambda.util.BlockUtils.emptyState
@@ -51,10 +52,10 @@ sealed class TargetState(val type: Type) : StateMatcher {
         ) = state.isEmpty
 
         context(_: AutomatedSafeContext)
-        override fun getStack(pos: BlockPos): ItemStack = ItemStack.EMPTY
+        override fun getStack(pos: BlockPos, state: BlockState): ItemStack = ItemStack.EMPTY
 
         context(automatedSafeContext: AutomatedSafeContext)
-        override fun getState(pos: BlockPos) = automatedSafeContext.blockState(pos).emptyState
+        override fun getState(pos: BlockPos, state: BlockState) = automatedSafeContext.blockState(pos).emptyState
 
         override fun isEmpty() = true
     }
@@ -70,10 +71,10 @@ sealed class TargetState(val type: Type) : StateMatcher {
         ) = state.isAir
 
         context(_: AutomatedSafeContext)
-        override fun getStack(pos: BlockPos): ItemStack = ItemStack.EMPTY
+        override fun getStack(pos: BlockPos, state: BlockState): ItemStack = ItemStack.EMPTY
 
         context(_: AutomatedSafeContext)
-        override fun getState(pos: BlockPos): BlockState = Blocks.AIR.defaultState
+        override fun getState(pos: BlockPos, state: BlockState): BlockState = Blocks.AIR.defaultState
 
         override fun isEmpty() = true
     }
@@ -89,15 +90,15 @@ sealed class TargetState(val type: Type) : StateMatcher {
         ) = with(safeContext) { state.isSolidBlock(world, pos) && state.block !in replace }
 
         context(automatedSafeContext: AutomatedSafeContext)
-        override fun getStack(pos: BlockPos) =
+        override fun getStack(pos: BlockPos, state: BlockState) =
             with(automatedSafeContext) {
                 findDisposable()?.stacks?.firstOrNull {
                     it.item.block in inventoryConfig.disposables && it.item.block !in replace
                 } ?: ItemStack(Items.NETHERRACK)
             }
 
         context(_: AutomatedSafeContext)
-        override fun getState(pos: BlockPos): BlockState = getStack(pos).item.block.defaultState
+        override fun getState(pos: BlockPos, state: BlockState): BlockState = getStack(pos, state).item.block.defaultState
 
         override fun isEmpty() = false
     }
@@ -116,15 +117,15 @@ sealed class TargetState(val type: Type) : StateMatcher {
         }
 
         context(automatedSafeContext: AutomatedSafeContext)
-        override fun getStack(pos: BlockPos) =
+        override fun getStack(pos: BlockPos, state: BlockState) =
             with(automatedSafeContext) {
                 findDisposable()?.stacks?.firstOrNull {
                     it.item.block in inventoryConfig.disposables
                 } ?: ItemStack(Items.NETHERRACK)
             }
 
         context(_: AutomatedSafeContext)
-        override fun getState(pos: BlockPos): BlockState = getStack(pos).item.block.defaultState
+        override fun getState(pos: BlockPos, state: BlockState): BlockState = getStack(pos, state).item.block.defaultState
 
         override fun isEmpty() = false
     }
@@ -141,11 +142,12 @@ sealed class TargetState(val type: Type) : StateMatcher {
             state.matches(blockState, ignoredProperties)
 
         context(automatedSafeContext: AutomatedSafeContext)
-        override fun getStack(pos: BlockPos): ItemStack =
-            blockState.block.getPickStack(automatedSafeContext.world, pos, blockState, true)
+        override fun getStack(pos: BlockPos, state: BlockState): ItemStack =
+            intermediaryBlockMap[blockState.block]?.startBlock?.item?.defaultStack
+                ?: blockState.block.getPickStack(automatedSafeContext.world, pos, blockState, true)
 
         context(_: AutomatedSafeContext)
-        override fun getState(pos: BlockPos): BlockState = blockState
+        override fun getState(pos: BlockPos, state: BlockState): BlockState = blockState
 
         override fun isEmpty() = blockState.isEmpty
     }
@@ -161,11 +163,11 @@ sealed class TargetState(val type: Type) : StateMatcher {
         ) = state.block == block
 
         context(automatedSafeContext: AutomatedSafeContext)
-        override fun getStack(pos: BlockPos): ItemStack =
+        override fun getStack(pos: BlockPos, state: BlockState): ItemStack =
             block.getPickStack(automatedSafeContext.world, pos, block.defaultState, true)
 
         context(_: AutomatedSafeContext)
-        override fun getState(pos: BlockPos): BlockState = block.defaultState
+        override fun getState(pos: BlockPos, state: BlockState): BlockState = block.defaultState
 
         override fun isEmpty() = block.defaultState.isEmpty
     }
@@ -184,11 +186,11 @@ sealed class TargetState(val type: Type) : StateMatcher {
         ) = state.block == block
 
         context(automatedSafeContext: AutomatedSafeContext)
-        override fun getStack(pos: BlockPos): ItemStack =
-            itemStack
+        override fun getStack(pos: BlockPos, state: BlockState): ItemStack =
+            intermediaryBlockMap[getState(pos, state).block]?.startBlock?.item?.defaultStack ?: itemStack
 
         context(_: AutomatedSafeContext)
-        override fun getState(pos: BlockPos): BlockState = block.defaultState
+        override fun getState(pos: BlockPos, state: BlockState): BlockState = block.defaultState
 
         override fun isEmpty() = false
     }

src/main/kotlin/com/lambda/interaction/construction/verify/TargetState.kt

@@ -41,6 +41,12 @@ object StateInfo : Module(
         .associateBy { it.get(null) as Property<*> }
 
     init {
+        onEnable {
+            val crosshair = mc.crosshairTarget ?: return@onEnable
+            if (crosshair !is BlockHitResult) return@onEnable
+            info(blockState(crosshair.blockPos).betterToString())
+        }
+
         listen<KeyboardEvent.Press> { event ->
             if (!event.isPressed ||
                 !event.satisfies(printBind)) return@listen