Forcing horizontal rotation, placement preprocessor, lots of fixes

Author: Avanatiker

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

@@ -25,6 +25,8 @@ interface InteractionConfig {
      */
     val reach: Double
 
+    val visibilityCheck: Boolean
+
     /**
      * Will check `resolution squared` many points on a grid on each visible surface of the hit box.
      */

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

@@ -26,6 +26,7 @@ class InteractionSettings(
 ) : InteractionConfig {
     override val reach by c.setting("Reach", defaultReach, 0.1..10.0, 0.1, "Players reach / range", " blocks", vis)
     override val useRayCast by c.setting("Raycast", true, "Verify hit vector with ray casting (for very strict ACs)", vis)
+    override val visibilityCheck by c.setting("Visibility Check", true, "Check if target is visible", vis)
     override val resolution by c.setting("Resolution", 4, 1..40, 1, "How many raycast checks per surface (will be squared)") { vis() && useRayCast }
     override val swingHand by c.setting("Swing Hand", true, "Swing hand on interactions", vis)
     override val pingTimeout by c.setting("Ping Timeout", false, "Timeout on high ping", vis)

common/src/main/kotlin/com/lambda/event/listener/SafeListener.kt

@@ -46,9 +46,9 @@ import kotlin.reflect.KProperty
  * The [SafeListener] will keep a reference to the last signal processed by the listener.
  * Allowing use cases where the last signal is needed.
  * ```kotlin
- * val lastPacketReceived by listener<PacketEvent.Receive.Pre>()
+ * val lastPacketReceived by listen<PacketEvent.Receive.Pre>()
  *
- * listener<PacketEvent.Send.Pre> { event ->
+ * listen<PacketEvent.Send.Pre> { event ->
  *     println("Last packet received: ${lastPacketReceived?.packet}")
  *     // prints the last packet received
  *     // prints null if no packet was received

common/src/main/kotlin/com/lambda/interaction/RotationManager.kt

@@ -123,19 +123,20 @@ object RotationManager : Loadable {
         currentRotation = currentContext?.let { context ->
             val rotationTo = if (keepTicks >= 0) context.rotation else player.rotation
 
-            var speedMultiplier = (context.config as? RotationSettings)?.speedMultiplier ?: 1.0
-            if (keepTicks < 0) speedMultiplier = 1.0
-
-            val turnSpeed = context.config.turnSpeed * speedMultiplier
-
-            currentRotation
-                .slerp(rotationTo, turnSpeed)
-                .fixSensitivity(prevRotation)
-                .apply {
-                    if (context.config.rotationMode != RotationMode.LOCK) return@apply
-                    player.yaw = this.yawF
-                    player.pitch = this.pitchF
-                }
+            rotationTo
+//            var speedMultiplier = (context.config as? RotationSettings)?.speedMultiplier ?: 1.0
+//            if (keepTicks < 0) speedMultiplier = 1.0
+//
+//            val turnSpeed = context.config.turnSpeed * speedMultiplier
+//
+//            currentRotation
+//                .slerp(rotationTo, turnSpeed)
+//                .fixSensitivity(prevRotation)
+//                .apply {
+//                    if (context.config.rotationMode != RotationMode.LOCK) return@apply
+//                    player.yaw = this.yawF
+//                    player.pitch = this.pitchF
+//                }
         } ?: player.rotation
     }
 

common/src/main/kotlin/com/lambda/interaction/construction/context/PlaceContext.kt

@@ -24,6 +24,7 @@ import net.minecraft.block.BlockState
 import net.minecraft.util.Hand
 import net.minecraft.util.hit.BlockHitResult
 import net.minecraft.util.math.BlockPos
+import net.minecraft.util.math.Direction
 import net.minecraft.util.math.Vec3d
 
 data class PlaceContext(
@@ -37,6 +38,7 @@ data class PlaceContext(
     val targetState: TargetState,
     val sneak: Boolean,
     val insideBlock: Boolean,
+    val primeDirection: Direction?
 ) : BuildContext {
     override val resultingPos: BlockPos
         get() = result.blockPos.offset(result.side)

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

@@ -0,0 +1,26 @@
+/*
+ * Copyright 2024 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.processing
+
+import net.minecraft.block.BlockState
+
+abstract class PlacementProcessor {
+    abstract fun acceptState(state: BlockState): Boolean
+    abstract fun preProcess(state: BlockState): PreprocessingStep
+}
+

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

@@ -0,0 +1,28 @@
+/*
+ * Copyright 2024 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.processing
+
+import com.lambda.interaction.construction.verify.SurfaceScan
+import net.minecraft.state.property.Property
+import net.minecraft.util.math.Direction
+
+data class PreprocessingStep(
+    val surfaceScan: SurfaceScan = SurfaceScan.DEFAULT,
+    val ignore: Set<Property<*>> = emptySet(),
+    val sides: Set<Direction> = Direction.entries.toSet(),
+)

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

@@ -0,0 +1,42 @@
+/*
+ * Copyright 2024 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.processing
+
+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.Blocks
+
+object ProcessorRegistry : Loadable {
+    private const val PROCESSOR_PACKAGE = "com.lambda.interaction.construction.processing.processors"
+    private val processors = getInstances<PlacementProcessor> { forPackages(PROCESSOR_PACKAGE) }
+    private val processorCache = mutableMapOf<BlockState, PreprocessingStep>()
+
+    fun findProcessorForState(target: TargetState): PreprocessingStep =
+        (target as? TargetState.State)?.let { state ->
+            processorCache.getOrPut(state.blockState) {
+                (processors.find { it.acceptState(state.blockState) } ?: DefaultProcessor).preProcess(state.blockState)
+            }
+        } ?: DefaultProcessor.preProcess(Blocks.AIR.defaultState)
+
+    object DefaultProcessor : PlacementProcessor() {
+        override fun acceptState(state: BlockState) = true
+        override fun preProcess(state: BlockState) = PreprocessingStep()
+    }
+}

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

@@ -0,0 +1,35 @@
+/*
+ * Copyright 2024 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.processing.processors
+
+import com.lambda.interaction.construction.processing.PlacementProcessor
+import com.lambda.interaction.construction.processing.PreprocessingStep
+import net.minecraft.block.BlockState
+import net.minecraft.state.property.Properties
+
+object FacingProcessor : PlacementProcessor() {
+    override fun acceptState(state: BlockState) =
+        state.getOrEmpty(Properties.FACING).isPresent
+
+    override fun preProcess(state: BlockState): PreprocessingStep {
+        // Needs two sets of blocks: native and opposite!
+        return PreprocessingStep(
+            sides = setOf(state.getOrEmpty(Properties.FACING).get())
+        )
+    }
+}

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

@@ -0,0 +1,50 @@
+/*
+ * Copyright 2024 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.processing.processors
+
+import com.lambda.interaction.construction.processing.PlacementProcessor
+import com.lambda.interaction.construction.processing.PreprocessingStep
+import com.lambda.interaction.construction.verify.ScanMode
+import com.lambda.interaction.construction.verify.SurfaceScan
+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.Direction
+
+object SlabProcessor : PlacementProcessor() {
+    override fun acceptState(state: BlockState) = state.block is SlabBlock
+
+    override fun preProcess(state: BlockState): PreprocessingStep {
+        val slab = state.getOrEmpty(Properties.SLAB_TYPE).get()
+
+        val surfaceScan = when (slab) {
+             SlabType.BOTTOM -> SurfaceScan(
+                 ScanMode.LESSER_HALF, Direction.Axis.Y
+             )
+             SlabType.TOP -> SurfaceScan(
+                 ScanMode.GREATER_HALF, Direction.Axis.Y
+             )
+             SlabType.DOUBLE -> SurfaceScan(
+                 ScanMode.FULL, Direction.Axis.Y
+             )
+        }
+
+        return PreprocessingStep(surfaceScan)
+    }
+}