crystal aura

Author: emyfops

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

@@ -162,12 +162,8 @@ abstract class Targeting(
          * @return The best [LivingEntity] target, or `null` if no valid target is found.
          */
         fun target(): LivingEntity? = runSafe {
-            val predicate = { entity: LivingEntity ->
-                validate(player, entity)
-            }
-
             return@runSafe fastEntitySearch<LivingEntity>(targetingRange) {
-                predicate(it)
+                validate(player, it)
             }.minByOrNull {
                 priority.factor(this, it)
             }

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

@@ -20,22 +20,31 @@ package com.lambda.module.modules.combat
 import com.lambda.config.groups.InteractionSettings
 import com.lambda.config.groups.RotationSettings
 import com.lambda.config.groups.Targeting
-import com.lambda.event.events.TickEvent
-import com.lambda.event.listener.SafeListener.Companion.listener
-import com.lambda.interaction.RotationManager.requestRotation
+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.interaction.RotationManager.rotate
 import com.lambda.interaction.visibilty.VisibilityChecker.lookAtBlock
 import com.lambda.module.Module
 import com.lambda.module.tag.ModuleTag
-import com.lambda.task.tasks.BreakBlock
-import com.lambda.util.combat.Explosion.explosionDamage
+import com.lambda.util.BlockUtils.blockState
+import com.lambda.util.collections.LimitedDecayQueue
+import com.lambda.util.combat.CombatUtils.explosionDamage
 import com.lambda.util.math.VecUtils.dist
+import com.lambda.util.math.transform
 import com.lambda.util.world.blockSearch
+import com.lambda.util.world.fastEntitySearch
 import net.minecraft.block.Blocks
-import net.minecraft.block.SideShapeType
+import net.minecraft.entity.Entity
 import net.minecraft.entity.LivingEntity
+import net.minecraft.entity.decoration.EndCrystalEntity
 import net.minecraft.util.Hand
 import net.minecraft.util.math.BlockPos
+import net.minecraft.util.math.Box
 import net.minecraft.util.math.Direction
+import java.awt.Color
+import java.time.Instant
 
 object CrystalAura : Module(
     name = "CrystalAura",
@@ -55,63 +64,91 @@ object CrystalAura : Module(
     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 multiPlace by setting("Multi Place", true, description = "Place crystals") { page == Page.Placing }
-    private val minSeparation by setting("Minimum Crystal Separation", 2, 1..3, 1, description = "The minimum space between crystals", unit = "blocks") { page == Page.Placing }
-
-
-    private val placeDelay by setting("Place Delay", 0, 0..20, 1, description = "Delay between crystal placements", unit = "ticks") { page == Page.Placing }
-    private val placeMinHealth by setting("Place Min Health", 10.0, 0.0..20.0, 0.5, description = "Minimum health to place a crystal") { page == Page.Placing }
-    private val placeMaxSelfDamage by setting("Place Max Self Damage", 8.0, 0.0..20.0, 0.5, description = "Maximum self damage to place a crystal") { 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 }
+    private val placeMinHealth by setting("Place Min Health", 10.0, 0.0..36.0, 0.5, description = "Minimum health to place a crystal") { page == Page.Placing }
     private val placeMinDamage by setting("Place Min Damage", 6.0, 0.0..20.0, 0.5, description = "Minimum damage to place a crystal") { page == Page.Placing }
+    private val placeMaxSelfDamage by setting("Place Max Self Damage", 8.0, 0.0..20.0, 0.5, description = "Maximum self damage to place a crystal") { page == Page.Placing }
 
     /* Exploding */
     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 preventDeath by setting("Prevent Death", true, description = "Prevent death from crystal explosions") { page == Page.Exploding }
+    private val explodeMethod by setting("Explode Sort", DamageSort.Deadly)
     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 }
-    private val noWeakness by setting("No Weakness", true, description = "Switch to a weapon when you have a weakness effect") { page == Page.Exploding }
 
     /* Rendering */
-    private val rendering = Targeting.ESP(this) { page == Page.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 placedCrystal = 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(),
+            step = minSeparation, // Need to change this behavior
+            pos = player.blockPos,
+        ) { pos, _ -> canPlace(pos, target) }
+            .keys.asSequence()
+            .sortedByDescending { placeMethod.sorted(this, target, it.up()) } // The explosion source of the crystal is not at its base
+    }
+
+    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 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>(1.5, pos.up()).isEmpty() && // Doesn't handle the edge case where there is a crystal floating
+
+                player.health + player.absorptionAmount >= placeMinHealth &&
+                explosionDamage(pos, target, 6.0) >= placeMinDamage &&
+                explosionDamage(pos, player, 6.0) <= placeMaxSelfDamage &&
+                // Checks if the last crystal was set more than [placeDelay] ms ago
+                placedCrystal.peek()?.second?.plusMillis(placeDelay)?.isBefore(Instant.now()) ?: true
+        //if (multiPlace) !placedCrystal.any { (crystalPos, _) -> pos.up() == crystalPos } else true
+    }
 
-    val targetEntity: LivingEntity? get() = targeting.target()
-    val validPositions = mutableListOf<BlockPos>()
 
     init {
-        BreakBlock
-        requestRotation(
-            onUpdate = {
-                val blockpos =
-                    validPositions.removeFirstOrNull() ?: return@requestRotation null
-                if (!rotate) return@requestRotation null
-
-                lookAtBlock(blockpos, rotation, placing)
-            },
-        )
-
-        listener<TickEvent.Pre> {
-            targetEntity?.let { target ->
-                // TODO: If we could provide our own selector to [PlaceFinder] we could use it instead of this
-                // Or maybe not since we want a fast way of finding the best positions
-                validPositions.clear() // not good
-                validPositions.addAll(
-                    blockSearch(
-                        range = placing.reach.toInt(),
-                        step = minSeparation,
-                        pos = target.blockPos, // Search around the target and not the player
-                    ) { pos, state ->
-                        !state.isSideSolid(world, pos, Direction.UP, SideShapeType.FULL) &&
-                                (state.isOf(Blocks.OBSIDIAN) || state.isOf(Blocks.BEDROCK)) &&
-                                // If the distance between the player and the place position for the
-                                // target is greater than the explosion range, we cannot use said
-                                // position as it is impossible to reach
-                                player dist pos <= explodeRange
-                    }.keys
-                        .asSequence()
-                        // https://minecraft.wiki/w/Explosion#Damage
-                        .sortedByDescending { explosionDamage(it, target, 6.0) }
+        rotate(
+            priority = 100,
+        ) {
+           onUpdate {
+               if (!rotate) return@onUpdate null
+
+               val blockpos = validPositions(
+                   target ?: return@onUpdate null
+               ).firstOrNull() ?: return@onUpdate null
+
+               // Taskflow interact block
+               // placedCrystal.add()
+               lookAtBlock(blockpos, rotation, placing, sides = setOf(Direction.UP))
+           }
+        }
+
+        listen<RenderEvent.StaticESP> {
+            worldCrystals(target ?: return@listen).forEach { crystal ->
+                it.renderer.build(
+                    Box.of(crystal.pos, 1.0, 1.0, 1.0),
+                    crystalColor.compared(this, target ?: return@forEach, crystal.blockPos),
+                    crystalColor.compared(this, target ?: return@forEach, crystal.blockPos)
                 )
             }
         }
@@ -124,4 +161,22 @@ object CrystalAura : Module(
         Exploding,
         Rendering
     }
+
+    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 ColorComparator(val compared: SafeContext.(LivingEntity, BlockPos) -> Color) {
+        Distance({ target, dest ->
+            val red = transform(target dist dest, 0.0, explodeRange, 255.0, 0.0).toInt()
+            Color(red, 255-red, 0, crystalAlpha)
+        }),
+
+        Damage({ target, dest ->
+            val red = transform(explosionDamage(dest, target, 6.0), 0.0, target.health.toDouble(), 0.0, 255.0).toInt()
+            Color(red, 255-red, 0, crystalAlpha)
+        })
+    }
 }

common/src/main/kotlin/com/lambda/util/collections/LimitedDecayQueue.kt

@@ -23,17 +23,13 @@ import java.util.concurrent.ConcurrentLinkedQueue
 class LimitedDecayQueue<E>(
     private var sizeLimit: Int,
     private var interval: Long,
-) {
-    private val queue: ConcurrentLinkedQueue<Pair<E, Instant>> = ConcurrentLinkedQueue()
-
-    val size: Int
-        get() = queue.size
-
+) : ConcurrentLinkedQueue<Pair<E, Instant>>() {
     @Synchronized
+    @JvmName("jvmAdd")
     fun add(element: E): Boolean {
         cleanUp()
-        return if (queue.size < sizeLimit) {
-            queue.add(element to Instant.now())
+        return if (size < sizeLimit) {
+            add(element to Instant.now())
             true
         } else {
             false
@@ -55,8 +51,8 @@ class LimitedDecayQueue<E>(
     @Synchronized
     private fun cleanUp() {
         val now = Instant.now()
-        while (queue.isNotEmpty() && now.minusMillis(interval).isAfter(queue.peek().second)) {
-            queue.poll()
+        while (isNotEmpty() && now.minusMillis(interval).isAfter(peek().second)) {
+            poll()
         }
     }
 }