aggressive speedup for capacity pathing solver using greedy multiplier

Author: seveibar

lib/solvers/CapacityMeshSolver/CapacityMeshNodeSolver2_NodesUnderObstacles.ts

@@ -181,7 +181,6 @@ export class CapacityMeshNodeSolver2_NodeUnderObstacle extends CapacityMeshNodeS
     }
 
     const childNodes = this.getChildNodes(nextNode)
-    console.log("childNodes", childNodes)
 
     const finishedNewNodes: CapacityMeshNode[] = []
     const unfinishedNewNodes: CapacityMeshNode[] = []
@@ -192,11 +191,6 @@ export class CapacityMeshNodeSolver2_NodeUnderObstacle extends CapacityMeshNodeS
         childNode.availableZ.length > 1 &&
         !shouldBeXYSubdivided &&
         childNode._containsObstacle
-      console.log(
-        childNode.capacityMeshNodeId,
-        shouldBeXYSubdivided,
-        shouldBeZSubdivided,
-      )
       if (shouldBeXYSubdivided) {
         unfinishedNewNodes.push(childNode)
       } else if (!shouldBeXYSubdivided && !childNode._containsObstacle) {

lib/solvers/CapacityPathingSolver/CapacityPathingSolver.ts

@@ -44,6 +44,15 @@ export class CapacityPathingSolver extends BaseSolver {
 
   activeCandidateStraightLineDistance?: number
 
+  debug_lastNodeCostMap: Map<
+    CapacityMeshNodeId,
+    {
+      g: number
+      h: number
+      f: number
+    }
+  >
+
   hyperParameters: Partial<CapacityHyperParameters>
 
   constructor({
@@ -82,6 +91,7 @@ export class CapacityPathingSolver extends BaseSolver {
     this.maxDepthOfNodes = Math.max(
       ...this.nodes.map((node) => node._depth ?? 0),
     )
+    this.debug_lastNodeCostMap = new Map()
   }
 
   getTotalCapacity(node: CapacityMeshNode): number {
@@ -245,6 +255,7 @@ export class CapacityPathingSolver extends BaseSolver {
     const [start, end] = nextConnection.nodes
     if (!this.candidates) {
       this.candidates = [{ prevCandidate: null, node: start, f: 0, g: 0, h: 0 }]
+      this.debug_lastNodeCostMap = new Map()
       this.visitedNodes = new Set([start.capacityMeshNodeId])
       this.activeCandidateStraightLineDistance = distance(
         start.center,
@@ -300,6 +311,13 @@ export class CapacityPathingSolver extends BaseSolver {
       const g = this.computeG(currentCandidate, neighborNode, end)
       const h = this.computeH(currentCandidate, neighborNode, end)
       const f = g + h * this.GREEDY_MULTIPLIER
+
+      this.debug_lastNodeCostMap.set(neighborNode.capacityMeshNodeId, {
+        f,
+        g,
+        h,
+      })
+
       const newCandidate = {
         prevCandidate: currentCandidate,
         node: neighborNode,
@@ -339,9 +357,17 @@ export class CapacityPathingSolver extends BaseSolver {
     }
 
     for (const node of this.nodes) {
+      const nodeCosts = this.debug_lastNodeCostMap.get(node.capacityMeshNodeId)
       graphics.rects!.push({
         ...createRectFromCapacityNode(node),
-        label: `${node.capacityMeshNodeId}\n${this.usedNodeCapacityMap.get(node.capacityMeshNodeId)}/${this.getTotalCapacity(node).toFixed(2)}\n${node.width.toFixed(2)}x${node.height.toFixed(2)}`,
+        label: [
+          `${node.capacityMeshNodeId}`,
+          `${this.usedNodeCapacityMap.get(node.capacityMeshNodeId)}/${this.getTotalCapacity(node).toFixed(2)}`,
+          `${node.width.toFixed(2)}x${node.height.toFixed(2)}`,
+          `g: ${nodeCosts?.g !== undefined ? nodeCosts.g.toFixed(2) : "?"}`,
+          `h: ${nodeCosts?.h !== undefined ? nodeCosts.h.toFixed(2) : "?"}`,
+          `f: ${nodeCosts?.f !== undefined ? nodeCosts.f.toFixed(2) : "?"}`,
+        ].join("\n"),
       })
     }
 

lib/solvers/CapacityPathingSolver/CapacityPathingSolver5.ts

@@ -6,6 +6,11 @@ export class CapacityPathingSolver5 extends CapacityPathingSolver {
   NEGATIVE_CAPACITY_PENALTY_FACTOR = 1
   REDUCED_CAPACITY_PENALTY_FACTOR = 1
 
+  constructor(...args: ConstructorParameters<typeof CapacityPathingSolver>) {
+    super(...args)
+    this.GREEDY_MULTIPLIER = 2.5
+  }
+
   get maxCapacityFactor() {
     return this.hyperParameters.MAX_CAPACITY_FACTOR ?? 1
   }
@@ -18,6 +23,7 @@ export class CapacityPathingSolver5 extends CapacityPathingSolver {
    * Penalty you pay for using this node
    */
   getNodeCapacityPenalty(node: CapacityMeshNode): number {
+    return 0.05
     if (node.availableZ.length === 1) {
       return 0
     }
@@ -66,12 +72,15 @@ export class CapacityPathingSolver5 extends CapacityPathingSolver {
     const dx = A.center.x - B.center.x
     const dy = A.center.y - B.center.y
 
-    const szx = Math.max(A.width, B.width)
-    const szy = Math.max(A.height, B.height)
+    return Math.sqrt(dx ** 2 + dy ** 2)
+
+    // REWARD BIG NODE TRAVEL
+    // const szx = Math.max(A.width, B.width)
+    // const szy = Math.max(A.height, B.height)
 
-    const dist = Math.sqrt(dx ** 2 + dy ** 2) / (szx * szy)
+    // const dist = Math.sqrt(dx ** 2 + dy ** 2) / (szx * szy)
 
-    return dist
+    // return dist
   }
 
   computeG(
@@ -91,9 +100,6 @@ export class CapacityPathingSolver5 extends CapacityPathingSolver {
     node: CapacityMeshNode,
     endGoal: CapacityMeshNode,
   ) {
-    return (
-      this.getDistanceBetweenNodes(node, endGoal) +
-      this.getNodeCapacityPenalty(node)
-    )
+    return this.getDistanceBetweenNodes(node, endGoal)
   }
 }

lib/solvers/SingleLayerNodeMerger/SingleLayerNodeMergerSolver.ts

@@ -39,7 +39,6 @@ export class SingleLayerNodeMergerSolver extends BaseSolver {
       }
     }
     nodeWithArea.sort((a, b) => a[1] - b[1])
-    console.log(nodeWithArea)
     this.currentBatchNodeIds = nodeWithArea.map((n) => n[0])
     this.nextBatchNodeIds = []
     this.batchHadModifications = false