implemented support for weighted paths

AStar.Tests/LongerPathingTests.cs

@@ -55,7 +55,7 @@ public void TestPathingOptions()
 
             var pathfinder = new PathFinder(_world, pathfinderOptions);
             var path = pathfinder.FindPath(new Position(1, 1), new Position(30, 30));
-            Helper.Print(_world, path);
+
         }
 
         [Test]
@@ -65,7 +65,7 @@ public void ShouldPathEnvironment()
 
             var path = pathfinder.FindPath(new Position(1, 1), new Position(30, 30));
 
-            Helper.Print(_world, path);
+
 
             path.ShouldBe(new[] {
                 new Position(1, 1),

AStar.Tests/OptionsTest.cs

@@ -27,8 +27,6 @@ public void ShouldEnforceSearchLimit()
 
             var path = pathfinder.FindPath(new Position(1, 1), new Position(1, 5));
 
-            Helper.Print(_world, path);
-
             path.ShouldBeEmpty();
         }
     }

AStar.Tests/PathfinderTests.cs

@@ -26,8 +26,6 @@ public void ShouldPathRectangleGrid()
 
             var path = pathfinder.FindPath(new Position(0, 0), new Position(2, 4));
 
-            Helper.Print(_world, path);
-
             path.ShouldBe(new[] {
                 new Position(0, 0),
                 new Position(1, 1),
@@ -52,8 +50,6 @@ public void ShouldPathToAdjacent()
         {
             var path = _pathFinder.FindPath(new Position(1, 1), new Position(2, 1));
 
-            Helper.Print(_world, path);
-
             path.ShouldBe(new[] {
                 new Position(1, 1),
                 new Position(2, 1),
@@ -65,8 +61,6 @@ public void ShouldDoSimplePath()
         {
             var path = _pathFinder.FindPath(new Position(1, 1), new Position(4, 2));
 
-            Helper.Print(_world, path);
-
             path.ShouldBe(new[] {
                 new Position(1, 1),
                 new Position(2, 2),
@@ -83,8 +77,6 @@ public void ShouldDoSimplePathWithNoDiagonal()
 
             var path = _pathFinder.FindPath(new Position(1, 1), new Position(4, 2));
 
-            Helper.Print(_world, path);
-
             path.ShouldBe(new[] {
                 new Position(1, 1),
                 new Position(2, 1),
@@ -105,7 +97,6 @@ public void ShouldDoSimplePathWithNoDiagonalAroundObstacle()
             _world[2, 2] = 0;
 
             var path = _pathFinder.FindPath(new Position(1, 1), new Position(4, 2));
-            Helper.Print(_world, path);
 
             path.ShouldBe(new[] {
                 new Position(1, 1),
@@ -127,8 +118,6 @@ public void ShouldPathAroundObstacle()
 
             var path = _pathFinder.FindPath(new Position(1, 1), new Position(4, 2));
 
-            Helper.Print(_world, path);
-
             path.ShouldBe(new[] {
                 new Position(1, 1),
                 new Position(1, 2),

AStar.Tests/PathingTests.cs

@@ -27,8 +27,6 @@ public void ShouldPathPredictably()
 
             var path = pathfinder.FindPath(new Position(1, 1), new Position(2, 3));
 
-            Helper.Print(_world, path);
-
             path.ShouldBe(new[] {
                 new Position(1, 1),
                 new Position(2, 2),
@@ -43,8 +41,6 @@ public void ShouldPathPredictably2()
 
             var path = pathfinder.FindPath(new Position(1, 1), new Position(1, 5));
 
-            Helper.Print(_world, path);
-
             path.ShouldBe(new[] {
                 new Position(1, 1),
                 new Position(1, 2),
@@ -62,8 +58,6 @@ public void ShouldPathPredictably3()
 
             var path = pathfinder.FindPath(new Position(1, 1), new Position(1, 5));
 
-            Helper.Print(_world, path);
-
             path.ShouldBe(new[] {
                 new Position(1, 1),
                 new Position(1, 2),

AStar.Tests/PunishChangeDirectionIssueTest.cs

@@ -34,8 +34,6 @@ public void ShouldPunishChangingDirectionsIssue()
 
             var path = pathfinder.FindPath(new Position(7, 2), new Position(1, 17));
 
-            Helper.Print(_world, path);
-
             path.ShouldBe(new[] {
                 new Position(7, 2),
                 new Position(7, 3),
@@ -70,8 +68,6 @@ public void ShouldCorrectIssue()
 
             var path = pathfinder.FindPath(new Position(1, 2), new Position(8, 14));
 
-            Helper.Print(_world, path);
-
             path.ShouldBe(new[] {
                 new Position(1, 2),
                 new Position(2, 3),

AStar.Tests/PunishChangeDirectionTests.cs

@@ -40,9 +40,6 @@ public void ShouldPunishChangingDirections()
 
             var path = pathfinder.FindPath(new Position(2, 9), new Position(15, 3));
 
-
-            Helper.Print(world, path);
-
             path.ShouldBe(new[]
             {
                 new Position(2, 9),
@@ -92,9 +89,7 @@ public void ShouldCalculateAdjacentCorrectly()
             };
 
             Console.WriteLine("actual");
-            Helper.Print(world, path);
             Console.WriteLine("expected");
-            Helper.Print(world, expected);
 
             path.ShouldBe(expected);
         }

AStar.Tests/WeightedPathingTests.cs

@@ -0,0 +1,55 @@
+using AStar.Options;
+using NUnit.Framework;
+using Shouldly;
+
+namespace AStar.Tests
+{
+  [TestFixture]
+  public class WeightedPathingTests
+  {
+    [Test]
+    public void ShouldPathWithWeight()
+    {
+        var level = @"1111115
+                      1511151
+                      1155511
+                      1111111";
+        var world = Helper.ConvertStringToPathfinderGrid(level);
+        var opts = new PathFinderOptions { Weighting = Weighting.Positive };
+        var pathfinder = new PathFinder(world, opts);
+
+        var path = pathfinder.FindPath(new Position(1, 1), new Position(1, 5));
+
+        path.ShouldBe(new[] {
+              new Position(1, 1),
+              new Position(2, 2),
+              new Position(2, 3),
+              new Position(2, 4),
+              new Position(1, 5),
+            });
+    }
+
+    [Test]
+    public void ShouldPathWithInvertedWeight()
+    {
+      var level = @"9999995
+                    9599959
+                    9955599
+                    9999999";
+
+        var world = Helper.ConvertStringToPathfinderGrid(level);
+        var opts = new PathFinderOptions { Weighting = Weighting.Negative };
+        var pathfinder = new PathFinder(world, opts);
+
+        var path = pathfinder.FindPath(new Position(1, 1), new Position(1, 5));
+
+        path.ShouldBe(new[] {
+              new Position(1, 1),
+              new Position(2, 2),
+              new Position(2, 3),
+              new Position(2, 4),
+              new Position(1, 5),
+            });
+    }
+  }
+}

AStar/Options/PathFinderOptions.cs

@@ -12,11 +12,22 @@ public class PathFinderOptions
 
         public int SearchLimit { get; set; }
 
+        public Weighting Weighting {get;set;}
+
         public PathFinderOptions()
         {
             HeuristicFormula = HeuristicFormula.Manhattan;
             UseDiagonals = true;
             SearchLimit = 2000;
         }
     }
+
+    public enum Weighting {
+        // The number in the grid will not influence the path.
+        None,
+        // Higher open values will be favoured and applied to the new h value.
+        Positive,
+        // Lower open values will be favoured and applied to the new h value.
+        Negative
+    }
 }

AStar/PathFinder.cs

@@ -68,10 +68,24 @@ public Position[] FindPath(Position start, Position end)
                         newG += CalculateModifierToG(q, successor, end);
                     }
 
+                    var newH = _heuristic.Calculate(successor.Position, end);
+                    switch (_options.Weighting)
+                    {
+                        case Weighting.Positive:
+                            newH -= _world[successor.Position];
+                            break;
+                        case Weighting.Negative:
+                            newH += _world[successor.Position];
+                            break;
+                        case Weighting.None:
+                        default:
+                            break;
+                    }
+
                     var updatedSuccessor = new PathFinderNode(
                         position: successor.Position,
                         g: newG,
-                        h:_heuristic.Calculate(successor.Position, end),
+                        h: newH,
                         parentNodePosition: q.Position);
 
                     if (BetterPathToSuccessorFound(updatedSuccessor, successor))
@@ -163,4 +177,4 @@ private static Position[] OrderClosedNodesAsArray(IModelAGraph<PathFinderNode> g
             return path.ToArray();
         }
     }
-}
+}

README.md

@@ -59,7 +59,18 @@ q. why doesn't this algorithm always find the shortest path?
 a. A* optimises speed over accuracy. Because the algorithm relies on a 
 heuristic to determine the distances from start and finish, it won't necessarily
 produce the shortest path to the target.
-
+## Changes from 1.1.0 to 1.3.0
+- Introduced path weighting to favour or penalize cells. This is off by default and
+can be opted into using the new options. See [this blog post for more info](https://valantonini.com/posts/20210401/)
+```csharp
+var level = @"1111115
+              1511151
+              1155511
+              1111111";
+var world = Helper.ConvertStringToPathfinderGrid(level);
+var opts = new PathFinderOptions { Weighting = Weighting.Positive };
+var pathfinder = new PathFinder(world, opts);
+```
 ## Changes from 1.0.0 to 1.1.0
 - Reimplemented the punish change direction to perform more consistently