Crystal Aura rewrite

- Collect damage data once and use that for comparison etc
- Use actual game checks for valid placements
- Added InteractionSettings
- Added RotationSettings

Author: Avanatiker

common/src/main/kotlin/com/lambda/module/modules/combat/CrystalAura.kt

@@ -23,7 +23,7 @@ import com.lambda.config.groups.Targeting
 import com.lambda.context.SafeContext
 import com.lambda.event.events.RenderEvent
 import com.lambda.event.listener.SafeListener.Companion.listen
-import com.lambda.graphics.renderer.esp.builders.build
+import com.lambda.graphics.renderer.esp.builders.ofShape
 import com.lambda.interaction.RotationManager.rotate
 import com.lambda.interaction.visibilty.VisibilityChecker.lookAtBlock
 import com.lambda.module.Module
@@ -34,20 +34,14 @@ import com.lambda.util.combat.CombatUtils.explosionDamage
 import com.lambda.util.math.VecUtils.dist
 import com.lambda.util.math.VecUtils.vec3d
 import com.lambda.util.math.transform
-import com.lambda.util.world.blockSearch
-import com.lambda.util.world.fastEntitySearch
+import net.minecraft.block.BlockState
 import net.minecraft.block.Blocks
-import net.minecraft.entity.Entity
 import net.minecraft.entity.LivingEntity
-import net.minecraft.entity.decoration.EndCrystalEntity
-import net.minecraft.item.EndCrystalItem
 import net.minecraft.util.Hand
 import net.minecraft.util.math.BlockPos
 import net.minecraft.util.math.Box
-import net.minecraft.util.math.Direction
 import net.minecraft.util.math.Vec3d
 import java.awt.Color
