Cleaner start padding

Author: Avanatiker

src/main/kotlin/trombone/Pathfinder.kt

@@ -22,6 +22,7 @@ import trombone.Trombone.active
 import trombone.handler.Container.containerTask
 import trombone.handler.Container.getCollectingPosition
 import trombone.handler.Inventory.lastHitVec
+import trombone.task.TaskManager.isBehindPos
 import trombone.task.TaskManager.populateTasks
 import trombone.task.TaskManager.tasks
 import trombone.task.TaskState
@@ -115,8 +116,7 @@ object Pathfinder {
     private fun checkForResidue(pos: BlockPos) =
         containerTask.taskState == TaskState.DONE
             && tasks.values.all {
-                it.taskState == TaskState.DONE
-                    || startingBlockPos.toVec3dCenter().distanceTo(pos.toVec3dCenter()) < startingBlockPos.toVec3dCenter().distanceTo(it.blockPos)
+                it.taskState == TaskState.DONE || !isBehindPos(pos, it.blockPos)
             }
 
     private fun SafeClientEvent.isTaskDone(pos: BlockPos): Boolean {
@@ -131,15 +131,15 @@ object Pathfinder {
 
     fun SafeClientEvent.shouldBridge(): Boolean {
         return scaffold
+            && containerTask.taskState == TaskState.DONE
             && world.isAirBlock(currentBlockPos.add(startingDirection.directionVec))
             && world.isAirBlock(currentBlockPos.add(startingDirection.directionVec).up())
             && world.getBlockState(currentBlockPos.add(startingDirection.directionVec).down()).isReplaceable
+            && tasks.values.none { it.taskState == TaskState.PENDING_PLACE }
             && tasks.values.filter {
                 it.taskState == TaskState.PLACE
                     || it.taskState == TaskState.LIQUID
             }.none { it.sequence.isNotEmpty() }
-            && tasks.values.none { it.taskState == TaskState.PENDING_PLACE }
-            && containerTask.taskState == TaskState.DONE
     }
 
     private fun SafeClientEvent.moveTo(target: Vec3d) {

src/main/kotlin/trombone/task/TaskManager.kt

@@ -12,7 +12,7 @@ import HighwayTools.multiBuilding
 import HighwayTools.saveFood
 import HighwayTools.saveTools
 import HighwayTools.storageManagement
-import com.lambda.client.commons.extension.ceilToInt
+import HighwayTools.width
 import com.lambda.client.event.SafeClientEvent
 import com.lambda.client.manager.managers.PlayerInventoryManager
 import com.lambda.client.util.items.countItem
@@ -33,6 +33,7 @@ import net.minecraft.item.ItemFood
 import net.minecraft.item.ItemPickaxe
 import net.minecraft.util.math.AxisAlignedBB
 import net.minecraft.util.math.BlockPos
+import net.minecraft.util.math.Vec3d
 import trombone.blueprint.BlueprintGenerator.blueprint
 import trombone.blueprint.BlueprintGenerator.generateBluePrint
 import trombone.blueprint.BlueprintGenerator.isInsideBlueprintBuild
@@ -86,7 +87,7 @@ object TaskManager {
 
         when {
             /* start padding */
-            shouldBeSpared(blockPos) -> { /* Ignore task */ }
+            startPadding(blockPos) -> { /* Ignore task */ }
 
             /* out of reach */
             eyePos.distanceTo(blockPos.toVec3dCenter()) >= maxReach + 1 -> { /* Ignore task */ }
@@ -164,9 +165,6 @@ object TaskManager {
 
     fun SafeClientEvent.runTasks() {
         when {
-            /* Wait for PIM to finish all inventory transactions */
-            !PlayerInventoryManager.isDone() -> {}
-
             /* Finish the container task first */
             containerTask.taskState != TaskState.DONE -> {
                 containerTask.updateTask(this)
@@ -293,14 +291,14 @@ object TaskManager {
         return false
     }
 
-    // ToDo: Fix padding for diagonal
-    private fun shouldBeSpared(blockPos: BlockPos) =
-        startingBlockPos.add(
-            startingDirection
-                .clockwise(4)
-                .directionVec
-                .multiply((maxReach * 2).ceilToInt() - 1)
-        ).distanceTo(blockPos) < maxReach * 2
+    private fun startPadding(c: BlockPos) = isBehindPos(startingBlockPos.add(startingDirection.directionVec), c)
+
+    fun isBehindPos(origin: BlockPos, check: BlockPos): Boolean {
+        val a = origin.add(startingDirection.counterClockwise(2).directionVec.multiply(width))
+        val b = origin.add(startingDirection.clockwise(2).directionVec.multiply(width))
+
+        return ((b.x - a.x) * (check.z - a.z) - (b.z - a.z) * (check.x - a.x)) > 0
+    }
 
     private fun shouldBeIgnored(blockPos: BlockPos, currentState: IBlockState) =
         ignoreBlocks.contains(currentState.block.registryName.toString())