Fix: use distance from boundbox edge for targeting distance

src/main/kotlin/com/lambda/graphics/mc/renderer/ChunkedRenderer.kt

@@ -29,8 +29,8 @@ import com.lambda.graphics.mc.RegionRenderer
 import com.lambda.graphics.mc.RenderBuilder
 import com.lambda.module.Module
 import com.lambda.module.modules.client.StyleEditor
-import com.lambda.util.world.FastVector
-import com.lambda.util.world.fastVectorOf
+import com.lambda.util.math.FastVector
+import com.lambda.util.math.fastVectorOf
 import com.mojang.blaze3d.buffers.GpuBufferSlice
 import com.mojang.blaze3d.systems.RenderSystem
 import net.minecraft.util.math.ChunkPos

src/main/kotlin/com/lambda/graphics/util/DirectionMask.kt

@@ -17,10 +17,10 @@
 
 package com.lambda.graphics.util
 
-import com.lambda.util.world.FastVector
-import com.lambda.util.world.offset
-import com.lambda.util.world.toBlockPos
-import com.lambda.util.world.toFastVec
+import com.lambda.util.math.FastVector
+import com.lambda.util.math.offset
+import com.lambda.util.math.toBlockPos
+import com.lambda.util.math.toFastVec
 import net.minecraft.util.math.BlockPos
 import net.minecraft.util.math.Direction
 

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

@@ -18,8 +18,8 @@
 package com.lambda.interaction.construction.simulation
 
 import baritone.api.pathing.goals.Goal
