R: Maze generation using grid

This page looks at maze generation in R using grid.

Here are links to a series on recursive maze generation and visualization

2021-02-19: Maze algorithm explanation using GIF images
2021-02-22: Lua: Maze generation with static SVG
2021-02-24: JavaScript: Maze generation with dynamic SVG
2021-02-27: JavaScript: Maze generation with dynamic SVG and D3
2021-02-25: R: Maze generation using grid (this page)
2021-03-04: Julia: Maze generation using Luxor
2021-02-26: Python: Maze generation using PIL
2021-03-04: Java: Maze generation using AWT
2021-03-02: C#: Maze generation

(more coming)

The grid package for R can be used for custom graphics. Here it is used to help create a recursively-generated maze.

R packages can be installed from R Studio or from the command line. Here is one way to install the R package grid from the Windows command line using the default Windows installation path for R.

"C:\Program Files\R\R-4.0.4\bin\Rscript.exe" -e "install.packages('grid', repos='https://cran.rstudio.com/')"

The repo parameter needs to be included and the single quotes need to be used inside the double quotes.
The path you use should include the installed version of R. The one here is 4.0.4. A Lua command line console program is now presented to create a maze as an image.

This may not be the best Lua program for this task, but is sufficient for the present purposes.

The global variable linesCount1 is used, in part to show how global variables can be used, when appropriate, as some languages require special handling or access mechanisms for global variables.

Here is a pseudo-code for the maze generation algorithm as described to make a maze of rows and columns.

Main: Start with an empty canvas. Outline the maze limits with an entry and exit point on opposite sides. Call MazeGenerate with the rows and columns to be filled in. MazeGenerate: If the rows and columns requested are both greater than 1 Then If the height is greater than the width Then Divide the grid into top and bottom parts. Draw a (horizontal) line between the parts, leaving a gap to pass through. Call MazeGenerate on the top part Call MazeGenerate on the bottom part Else Divide the grid into left and right parts. Draw a (vertical) line between the parts, leaving a gap to pass through. Call MazeGenerate on the left part Call MazeGenerate on the right part End If End If

The actual code fills in details that are not needed at the higher level of the algorithm description. For example, the side and gap lengths, and exact x and y coordinates are omitted. As another example, the division into parts can be done using pseudo-random numbers, but that is omitted from the algorithm.

