Added argument parsing to run the solver correctly

took to do a certain part of the program

assets/normal2.txt

@@ -0,0 +1,15 @@
+####### #######
+#   #       # #
+### # ##### # #
+#   #     #   #
+# ########### #
+#     #     # #
+### # # ##### #
+#   #   #   # #
+# ### ### # # #
+# #   #   #   #
+# ### # #######
+#   # # #     #
+# # ### ### # #
+# #         # #
+####### #######

go.mod

@@ -3,6 +3,7 @@ module maze-solver
 go 1.21
 
 require (
+	github.com/akamensky/argparse v1.4.0
 	github.com/mazznoer/colorgrad v0.9.1
 	golang.org/x/exp v0.0.0-20230801115018-d63ba01acd4b
 )

go.sum

@@ -1,3 +1,5 @@
+github.com/akamensky/argparse v1.4.0 h1:YGzvsTqCvbEZhL8zZu2AiA5nq805NZh75JNj4ajn1xc=
+github.com/akamensky/argparse v1.4.0/go.mod h1:S5kwC7IuDcEr5VeXtGPRVZ5o/FdhcMlQz4IZQuw64xA=
 github.com/lucasb-eyer/go-colorful v1.2.0 h1:1nnpGOrhyZZuNyfu1QjKiUICQ74+3FNCN69Aj6K7nkY=
 github.com/lucasb-eyer/go-colorful v1.2.0/go.mod h1:R4dSotOR9KMtayYi1e77YzuveK+i7ruzyGqttikkLy0=
 github.com/mazznoer/colorgrad v0.9.1 h1:MB80JYVndKWSMEM1beNqnuOowWGhoQc3DXWXkFp6JlM=

io/reader/image.go

