assets/normal2.txt

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

go.mod

@@ -3,7 +3,6 @@ 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,5 +1,3 @@
-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,7 +4,6 @@ import (
 	"image"
 	"image/color"
 	"image/png"
-	"maze-solver/utils"
 	"os"
 
 	"golang.org/x/image/draw"
@@ -17,7 +16,6 @@ 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,30 +78,6 @@ 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,48 +1,5 @@
 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,7 +11,6 @@ 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,7 +2,6 @@ package reader
 
 import (
 	"bufio"
-	"maze-solver/utils"
 	"os"
 )
 
@@ -11,8 +10,7 @@ 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,7 +7,6 @@ import (
 	"image/draw"
 	"image/png"
 	"maze-solver/maze"
-	"maze-solver/utils"
 	"os"
 
 	"github.com/mazznoer/colorgrad"
@@ -23,7 +22,6 @@ 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")
 	}
@@ -58,28 +56,17 @@ 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

@@ -1,75 +0,0 @@
-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,7 +4,6 @@ import (
 	"bytes"
 	"fmt"
 	"maze-solver/maze"
-	"maze-solver/utils"
 )
 
 type StringsWriter struct {
@@ -15,7 +14,6 @@ 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
@@ -60,9 +58,6 @@ 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,6 +13,7 @@ func trivial() *maze.SolvedMaze {
 	   #123#
 	   ###4#
 	*/
+	ret := &maze.SolvedMaze{}
 	nodes := make([]*maze.Node, 5)
 
 	nodes[0] = maze.NewNode(maze.Coordinates{X: 2, Y: 0})
@@ -36,17 +37,16 @@ func trivial() *maze.SolvedMaze {
 
 	nodes[4].Up = nodes[3]
 
-	ret := &maze.SolvedMaze{
+	solution := []*maze.Node{
-		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,46 +1,5 @@
 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,154 +1,25 @@
 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() {
-	argparser := argparse.NewParser("maze-solver", "Solves the given maze (insane, right? who would've guessed?)")
+	output := "filename"
 
-	var verboseLevel *int = argparser.FlagCounter("v", "verbose", &argparse.Options{
+	reader := &reader.TextReader{Filename: "filename", PathChar: ' ', WallChar: '#'}
-		Help: `Verbose level of the solver
+	writer := &writer.ImageWriter{}
-        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)`,
-	})
 
-	readerFactory := reader.ReaderFactory{}
+	solver := &solver.Bfs{}
-	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")
+	utils.Check(err, "Couldn't read maze from %q", reader.Filename)
 
-	solver := solverFactory.Get()
 	solved := solver.Solve(maze)
-
+	err = writer.Write(output, solved)
-	writer := writerFactory.Get(solved)
+	utils.Check(err, "Couldn't write solved maze to %q", output)
-
-	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,10 +107,6 @@ 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))
 		}
@@ -126,11 +122,7 @@ 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) && x == node.Coords.X+1 {
+		if raw_maze.IsWall(x, node.Coords.Y) {
-			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,207 +340,12 @@ 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 && got != nil {
+	if expected == nil {
-		t.Fatalf("Somehow there is a node %s of %v, didn't want any", side, i)
-	}
-
-	if expected == nil && got == nil {
 		return
 	}
 
-	if expected != nil && got == nil {
+	if got == nil {
 		t.Fatalf("No %s node of %v, want %v", side, i, expected.Coords)
 	}
 

solver/solver.go

@@ -1,30 +1,7 @@
 package solver
 
-import (
+import "maze-solver/maze"
-	"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

@@ -1,63 +0,0 @@
-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,10 +1,8 @@
 package utils
 
 import (
-	"fmt"
 	"log"
 	"testing"
-	"time"
 
 	"golang.org/x/exp/constraints"
 )
@@ -29,14 +27,3 @@ 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))
-		}
-	}
-}