-import java.time.Instant
 
 object CrystalAura : Module(
     name = "CrystalAura",
@@ -57,17 +51,13 @@ object CrystalAura : Module(
     private val page by setting("Page", Page.Targeting)
 
     /* Targeting */
-    private val targeting = Targeting.Combat(this) { page == Page.Targeting }
-
-    /* Rotation */
-    private val rotate by setting("Rotate", true) { page == Page.Rotation }
-    private val rotation = RotationSettings(this) { page == Page.Rotation && rotate }
+    // ToDo: Targeting Range should be reach + crystal range (also based on min damage)
+    private val targeting = Targeting.Combat(this, 10.0) { page == Page.Targeting }
 
     /* Placing */
     private val doPlace by setting("Do Place", true) { page == Page.Placing }
-    private val placing = InteractionSettings(this) { page == Page.Placing }
     private val swap by setting("Swap", Hand.MAIN_HAND, description = "Automatically swap to place crystals") { page == Page.Placing }
-    private val placeMethod by setting("Place Sort", DamageSort.Deadly)
+    private val placeMethod by setting("Place Sort", DamageSort.Deadly) { page == Page.Placing }
     //private val multiPlace by setting("Multi Place", true, description = "Place crystals") { page == Page.Placing }
     private val minSeparation by setting("Minimum Crystal Separation", 1, 1..3, 1, description = "The minimum space between crystals", unit = "blocks") { page == Page.Placing }
     private val placeDelay by setting("Place Delay", 0L, 0L..1000L, 10L, description = "Delay between crystal placements", unit = "ms") { page == Page.Placing }
@@ -79,117 +69,109 @@ object CrystalAura : Module(
     private val doExplode by setting("Do Explode", true) { page == Page.Exploding }
     private val explodeDelay by setting("Explode Delay", 0, 0..20, 1, description = "Delay between crystal explosions", unit = "ticks") { page == Page.Exploding }
     private val explodeRange by setting("Explode Range", 5.0, 0.1..7.0, 0.1, description = "Range to explode crystals") { page == Page.Exploding }
-    private val explodeMethod by setting("Explode Sort", DamageSort.Deadly)
+    private val explodeMethod by setting("Explode Sort", DamageSort.Deadly) { page == Page.Exploding }
     private val explodeMinDamage by setting("Explode Min Damage", 6.0, 0.0..20.0, 0.5, description = "Minimum damage to explode a crystal") { page == Page.Exploding }
 
+    /* Rotation */
+    private val rotation = RotationSettings(this) { page == Page.Rotation }
+
+    /* Interaction */
+    private val interact = InteractionSettings(this) { page == Page.Interaction }
+
     /* Rendering */
     private val renderCrystals by setting("Render Crystal", true) { page == Page.Rendering }
     private val crystalColor by setting("Color Comparator", ColorComparator.Damage) { page == Page.Rendering && renderCrystals }
-    private val crystalAlpha by setting("Color Alpha", 128, 0..255)
+    private val crystalAlpha by setting("Color Alpha", 128, 0..255) { page == Page.Rendering && renderCrystals }
 
-    private val placedCrystal = LimitedDecayQueue<BlockPos>(64, 1000L)
+    private val placements = LimitedDecayQueue<BlockPos>(64, 1000L)
     private val target: LivingEntity? get() = targeting.target()
 
-    private fun SafeContext.worldCrystals(target: LivingEntity): List<EndCrystalEntity> {
-        return fastEntitySearch<EndCrystalEntity>(explodeRange, pos = target.blockPos)
-            .sortedByDescending { explodeMethod.sorted(this, target, it.blockPos) }
-    }
-
-    private fun SafeContext.validPositions(target: LivingEntity): Sequence<BlockPos> {
-        return blockSearch(range = placing.reach.toInt()) { pos, _ -> canPlace(pos, target) }
-            .keys.asSequence()
-            .sortedByDescending { placeMethod.sorted(this, target, it.up()) }
-    }
-
-    private fun SafeContext.canPlace(pos: BlockPos, target: LivingEntity): Boolean {
-        // Checks if the distance between the player and the target
-        // and the player and the place position is <= to the placing range
-        return player dist target <= placing.reach &&
-                player dist pos <= placing.reach &&
-                // Checks if the position is within the player hitbox
-                !player.boundingBox.intersects(Box.of(pos.vec3d, 1.0, 1.0, 1.0)) &&
-                // Checks if the support block is either obsidian or bedrock
-                (pos.blockState(world).isOf(Blocks.OBSIDIAN)
-                        || pos.blockState(world).isOf(Blocks.BEDROCK)) &&
-                // Checks if the crystal can be placed on top of a block
-                // It checks if there's another entity in the air block
-                // Or if there's another crystal 2 blocks around the air block
-                world.isAir(pos.up()) &&
-                fastEntitySearch<Entity>(0.5, pos.up()).isEmpty() &&
-                fastEntitySearch<EndCrystalEntity>(2.0, pos.up()).isEmpty() && // Replace by intersection check bc blockpos is corner
-
-                // player.health + player.absorptionAmount >= placeMinHealth &&
-                explosionDamage(pos.up(), target, 6.0) >= placeMinDamage &&
-                explosionDamage(pos.up(), player, 6.0) <= placeMaxSelfDamage
-                // Checks if the last crystal was set more than [placeDelay] ms ago
-                // placedCrystal.lastOrNull()?.second?.plusMillis(placeDelay)?.isBefore(Instant.now()) ?: true
-        //if (multiPlace) !placedCrystal.any { (crystalPos, _) -> pos.up() == crystalPos } else true
-    }
-
-    private val testRender = mutableListOf<BlockPos>()
-
-
     init {
         rotate {
-           onUpdate {
-               if (!rotate) return@onUpdate null
-
-               val poss = validPositions(
-                   target ?: return@onUpdate null
-               )
-
-               testRender.addAll(poss)
+            onUpdate {
+                val targetEntity = target ?: return@onUpdate null
+                val validPositions = findTargetPositions(targetEntity)
 
-               val blockpos = poss.firstOrNull() ?: return@onUpdate null
+                testRender.addAll(validPositions.map { it.blockPos })
 
-               // Taskflow interact block
-               // placedCrystal.add()
-               lookAtBlock(blockpos, rotation, placing, sides = setOf(Direction.UP))
-           }
+                validPositions.firstNotNullOfOrNull {
+                    lookAtBlock(it.blockPos, rotation, interact)
+                }
+            }
         }
 
         listen<RenderEvent.StaticESP> {
-            worldCrystals(target ?: return@listen).forEach { crystal ->
-                it.renderer.build(
-                    Box.of(crystal.blockPos.toCenterPos(), 1.0, 1.0, 1.0),
-                    crystalColor.compared(this, target ?: return@forEach, crystal.pos),
-                    crystalColor.compared(this, target ?: return@forEach, crystal.pos)
-                )
-            }
-
-            testRender.forEachIndexed { index, pos ->
-                val center = pos.toCenterPos()
-                val blurple = Color(85, 57, 204, 50)
-                it.renderer.build(
-                    Box.of(center, 1.0, 1.0, 1.0),
-                    blurple,
-                    blurple
-                )
+//            worldCrystals(target ?: return@listen).forEach { crystal ->
+//                it.renderer.build(
+//                    Box.of(crystal.blockPos.toCenterPos(), 1.0, 1.0, 1.0),
+//                    crystalColor.compared(this, target ?: return@forEach, crystal.pos),
+//                    crystalColor.compared(this, target ?: return@forEach, crystal.pos)
+//                )
+//            }
+
+            val blurple = Color(85, 57, 204, 50)
+            testRender.forEach { pos ->
+                it.renderer.ofShape(pos, blurple, blurple)
             }
 
             testRender.clear()
         }
     }
 
-    private enum class Page {
-        Targeting,
-        Rotation,
-        Placing,
-        Exploding,
-        Rendering
+//    private fun SafeContext.worldCrystals(target: LivingEntity) =
+//        fastEntitySearch<EndCrystalEntity>(explodeRange, pos = target.blockPos)
+//            .sortedByDescending { explodeMethod.sorted(this, target, it.blockPos) }
+
+    private fun SafeContext.findTargetPositions(target: LivingEntity): List<TargetPosition> {
+        // This formula is derived from the explosion damage scaling logic. The damage decreases linearly
+        // with distance, modeled as `damage = (1 - (distance / (power * 2))) * exposure`, where power is the
+        // explosion's strength (6.0) and exposure defines how much of the explosion affects the target.
+        val maximumRange = ((1 - (placeMinDamage / 12.0)) * 12.0).toInt()
+
+        return BlockPos.iterateOutwards(target.blockPos, maximumRange, maximumRange, maximumRange).mapNotNull { pos ->
+            targetData(pos, pos.blockState(world), target)
+        }.sortedWith(placeMethod.comparator)
+    }
+
+    private fun SafeContext.targetData(pos: BlockPos, state: BlockState, target: LivingEntity): TargetPosition? {
+        val inRange = pos.dist(player.eyePos) < interact.reach + 1
+        if (!inRange) return null
+        val isOfBlock = state.isOf(Blocks.OBSIDIAN) || state.isOf(Blocks.BEDROCK)
+        if (!isOfBlock) return null
+        if (pos in placements) return null
+        val above = pos.up()
+        val isAirAbove = world.isAir(above)
+        if (!isAirAbove) return null
+        val checkBox = Box(above).withMaxY(above.y + 2.0)
+        val entitiesAbove = world.getOtherEntities(null, checkBox)
+        if (entitiesAbove.isNotEmpty()) return null
+        val crystalPos = above.vec3d.add(0.5, 0.0, 0.5)
+        val targetDamage = explosionDamage(crystalPos, target, 6.0)
+        if (targetDamage <= placeMinDamage) return null
+        val selfDamage = explosionDamage(crystalPos, player, 6.0)
+        if (selfDamage > placeMaxSelfDamage) return null
+        return TargetPosition(pos.toImmutable(), targetDamage, selfDamage)
     }
 
+    private val testRender = mutableListOf<BlockPos>()
+
+    data class TargetPosition(
+        val blockPos: BlockPos,
+        val targetDamage: Double,
+        val selfDamage: Double,
+    )
+
     /**
      * Damage sorter parameter
      *
      * deadly -> always prioritize enemy damage no matter what
-     * balanced -> sort by the highest ratio of enemy damage to self damage
-     * safe -> always prioritize the least amount of self damage
+     * balanced -> sort by the highest ratio of enemy damage to self-damage
+     * safe -> always prioritize the least amount of self-damage
      */
-    private enum class DamageSort(val sorted: SafeContext.(LivingEntity, BlockPos) -> Double) {
-        Deadly({ target, source -> explosionDamage(source, target, 6.0) }),
-        Balanced({ target, source -> explosionDamage(source, player, 6.0) - explosionDamage(source, target, 6.0) }),
-        Safe({ target, source -> explosionDamage(source, target, 6.0) - explosionDamage(source, player, 6.0) });
+    private enum class DamageSort(val comparator: Comparator<TargetPosition>) {
+        Deadly(compareByDescending<TargetPosition> { it.targetDamage }.thenBy { it.selfDamage }),
+        Balanced(compareByDescending<TargetPosition> { it.targetDamage / it.selfDamage }.thenBy { it.selfDamage }),
+        Safe(compareBy<TargetPosition> { it.selfDamage }.thenByDescending { it.targetDamage });
     }
 
     /**
@@ -202,7 +184,6 @@ object CrystalAura : Module(
             val red = transform(target dist dest, 0.0, explodeRange, 255.0, 0.0).toInt()
             Color(red, 255-red, 0, crystalAlpha)
         }),
-
         Damage({ target, dest ->
             val damage = explosionDamage(dest, target, 6.0)
                 .coerceIn(0.0, target.health.toDouble())
@@ -211,4 +192,13 @@ object CrystalAura : Module(
             Color(red, 255-red, 0, crystalAlpha)
         })
     }
+
+    private enum class Page {
+        Targeting,
+        Placing,
+        Exploding,
+        Rotation,
+        Interaction,
+        Rendering
+    }
 }