@@ -4,6 +4,7 @@ import (
 	"image"
 	"image/color"
 	"image/png"
+	"maze-solver/utils"
 	"os"
 
 	"golang.org/x/image/draw"
@@ -16,6 +17,7 @@ type ImageReader struct {
 }
 
 func (r *ImageReader) Read() (*RawMaze, error) {
+	defer utils.Timer("Image reader", 3)()
 	image, err := r.getShrunkImage()
 	if err != nil {
 		return nil, err

io/reader/image_test.go

@@ -78,6 +78,30 @@ func TestImageReader(t *testing.T) {
 				{0b_00000100, 0b000_00000},
 			},
 		},
+		{
+			"Normal2",
+			15, 15,
+			20, 20,
+			white, black,
+			"../../assets/normal2.png",
+			[][]byte{
+				{0b00000001, 0b0000000_0},
+				{0b01110111, 0b1111010_0},
+				{0b00010100, 0b0001010_0},
+				{0b01110111, 0b1101110_0},
+				{0b01000000, 0b0000010_0},
+				{0b01111101, 0b1111010_0},
+				{0b00010101, 0b0000010_0},
+				{0b01110111, 0b0111010_0},
+				{0b01000100, 0b0101010_0},
+				{0b01011101, 0b1101110_0},
+				{0b01000101, 0b0000000_0},
+				{0b01110101, 0b0111110_0},
+				{0b01010001, 0b0001010_0},
+				{0b01011111, 0b1111010_0},
+				{0b00000001, 0b0000000_0},
+			},
+		},
 	}
 
 	for _, test := range tests {

io/reader/reader.go

@@ -1,5 +1,48 @@
 package reader
 
+import (
+	"fmt"
+	"image/color"
+)
+
 type Reader interface {
 	Read() (*RawMaze, error)
 }
+
+type ReaderFactory struct {
+	Type                             string
+	Filename                         *string
+	PathChar, WallChar, SolutionChar *string
+	CellWidth, CellHeight            *int
+	WallColor, PathColor             color.Color
+}
+
+const (
+	_IMAGE = "image"
+	_TEXT  = "text"
+)
+
+var TYPES = map[string]string{
+	".png": _IMAGE,
+	".txt": _TEXT,
+}
+
+func (f *ReaderFactory) Get() Reader {
+	switch f.Type {
+	case _TEXT:
+		return &TextReader{
+			Filename: *f.Filename,
+			PathChar: byte((*f.PathChar)[0]),
+			WallChar: byte((*f.WallChar)[0]),
+		}
+	case _IMAGE:
+		return &ImageReader{
+			Filename:   *f.Filename,
+			CellWidth:  *f.CellWidth,
+			CellHeight: *f.CellHeight,
+			WallColor:  f.WallColor,
+			PathColor:  f.PathColor,
+		}
+	}
+	panic(fmt.Sprintf("Unrecognized reader type %q", f.Type))
+}

io/reader/strings.go

@@ -11,6 +11,7 @@ type StringsReader struct {
 }
 
 func (r *StringsReader) Read() (*RawMaze, error) {
+	defer utils.Timer("Strings Reader", 3)()
 	width, height := len((*r.Lines)[0]), len(*r.Lines)
 	ret := &RawMaze{
 		Width:  width,

io/reader/text.go

@@ -2,6 +2,7 @@ package reader
 
 import (
 	"bufio"
+	"maze-solver/utils"
 	"os"
 )
 
@@ -10,7 +11,8 @@ type TextReader struct {
 	PathChar, WallChar byte
 }
 
-func (r TextReader) Read() (*RawMaze, error) {
+func (r *TextReader) Read() (*RawMaze, error) {
+	defer utils.Timer("Text Reader", 3)()
 	lines, err := getLines(r.Filename)
 	if err != nil {
 		return nil, err

io/writer/image.go

@@ -7,6 +7,7 @@ import (
 	"image/draw"
 	"image/png"
 	"maze-solver/maze"
+	"maze-solver/utils"
 	"os"
 
 	"github.com/mazznoer/colorgrad"
@@ -22,6 +23,7 @@ type ImageWriter struct {
 }
 
 func (w *ImageWriter) Write() error {
+	defer utils.Timer("Image writer", 3)()
 	if w.Filename[len(w.Filename)-4:] != ".png" {
 		return errors.New("Filename of ImageWriter doesn't have .png extension. The only suppported image type is png")
 	}
@@ -56,17 +58,28 @@ func (w *ImageWriter) Write() error {
 	width, height = w.CellWidth, w.CellHeight
 	for i, from := range w.Maze.Solution[:len(w.Maze.Solution)-1] {
 		to := w.Maze.Solution[i+1]
+
 		if from.Coords.X == to.Coords.X {
+			// Fill verticallly
 			x0 = from.Coords.X * w.CellWidth
 
+			if from.Coords.Y < to.Coords.Y {
 				for y := from.Coords.Y; y < to.Coords.Y; y++ {
 					y0 = y * w.CellHeight
 					w.draw(x0, y0, width, height, colors[c])
 					c++
 				}
+			} else {
+				for y := from.Coords.Y; y > to.Coords.Y; y-- {
+					y0 = y * w.CellHeight
+					w.draw(x0, y0, width, height, colors[c])
+					c++
+				}
+			}
 			y0 = to.Coords.Y * w.CellHeight
 			w.draw(x0, y0, width, height, colors[c])
 		} else {
+			// Fill horizontally
 			y0 = from.Coords.Y * w.CellHeight
 
 			if from.Coords.X < to.Coords.X {

io/writer/image_test.go

@@ -0,0 +1,75 @@
+package writer
+
+import (
+	"image/color"
+	"maze-solver/maze"
+	"testing"
+
+	"github.com/mazznoer/colorgrad"
+)
+
+func TestImageWriter(t *testing.T) {
+	pathGradient, err := colorgrad.NewGradient().Colors(color.White).Build()
+	if err != nil {
+		panic(err)
+	}
+
+	tests := []struct {
+		name                  string
+		filename              string
+		m                     *maze.SolvedMaze
+		CellWidth, cellHeight int
+		pathColor, wallColor  color.Color
+		gradient              colorgrad.Gradient
+	}{
+		{
+			"Trivial",
+			"../../out/trivial_sol.png",
+			trivial(),
+			40, 40,
+			color.White, color.Black,
+			colorgrad.Warm(),
+		},
+		{
+			"Bigger",
+			"../../out/bigger_sol.png",
+			bigger(),
+			40, 40,
+			color.White, color.Black,
+			colorgrad.Warm(),
+		},
+		{
+			"Bigger Staggered",
+			"../../out/bigger_staggered_sol.png",
+			bigger_staggered(),
+			40, 40,
+			color.White, color.Black,
+			pathGradient,
+		},
+		{
+			"Normal",
+			"../../out/normal_sol.png",
+			normal(),
+			40, 40,
+			color.White, color.Black,
+			colorgrad.Warm(),
+		},
+	}
+
+	for _, test := range tests {
+		writer := ImageWriter{
+			Filename:         test.filename,
+			Maze:             test.m,
+			CellWidth:        test.CellWidth,
+			CellHeight:       test.cellHeight,
+			WallColor:        test.wallColor,
+			PathColor:        test.pathColor,
+			SolutionGradient: test.gradient,
+		}
+
+		err := writer.Write()
+		if err != nil {
+			t.Fatalf("%s: couldn't write solution, got following error\n%v", test.name, err)
+		}
+	}
+}

io/writer/strings.go

@@ -4,6 +4,7 @@ import (
 	"bytes"
 	"fmt"
 	"maze-solver/maze"
+	"maze-solver/utils"
 )
 
 type StringsWriter struct {
@@ -14,6 +15,7 @@ type StringsWriter struct {
 }
 
 func (w *StringsWriter) Write() error {
+	defer utils.Timer("Strings writer", 3)()
 	w.lines = make([][]byte, w.Maze.Height)
 
 	// Fill the lines with walls
@@ -58,6 +60,9 @@ func (w *StringsWriter) fillHorizontally(from maze.Coordinates, to maze.Coordina
 
 func (w *StringsWriter) fillVertically(from maze.Coordinates, to maze.Coordinates, char byte) {
 	x := from.X
+	if from.Y > to.Y {
+		from, to = to, from
+	}
 	for y := from.Y; y <= to.Y; y++ {
 		w.lines[y][x] = char
 	}

io/writer/utils.go

@@ -13,7 +13,6 @@ func trivial() *maze.SolvedMaze {
 	   #123#
 	   ###4#
 	*/
-	ret := &maze.SolvedMaze{}
 	nodes := make([]*maze.Node, 5)
 
 	nodes[0] = maze.NewNode(maze.Coordinates{X: 2, Y: 0})
@@ -37,16 +36,17 @@ func trivial() *maze.SolvedMaze {
 
 	nodes[4].Up = nodes[3]
 
-	solution := []*maze.Node{
+	ret := &maze.SolvedMaze{
+		Maze: &maze.Maze{
+			Width:  5,
+			Height: 3,
+			Nodes:  nodes,
+		},
+		Solution: []*maze.Node{
 			nodes[0], nodes[2], nodes[3], nodes[4],
+		},
 	}
 
-	ret.Nodes = nodes
-	ret.Width = 5
-	ret.Height = 3
-
-	ret.Solution = solution
-
 	return ret
 }
 
@@ -89,7 +89,7 @@ func bigger() *maze.SolvedMaze {
 	nodes[4].Up = nodes[3]
 
 	ret := &maze.SolvedMaze{
-		Maze: maze.Maze{
+		Maze: &maze.Maze{
 			Width:  7,
 			Height: 5,
 			Nodes:  nodes,
@@ -146,7 +146,7 @@ func bigger_staggered() *maze.SolvedMaze {
 	nodes[5].Up = nodes[4]
 
 	ret := &maze.SolvedMaze{
-		Maze: maze.Maze{
+		Maze: &maze.Maze{
 			Width:  7,
 			Height: 5,
 			Nodes:  nodes,
@@ -266,7 +266,7 @@ func normal() *maze.SolvedMaze {
 	}
 
 	ret := &maze.SolvedMaze{
-		Maze: maze.Maze{
+		Maze: &maze.Maze{
 			Width:  11,
 			Height: 11,
 			Nodes:  nodes,

io/writer/writer.go

@@ -1,5 +1,46 @@
 package writer
 
+import (
+	"fmt"
+	"image/color"
+	"maze-solver/maze"
+
+	"github.com/mazznoer/colorgrad"
+)
+
 type Writer interface {
 	Write() error
 }
+
+type WriterFactory struct {
+	Type                             string
+	Filename                         *string
+	PathChar, WallChar, SolutionChar *string
+	CellWidth, CellHeight            *int
+	WallColor, PathColor             color.Color
+	SolutionGradient                 colorgrad.Gradient
+}
+
+const (
+	_IMAGE = "image"
+)
+
+var TYPES = map[string]string{
+	".png": _IMAGE,
+}
+
+func (f *WriterFactory) Get(m *maze.SolvedMaze) Writer {
+	switch f.Type {
+	case _IMAGE:
+		return &ImageWriter{
+			Filename:         *f.Filename,
+			Maze:             m,
+			CellWidth:        *f.CellWidth,
+			CellHeight:       *f.CellHeight,
+			WallColor:        f.WallColor,
+			PathColor:        f.PathColor,
+			SolutionGradient: f.SolutionGradient,
+		}
+	}
+	panic(fmt.Sprintf("Unrecognized writer type %q", f.Type))
+}

main.go

@@ -1,25 +1,154 @@
 package main
 
 import (
+	"errors"
+	"fmt"
+	"image/color"
 	"maze-solver/io/reader"
 	"maze-solver/io/writer"
 	"maze-solver/maze/parser"
 	"maze-solver/solver"
 	"maze-solver/utils"
+	"os"
+	"strings"
+
+	"github.com/akamensky/argparse"
+	"github.com/mazznoer/colorgrad"
 )
 
 func main() {
-	output := "filename"
+	argparser := argparse.NewParser("maze-solver", "Solves the given maze (insane, right? who would've guessed?)")
 
-	reader := &reader.TextReader{Filename: "filename", PathChar: ' ', WallChar: '#'}
-	writer := &writer.ImageWriter{}
+	var verboseLevel *int = argparser.FlagCounter("v", "verbose", &argparse.Options{
+		Help: `Verbose level of the solver
+        0: nothing printed to stdout
+        1: print the total time taken by the solver (time of the main() function)
+        2: prints the time the solving algorithm took to run
+        3: prints the time taken by each section (reader, solving algorithm, writer)`,
+	})
 
-	solver := &solver.Bfs{}
+	readerFactory := reader.ReaderFactory{}
+	writerFactory := writer.WriterFactory{}
+	solverFactory := solver.SolverFactory{}
+
+	readerFactory.Type = reader.TYPES[".png"]
+	readerFactory.Filename = argparser.String("i", "input", &argparse.Options{
+		Help:    "Input file",
+		Default: "maze.png",
+		Validate: func(args []string) error {
+			var ok bool
+			extension := args[0][len(args[0])-4:]
+			readerFactory.Type, ok = reader.TYPES[extension]
+			if ok {
+				return nil
+			} else {
+				return errors.New(fmt.Sprintf("Filetype not recognized %q", extension))
+			}
+		},
+	})
+
+	writerFactory.Type = writer.TYPES[".png"]
+	writerFactory.Filename = argparser.String("o", "output", &argparse.Options{
+		Help:    "Input file",
+		Default: "maze_sol.png",
+		Validate: func(args []string) error {
+			var ok bool
+			extension := args[0][len(args[0])-4:]
+			writerFactory.Type, ok = writer.TYPES[extension]
+			if ok {
+				return nil
+			} else {
+				return errors.New(fmt.Sprintf("Filetype not recognized %q", extension))
+			}
+		},
+	})
+
+	readerFactory.PathChar = argparser.String("", "path-char-in", &argparse.Options{
+		Help:    "Character to represent the path in a input text file",
+		Default: " ",
+		Validate: func(args []string) error {
+			if len(args[0]) > 1 {
+				return errors.New("Character must a string of length 1")
+			}
+			return nil
+		},
+	})
+
+	readerFactory.WallChar = argparser.String("", "wall-char-in", &argparse.Options{
+		Help:    "Character to represent the wall in a input text file",
+		Default: "#",
+		Validate: func(args []string) error {
+			if len(args[0]) > 1 {
+				return errors.New("Character must a string of length 1")
+			}
+			return nil
+		},
+	})
+
+	writerFactory.PathChar = argparser.String("", "path-char-out", &argparse.Options{
+		Help:    "Character to represent the path in a output text file",
+		Default: " ",
+		Validate: func(args []string) error {
+			if len(args[0]) > 1 {
+				return errors.New("Character must a string of length 1")
+			}
+			return nil
+		},
+	})
+
+	writerFactory.WallChar = argparser.String("", "wall-char-out", &argparse.Options{
+		Help:    "Character to represent the wall in a output text file",
+		Default: "#",
+		Validate: func(args []string) error {
+			if len(args[0]) > 1 {
+				return errors.New("Character must a string of length 1")
+			}
+			return nil
+		},
+	})
+
+	cellSizeIn := argparser.Int("", "cell-size-in", &argparse.Options{
+		Help:    "Size of a cell (in pixels) for input file of image type",
+		Default: 20,
+	})
+
+	cellSizeOut := argparser.Int("", "cell-size-out", &argparse.Options{
+		Help:    "Size of a cell (in pixels) for output file of image type",
+		Default: 20,
+	})
+
+	solverFactory.Type = argparser.Selector("a", "algo", solver.TYPES, &argparse.Options{
+		Help:    fmt.Sprintf("Algorithm to solve the maze, avaiable options: %s", strings.Join(solver.TYPES, ", ")),
+		Default: solver.TYPES[0],
+	})
+
+	if err := argparser.Parse(os.Args); err != nil {
+		fmt.Println(argparser.Usage(err))
+		return
+	}
+	utils.VERBOSE_LEVEL = *verboseLevel
+
+	readerFactory.CellHeight, readerFactory.CellWidth = cellSizeIn, cellSizeIn
+	readerFactory.WallColor = color.RGBA{0, 0, 0, 255}
+	readerFactory.PathColor = color.RGBA{255, 255, 255, 255}
+
+	writerFactory.CellHeight, writerFactory.CellWidth = cellSizeOut, cellSizeOut
+	writerFactory.WallColor = color.RGBA{0, 0, 0, 255}
+	writerFactory.PathColor = color.RGBA{255, 255, 255, 255}
+	writerFactory.SolutionGradient = colorgrad.Warm()
+
+	defer utils.Timer("TOTAL", 1)()
+
+	reader := readerFactory.Get()
 
 	maze, err := parser.Parse(reader)
-	utils.Check(err, "Couldn't read maze from %q", reader.Filename)
+	utils.Check(err, "Couldn't read maze")
 
+	solver := solverFactory.Get()
 	solved := solver.Solve(maze)
-	err = writer.Write(output, solved)
-	utils.Check(err, "Couldn't write solved maze to %q", output)
+
+	writer := writerFactory.Get(solved)
+
+	err = writer.Write()
+	utils.Check(err, "Couldn't write solved maze")
 }

maze/maze.go

@@ -48,6 +48,6 @@ type Maze struct {
 }
 
 type SolvedMaze struct {
-	Maze
+	*Maze
 	Solution []*Node
 }

maze/parser/parser.go

@@ -85,7 +85,7 @@ func lookupNeighbourAbove(raw_maze *reader.RawMaze, node *maze.Node, nodesByCoor
 			break
 		}
 
-		if y > 0 && raw_maze.IsWall(node.Coords.X, y) {
+		if y >= 0 && raw_maze.IsWall(node.Coords.X, y) {
 			y++
 			if y == node.Coords.Y {
 				break
@@ -107,6 +107,10 @@ func lookupNeighbourAbove(raw_maze *reader.RawMaze, node *maze.Node, nodesByCoor
 
 func lookupNeighbourLeft(raw_maze *reader.RawMaze, node *maze.Node, nodesByCoord *map[maze.Coordinates]*maze.Node) {
 	for x := node.Coords.X - 1; x > 0; x-- {
+		if raw_maze.IsWall(x, node.Coords.Y) && x == node.Coords.X-1 {
+			return
+		}
+
 		if raw_maze.IsWall(x, node.Coords.Y) && x < node.Coords.X-1 {
 			panic(fmt.Sprintf("Found no node before wall while looking to the left at neighbours of node %v (arrived at x=%v before hitting a wall)", node, x))
 		}
@@ -122,7 +126,11 @@ func lookupNeighbourLeft(raw_maze *reader.RawMaze, node *maze.Node, nodesByCoord
 
 func lookupNeighbourRight(raw_maze *reader.RawMaze, node *maze.Node, nodesByCoord *map[maze.Coordinates]*maze.Node) {
 	for x := node.Coords.X + 1; x < raw_maze.Width; x++ {
-		if raw_maze.IsWall(x, node.Coords.Y) {
+		if raw_maze.IsWall(x, node.Coords.Y) && x == node.Coords.X+1 {
+			return
+		}
+
+		if raw_maze.IsWall(x, node.Coords.Y) && x > node.Coords.X+1 {
 			panic(fmt.Sprintf("Found no node before wall while looking to the right at neighbours of node %v", node))
 		}
 

maze/parser/parser_test.go

@@ -340,12 +340,207 @@ func TestTextReadNormal(t *testing.T) {
 	}
 }
 
+func TestTextReadNormal2(t *testing.T) {
+	/* normal2.txt
+	   ####### #######
+	   #   #       # #
+	   ### # ##### # #
+	   #   #     #   #
+	   # ########### #
+	   #     #     # #
+	   ### # # ##### #
+	   #   #   #   # #
+	   # ### ### # # #
+	   # #   #   #   #
+	   # ### # #######
+	   #   # # #     #
+	   # # ### ### # #
+	   # #         # #
+	   ####### #######
+
+	   Nodes are
+	   #######0#######
+	   #1 2#3 4   5#B#
+	   ### # ##### # #
+	   #6 7#8   9#A C#
+	   # ########### #
+	   #D I E#F   G# #
+	   ### # # ##### #
+	   #H J#K L#M N# #
+	   # ### ### # # #
+	   # #O P#Q R#S T#
+	   # ### # #######
+	   #U V#W# #X C Y#
+	   # # ### ### # #
+	   #Z#A   B   D#E#
+	   #######F#######
+	*/
+	nodes := make([]*maze.Node, 42)
+
+	// ---- Node creation ----
+	coords := []struct{ x, y int }{
+		{7, 0}, // 0
+
+		{1, 1},  // 1
+		{3, 1},  // 2
+		{5, 1},  // 3
+		{7, 1},  // 4
+		{11, 1}, // 5
+
+		{1, 3},  // 6
+		{3, 3},  // 7
+		{5, 3},  // 8
+		{9, 3},  // 9
+		{11, 3}, // 10 (A)
+		{13, 1}, // 11 (B)
+		{13, 3}, // 12 (C)
+
+		{1, 5},  // 13 (D)
+		{5, 5},  // 14 (E)
+		{7, 5},  // 15 (F)
+		{11, 5}, // 16 (G)
+
+		{1, 7},  // 17 (H)
+		{3, 5},  // 18 (I)
+		{3, 7},  // 19 (J)
+		{5, 7},  // 20 (K)
+		{7, 7},  // 21 (L)
+		{9, 7},  // 22 (M)
+		{11, 7}, // 23 (N)
+
+		{3, 9},  // 24 (O)
+		{5, 9},  // 25 (P)
+		{7, 9},  // 26 (Q)
+		{9, 9},  // 27 (R)
+		{11, 9}, // 28 (S)
+		{13, 9}, // 29 (T)
+
+		{1, 11},  // 30 (U)
+		{3, 11},  // 31 (V)
+		{5, 11},  // 32 (W)
+		{9, 11},  // 33 (X)
+		{13, 11}, // 34 (Y)
+
+		{1, 13},  // 35 (Z)
+		{3, 13},  // 36 (AA)
+		{7, 13},  // 37 (AB)
+		{11, 11}, // 38 (AC)
+		{11, 13}, // 39 (AD)
+		{13, 13}, // 40 (AE)
+
+		{7, 14}, // 42 (AF)
+	}
+
+	for i, coord := range coords {
+		nodes[i] = maze.NewNode(maze.Coordinates{X: coord.x, Y: coord.y})
+	}
+
+	// ---- Node linking ----
+	// Vertical
+	links := []struct {
+		from, to int
+	}{
+		{0, 4},
+		{2, 7},
+		{3, 8},
+		{5, 10},
+		{11, 12},
+		{6, 13},
+		{12, 29},
+		{18, 19},
+		{14, 20},
+		{15, 21},
+		{17, 30},
+		{20, 25},
+		{22, 27},
+		{23, 28},
+		{25, 32},
+		{26, 37},
+		{30, 35},
+		{31, 36},
+		{38, 39},
+		{34, 40},
+		{37, 41},
+	}
+	for _, link := range links {
+		nodes[link.from].Down = nodes[link.to]
+		nodes[link.to].Up = nodes[link.from]
+	}
+
+	links = []struct {
+		from, to int
+	}{
+		{1, 2},
+		{3, 4},
+		{4, 5},
+
+		{6, 7},
+		{8, 9},
+		{10, 12},
+
+		{13, 18},
+		{18, 14},
+		{15, 16},
+
+		{17, 19},
+		{20, 21},
+		{22, 23},
+
+		{24, 25},
+		{26, 27},
+		{28, 29},
+
+		{30, 31},
+		{33, 38},
+		{38, 34},
+		{36, 37},
+		{37, 39},
+	}
+	for _, link := range links {
+		nodes[link.from].Right = nodes[link.to]
+		nodes[link.to].Left = nodes[link.from]
+	}
+
+	reader := reader.TextReader{
+		Filename: "../../assets/normal2.txt",
+		PathChar: ' ',
+		WallChar: '#',
+	}
+
+	got, err := Parse(reader)
+	utils.Check(err, "Couldn't create maze from %q", reader.Filename)
+
+	utils.AssertEqual(t, got.Width, 15, "Normal 2: width differ")
+	utils.AssertEqual(t, got.Height, 15, "Normal 2: height differ")
+
+	if len(nodes) != len(got.Nodes) {
+		for i, node := range got.Nodes {
+			fmt.Printf("%v: %v\n", i, node)
+		}
+		t.Fatalf("Didn't get the same size of nodes: %v, want %v", len(got.Nodes), len(nodes))
+	}
+
+	for i, got := range got.Nodes {
+		expected := nodes[i]
+
+		checkNode(t, i, got, expected, "")
+		checkNode(t, i, got.Left, expected.Left, "left")
+		checkNode(t, i, got.Right, expected.Right, "Right")
+		checkNode(t, i, got.Up, expected.Up, "Up")
+		checkNode(t, i, got.Down, expected.Down, "Down")
+	}
+}
+
 func checkNode(t *testing.T, i int, got *maze.Node, expected *maze.Node, side string) {
-	if expected == nil {
+	if expected == nil && got != nil {
+		t.Fatalf("Somehow there is a node %s of %v, didn't want any", side, i)
+	}
+
+	if expected == nil && got == nil {
 		return
 	}
 
-	if got == nil {
+	if expected != nil && got == nil {
 		t.Fatalf("No %s node of %v, want %v", side, i, expected.Coords)
 	}
 

solver/solver.go

@@ -1,7 +1,30 @@
 package solver
 
-import "maze-solver/maze"
+import (
+	"fmt"
+	"maze-solver/maze"
+)
 
 type Solver interface {
 	Solve(*maze.Maze) *maze.SolvedMaze
 }
+
+type SolverFactory struct {
+	Type *string
+}
+
+const (
+	_TURN_LEFT = "turn-left"
+)
+
+var TYPES = []string{
+	_TURN_LEFT,
+}
+
+func (f *SolverFactory) Get() Solver {
+	switch *f.Type {
+	case _TURN_LEFT:
+		return &TurnLeftSolver{}
+	}
+	panic(fmt.Sprintf("Unrecognized solver type %q", *f.Type))
+}

solver/turn_left.go

@@ -0,0 +1,63 @@
+package solver
+
+import (
+	"maze-solver/maze"
+	"maze-solver/utils"
+)
+
+type TurnLeftSolver struct {
+	visited map[*maze.Node]bool
+}
+
+func (s *TurnLeftSolver) Solve(m *maze.Maze) *maze.SolvedMaze {
+	defer utils.Timer("Turn left algorithm", 2)()
+
+	current, end := m.Nodes[0], m.Nodes[len(m.Nodes)-1]
+	s.visited = make(map[*maze.Node]bool, len(m.Nodes))
+
+	for _, node := range m.Nodes {
+		s.visited[node] = false
+	}
+
+	stack := make([]*maze.Node, 0, len(m.Nodes))
+	stack = append(stack, current)
+
+	for current != end {
+		s.visited[current] = true
+
+		left_visited, right_visited, up_visited, down_visited := s.wasVisited(current.Left), s.wasVisited(current.Right), s.wasVisited(current.Up), s.wasVisited(current.Down)
+
+		if left_visited && right_visited && up_visited && down_visited {
+			// dead end or no more visited nodes
+			stack = stack[:len(stack)-1]
+			current = stack[len(stack)-1]
+		} else {
+
+			if !left_visited {
+				current = current.Left
+			} else if !down_visited {
+				current = current.Down
+			} else if !right_visited {
+				current = current.Right
+			} else if !up_visited {
+				current = current.Up
+			}
+
+			stack = append(stack, current)
+		}
+	}
+
+	ret := &maze.SolvedMaze{
+		Maze:     m,
+		Solution: stack,
+	}
+	return ret
+}
+
+func (s *TurnLeftSolver) wasVisited(node *maze.Node) bool {
+	if node == nil {
+		return true
+	}
+	visited, _ := s.visited[node]
+	return visited
+}

utils/utils.go

@@ -1,8 +1,10 @@
 package utils
 
 import (
+	"fmt"
 	"log"
 	"testing"
+	"time"
 
 	"golang.org/x/exp/constraints"
 )
@@ -27,3 +29,14 @@ func AssertEqual[T comparable](t *testing.T, got T, want T, msg string, args ...
 		t.Fatalf(msg+"\nGot: %v, Want: %v", args...)
 	}
 }
+
+var VERBOSE_LEVEL int
+
+func Timer(msg string, level int) func() {
+	start := time.Now()
+	return func() {
+		if level <= VERBOSE_LEVEL {
+			fmt.Printf("%-19s %12v\n", msg, time.Since(start))
+		}
+	}
+}