-import com.lambda.util.world.fastVectorOf
-import com.lambda.util.world.toFastVec
+import com.lambda.util.math.fastVectorOf
+import com.lambda.util.math.toFastVec
 import net.minecraft.util.math.BlockPos
 
 class BuildGoal(

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

@@ -20,16 +20,15 @@ package com.lambda.interaction.construction.simulation
 import com.lambda.context.Automated
 import com.lambda.context.SafeContext
 import com.lambda.graphics.mc.RenderBuilder
-import com.lambda.graphics.mc.renderer.TickedRenderer
 import com.lambda.interaction.construction.blueprint.Blueprint
 import com.lambda.interaction.construction.simulation.BuildSimulator.simulate
 import com.lambda.interaction.construction.simulation.result.BuildResult
 import com.lambda.interaction.construction.simulation.result.Drawable
 import com.lambda.threading.runSafeAutomated
 import com.lambda.util.BlockUtils.blockState
-import com.lambda.util.world.FastVector
-import com.lambda.util.world.toBlockPos
-import com.lambda.util.world.toVec3d
+import com.lambda.util.math.FastVector
+import com.lambda.util.math.toBlockPos
+import com.lambda.util.math.toVec3d
 import net.minecraft.client.network.ClientPlayerEntity
 import net.minecraft.util.math.BlockPos
 import net.minecraft.util.math.Box

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

@@ -55,6 +55,8 @@ import com.lambda.util.math.minus
 import com.lambda.util.math.plus
 import com.lambda.util.player.SlotUtils.hotbarStacks
 import com.lambda.util.world.fastEntitySearch
+import com.lambda.util.math.toFastVec
+import com.lambda.util.math.vec3d
 import net.minecraft.block.Blocks
 import net.minecraft.entity.Entity
 import net.minecraft.entity.LivingEntity
@@ -356,7 +358,7 @@ object CrystalAura : Module(
                 // Exclude blocks blocked by entities
                 val crystalBox = pos.crystalBox
 
-                val entitiesNearby = fastEntitySearch<Entity>(3.5, pos)
+                val entitiesNearby = fastEntitySearch<Entity>(3.5, pos.vec3d)
                 val crystals = entitiesNearby.filterIsInstance<EndCrystalEntity>()
                 val otherEntities = entitiesNearby - crystals + player
 

src/main/kotlin/com/lambda/module/modules/combat/PlayerTrap.kt

@@ -73,11 +73,12 @@ object PlayerTrap : Module(
 				val block = player.hotbarAndInventoryStacks.firstOrNull {
 					it.item is BlockItem && blocks.contains(it.item.block)
 				}?.item?.block ?: return@tickingBlueprint emptyMap()
+
 				val targetPlayer = if (self) player
-				else entitySearch<OtherClientPlayerEntity>(
-					buildConfig.blockReach,
-					player.eyePos.flooredBlockPos
-				).firstOrNull { friends || !isFriend(it.gameProfile) } ?: return@tickingBlueprint emptyMap()
+				else entitySearch<OtherClientPlayerEntity>(buildConfig.blockReach, player.eyePos)
+					.firstOrNull { friends || !isFriend(it.gameProfile) }
+					?: return@tickingBlueprint emptyMap()
+
 				getTrapPositions(targetPlayer).associateWith { TargetState.Block(block) }
 			}.build(finishOnDone = false).run()
 		}

src/main/kotlin/com/lambda/module/modules/debug/RendererTestModule.kt

@@ -30,19 +30,14 @@ import com.lambda.graphics.mc.RenderBuilder.SDFStyle
 import com.lambda.graphics.mc.renderer.ChunkedRenderer.Companion.chunkedRenderer
 import com.lambda.graphics.mc.renderer.ImmediateRenderer.Companion.immediateRenderer
 import com.lambda.graphics.mc.renderer.TickedRenderer.Companion.tickedRenderer
-import com.lambda.graphics.outline.OutlineManager
 import com.lambda.graphics.outline.OutlineStyle
-import com.lambda.graphics.outline.VertexCapture
 import com.lambda.module.Module
 import com.lambda.module.tag.ModuleTag
 import com.lambda.threading.runSafe
 import com.lambda.util.extension.prevPos
 import com.lambda.util.extension.tickDelta
 import com.lambda.util.math.lerp
-import com.lambda.util.world.toBlockPos
-import net.minecraft.entity.mob.HostileEntity
-import net.minecraft.entity.passive.PassiveEntity
-import net.minecraft.entity.player.PlayerEntity
+import com.lambda.util.math.toBlockPos
 import net.minecraft.item.ItemStack
 import net.minecraft.item.Items
 import net.minecraft.util.Identifier

src/main/kotlin/com/lambda/module/modules/render/Search.kt

@@ -41,7 +41,7 @@ import com.lambda.util.extension.blockColor
 import com.lambda.util.extension.entityColor
 import com.lambda.util.extension.getBlockState
 import com.lambda.util.math.setAlpha
-import com.lambda.util.world.toBlockPos
+import com.lambda.util.math.toBlockPos
 import net.minecraft.block.BlockState
 import net.minecraft.block.Blocks
 import net.minecraft.entity.Entity

src/main/kotlin/com/lambda/util/extension/Structures.kt

@@ -20,11 +20,11 @@ package com.lambda.util.extension
 import com.lambda.Lambda.mc
 import com.lambda.util.math.MathUtils.logCap
 import com.lambda.util.varIterator
-import com.lambda.util.world.FastVector
-import com.lambda.util.world.fastVectorOf
-import com.lambda.util.world.x
-import com.lambda.util.world.y
-import com.lambda.util.world.z
+import com.lambda.util.math.FastVector
+import com.lambda.util.math.fastVectorOf
+import com.lambda.util.math.x
+import com.lambda.util.math.y
+import com.lambda.util.math.z
 import net.minecraft.block.Block
 import net.minecraft.datafixer.DataFixTypes
 import net.minecraft.nbt.NbtCompound

src/main/kotlin/com/lambda/util/extension/World.kt

@@ -19,12 +19,11 @@ package com.lambda.util.extension
 
 import com.lambda.Lambda.mc
 import com.lambda.context.SafeContext
-import com.lambda.util.extension.paintingColorCache
-import com.lambda.util.world.FastVector
-import com.lambda.util.world.toBlockPos
-import com.lambda.util.world.x
-import com.lambda.util.world.y
-import com.lambda.util.world.z
+import com.lambda.util.math.FastVector
+import com.lambda.util.math.toBlockPos
+import com.lambda.util.math.x
+import com.lambda.util.math.y
+import com.lambda.util.math.z
 import net.minecraft.block.Block
 import net.minecraft.block.BlockState
 import net.minecraft.block.Blocks

src/main/kotlin/com/lambda/util/world/Position.kt → src/main/kotlin/com/lambda/util/math/FastVector.kt

@@ -15,7 +15,7 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-package com.lambda.util.world
+package com.lambda.util.math
 
 import net.minecraft.util.math.BlockPos
 import net.minecraft.util.math.Direction
@@ -31,6 +31,8 @@ import net.minecraft.util.math.Vec3i
  * and the Y coordinate is stored in the 12 least significant bits.
  * This encoding allows for a maximum world size of ±33,554,432 blocks
  * in the X and Z directions and ±2,048 blocks in the Y direction, which is more than needed.
+ *
+ * Note for those who haven't figured it out yet: This does NOT have any floating point capability.
  */
 typealias FastVector = Long
 

src/main/kotlin/com/lambda/util/math/Vectors.kt

@@ -23,6 +23,7 @@ import com.lambda.util.math.MathUtils.floorToInt
 import com.lambda.util.math.MathUtils.sq
 import net.minecraft.entity.Entity
 import net.minecraft.util.math.BlockPos
+import net.minecraft.util.math.Box
 import net.minecraft.util.math.ChunkPos
 import net.minecraft.util.math.Direction
 import net.minecraft.util.math.EightWayDirection
@@ -111,6 +112,19 @@ val Vec3d.flooredBlockPos: BlockPos
 val Entity.netherCoord: Vec3d get() = pos.multiply(0.125, 1.0, 0.125)
 val Entity.overworldCoord: Vec3d get() = pos.multiply(8.0, 1.0, 8.0)
 
+/**
+ * Returns the distance squared to the closest side of a [Box]
+ */
+fun Vec3d.distanceToSideSq(box: Box, epsilon: Double = 1e-7): Double {
+    val closestX = x.coerceIn(box.minX - epsilon, box.maxX + epsilon)
+    val closestY = y.coerceIn(box.minY - epsilon, box.maxY + epsilon)
+    val closestZ = z.coerceIn(box.minZ - epsilon, box.maxZ + epsilon)
+    val dx = x - closestX
+    val dy = y - closestY
+    val dz = z - closestZ
+    return dx * dx + dy * dy + dz * dz
+}
+
 fun Vec3d.interpolate(value: Double, max: Vec3d) = lerp(value, this, max)
 fun Vec3d.interpolate(value: Float, max: Vec3d) = lerp(value.toDouble(), this, max)
 

src/main/kotlin/com/lambda/util/world/WorldDsl.kt

@@ -19,6 +19,8 @@ package com.lambda.util.world
 
 import com.lambda.context.SafeContext
 import com.lambda.util.math.distSq
+import com.lambda.util.math.toBlockPos
+import com.lambda.util.math.toFastVec
 import com.lambda.util.world.WorldUtils.internalGetBlockEntities
 import com.lambda.util.world.WorldUtils.internalGetEntities
 import com.lambda.util.world.WorldUtils.internalGetFastEntities
@@ -30,6 +32,7 @@ import net.minecraft.entity.Entity
 import net.minecraft.fluid.Fluid
 import net.minecraft.fluid.FluidState
 import net.minecraft.util.math.BlockPos
+import net.minecraft.util.math.Vec3d
 import net.minecraft.util.math.Vec3i
 
 @DslMarker
@@ -114,7 +117,7 @@ annotation class EntityMarker
 @EntityMarker
 inline fun <reified T : Entity> SafeContext.closestEntity(
     range: Double = 64.0,
-    pos: BlockPos = player.blockPos,
+    pos: Vec3d = player.pos,
     noinline filter: (T) -> Boolean = { true },
 ): T? =
     entitySearch<T>(range, pos, filter)
@@ -131,9 +134,9 @@ inline fun <reified T : Entity> SafeContext.closestEntity(
 @EntityMarker
 inline fun <reified T : Entity> SafeContext.entitySearch(
     range: Double,
-    pos: BlockPos = player.blockPos,
+    pos: Vec3d = player.pos,
     noinline filter: (T) -> Boolean = { true },
-) = internalGetEntities<T>(pos.toFastVec(), range, filter = filter)
+) = internalGetEntities<T>(pos, range, filter = filter)
 
 /**
  * Example:
@@ -146,10 +149,10 @@ inline fun <reified T : Entity> SafeContext.entitySearch(
  */
 @EntityMarker
 inline fun <reified T : Entity> SafeContext.fastEntitySearch(
-    range: Double,
-    pos: BlockPos = player.blockPos,
-    noinline filter: (T) -> Boolean = { true },
-) = internalGetFastEntities<T>(pos.toFastVec(), range, filter = filter)
+	range: Double,
+	pos: Vec3d = player.pos,
+	noinline filter: (T) -> Boolean = { true },
+) = internalGetFastEntities<T>(pos, range, filter = filter)
 
 @DslMarker
 annotation class FluidMarker

