small place sim refactor and non-standard placement rotations

Author: beanbag44

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

@@ -28,7 +28,6 @@ import com.lambda.interaction.construction.simulation.Sim
 import com.lambda.interaction.construction.simulation.SimDsl
 import com.lambda.interaction.construction.simulation.SimInfo
 import com.lambda.interaction.construction.simulation.checks.BreakSim.Companion.simBreak
-import com.lambda.interaction.construction.simulation.checks.PlaceSim.RotatePlaceTest.Companion.rotatePlaceTest
 import com.lambda.interaction.construction.verify.TargetState
 import com.lambda.interaction.material.ContainerSelection.Companion.selectContainer
 import com.lambda.interaction.material.StackSelection.Companion.select
@@ -64,9 +63,11 @@ import net.minecraft.entity.Entity
 import net.minecraft.item.BlockItem
 import net.minecraft.item.ItemPlacementContext
 import net.minecraft.item.ItemStack
+import net.minecraft.state.property.Properties
 import net.minecraft.util.Hand
 import net.minecraft.util.math.BlockPos
 import net.minecraft.util.math.Direction
+import net.minecraft.util.math.RotationPropertyHelper
 import net.minecraft.util.shape.VoxelShapes
 
 class PlaceSim private constructor(simInfo: ISimInfo)
@@ -93,8 +94,7 @@ class PlaceSim private constructor(simInfo: ISimInfo)
                 launch {
                     val neighborPos = pos.offset(side)
                     val neighborSide = side.opposite
-                    if (!placeConfig.airPlace.isEnabled)
-                        testBlock(neighborPos, neighborSide, this@supervisorScope)
+                    testBlock(neighborPos, neighborSide, this@supervisorScope)
                     testBlock(pos, side, this@supervisorScope)
                 }
             }
@@ -180,9 +180,9 @@ class PlaceSim private constructor(simInfo: ISimInfo)
 
             val rotatePlaceTest = simRotatePlace(fakePlayer, checkedHit, context) ?: return
 
-            val rotationRequest = if (placeConfig.axisRotate) {
+            val rotationRequest = if (placeConfig.axisRotate && (targetState as? TargetState.State)?.blockState?.contains(Properties.ROTATION) != true)
                 lookInDirection(PlaceDirection.fromRotation(rotatePlaceTest.rotation))
-            } else lookAt(rotatePlaceTest.rotation, 0.001)
+            else lookAt(rotatePlaceTest.rotation, 0.001)
 
             val swapStack = getSwapStack() ?: return
             if (!swapStack.item.isEnabled(world.enabledFeatures)) {
@@ -215,39 +215,53 @@ class PlaceSim private constructor(simInfo: ISimInfo)
         context: ItemPlacementContext
     ): RotatePlaceTest? {
         fakePlayer.rotation = RotationManager.serverRotation
-        val currentDirIsValid = testPlaceState(context).testResult == PlaceTestResult.Success
+        val currentDirIsValid = testPlaceState(context) != null
 
         if (!placeConfig.axisRotate) {
             fakePlayer.rotation = checkedHit.targetRotation
-            return rotatePlaceTest(testPlaceState(context), currentDirIsValid, fakePlayer.rotation)
+            return testPlaceState(context)?.let { RotatePlaceTest(it, currentDirIsValid, fakePlayer.rotation) }
         }
 
         fakePlayer.rotation = player.rotation
-        testPlaceState(context).takeIf { it.testResult == PlaceTestResult.Success }?.let { playerRotTest ->
-            return rotatePlaceTest(playerRotTest, currentDirIsValid, fakePlayer.rotation)
+        testPlaceState(context)?.let { playerRotTest ->
+            return RotatePlaceTest(playerRotTest, currentDirIsValid, fakePlayer.rotation)
+        }
+
+        (targetState as? TargetState.State)?.blockState?.let { targetState ->
+            if (Properties.ROTATION !in targetState) return@let
+            val rotation = targetState.get(Properties.ROTATION)
+            fakePlayer.yaw = RotationPropertyHelper.toDegrees(rotation)
+            listOf(rotation, rotation + 8).forEach { yaw ->
+                listOf(90f, 0f, -90f).forEach { pitch ->
+                    fakePlayer.rotation = Rotation(RotationPropertyHelper.toDegrees(yaw), pitch)
+                    testPlaceState(context)?.let { axisRotateTest ->
+                        return RotatePlaceTest(axisRotateTest, currentDirIsValid, fakePlayer.rotation)
+                    }
+                }
+            }
         }
 
         PlaceDirection.entries.asReversed().forEach direction@{ direction ->
             fakePlayer.rotation = direction.rotation
-            testPlaceState(context).takeIf { it.testResult == PlaceTestResult.Success }?.let { axisRotateTest ->
-                return rotatePlaceTest(axisRotateTest, currentDirIsValid, fakePlayer.rotation)
+            testPlaceState(context)?.let { axisRotateTest ->
+                return RotatePlaceTest(axisRotateTest, currentDirIsValid, fakePlayer.rotation)
             }
         }
 
         return null
     }
 
-    private suspend fun AutomatedSafeContext.testPlaceState(context: ItemPlacementContext): PlaceTest {
+    private suspend fun AutomatedSafeContext.testPlaceState(context: ItemPlacementContext): BlockState? {
         val resultState = context.stack.blockItem.getPlacementState(context)
             ?: run {
                 handleEntityBlockage(context)
-                return PlaceTest(state, PlaceTestResult.BlockedByEntity)
+                return null
             }
 
         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)
+            null
+        } else resultState
     }
 
     private suspend fun AutomatedSafeContext.handleEntityBlockage(context: ItemPlacementContext): List<Entity> {
@@ -286,26 +300,5 @@ class PlaceSim private constructor(simInfo: ISimInfo)
         return collidingEntities
     }
 
-    private class RotatePlaceTest private constructor(
-        val resultState: BlockState,
-        val currentDirIsValid: Boolean,
-        val rotation: Rotation
-    ) {
-        companion object {
-            fun rotatePlaceTest(
-                placeTest: PlaceTest,
-                currentDirIsValid: Boolean,
-                rotation: Rotation
-            ): RotatePlaceTest? {
-                return if (placeTest.testResult != PlaceTestResult.Success) null
-                else RotatePlaceTest(placeTest.resultState, currentDirIsValid, rotation)
-            }
-        }
-    }
-    private data class PlaceTest(val resultState: BlockState, val testResult: PlaceTestResult)
-    private enum class PlaceTestResult {
-        Success,
-        BlockedByEntity,
-        NoIntegrity
-    }
+    private class RotatePlaceTest(val resultState: BlockState, val currentDirIsValid: Boolean, val rotation: Rotation)
 }