added options

README.md

@@ -15,7 +15,7 @@ weights := []int{
 grid := astar.NewGridFromSlice(8, 4, weights)
 
 pathfinder := astar.NewPathfinder(grid)
-got := pathfinder.Find(Vec2{1, 1}, Vec2{6, 2})
+got := pathfinder.Find(astar.Vec2{1, 1}, astar.Vec2{6, 2})
 
 want := []Vec2{
     {1, 1},

astar.go

@@ -48,35 +48,50 @@ type node struct {
 // Pathfinder is a simple A* pathfinding algorithm implementation.
 type Pathfinder struct {
 	weights       Grid[int]
+	options       Options
 	heuristic     heuristicFunc
 	getSuccessors getSuccessorsFunc
 }
 
-// NewPathfinder creates a new Pathfinder with the given weights. The weights
-// are used to determine the cost of traversing a cell. A weight of 0 means the
-// cell is not traversable. A weight of 1 or higher means the cell is
-// traversable.
-func NewPathfinder(weights Grid[int]) Pathfinder {
-	return Pathfinder{
+// NewPathfinder creates a new Pathfinder with the given weights and options.
+// The weights are used to determine the cost of traversing a cell. A weight of
+// 0 means the cell is not traversable. A weight of 1 or higher means the cell
+// is traversable.
+func NewPathfinder(weights Grid[int], opts ...Option) Pathfinder {
+	opt := Options{
+		heuristic: man,
+	}
+
+	for _, optFunc := range opts {
+		optFunc(&opt)
+	}
+
+	pf := Pathfinder{
 		weights:   weights,
+		options:   opt,
 		heuristic: manhattan,
 		getSuccessors: func(v Vec2) []Vec2 {
 			return getSuccessors(v, weights.Width, weights.Height, cardinalSuccessors)
 		},
 	}
-}
 
-// NewDiagonalPathfinder creates a new Pathfinder with the given weights that
-// supports diagonal movement. A weight of 0 means the cell is not traversable.
-// A weight of 1 or higher means the cell is traversable.
-func NewDiagonalPathfinder(weights Grid[int]) Pathfinder {
-	return Pathfinder{
-		weights:   weights,
-		heuristic: diagonalDistance,
-		getSuccessors: func(v Vec2) []Vec2 {
+	switch opt.heuristic {
+	case man:
+		pf.heuristic = manhattan
+	case dd:
+		pf.heuristic = diagonalDistance
+	}
+
+	if opt.diagonals {
+		if opt.heuristic == man {
+			pf.heuristic = diagonalDistance
+		}
+		pf.getSuccessors = func(v Vec2) []Vec2 {
 			return getSuccessors(v, weights.Width, weights.Height, diagonalSuccessors)
-		},
+		}
 	}
+
+	return pf
 }
 
 // Find returns a path from start to end. If no path is found, an empty slice

astar_test.go

@@ -187,7 +187,7 @@ func TestPath_Diagonal1(t *testing.T) {
 	}
 	grid := NewGridFromSlice(5, 5, weights)
 
-	pathfinder := NewDiagonalPathfinder(grid)
+	pathfinder := NewPathfinder(grid, WithDiagonals())
 	got := pathfinder.Find(Vec2{1, 1}, Vec2{3, 1})
 
 	want := []Vec2{
@@ -209,7 +209,7 @@ func TestPath_Diagonal2(t *testing.T) {
 	}
 	grid := NewGridFromSlice(8, 4, weights)
 
-	pathfinder := NewDiagonalPathfinder(grid)
+	pathfinder := NewPathfinder(grid, WithDiagonals())
 	got := pathfinder.Find(Vec2{1, 1}, Vec2{6, 2})
 
 	want := []Vec2{

options.go

@@ -0,0 +1,26 @@
+package astar
+
+type heuristic int
+
+const (
+	// Manhattan heuristic.
+	man heuristic = iota
+	// Euclidean heuristic.
+	dd
+)
+
+// Option is a functional option for the pathfinder.
+type Option func(o *Options)
+
+// Options contains the options for the pathfinder.
+type Options struct {
+	diagonals bool
+	heuristic heuristic
+}
+
+// WithDiagonals enables diagonal movement in the search space.
+func WithDiagonals() Option {
+	return Option(func(o *Options) {
+		o.diagonals = true
+	})
+}