src/main/kotlin/com/lambda/util/world/WorldUtils.kt

@@ -20,6 +20,16 @@ package com.lambda.util.world
 import com.lambda.context.SafeContext
 import com.lambda.util.extension.getBlockState
 import com.lambda.util.extension.getFluidState
+import com.lambda.util.math.F_ONE
+import com.lambda.util.math.FastVector
+import com.lambda.util.math.distSq
+import com.lambda.util.math.distanceToSideSq
+import com.lambda.util.math.fastVectorOf
+import com.lambda.util.math.plus
+import com.lambda.util.math.times
+import com.lambda.util.math.x
+import com.lambda.util.math.y
+import com.lambda.util.math.z
 import com.lambda.util.world.WorldUtils.internalGetEntities
 import com.lambda.util.world.WorldUtils.internalGetFastEntities
 import net.minecraft.block.BlockState
@@ -29,9 +39,8 @@ import net.minecraft.fluid.Fluid
 import net.minecraft.fluid.FluidState
 import net.minecraft.util.math.BlockPos
 import net.minecraft.util.math.ChunkSectionPos
-import kotlin.collections.asSequence
+import net.minecraft.util.math.Vec3d
 import kotlin.math.ceil
-import kotlin.sequences.filter
 
 object WorldUtils {
     fun SafeContext.isLoaded(pos: BlockPos) =
@@ -48,14 +57,14 @@ object WorldUtils {
      * @see [fastEntitySearch]
      */
     inline fun <reified T : Entity> SafeContext.internalGetFastEntities(
-        pos: FastVector,
-        distance: Double,
-        crossinline filter: (T) -> Boolean = { true },
+	    pos: Vec3d,
+	    distance: Double,
+	    crossinline filter: (T) -> Boolean = { true },
     ): Sequence<T> {
         val chunks = ceil(distance / 16).toInt()
-        val sectionX = pos.x shr 4
-        val sectionY = pos.y shr 4
-        val sectionZ = pos.z shr 4
+        val sectionX = (pos.x / 4).toInt()
+        val sectionY = (pos.y / 4).toInt()
+        val sectionZ = (pos.z / 4).toInt()
 
         return sequence {
             for (x in sectionX - chunks..sectionX + chunks) {
@@ -68,9 +77,9 @@ object WorldUtils {
                                 ?.asSequence()
                                 ?.filterIsInstance<T>()
                                 ?.filter {
-                                    it != player &&
-                                            pos distSq it.pos <= distance * distance &&
-                                            filter(it)
+                                    it != player
+                                            && pos.distanceToSideSq(it.boundingBox) <= distance * distance
+                                            && filter(it)
                                 } ?: emptySequence()
                         )
                     }
@@ -86,15 +95,15 @@ object WorldUtils {
      * @see [entitySearch]
      */
     inline fun <reified T : Entity> SafeContext.internalGetEntities(
-        pos: FastVector,
-        distance: Double,
-        crossinline filter: (T) -> Boolean = { true },
+	    pos: Vec3d,
+	    distance: Double,
+	    crossinline filter: (T) -> Boolean = { true },
     ) = world.entities
         .asSequence()
         .filterIsInstance<T>()
         .filter {
             it != player &&
-                    pos distSq it.pos <= distance * distance &&
+                    pos.distanceToSideSq(it.boundingBox) <= distance * distance &&
                     filter(it)
         }
 
@@ -103,9 +112,9 @@ object WorldUtils {
      * @see [blockEntitySearch]
      */
     inline fun <reified T : BlockEntity> SafeContext.internalGetBlockEntities(
-        pos: FastVector,
-        distance: Double,
-        crossinline predicate: (T) -> Boolean = { true },
+	    pos: FastVector,
+	    distance: Double,
+	    crossinline predicate: (T) -> Boolean = { true },
     ): Sequence<T> {
         val chunks = ceil(distance / 16).toInt()
         val chunkX = pos.x shr 4
@@ -136,14 +145,14 @@ object WorldUtils {
      * @see [blockSearch]
      */
     inline fun SafeContext.internalSearchBlocks(
-        pos: FastVector,
-        range: FastVector = F_ONE times 7,
-        step: FastVector = F_ONE,
-        crossinline filter: (FastVector, BlockState) -> Boolean = { _, _ -> true },
+	    pos: FastVector,
+	    range: FastVector = F_ONE times 7,
+	    step: FastVector = F_ONE,
+	    crossinline filter: (FastVector, BlockState) -> Boolean = { _, _ -> true },
     ) = fastSequence(pos, range, step)
         .filter {
-            val state = world.getBlockState(it)
-            filter(it, state)
+            filter(it,
+                world.getBlockState(it))
         }
         .associateWith { world.getBlockState(it) }
 
@@ -153,10 +162,10 @@ object WorldUtils {
      * @see [fluidSearch]
      */
     inline fun <reified T : Fluid> SafeContext.internalSearchFluids(
-        pos: FastVector,
-        range: FastVector = F_ONE times 7,
-        step: FastVector = F_ONE,
-        crossinline filter: (FastVector, FluidState) -> Boolean = { _, _ -> true },
+	    pos: FastVector,
+	    range: FastVector = F_ONE times 7,
+	    step: FastVector = F_ONE,
+	    crossinline filter: (FastVector, FluidState) -> Boolean = { _, _ -> true },
     ) = fastSequence(pos, range, step)
         .filter {
             val state = world.getFluidState(it.x, it.y, it.z)
@@ -169,9 +178,9 @@ object WorldUtils {
      * Returns a sequence of [FastVector]s
      */
     fun fastSequence(
-        pos: FastVector,
-        range: FastVector,
-        step: FastVector,
+	    pos: FastVector,
+	    range: FastVector,
+	    step: FastVector,
     ) = sequence {
         for (x in -range.x..range.x step step.x) {
             for (y in -range.y..range.y step step.y) {