Compare commits
No commits in common. "a7dd3e1a81d644735422684ae6946016c5ccc312" and "99fc6ba48a021e73d5ad2f8bee1c61c63bb4aec9" have entirely different histories.
a7dd3e1a81
...
99fc6ba48a
Binary file not shown.
|
Before 
(image error) Size: 4.5 KiB |
@ -1,15 +0,0 @@
|
||||
####### #######
|
||||
# # # #
|
||||
### # ##### # #
|
||||
# # # #
|
||||
# ########### #
|
||||
# # # #
|
||||
### # # ##### #
|
||||
# # # # #
|
||||
# ### ### # # #
|
||||
# # # # #
|
||||
# ### # #######
|
||||
# # # # #
|
||||
# # ### ### # #
|
||||
# # # #
|
||||
####### #######
|
||||
1
go.mod
1
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
|
||||
)
|
||||
|
||||
2
go.sum
2
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=
|
||||
|
||||
@ -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
|
||||
|
||||
@ -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 {
|
||||
|
||||
@ -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))
|
||||
}
|
||||
|
||||
@ -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,
|
||||
|
||||
@ -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) {
|
||||
defer utils.Timer("Text Reader", 3)()
|
||||
func (r TextReader) Read() (*RawMaze, error) {
|
||||
lines, err := getLines(r.Filename)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
|
||||
@ -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 {
|
||||
|
||||
@ -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)
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -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
|
||||
}
|
||||
|
||||
@ -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{
|
||||
Maze: &maze.Maze{
|
||||
Width: 5,
|
||||
Height: 3,
|
||||
Nodes: nodes,
|
||||
},
|
||||
Solution: []*maze.Node{
|
||||
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,
|
||||
|
||||
@ -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))
|
||||
}
|
||||
|
||||
143
main.go
143
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{
|
||||
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)`,
|
||||
})
|
||||
reader := &reader.TextReader{Filename: "filename", PathChar: ' ', WallChar: '#'}
|
||||
writer := &writer.ImageWriter{}
|
||||
|
||||
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()
|
||||
solver := &solver.Bfs{}
|
||||
|
||||
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)
|
||||
|
||||
writer := writerFactory.Get(solved)
|
||||
|
||||
err = writer.Write()
|
||||
utils.Check(err, "Couldn't write solved maze")
|
||||
err = writer.Write(output, solved)
|
||||
utils.Check(err, "Couldn't write solved maze to %q", output)
|
||||
}
|
||||
|
||||
@ -48,6 +48,6 @@ type Maze struct {
|
||||
}
|
||||
|
||||
type SolvedMaze struct {
|
||||
*Maze
|
||||
Maze
|
||||
Solution []*Node
|
||||
}
|
||||
|
||||
@ -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 {
|
||||
return
|
||||
}
|
||||
|
||||
if raw_maze.IsWall(x, node.Coords.Y) && x > node.Coords.X+1 {
|
||||
if raw_maze.IsWall(x, node.Coords.Y) {
|
||||
panic(fmt.Sprintf("Found no node before wall while looking to the right at neighbours of node %v", node))
|
||||
}
|
||||
|
||||
|
||||
@ -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 {
|
||||
t.Fatalf("Somehow there is a node %s of %v, didn't want any", side, i)
|
||||
}
|
||||
|
||||
if expected == nil && got == nil {
|
||||
if expected == nil {
|
||||
return
|
||||
}
|
||||
|
||||
if expected != nil && got == nil {
|
||||
if got == nil {
|
||||
t.Fatalf("No %s node of %v, want %v", side, i, expected.Coords)
|
||||
}
|
||||
|
||||
|
||||
@ -1,30 +1,7 @@
|
||||
package solver
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"maze-solver/maze"
|
||||
)
|
||||
import "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))
|
||||
}
|
||||
|
||||
@ -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
|
||||
}
|
||||
@ -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))
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user