From ab6f85b7b65c4392269383f73aab91208d0ea9a6 Mon Sep 17 00:00:00 2001 From: Karma Riuk Date: Sat, 5 Aug 2023 10:38:46 +0200 Subject: [PATCH] Reader -> Reader+Parser refacfotring: create the parser package, moved the parsing aspect of reader to parser (still have some naughty stuff like WallChar and PathChar in parser but it'll be fixed in next commit) --- io/reader/reader.go | 2 +- io/reader/text.go | 128 +----------- maze/maze.go | 5 + maze/parser/parser.go | 138 +++++++++++++ .../parser/parser_test.go | 194 ++++++++++++++++-- 5 files changed, 329 insertions(+), 138 deletions(-) create mode 100644 maze/parser/parser.go rename io/reader/text_test.go => maze/parser/parser_test.go (52%) diff --git a/io/reader/reader.go b/io/reader/reader.go index 9116d6e..304d842 100644 --- a/io/reader/reader.go +++ b/io/reader/reader.go @@ -3,5 +3,5 @@ package reader import "maze-solver/maze" type Reader interface { - Read(filename string) (*maze.Maze, error) + Read() (*maze.RawMaze, error) } diff --git a/io/reader/text.go b/io/reader/text.go index 5355b8b..24b28bb 100644 --- a/io/reader/text.go +++ b/io/reader/text.go @@ -2,26 +2,23 @@ package reader import ( "bufio" - "fmt" "maze-solver/maze" "os" ) type TextReader struct { + Filename string PathChar, WallChar byte } -func (r *TextReader) Read(filename string) (*maze.Maze, error) { - nodesByCoord := make(map[maze.Coordinates]*maze.Node) +func (r TextReader) Read() (*maze.RawMaze, error) { var lines []string - ret := &maze.Maze{} - - if _, err := os.Stat(filename); err != nil { + if _, err := os.Stat(r.Filename); err != nil { return nil, err } - file, err := os.Open(filename) + file, err := os.Open(r.Filename) if err != nil { return nil, err } @@ -37,120 +34,5 @@ func (r *TextReader) Read(filename string) (*maze.Maze, error) { file.Close() } - for y, line := range lines { - fmt.Println(line) - for x := 1; x < len(line)-1; x++ { - char := line[x] - var left_char, right_char, above_char byte - - if y > 0 { - left_char = line[x-1] - right_char = line[x+1] - above_char = lines[y-1][x] - } - - // Parse first line to get entrance - if y == 0 && char == r.PathChar { - coords := maze.Coordinates{X: x, Y: y} - node := maze.NewNode(coords) - ret.Nodes = append(ret.Nodes, node) - nodesByCoord[coords] = node - continue - } - - // Parse middle of the maze - if y > 0 && char == r.PathChar && - (left_char == r.WallChar && right_char == r.PathChar || - left_char == r.PathChar && right_char == r.WallChar || - above_char == r.PathChar && (left_char == r.PathChar || right_char == r.PathChar)) { - coords := maze.Coordinates{X: x, Y: y} - node := maze.NewNode(coords) - - r.lookupNeighbourAbove(&lines, node, &nodesByCoord, ret) - - ret.Nodes = append(ret.Nodes, node) - nodesByCoord[coords] = node - - if left_char == r.PathChar && right_char == r.WallChar || - above_char == r.PathChar && (left_char == r.PathChar || right_char == r.PathChar) { - r.lookupNeighbourLeft(&line, node, &nodesByCoord) - } - } - } - } - - fmt.Println(len(lines)) - // Parse last line to get exit - for x, rune := range lines[len(lines)-1] { - char := byte(rune) - if char == r.PathChar { - coords := maze.Coordinates{X: x, Y: len(lines) - 1} - node := maze.NewNode(coords) - r.lookupNeighbourAbove(&lines, node, &nodesByCoord, ret) - ret.Nodes = append(ret.Nodes, node) - break - } - } - - return ret, nil -} - -func (r *TextReader) lookupNeighbourAbove(lines *[]string, node *maze.Node, nodesByCoord *map[maze.Coordinates]*maze.Node, m *maze.Maze) { - for y := node.Coords.Y - 1; y >= 0; y-- { - neighbour, ok := (*nodesByCoord)[maze.Coordinates{X: node.Coords.X, Y: y}] - - if ok { - node.Up = neighbour - neighbour.Down = node - break - } - - if y > 0 && (*lines)[y][node.Coords.X] == r.WallChar { - y++ - if y == node.Coords.Y { - break - } - coords := maze.Coordinates{X: node.Coords.X, Y: y} - new_node := maze.NewNode(coords) - r.lookupNeighbourLeft(&(*lines)[y], new_node, nodesByCoord) - r.lookupNeighbourRight(&(*lines)[y], new_node, nodesByCoord) - (*nodesByCoord)[coords] = new_node - m.Nodes = append(m.Nodes, new_node) - - node.Up = new_node - new_node.Down = node - break - } - - } -} - -func (r *TextReader) lookupNeighbourLeft(line *string, node *maze.Node, nodesByCoord *map[maze.Coordinates]*maze.Node) { - for x := node.Coords.X - 1; x > 0; x-- { - if (*line)[x] == r.WallChar && x < node.Coords.X-1 { - panic(fmt.Sprintf("Found no node before wall while looking to the left at neighbours of node %v", node)) - } - - neighbour, ok := (*nodesByCoord)[maze.Coordinates{X: x, Y: node.Coords.Y}] - if ok { - node.Left = neighbour - neighbour.Right = node - break - } - } -} - -func (r *TextReader) lookupNeighbourRight(line *string, node *maze.Node, nodesByCoord *map[maze.Coordinates]*maze.Node) { - for x := node.Coords.X + 1; x < len(*line); x++ { - if (*line)[x] == r.WallChar { - panic(fmt.Sprintf("Found no node before wall while looking to the right at neighbours of node %v", node)) - } - - neighbour, ok := (*nodesByCoord)[maze.Coordinates{X: x, Y: node.Coords.Y}] - if ok { - node.Right = neighbour - neighbour.Left = node - break - } - } + return &maze.RawMaze{PathChar: r.PathChar, WallChar: r.WallChar, Data: lines}, nil } diff --git a/maze/maze.go b/maze/maze.go index 471e361..c95c00e 100644 --- a/maze/maze.go +++ b/maze/maze.go @@ -19,6 +19,11 @@ func NewNode(coords Coordinates) *Node { } } +type RawMaze struct { + PathChar, WallChar byte + Data []string +} + type Maze struct { Width, Height uint Nodes []*Node diff --git a/maze/parser/parser.go b/maze/parser/parser.go new file mode 100644 index 0000000..d445b12 --- /dev/null +++ b/maze/parser/parser.go @@ -0,0 +1,138 @@ +package parser + +import ( + "fmt" + "maze-solver/io/reader" + "maze-solver/maze" +) + +const ( + WallChar = '#' + PathChar = ' ' +) + +func Parse(reader reader.Reader) (*maze.Maze, error) { + nodesByCoord := make(map[maze.Coordinates]*maze.Node) + ret := &maze.Maze{} + + raw_maze, err := reader.Read() + if err != nil { + return nil, err + } + + for y, line := range raw_maze.Data { + fmt.Println(line) + for x := 1; x < len(line)-1; x++ { + char := line[x] + var left_char, right_char, above_char byte + + if y > 0 { + left_char = line[x-1] + right_char = line[x+1] + above_char = raw_maze.Data[y-1][x] + } + + // Parse first line to get entrance + if y == 0 && char == PathChar { + coords := maze.Coordinates{X: x, Y: y} + node := maze.NewNode(coords) + ret.Nodes = append(ret.Nodes, node) + nodesByCoord[coords] = node + continue + } + + // Parse middle of the maze + if y > 0 && char == PathChar && + (left_char == WallChar && right_char == PathChar || + left_char == PathChar && right_char == WallChar || + above_char == PathChar && (left_char == PathChar || right_char == PathChar)) { + coords := maze.Coordinates{X: x, Y: y} + node := maze.NewNode(coords) + + lookupNeighbourAbove(&raw_maze.Data, node, &nodesByCoord, ret) + + ret.Nodes = append(ret.Nodes, node) + nodesByCoord[coords] = node + + if left_char == PathChar && right_char == WallChar || + above_char == PathChar && (left_char == PathChar || right_char == PathChar) { + lookupNeighbourLeft(&line, node, &nodesByCoord) + } + } + } + } + + // Parse last line to get exit + for x, rune := range raw_maze.Data[len(raw_maze.Data)-1] { + char := byte(rune) + if char == PathChar { + coords := maze.Coordinates{X: x, Y: len(raw_maze.Data) - 1} + node := maze.NewNode(coords) + lookupNeighbourAbove(&raw_maze.Data, node, &nodesByCoord, ret) + ret.Nodes = append(ret.Nodes, node) + break + } + } + + return ret, nil +} + +func lookupNeighbourAbove(Data *[]string, node *maze.Node, nodesByCoord *map[maze.Coordinates]*maze.Node, m *maze.Maze) { + for y := node.Coords.Y - 1; y >= 0; y-- { + neighbour, ok := (*nodesByCoord)[maze.Coordinates{X: node.Coords.X, Y: y}] + + if ok { + node.Up = neighbour + neighbour.Down = node + break + } + + if y > 0 && (*Data)[y][node.Coords.X] == WallChar { + y++ + if y == node.Coords.Y { + break + } + coords := maze.Coordinates{X: node.Coords.X, Y: y} + new_node := maze.NewNode(coords) + lookupNeighbourLeft(&(*Data)[y], new_node, nodesByCoord) + lookupNeighbourRight(&(*Data)[y], new_node, nodesByCoord) + (*nodesByCoord)[coords] = new_node + m.Nodes = append(m.Nodes, new_node) + + node.Up = new_node + new_node.Down = node + break + } + + } +} + +func lookupNeighbourLeft(line *string, node *maze.Node, nodesByCoord *map[maze.Coordinates]*maze.Node) { + for x := node.Coords.X - 1; x > 0; x-- { + if (*line)[x] == WallChar && x < node.Coords.X-1 { + panic(fmt.Sprintf("Found no node before wall while looking to the left at neighbours of node %v", node)) + } + + neighbour, ok := (*nodesByCoord)[maze.Coordinates{X: x, Y: node.Coords.Y}] + if ok { + node.Left = neighbour + neighbour.Right = node + break + } + } +} + +func lookupNeighbourRight(line *string, node *maze.Node, nodesByCoord *map[maze.Coordinates]*maze.Node) { + for x := node.Coords.X + 1; x < len(*line); x++ { + if (*line)[x] == WallChar { + panic(fmt.Sprintf("Found no node before wall while looking to the right at neighbours of node %v", node)) + } + + neighbour, ok := (*nodesByCoord)[maze.Coordinates{X: x, Y: node.Coords.Y}] + if ok { + node.Right = neighbour + neighbour.Left = node + break + } + } +} diff --git a/io/reader/text_test.go b/maze/parser/parser_test.go similarity index 52% rename from io/reader/text_test.go rename to maze/parser/parser_test.go index 8386db7..1ae878d 100644 --- a/io/reader/text_test.go +++ b/maze/parser/parser_test.go @@ -1,13 +1,15 @@ -package reader +package parser import ( "fmt" + "maze-solver/io/reader" "maze-solver/maze" "maze-solver/utils" "testing" ) func TestTextReadTrivial(t *testing.T) { + fmt.Println("---------- Trivial ----------") /* trivial.txt ## ## # # @@ -41,14 +43,14 @@ func TestTextReadTrivial(t *testing.T) { nodes[4].Up = nodes[3] - reader := TextReader{ + reader := reader.TextReader{ + Filename: "../../assets/trivial.txt", PathChar: ' ', WallChar: '#', } - filename := "../../assets/trivial.txt" - got, err := reader.Read(filename) - utils.Check(err, "Couldn't create maze from %q", filename) + got, err := Parse(reader) + utils.Check(err, "Couldn't create maze from %q", reader.Filename) if len(nodes) != len(got.Nodes) { t.Fatalf("Didn't get the same size of nodes: %v, want %v", len(got.Nodes), len(nodes)) @@ -66,6 +68,7 @@ func TestTextReadTrivial(t *testing.T) { } func TestTextReadTrivialBigger(t *testing.T) { + fmt.Println("---------- Trivial Bigger ----------") /* trivial-bigger.txt ### ### ### ### @@ -103,14 +106,14 @@ func TestTextReadTrivialBigger(t *testing.T) { nodes[4].Up = nodes[3] - reader := TextReader{ + reader := reader.TextReader{ + Filename: "../../assets/trivial-bigger.txt", PathChar: ' ', WallChar: '#', } - filename := "../../assets/trivial-bigger.txt" - got, err := reader.Read(filename) - utils.Check(err, "Couldn't create maze from %q", filename) + got, err := Parse(reader) + utils.Check(err, "Couldn't create maze from %q", reader.Filename) if len(nodes) != len(got.Nodes) { t.Fatalf("Didn't get the same size of nodes: %v, want %v", len(got.Nodes), len(nodes)) @@ -132,6 +135,7 @@ func TestTextReadTrivialBigger(t *testing.T) { } func TestTextReadTrivialBiggerStaggered(t *testing.T) { + fmt.Println("---------- Trivial Staggered ----------") /* trivial-bigger-staggered.txt ### ### ### ### @@ -146,7 +150,6 @@ func TestTextReadTrivialBiggerStaggered(t *testing.T) { #### ## ####5## */ - fmt.Println("---------- STAGGERED ----------") nodes := make([]*maze.Node, 6) nodes[0] = maze.NewNode(maze.Coordinates{X: 3, Y: 0}) @@ -175,14 +178,14 @@ func TestTextReadTrivialBiggerStaggered(t *testing.T) { nodes[5].Up = nodes[4] - reader := TextReader{ + reader := reader.TextReader{ + Filename: "../../assets/trivial-bigger-staggered.txt", PathChar: ' ', WallChar: '#', } - filename := "../../assets/trivial-bigger-staggered.txt" - got, err := reader.Read(filename) - utils.Check(err, "Couldn't create maze from %q", filename) + got, err := Parse(reader) + utils.Check(err, "Couldn't create maze from %q", reader.Filename) if len(nodes) != len(got.Nodes) { t.Fatalf("Didn't get the same size of nodes: %v, want %v", len(got.Nodes), len(nodes)) @@ -203,6 +206,169 @@ func TestTextReadTrivialBiggerStaggered(t *testing.T) { } } +func TestTextReadNormal(t *testing.T) { + return + fmt.Println("---------- Normal ----------") + /* trivial-bigger-staggered.txt + ##### ##### + # # # + ##### ### # + # # # + # # ##### # + # # # + ### ### # # + # # # # + # ####### # + # # # + ##### ##### + + Nodes are + #####0##### + #1 2#3 4# + ##### ### # + #5 6#7 8# + # # ##### # + #9#A G B# + ### ### # # + #C D#E F# # + # ####### # + #H I#J K# + #####L##### + */ + // TODO: we are not detecting vertical dead-ends that go downwards + nodes := make([]*maze.Node, 22) + + // ---- Node creation ---- + coords := []struct{ x, y int }{ + {5, 0}, // 0 + + {1, 1}, // 1 + {5, 1}, // 2 + {7, 1}, // 3 + {9, 1}, // 4 + + {1, 3}, // 5 + {3, 3}, // 6 + {5, 3}, // 7 + {9, 3}, // 8 + + {1, 5}, // 9 + {3, 5}, // A (10) + {7, 5}, // G (16) + {9, 5}, // B (11) + + {1, 7}, // C (12) + {3, 7}, // D (13) + {5, 7}, // E (14) + {7, 7}, // F (15) + + {1, 9}, // H (17) + {5, 9}, // I (18) + {7, 9}, // J (19) + {9, 9}, // K (20) + + {5, 10}, // L (21) + } + + for i, coord := range coords { + nodes[i] = maze.NewNode(maze.Coordinates{X: coord.x, Y: coord.y}) + } + + // ---- Node linking ---- + nodes[0].Down = nodes[2] + + nodes[1].Right = nodes[2] + + nodes[2].Up = nodes[0] + nodes[2].Left = nodes[1] + nodes[2].Down = nodes[7] + + nodes[3].Right = nodes[4] + + nodes[4].Left = nodes[3] + nodes[4].Down = nodes[8] + + nodes[5].Right = nodes[6] + nodes[5].Down = nodes[9] + + nodes[6].Left = nodes[5] + nodes[6].Down = nodes[10] + + nodes[7].Right = nodes[8] + + nodes[8].Up = nodes[4] + nodes[8].Left = nodes[7] + nodes[8].Down = nodes[11] + + nodes[9].Up = nodes[5] + + nodes[10].Up = nodes[6] + nodes[10].Right = nodes[16] + nodes[10].Down = nodes[13] + + nodes[11].Up = nodes[6] + nodes[11].Right = nodes[16] + nodes[11].Down = nodes[20] + + nodes[12].Right = nodes[13] + nodes[12].Down = nodes[17] + + nodes[13].Up = nodes[10] + nodes[13].Left = nodes[16] + + nodes[14].Right = nodes[15] + + nodes[15].Up = nodes[16] + nodes[15].Left = nodes[14] + + nodes[16].Left = nodes[10] + nodes[16].Right = nodes[11] + nodes[16].Down = nodes[15] + + nodes[17].Up = nodes[12] + nodes[17].Right = nodes[18] + + nodes[18].Left = nodes[17] + nodes[18].Down = nodes[21] + + nodes[19].Right = nodes[20] + + nodes[20].Up = nodes[11] + nodes[20].Left = nodes[19] + + nodes[21].Up = nodes[20] + + reader := reader.TextReader{ + Filename: "../../assets/normal.txt", + PathChar: ' ', + WallChar: '#', + } + + got, err := Parse(reader) + utils.Check(err, "Couldn't create maze from %q", reader.Filename) + + 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 _, node := range got.Nodes { + fmt.Println(node) + } + + 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 { return