axis rotations for air placing rotational blocks

Author: beanbag44

common/src/main/kotlin/com/lambda/config/groups/PlaceSettings.kt

@@ -28,6 +28,9 @@ class PlaceSettings(
 ) : PlaceConfig(priority) {
     override val rotateForPlace by c.setting("Rotate For Place", true, "Rotate towards block while placing") { vis() }
     override val airPlace by c.setting("Air Place", AirPlaceMode.None, "Allows for placing blocks without adjacent faces") { vis() }
+    override val axisRotateSetting by c.setting("Axis Rotate", true, "Overrides the Rotate For Place setting and rotates the player on each axis to air place rotational blocks") { vis() && airPlace.isEnabled() }
+    override val axisRotate
+        get() = airPlace.isEnabled() && axisRotateSetting
     override val placeConfirmationMode by c.setting("Place Confirmation", PlaceConfirmationMode.PlaceThenAwait, "Wait for block placement confirmation") { vis() }
     override val maxPendingPlacements by c.setting("Max Pending Placements", 5, 0..30, 1, "The maximum amount of pending placements") { vis() }
     override val placementsPerTick by c.setting("Instant Places Per Tick", 1, 1..30, 1, "Maximum instant block places per tick") { vis() }

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

@@ -58,6 +58,7 @@ import com.lambda.util.math.distSq
 import com.lambda.util.player.SlotUtils.hotbar
 import com.lambda.util.player.copyPlayer
 import com.lambda.util.player.gamemode
+import com.lambda.util.player.placementRotations
 import com.lambda.util.world.raycast.RayCastUtils.blockResult
 import net.minecraft.block.OperatorBlock
 import net.minecraft.block.pattern.CachedBlockPosition
@@ -292,18 +293,52 @@ object BuildSimulator {
                     context = checked
                 }
 
-                val resultState = blockItem.getPlacementState(context) ?: run {
+                var resultState = blockItem.getPlacementState(context) ?: run {
                     acc.add(PlaceResult.BlockedByEntity(pos))
                     return@forEach
                 }
+                var rot = checkedHit.targetRotation
 
-                if (!target.matches(resultState, pos, world)) {
-                    acc.add(
-                        PlaceResult.NoIntegrity(
+                val simulatePlaceState = placeState@ {
+                    resultState = blockItem.getPlacementState(context)
+                        ?: return@placeState PlaceResult.BlockedByEntity(pos)
+
+                    if (!target.matches(resultState, pos, world)) {
+                        return@placeState PlaceResult.NoIntegrity(
                             pos, resultState, context, (target as? TargetState.State)?.blockState
                         )
-                    )
-                    return@forEach
+                    } else {
+                        rot = fakePlayer.rotation
+                        return@placeState null
+                    }
+                }
+
+                if (!place.axisRotate && place.rotateForPlace) {
+                    simulatePlaceState()?.let { placeResult ->
+                        acc.add(placeResult)
+                        return@forEach
+                    }
+                } else if (place.rotateForPlace) run axisRotate@ {
+                    placementRotations.forEachIndexed direction@ { index, angle ->
+                        fakePlayer.rotation = angle
+
+                        when (val placeResult = simulatePlaceState()) {
+                            is PlaceResult.BlockedByEntity -> {
+                                acc.add(placeResult)
+                                return@forEach
+                            }
+
+                            is PlaceResult.NoIntegrity -> {
+                                if (index != placementRotations.lastIndex) return@direction
+                                acc.add(placeResult)
+                                return@forEach
+                            }
+
+                            else -> {
+                                return@axisRotate
+                            }
+                        }
+                    }
                 }
 
                 val blockHit = checkedResult.blockResult ?: return@forEach
@@ -316,7 +351,7 @@ object BuildSimulator {
                 val placeContext = PlaceContext(
                     eye,
                     blockHit,
-                    RotationRequest(lookAt(checkedHit.targetRotation, 0.001), rotation),
+                    RotationRequest(lookAt(rot, 0.001), rotation),
                     eye.distanceTo(blockHit.pos),
                     resultState,
                     blockState(blockHit.blockPos.offset(blockHit.side)),

common/src/main/kotlin/com/lambda/interaction/request/placing/PlaceConfig.kt

@@ -26,6 +26,8 @@ abstract class PlaceConfig(
 ) : RequestConfig<PlaceRequest>(priority) {
     abstract val rotateForPlace: Boolean
     abstract val airPlace: AirPlaceMode
+    protected abstract val axisRotateSetting: Boolean
+    abstract val axisRotate: Boolean
     abstract val placeConfirmationMode: PlaceConfirmationMode
     abstract val maxPendingPlacements: Int
     abstract val placementsPerTick: Int

common/src/main/kotlin/com/lambda/util/player/PlayerUtils.kt

@@ -2,6 +2,8 @@ package com.lambda.util.player
 
 import com.lambda.config.groups.BuildConfig
 import com.lambda.context.SafeContext
+import com.lambda.interaction.request.rotation.Rotation
+import com.lambda.interaction.request.rotation.Rotation.Companion.yaw
 import com.mojang.authlib.GameProfile
 import net.minecraft.client.network.ClientPlayerEntity
 import net.minecraft.client.network.OtherClientPlayerEntity
@@ -10,6 +12,7 @@ import net.minecraft.entity.player.PlayerEntity
 import net.minecraft.item.Item
 import net.minecraft.network.packet.c2s.play.HandSwingC2SPacket
 import net.minecraft.util.Hand
+import net.minecraft.util.math.Direction
 
 val SafeContext.gamemode
     get() = interaction.currentGameMode
@@ -62,4 +65,15 @@ fun SafeContext.swingHandClient(hand: Hand) {
     }
 }
 
-fun SafeContext.isItemOnCooldown(item: Item) = player.itemCooldownManager.isCoolingDown(item)
+fun SafeContext.isItemOnCooldown(item: Item) = player.itemCooldownManager.isCoolingDown(item)
+
+val placementRotations = Direction.entries
+    .filter { it.axis.isHorizontal }
+    .flatMap { dir ->
+        val yaw = dir.yaw
+        listOf(
+            Rotation(yaw, 0f),
+            Rotation(yaw, -90f),
+            Rotation(yaw, 90f)
+        )
+    }