big build sim performance increase

Author: beanbag44

src/main/kotlin/com/lambda/config/AutomationConfig.kt

@@ -72,7 +72,7 @@ open class AutomationConfig(
         fun automationConfig(name: String, edits: (AutomationConfig.() -> Unit)? = null): AutomationConfig =
             AutomationConfig("Default $name Automation Config").apply { edits?.invoke(this) }
 
-        object DEFAULT : AutomationConfig("Default Automation Config") {
+        object DEFAULT : AutomationConfig("Default") {
             val renders by setting("Render", false).group(Group.Render)
             val avoidDesync by setting("Avoid Desync", true, "Cancels incoming inventory update packets if they match previous actions").group(Group.Debug)
             val desyncTimeout by setting("Desync Timeout", 30, 1..30, 1, unit = " ticks", description = "Time to store previous inventory actions before dropping the cache") { avoidDesync }.group(Group.Debug)

src/main/kotlin/com/lambda/gui/MenuBar.kt

@@ -21,6 +21,7 @@ import com.lambda.Lambda
 import com.lambda.Lambda.REPO_URL
 import com.lambda.Lambda.mc
 import com.lambda.command.CommandRegistry
+import com.lambda.config.AutomationConfig
 import com.lambda.config.Configuration
 import com.lambda.config.Configuration.Companion.configurables
 import com.lambda.config.UserAutomationConfig
@@ -34,6 +35,8 @@ import com.lambda.gui.components.HudGuiLayout
 import com.lambda.gui.components.QuickSearch
 import com.lambda.gui.components.SettingsWidget.buildConfigSettingsContext
 import com.lambda.gui.dsl.ImGuiBuilder
+import com.lambda.gui.dsl.ImGuiBuilder.popupContextItem
+import com.lambda.gui.dsl.ImGuiBuilder.selectable
 import com.lambda.interaction.BaritoneManager
 import com.lambda.module.ModuleRegistry
 import com.lambda.module.ModuleRegistry.moduleNameMap
@@ -73,7 +76,7 @@ object MenuBar {
             menu("HUD") { buildHudMenu() }
             menu("GUI") { buildGuiMenu() }
             menu("Modules") { buildModulesMenu() }
-            menu("Automation Presets") { buildConfigPresetsMenu() }
+            menu("Automation Configs") { buildConfigPresetsMenu() }
             menu("Minecraft") { buildMinecraftMenu() }
             menu("Help") { buildHelpMenu() }
             buildGitHubReference()
@@ -303,9 +306,15 @@ object MenuBar {
 
         UserAutomationConfigs.configurables.forEach { config ->
             if (config !is UserAutomationConfig) throw java.lang.IllegalStateException("All configurables within UserAutomationConfigs must be UserAutomationConfigs!")
-            selectable(config.name)
+            buildAutomationConfigSelectable(config)
+        }
+        buildAutomationConfigSelectable(AutomationConfig.Companion.DEFAULT)
+    }
 
-            popupContextItem("##automation-config-popup-${config.name}") {
+    private fun buildAutomationConfigSelectable(config: AutomationConfig) {
+        selectable(config.name)
+        popupContextItem("##automation-config-popup-${config.name}") {
+            if (config is UserAutomationConfig) {
                 with(config.linkedModules) { buildLayout() }
                 button("Delete") {
                     config.linkedModules.value.forEach {
@@ -316,8 +325,8 @@ object MenuBar {
                     UserAutomationConfigs.configurables.remove(config)
                 }
                 separator()
-                buildConfigSettingsContext(config)
             }
+            buildConfigSettingsContext(config)
         }
     }
 

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

@@ -48,7 +48,7 @@ object BuildSimulator : Sim<PostSimResult>() {
     context(automatedSafeContext: AutomatedSafeContext)
     fun Structure.simulate(
         pov: Vec3d = automatedSafeContext.player.eyePos
-    ) : Set<BuildResult> = runBlocking(Dispatchers.Default) {
+    ): Set<BuildResult> = runBlocking(Dispatchers.Default) {
         supervisorScope {
             val concurrentSet = ConcurrentSet<BuildResult>()
 

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

@@ -22,6 +22,7 @@ import com.lambda.interaction.construction.result.BuildResult
 import com.lambda.interaction.construction.result.results.GenericResult
 import com.lambda.interaction.request.rotating.Rotation.Companion.rotationTo
 import com.lambda.interaction.request.rotating.visibilty.VisibilityChecker.CheckedHit
+import com.lambda.interaction.request.rotating.visibilty.VisibilityChecker.getClosestPoints
 import com.lambda.interaction.request.rotating.visibilty.VisibilityChecker.getVisibleSurfaces
 import com.lambda.interaction.request.rotating.visibilty.VisibilityChecker.scanSurfaces
 import com.lambda.util.math.distSq
@@ -102,26 +103,31 @@ abstract class Sim<T : BuildResult> : Results<T> {
         supervisorScope {
             boxes.forEach { box ->
                 launch {
-                    val sides = if (buildConfig.checkSideVisibility || buildConfig.strictRayCast) {
+                    val sides = if (buildConfig.checkSideVisibility || buildConfig.strictRayCast)
                         sides.intersect(box.getVisibleSurfaces(pov))
-                    } else sides
-
-                    scanSurfaces(box, sides, buildConfig.resolution, preProcessing.surfaceScan) { side, vec ->
+                    else sides
+
+                    if (!buildConfig.strictRayCast) {
+                        box.getClosestPoints(pov, sides, preProcessing.surfaceScan, placeConfig.airPlace.isEnabled) { vec, side ->
+                            if (pov distSq vec > reachSq)
+                                misses.add(Pair(vec, side))
+                            else {
+                                validHits.add(
+                                    CheckedHit(
+                                        BlockHitResult(vec, side, pos, false),
+                                        pov.rotationTo(vec)
+                                    )
+                                )
+                            }
+                        }
+                    } else box.scanSurfaces(sides, buildConfig.resolution, preProcessing.surfaceScan, false) { side, vec ->
                         if (pov distSq vec > reachSq) {
                             misses.add(Pair(vec, side))
                             return@scanSurfaces
                         }
 
                         val newRotation = pov.rotationTo(vec)
-
-                        val hit = if (buildConfig.strictRayCast) {
-                            newRotation.rayCast(buildConfig.interactReach, pov)?.blockResult ?: return@scanSurfaces
-                        } else {
-                            val hitVec =
-                                if (buildConfig.checkSideVisibility) newRotation.castBox(box, buildConfig.interactReach, pov) ?: return@scanSurfaces
-                                else vec
-                            BlockHitResult(hitVec, side, pos, false)
-                        }
+                        val hit = newRotation.rayCast(buildConfig.interactReach, pov)?.blockResult ?: return@scanSurfaces
 
                         if (hit.blockPos != pos || hit.side != side) return@scanSurfaces
                         val checked = CheckedHit(hit, newRotation)

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

@@ -129,7 +129,7 @@ class BreakSim private constructor(simInfo: ISimInfo)
         val validHits = scanShape(pov, shape, pos, Direction.entries.toSet(), preProcessing) ?: return
 
         val bestHit = buildConfig.pointSelection.select(validHits) ?: return
-        val target = lookAt(bestHit.targetRotation)
+        val target = lookAt(bestHit.rotation)
         val rotationRequest = RotationRequest(target, this)
 
         val breakContext = BreakContext(

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

@@ -216,7 +216,7 @@ class PlaceSim private constructor(simInfo: ISimInfo)
         val currentDirIsValid = testPlaceState(context) != null
 
         if (!placeConfig.axisRotate) {
-            fakePlayer.rotation = checkedHit.targetRotation
+            fakePlayer.rotation = checkedHit.rotation
             return testPlaceState(context)?.let { RotatePlaceTest(it, currentDirIsValid, fakePlayer.rotation) }
         }
 

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

@@ -151,7 +151,7 @@ class PostProcessingSim private constructor(simInfo: ISimInfo)
     ) {
         buildConfig.pointSelection.select(validHits)?.let { checkedHit ->
             val checkedResult = checkedHit.hit.blockResult ?: return
-            val rotationTarget = lookAt(checkedHit.targetRotation)
+            val rotationTarget = lookAt(checkedHit.rotation)
             val context = InteractContext(
                 checkedResult,
                 RotationRequest(rotationTarget, this),

src/main/kotlin/com/lambda/interaction/request/rotating/visibilty/PointSelection.kt

@@ -33,7 +33,7 @@ enum class PointSelection(
         "By Rotation",
         "Choose the point that needs the least rotation from your current view (minimal camera turn).",
         select = { hits ->
-            hits.minByOrNull { RotationManager.activeRotation dist it.targetRotation }
+            hits.minByOrNull { RotationManager.activeRotation dist it.rotation }
         }
     ),
     Optimum(

src/main/kotlin/com/lambda/interaction/request/rotating/visibilty/RotationTargets.kt

@@ -108,8 +108,9 @@ fun Automated.lookAtEntity(entity: LivingEntity): RotationTarget {
                 player.eyePos,
                 ALL_SIDES,
                 SurfaceScan.DEFAULT,
+                false,
                 InteractionMask.Entity
-            ) { requestedHit.verifyHit(hit) }?.targetRotation
+            ) { requestedHit.verifyHit(hit) }?.rotation
         }
     }
 }
@@ -138,8 +139,9 @@ fun Automated.lookAtBlock(
                 player.eyePos,
                 sides,
                 surfaceScan,
+                false,
                 InteractionMask.Block
-            ) { requestedHit.verifyHit(hit) }?.targetRotation
+            ) { requestedHit.verifyHit(hit) }?.rotation
         }
     }
 }