For more information, see the following: Maze algorithm explanation using GIF images Here is the R code [#1]

library(grid)
linesCount1 <- 0
lineAdd1 <- function(n1, x1, y1, x2, y2) {
	if ((x1 != x2) || (y1 != y2)) {
		linesCount1 <<- linesCount1 + 1
		grid.lines(c(x1,x2),c(y1,y2),default.units="native",gp=gpar(col="#000000",lwd=2))
		cat(sprintf("%d. ( %d , %d ) to ( %d , %d )\n",linesCount1,x1,y1,x2,y2))
		}
	invisible()
	}
mazeMake2 <- function(n1, rlen1, clen1, side1, x1, y1) {
	if ((rlen1 <= 1) || (clen1 <= 1)) {
		invisible(return())
		}
	x3 <- x1+side1*clen1
	y3 <- y1+side1*rlen1
	n2 <- n1+1
	r1 <- runif(1)
	c1 <- runif(1)
	if (rlen1 > clen1) {
		cpos1 <- floor(c1*clen1)
		rpos1 <- floor(r1*(rlen1-1))+1
		x2 <- x1+side1*cpos1
		y2 <- y1+side1*rpos1
		lineAdd1(n2,x1,y2,x2,y2)
		lineAdd1(n2,x2+side1,y2,x3,y2)
		mazeMake2(n2,rpos1,clen1,side1,x1,y1)
		mazeMake2(n2,rlen1-rpos1,clen1,side1,x1,y2)
		}
	else {
		cpos1 <- floor(c1*(clen1-1))+1
		rpos1 <- floor(r1*rlen1)
		x2 <- x1+side1*cpos1
		y2 <- y1+side1*rpos1
		lineAdd1(n2,x2,y1,x2,y2)
		lineAdd1(n2,x2,y2+side1,x2,y3)
		mazeMake2(n2,rlen1,cpos1,side1,x1,y1)
		mazeMake2(n2,rlen1,clen1-cpos1,side1,x2,y1)
		}
	invisible()
	}
mazeMake1 <- function(rlen1, clen1, side1, gap1) {
	x1 <- side1*gap1
	y1 <- side1*gap1
	x3 <- x1+side1*clen1
	y3 <- y1+side1*rlen1
	lineAdd1(0,x1,y3,x3,y3)
	lineAdd1(0,x1,y1,x3,y1)
	lineAdd1(0,x1,y1,x1,y3-side1)
	lineAdd1(0,x3,y1+side1,x3,y3)
	mazeMake2(1,rlen1,clen1,side1,x1,y1)
	invisible()
	}
mazeMake0 <- function() {
	rlen1 <- 8
	clen1 <- 12
	side1 <- 10
	gap1 <- 1
	width1 <- side1*(gap1+clen1+gap1)
	height1 <- side1*(gap1+rlen1+gap1)
	linesCount1 <<- 0
	imageFs2 <- "D:\\W\\PROGRAM1.IMG\\rx.rx-82-01.png"
	cat(sprintf("Create a %d x %d image as \"%s\".\n",width1,height1,imageFs2))
	cat("\n")
	png(
		imageFs2,
		width=width1,
		height=height1
		)
	mazeMake1(rlen1,clen1,side1,gap1)
	invisible(dev.off())
	invisible()
	}
mazeMake0()

Here is the output of the R code.

Create a 140 x 100 image as "D:\W\PROGRAM1.IMG\rx.rx-82-01.png".
1. ( 10 , 90 ) to ( 130 , 90 )
2. ( 10 , 10 ) to ( 130 , 10 )
3. ( 10 , 10 ) to ( 10 , 80 )
4. ( 130 , 20 ) to ( 130 , 90 )
5. ( 40 , 20 ) to ( 40 , 90 )
6. ( 10 , 60 ) to ( 30 , 60 )
7. ( 10 , 50 ) to ( 30 , 50 )
8. ( 20 , 20 ) to ( 40 , 20 )
9. ( 20 , 20 ) to ( 20 , 40 )
10. ( 20 , 30 ) to ( 30 , 30 )
11. ( 30 , 30 ) to ( 30 , 40 )
12. ( 20 , 60 ) to ( 20 , 70 )
13. ( 20 , 80 ) to ( 20 , 90 )
14. ( 20 , 70 ) to ( 30 , 70 )
15. ( 30 , 70 ) to ( 30 , 80 )
16. ( 100 , 10 ) to ( 100 , 80 )
17. ( 40 , 30 ) to ( 90 , 30 )
18. ( 80 , 20 ) to ( 80 , 30 )
19. ( 50 , 10 ) to ( 50 , 20 )
20. ( 60 , 10 ) to ( 60 , 20 )
21. ( 70 , 10 ) to ( 70 , 20 )
22. ( 90 , 10 ) to ( 90 , 20 )
23. ( 50 , 30 ) to ( 50 , 60 )
24. ( 50 , 70 ) to ( 50 , 90 )
25. ( 50 , 60 ) to ( 80 , 60 )
26. ( 90 , 60 ) to ( 100 , 60 )
27. ( 90 , 30 ) to ( 90 , 40 )
28. ( 90 , 50 ) to ( 90 , 60 )
29. ( 70 , 40 ) to ( 70 , 60 )
30. ( 50 , 50 ) to ( 60 , 50 )
31. ( 60 , 40 ) to ( 60 , 50 )
32. ( 70 , 40 ) to ( 80 , 40 )
33. ( 80 , 40 ) to ( 80 , 50 )
34. ( 80 , 70 ) to ( 80 , 90 )
35. ( 70 , 60 ) to ( 70 , 80 )
36. ( 60 , 70 ) to ( 70 , 70 )
37. ( 60 , 70 ) to ( 60 , 80 )
38. ( 90 , 70 ) to ( 100 , 70 )
39. ( 90 , 80 ) to ( 90 , 90 )
40. ( 100 , 60 ) to ( 120 , 60 )
41. ( 100 , 30 ) to ( 110 , 30 )
42. ( 120 , 30 ) to ( 130 , 30 )
43. ( 120 , 10 ) to ( 120 , 20 )
44. ( 110 , 10 ) to ( 110 , 20 )
45. ( 120 , 30 ) to ( 120 , 40 )
46. ( 120 , 50 ) to ( 120 , 60 )
47. ( 110 , 40 ) to ( 120 , 40 )
48. ( 110 , 40 ) to ( 110 , 50 )
49. ( 120 , 70 ) to ( 120 , 90 )
50. ( 100 , 70 ) to ( 110 , 70 )
51. ( 110 , 70 ) to ( 110 , 80 )

Here is the image created by the R code. Maze

It was not clear how to cap the lines such that they appear more continuous (as can be done in PostScript and SVG).
Most variables are local so the "<-" assignment is used. For global variables, such as linesCount1, the "<<-" assignment operator is used.
The invisible() function is used to avoid having "ugly" output created. This can be done with return() statements.

The same code notes apply here as applied to the Lua code for the same problem at Lua: Maze generation with static SVG .