More dynamic configuration of the highway

Avanatiker · Avanatiker · commit 094c874ccbae · 2024-10-07T06:38:59.000+02:00
diff --git a/common/src/main/kotlin/com/lambda/module/modules/player/HighwayTools.kt b/common/src/main/kotlin/com/lambda/module/modules/player/HighwayTools.kt
@@ -10,6 +10,10 @@ import com.lambda.util.BaritoneUtils
 import com.lambda.util.Communication.info
 import com.lambda.util.player.MovementUtils.octant
 import com.lambda.util.extension.Structure
+import com.lambda.util.extension.moveY
+import com.lambda.util.math.MathUtils.ceilToInt
+import com.lambda.util.math.MathUtils.floorToInt
+import com.lambda.util.math.VecUtils.rotateClockwise
 import com.lambda.util.world.StructureUtils.generateDirectionalTube
 import net.minecraft.block.Blocks
 import net.minecraft.util.math.BlockPos
@@ -23,22 +27,38 @@ object HighwayTools : Module(
     description = "Auto highway builder",
     defaultTags = setOf(ModuleTag.PLAYER, ModuleTag.AUTOMATION)
 ) {
-    private val height by setting("Height", 4, 1..10, 1)
+    private val height by setting("Height", 4, 2..10, 1)
     private val width by setting("Width", 6, 1..30, 1)
-    private val rimHeight by setting("Rim Height", 1, 0..6, 1)
-    private val cornerBlock by setting("Corner Block", false, description = "Include corner blocks in the highway")
-    private val ceiling by setting("Ceiling", false, description = "Smooth roof over the highway")
-    private val ceilingMaterial by setting("Ceiling Material", Blocks.OBSIDIAN, description = "Material to build the ceiling with") { ceiling }
-    private val distance by setting("Distance", -1, -1..1000000, 1, description = "Distance to build the highway (negative for infinite)")
+    private val pavement by setting("Pavement", Material.Block, description = "Material for the pavement")
+    private val rimHeight by setting("Pavement Rim Height", 1, 0..6, 1) { pavement != Material.Any }
+    private val cornerBlock by setting("Corner", Corner.None, description = "Include corner blocks in the highway") { pavement != Material.Any }
+    private val pavementMaterial by setting("Pavement Material", Blocks.OBSIDIAN, description = "Material to build the highway with") { pavement == Material.Block }
+    private val floor by setting("Floor", Material.Any, description = "Material for the floor")
+    private val floorMaterial by setting("Floor Material", Blocks.NETHERRACK, description = "Material to build the floor with") { floor == Material.Block }
+    private val walls by setting("Walls", Material.Any, description = "Material for the walls")
+    private val wallMaterial by setting("Wall Material", Blocks.NETHERRACK, description = "Material to build the walls with") { walls == Material.Block }
+    private val ceiling by setting("Ceiling", Material.Any, description = "Material for the ceiling")
+    private val ceilingMaterial by setting("Ceiling Material", Blocks.OBSIDIAN, description = "Material to build the ceiling with") { ceiling == Material.Block }
+    private val distance by setting("Distance", -1, -1..1000000, 1, description = "Distance to build the highway/tunnel (negative for infinite)")
     private val sliceSize by setting("Slice Size", 3, 1..5, 1, description = "Number of slices to build at once")
-    private val material by setting("Highway Material", Blocks.OBSIDIAN, description = "Material to build the highway with")
 
     private var octant = EightWayDirection.NORTH
     private var distanceMoved = 0
     private var startPos = BlockPos.ORIGIN
     private var currentPos = BlockPos.ORIGIN
     private var runningTask: Task<*>? = null
 
+    enum class Material {
+        Any,
+        Solid,
+        Block,
+    }
+
+    enum class Corner {
+        None,
+        Solid,
+    }
+
     init {
         onEnable {
             octant = player.octant
@@ -58,7 +78,7 @@ object HighwayTools : Module(
         distanceMoved += sliceSize
 
         var structure: Structure = mutableMapOf()
-        val slice = highwaySlice()
+        val slice = generateSlice()
         repeat(sliceSize) {
             val vec = Vec3i(octant.offsetX, 0, octant.offsetZ)
             currentPos = currentPos.add(vec)
@@ -77,93 +97,121 @@ object HighwayTools : Module(
         }.start(null)
     }
 
-    private fun highwaySlice(): Structure {
+    private fun generateSlice(): Structure {
         val structure = mutableMapOf<BlockPos, TargetState>()
-        val orthogonal = EightWayDirection.entries[(octant.ordinal + 2).mod(8)]
-        val center = (width / 2.0).roundToInt()
+        val orthogonal = octant.rotateClockwise(2)
+        val center = (width / 2.0).floorToInt()
 
-        // Area to clear
+        // Hole
         structure += generateDirectionalTube(
             orthogonal,
             width,
             height,
             -center,
-            -1,
-        ).associateWith { TargetState.Air }
-
-        // Highway
-        structure += generateDirectionalTube(
-            orthogonal,
-            width,
-            1,
-            -center,
-            -1,
-        ).associateWith { TargetState.Block(material) }
-
-        // Left rim
-        structure += generateDirectionalTube(
-            orthogonal,
-            1,
-            rimHeight,
-            -center + width - 1,
-            0,
-        ).associateWith { TargetState.Block(material) }
-
-        // Right rim
-        structure += generateDirectionalTube(
-            orthogonal,
-            1,
-            rimHeight,
-            -center,
             0,
-        ).associateWith { TargetState.Block(material) }
+        ).associateWith { TargetState.Air }
 
-        if (!cornerBlock) {
-            structure -= generateDirectionalTube(
+        if (pavement != Material.Any) {
+            structure += generateDirectionalTube(
                 orthogonal,
+                width,
                 1,
+                -center,
+                0,
+            ).associateWith { target(pavement, pavementMaterial) }
+
+            // Left rim
+            structure += generateDirectionalTube(
+                orthogonal,
                 1,
+                rimHeight,
                 -center + width - 1,
-                -1,
-            )
+                1,
+            ).associateWith { target(pavement, pavementMaterial) }
 
-            structure -= generateDirectionalTube(
+            // Right rim
+            structure += generateDirectionalTube(
                 orthogonal,
                 1,
+                rimHeight,
+                -center,
+                1,
+            ).associateWith { target(pavement, pavementMaterial) }
+
+            if (cornerBlock == Corner.None) {
+                // Support for the left rim
+                structure += generateDirectionalTube(
+                    orthogonal,
+                    1,
+                    1,
+                    -center + width - 1,
+                    0,
+                ).associateWith { TargetState.Support(Direction.UP) }
+
+                // Support for the right rim
+                structure += generateDirectionalTube(
+                    orthogonal,
+                    1,
+                    1,
+                    -center,
+                    0,
+                ).associateWith { TargetState.Support(Direction.UP) }
+            }
+        }
+
+        if (ceiling != Material.Any) {
+            structure += generateDirectionalTube(
+                orthogonal,
+                width,
                 1,
                 -center,
-                -1,
-            )
+                height,
+            ).associateWith { target(ceiling, ceilingMaterial) }
         }
 
-        // Support for the left corner
-        structure += generateDirectionalTube(
-            orthogonal,
-            1,
-            1,
-            -center + width - 1,
-            -1,
-        ).associateWith { TargetState.Support(Direction.UP) }
+        if (walls != Material.Any) {
+            // Left wall
+            structure += generateDirectionalTube(
+                orthogonal,
+                1,
+                height,
+                -center + width,
+                0,
+            ).associateWith { target(walls, wallMaterial) }
 
-        // Support for the right corner
-        structure += generateDirectionalTube(
-            orthogonal,
-            1,
-            1,
-            -center,
-            -1,
-        ).associateWith { TargetState.Support(Direction.UP) }
+            // Right wall
+            structure += generateDirectionalTube(
+                orthogonal,
+                1,
+                height,
+                -center - 1,
+                0,
+            ).associateWith { target(walls, wallMaterial) }
+        }
 
-        if (ceiling) {
+        if (floor != Material.Any) {
             structure += generateDirectionalTube(
                 orthogonal,
                 width,
                 1,
                 -center,
-                height - 1,
-            ).associateWith { TargetState.Block(ceilingMaterial) }
+                -1,
+            ).associateWith { target(floor, floorMaterial) }
+        }
+
+        val transformed = when {
+            pavement != Material.Any -> structure.moveY(-1)
+            else -> structure
         }
 
-        return structure
+        return transformed
+    }
+
+    private fun target(target: Material, material: net.minecraft.block.Block): TargetState {
+        return when (target) {
+            Material.Solid -> TargetState.Solid
+            Material.Block -> TargetState.Block(material)
+            else -> throw IllegalStateException("Invalid material")
+        }
     }
 }
diff --git a/common/src/main/kotlin/com/lambda/util/extension/Aliases.kt b/common/src/main/kotlin/com/lambda/util/extension/Aliases.kt
@@ -7,3 +7,15 @@ import net.minecraft.util.math.BlockPos
 
 typealias CommandBuilder = LiteralArgumentBuilder<CommandSource>
 typealias Structure = Map<BlockPos, TargetState>
+
+fun Structure.move(offset: BlockPos): Structure =
+    mapKeys { (pos, _) -> pos.add(offset) }
+
+fun Structure.moveX(x: Int): Structure =
+    mapKeys { (pos, _) -> pos.east(x) }
+
+fun Structure.moveY(y: Int): Structure =
+    mapKeys { (pos, _) -> pos.up(y) }
+
+fun Structure.moveZ(z: Int): Structure =
+    mapKeys { (pos, _) -> pos.south(z) }
diff --git a/common/src/main/kotlin/com/lambda/util/math/VecUtils.kt b/common/src/main/kotlin/com/lambda/util/math/VecUtils.kt
@@ -1,13 +1,10 @@
 package com.lambda.util.math
 
 import com.lambda.util.math.MathUtils.sq
-import com.lambda.util.world.FastVector
-import com.lambda.util.world.x
-import com.lambda.util.world.y
-import com.lambda.util.world.z
 import net.minecraft.entity.Entity
 import net.minecraft.util.math.BlockPos
 import net.minecraft.util.math.Direction
+import net.minecraft.util.math.EightWayDirection
 import net.minecraft.util.math.Vec3d
 import net.minecraft.util.math.Vec3i
 import kotlin.math.pow
@@ -25,6 +22,9 @@ object VecUtils {
     val Direction.hitVecOffset get() =
         CENTER + vector.vec3d * 0.5
 
+    fun EightWayDirection.rotateClockwise(steps: Int) =
+        EightWayDirection.entries[(ordinal + steps) % 8]
+
     infix fun Vec3d.dist(other: Vec3d): Double = this.distanceTo(other)
 
     infix fun Vec3d.distSq(other: Vec3d): Double = this.squaredDistanceTo(other)
