Java: Maze generation using AWT

This page uses Lua to do recursive maze generation using the AWT (Abstract Windows Toolkit)

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
2021-03-04: Julia: Maze generation using Luxor
2021-02-26: Python: Maze generation using PIL
2021-03-04: Java: Maze generation using AWT (this page)
2021-03-02: C#: Maze generation

(more coming) 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 Java code [#1]

import java.awt.BasicStroke;
import java.awt.Color;
import java.awt.GradientPaint;
import java.awt.Graphics2D;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.IOException;
import java.util.Random;
import javax.imageio.ImageIO;
public class jax21_01 {
	public int linesCount1 = 0;
	public Random random1 = new Random();
	public BufferedImage image1;
	public Graphics2D graphics1;
	public double rand() {
		double r1 = random1.nextDouble();
		return r1;
		}
	public void lineAdd1(int n1, int x1, int y1, int x2, int y2) {
		if ((x1 != x2) || (y1 != y2)) {
			linesCount1 += 1;
			graphics1.drawLine(x1,y1,x2,y2);
			System.out.print(String.format("%d. ( %d , %d ) to ( %d , %d )\n",linesCount1,x1,y1,x2,y2));
			}
		}
	public void mazeMake2(int n1, int rlen1, int clen1, int side1, int x1, int y1) {
		if ((rlen1 <= 1) || (clen1 <= 1)) {
			return;
			}
		int x3 = x1+side1*clen1;
		int y3 = y1+side1*rlen1;
		int n2 = n1+1;
		double r1 = rand();
		double c1 = rand();
		if (rlen1 > clen1) {
			int cpos1 = (int) (c1*clen1);
			int rpos1 = (int) (r1*(rlen1-1))+1;
			int x2 = x1+side1*cpos1;
			int 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 {
			int cpos1 = (int) (c1*(clen1-1))+1;
			int rpos1 = (int) (r1*rlen1);
			int x2 = x1+side1*cpos1;
			int 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);
			}
		}
	public void mazeMake1(int rlen1, int clen1, int side1, int gap1) {
		int x1 = side1*gap1;
		int y1 = side1*gap1;
		int x3 = x1+side1*clen1;
		int 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);
		}
	public void mazeMake0() {
		int rlen1 = 8;
		int clen1 = 12;
		int side1 = 10;
		int gap1 = 1;
		random1.setSeed(12345);
		int width1 = side1*(gap1+clen1+gap1);
		int height1 = side1*(gap1+rlen1+gap1);
		linesCount1 = 0;
		String imageFs2 = "D:\\W\\PROGRAM1.IMG\\jax.jax-21-01.png";
		System.out.print(String.format("Create a %d x %d image as \"%s\".\n",width1,height1,imageFs2));
		System.out.print("\n");
		image1 = new BufferedImage(width1,height1,BufferedImage.TYPE_INT_ARGB);
		graphics1 = image1.createGraphics();
		graphics1.setStroke(new BasicStroke(2));
		graphics1.setColor(new Color(0x00,0x00,0x00));
		mazeMake1(rlen1,clen1,side1,gap1);
		try {
			ImageIO.write(image1,"PNG",new File(imageFs2));
			}
		catch (Exception e) {
			System.out.print(String.format("Error creating image file \"%s\".\n",imageFs2));
			}
		}
	public jax21_01() {
		mazeMake0();
		}
	public static void main(String [] args) {
		new jax21_01();
		}
	}

Here is the output of the Java code.

Create a 140 x 100 image as "D:\W\PROGRAM1.IMG\jax.jax-21-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. ( 120 , 10 ) to ( 120 , 30 )
6. ( 120 , 40 ) to ( 120 , 90 )
7. ( 50 , 10 ) to ( 50 , 70 )
8. ( 50 , 80 ) to ( 50 , 90 )
9. ( 10 , 30 ) to ( 20 , 30 )
10. ( 30 , 30 ) to ( 50 , 30 )
11. ( 30 , 20 ) to ( 30 , 30 )
12. ( 20 , 20 ) to ( 20 , 30 )
13. ( 40 , 10 ) to ( 40 , 20 )
14. ( 10 , 80 ) to ( 20 , 80 )
15. ( 30 , 80 ) to ( 50 , 80 )
16. ( 10 , 50 ) to ( 30 , 50 )
17. ( 40 , 50 ) to ( 50 , 50 )
18. ( 30 , 30 ) to ( 30 , 40 )
19. ( 20 , 40 ) to ( 20 , 50 )
20. ( 40 , 40 ) to ( 40 , 50 )
21. ( 20 , 60 ) to ( 20 , 80 )
22. ( 30 , 50 ) to ( 30 , 70 )
23. ( 30 , 60 ) to ( 40 , 60 )
24. ( 40 , 70 ) to ( 40 , 80 )
25. ( 60 , 30 ) to ( 120 , 30 )
26. ( 90 , 20 ) to ( 90 , 30 )
27. ( 70 , 20 ) to ( 70 , 30 )
28. ( 60 , 10 ) to ( 60 , 20 )
29. ( 80 , 20 ) to ( 80 , 30 )
30. ( 110 , 10 ) to ( 110 , 20 )
31. ( 100 , 20 ) to ( 100 , 30 )
32. ( 80 , 30 ) to ( 80 , 70 )
33. ( 80 , 80 ) to ( 80 , 90 )
34. ( 50 , 40 ) to ( 60 , 40 )
35. ( 70 , 40 ) to ( 80 , 40 )
36. ( 50 , 70 ) to ( 70 , 70 )
37. ( 60 , 40 ) to ( 60 , 50 )
38. ( 60 , 60 ) to ( 60 , 70 )
39. ( 60 , 50 ) to ( 70 , 50 )
40. ( 70 , 60 ) to ( 70 , 70 )
41. ( 60 , 80 ) to ( 60 , 90 )
42. ( 70 , 70 ) to ( 70 , 80 )
43. ( 80 , 50 ) to ( 100 , 50 )
44. ( 110 , 50 ) to ( 120 , 50 )
45. ( 90 , 40 ) to ( 90 , 50 )
46. ( 110 , 30 ) to ( 110 , 40 )
47. ( 100 , 30 ) to ( 100 , 40 )
48. ( 110 , 50 ) to ( 110 , 70 )
49. ( 110 , 80 ) to ( 110 , 90 )
50. ( 80 , 80 ) to ( 90 , 80 )
51. ( 100 , 80 ) to ( 110 , 80 )
52. ( 100 , 50 ) to ( 100 , 60 )
53. ( 100 , 70 ) to ( 100 , 80 )
54. ( 80 , 70 ) to ( 90 , 70 )
55. ( 90 , 50 ) to ( 90 , 60 )

Here is the image created by the Java code. Maze