Merge pull request #47 from awrped/master

cleanup pf code

Author: quiteboring

src/main/kotlin/org/cobalt/api/pathfinder/Node.kt

@@ -1,50 +1,29 @@
 package org.cobalt.api.pathfinder
 
-
 import org.cobalt.api.pathfinder.pathing.heuristic.HeuristicContext
 import org.cobalt.api.pathfinder.pathing.heuristic.HeuristicWeights
 import org.cobalt.api.pathfinder.pathing.heuristic.IHeuristicStrategy
 import org.cobalt.api.pathfinder.wrapper.PathPosition
 
 class Node(
-  private val position: PathPosition,
+  val position: PathPosition,
   start: PathPosition,
   target: PathPosition,
   heuristicWeights: HeuristicWeights,
   heuristicStrategy: IHeuristicStrategy,
-  private val depth: Int,
+  val depth: Int,
 ) : Comparable<Node> {
 
-  private val hCost: Double = heuristicStrategy.calculate(
-    HeuristicContext(position, start, target, heuristicWeights)
-  )
-
-  private var gCost: Double = 0.0
-  private var parent: Node? = null
-
-  fun getPosition(): PathPosition = position
+  val heuristic: Double =
+    heuristicStrategy.calculate(HeuristicContext(position, start, target, heuristicWeights))
 
-  fun getHeuristic(): Double = hCost
+  var gCost: Double = 0.0
+  var parent: Node? = null
 
-  fun getParent(): Node? = parent
-
-  fun getDepth(): Int = depth
-
-  fun setGCost(gCost: Double) {
-    this.gCost = gCost
-  }
+  val fCost: Double
+    get() = gCost + heuristic
 
-  fun setParent(parent: Node?) {
-    this.parent = parent
-  }
-
-  fun isTarget(target: PathPosition): Boolean = this.position == target
-
-  fun getFCost(): Double = getGCost() + getHeuristic()
-
-  fun getGCost(): Double {
-    return if (this.parent == null) 0.0 else this.gCost
-  }
+  fun isTarget(target: PathPosition): Boolean = position == target
 
   override fun equals(other: Any?): Boolean {
     if (other == null || this::class != other::class) return false
@@ -55,12 +34,12 @@ class Node(
   override fun hashCode(): Int = position.hashCode()
 
   override fun compareTo(other: Node): Int {
-    val fCostComparison = this.getFCost().compareTo(other.getFCost())
+    val fCostComparison = fCost.compareTo(other.fCost)
     if (fCostComparison != 0) {
       return fCostComparison
     }
 
-    val heuristicComparison = this.getHeuristic().compareTo(other.getHeuristic())
+    val heuristicComparison = heuristic.compareTo(other.heuristic)
     if (heuristicComparison != 0) {
       return heuristicComparison
     }

src/main/kotlin/org/cobalt/api/pathfinder/PathExecutor.kt

@@ -8,13 +8,14 @@ import org.cobalt.api.event.EventBus
 import org.cobalt.api.event.annotation.SubscribeEvent
 import org.cobalt.api.event.impl.client.TickEvent
 import org.cobalt.api.event.impl.render.WorldRenderEvent
-import org.cobalt.api.pathfinder.factory.impl.AStarPathfinderFactory
+import org.cobalt.api.pathfinder.pathfinder.AStarPathfinder
 import org.cobalt.api.pathfinder.pathing.NeighborStrategies
 import org.cobalt.api.pathfinder.pathing.configuration.PathfinderConfiguration
 import org.cobalt.api.pathfinder.pathing.processing.impl.MinecraftPathProcessor
 import org.cobalt.api.pathfinder.pathing.result.Path
 import org.cobalt.api.pathfinder.pathing.result.PathState
 import org.cobalt.api.pathfinder.provider.impl.MinecraftNavigationProvider
+import org.cobalt.api.pathfinder.result.PathImpl
 import org.cobalt.api.pathfinder.wrapper.PathPosition
 import org.cobalt.api.util.ChatUtils
 import org.cobalt.api.util.render.Render3D
@@ -38,53 +39,66 @@ object PathExecutor {
     val start = PathPosition(player.x, player.y, player.z)
     val target = PathPosition(x, y, z)
 
-    val factory = AStarPathfinderFactory()
-
     val processor = MinecraftPathProcessor()
     val config =
-      PathfinderConfiguration.builder()
-        .provider(MinecraftNavigationProvider())
-        .maxIterations(20000)
-        .async(true)
-        .neighborStrategy(NeighborStrategies.HORIZONTAL_DIAGONAL_AND_VERTICAL)
-        .nodeValidationProcessors(listOf(processor))
-        .nodeCostProcessors(listOf(processor))
-        .build()
+      PathfinderConfiguration(
+        provider = MinecraftNavigationProvider(),
+        // as of now max iterations is 20,000 but maybe wanna higher
+        maxIterations = 20000,
+        async = true,
+        neighborStrategy = NeighborStrategies.HORIZONTAL_DIAGONAL_AND_VERTICAL,
+        processors = listOf(processor)
+      )
 
-    val pathfinder = factory.createPathfinder(config)
+    val pathfinder = AStarPathfinder(config)
 
     ChatUtils.sendDebug("Calculating path to $x, $y, $z...")
     val startTime = System.currentTimeMillis()
     pathfinder.findPath(start, target).thenAccept { result ->
-      val duration = System.currentTimeMillis() - startTime
-      if (result.successful()) {
-        currentPath = result.getPath()
-        currentWaypointIndex = 0
-
+      mc.execute {
+        val duration = System.currentTimeMillis() - startTime
         val state = result.getPathState()
-        val path = result.getPath()
-
-        if (state == PathState.FOUND) {
-          ChatUtils.sendMessage(
-            "§aPath found! §7Calculated in §f${duration}ms §8(${path.length()} nodes)"
-          )
-        } else {
-          /*
-           * partial paths can happen, i would recommend improving this functionality
-           * to whoever maintainer wants to maintain my horrible shitcode of a pathfinder.
-           * i think partial paths should be refactored, i will write all the cases now
-           * iteration limit -> self explanatory xd (or if u cant use ur brain
-           * then its just if the algorithm takes too many iterations to find a goal.
-           * this is set literaaally like 20 lines above you...)
-           * fallback -> pf searches everywhere and couldnt find a possible way to get there.
-           * this can happen in the case of unloaded chunks, or an obstruction
-           */
-          ChatUtils.sendMessage(
-            "§ePartial path found! §7Calculated in §f${duration}ms §8(${path.length()} nodes)"
-          )
+        if (state != PathState.FOUND) {
+          ChatUtils.sendMessage("§cFailed to find path: $state")
+          return@execute
         }
-      } else {
-        ChatUtils.sendMessage("§cFailed to find path: ${result.getPathState()}")
+
+        val rawPath = result.getPath()
+        val positions = rawPath.collect().toList()
+        val path =
+          if (positions.size <= 2) {
+            rawPath
+          } else {
+            val simplified = ArrayList<PathPosition>(positions.size)
+            simplified.add(positions.first())
+
+            for (i in 1 until positions.size - 1) {
+              val prev = simplified.last()
+              val curr = positions[i]
+              val next = positions[i + 1]
+
+              val prevDx = (curr.flooredX - prev.flooredX).coerceIn(-1, 1)
+              val prevDy = (curr.flooredY - prev.flooredY).coerceIn(-1, 1)
+              val prevDz = (curr.flooredZ - prev.flooredZ).coerceIn(-1, 1)
+              val nextDx = (next.flooredX - curr.flooredX).coerceIn(-1, 1)
+              val nextDy = (next.flooredY - curr.flooredY).coerceIn(-1, 1)
+              val nextDz = (next.flooredZ - curr.flooredZ).coerceIn(-1, 1)
+
+              if (prevDx == nextDx && prevDy == nextDy && prevDz == nextDz) {
+                continue
+              }
+              simplified.add(curr)
+            }
+
+            simplified.add(positions.last())
+            PathImpl(rawPath.getStart(), rawPath.getEnd(), simplified)
+          }
+        currentPath = path
+        currentWaypointIndex = 0
+
+        ChatUtils.sendMessage(
+          "§aPath found! §7Calculated in §f${duration}ms §8(${path.length()} nodes)"
+        )
       }
     }
   }