Create 3D maze in an array

This code has been declared by its author to be Public Domain code.

Create 3D maze in an array by Zethrax

2015

*** Blitz3D Code ***

This library uses Wilson's algorithm to create a 3D (cuboid) maze of a specified width, height, and depth.
The maze will be fully connected (no isolated sections or unconnected cells) and will not contain any loops.
The maze is stored in the 'A_maze' array with data for the maze cells stored in 'T_maze_cell' custom type objects.

EXTERNAL LIBRARY FUNCTIONS:-
SetupMaze - Creates a blank maze and initializes it. Call this before calling 'GenerateMaze'.
GenerateMaze - Generates the maze structure (the connections between cells). Call this after calling 'SetupMaze'.
DestroyMaze - Destroys the maze to free up the memory used by it.

INTERNAL LIBRARY FUNCTIONS:-
DoRandomWalk - Called by 'GenerateMaze' to create the paths for the maze.
ConnectMazeCells - Called by 'DoRandomWalk' to create connections between maze cells.

REQUIRES:-
T_maze_cell (type)
A_maze (array)
C_TOP, C_RIGHT, C_BOTTOM, C_LEFT (constants)
G_maze_width, G_maze_height, G_maze_depth (globals)

ADDITIONAL FUNCTIONS:-
SaveMaze - Saves the maze to a binary file. See the function's definition for the structure of the saved data.
LoadMaze - Loads a saved maze.
DrawMaze - Draws the maze with white lines representing horizontal connections, red squares representing upward connections, and blue squares representing downward connections.
CountEstablishedMazeCells - Counts the number of cells that have been added to the established maze structure. Just used for debugging, but I've left it in as it shows how to iterate the maze structure.

NOTES:-
The maze is a connected graph so there will be a path between any two cells in the maze. For the beginning and end of the maze just pick any two cells.
The number of cells in the array (width * height * depth) set in 'SetupMaze' must be larger than the value set for 'start_limit' in 'GenerateMaze'.
Note that 0, 0, 0 in the array is at the left-bottom-back position in the maze. Looking at the maze face-on the front is the side nearest the observer. This means that the 3D world Z axis will need to be inverted when translating into 3D space (the front will be Z+ and the back will be Z- in 3D world space).

REFERENCES:-
Wilson’s algorithm
http://bl.ocks.org/mbostock/11357811
http://www.pixieland.org.uk/2014/wilsons-algorithm/
https://eventuallyalmosteverywhere.wordpress.com/tag/wilsons-algorithm/
http://en.wikipedia.org/wiki/Loop-erased_random_walk

Minimum spanning tree (with decent definitions and summary) (BlitzMax code)
http://www.blitzbasic.com/codearcs/codearcs.php?code=2870

Some interesting summaries of maze algorithms
http://www.astrolog.org/labyrnth/algrithm.htm

; This library uses Wilson's algorithm to create a 3D (cuboid) maze of a specified width, height, and depth.
; The maze will be fully connected (no isolated sections or unconnected cells) and will not contain any loops.
; The maze is stored in the 'A_maze' array with data for the maze cells stored in 'T_maze_cell' custom type objects.
; 
; 
; EXTERNAL LIBRARY FUNCTIONS:-
; SetupMaze - Creates a blank maze and initializes it. Call this before calling 'GenerateMaze'.
; GenerateMaze - Generates the maze structure (the connections between cells). Call this after calling 'SetupMaze'.
; DestroyMaze - Destroys the maze to free up the memory used by it.
; 
; INTERNAL LIBRARY FUNCTIONS:-
; DoRandomWalk - Called by 'GenerateMaze' to create the paths for the maze.
; ConnectMazeCells - Called by 'DoRandomWalk' to create connections between maze cells.
; 
; REQUIRES:-
; T_maze_cell (type)
; A_maze (array)
; C_TOP, C_RIGHT, C_BOTTOM, C_LEFT (constants)
; G_maze_width, G_maze_height, G_maze_depth (globals)
; 
; ADDITIONAL FUNCTIONS:-
; SaveMaze - Saves the maze to a binary file. See the function's definition for the structure of the saved data.
; LoadMaze - Loads a saved maze.
; DrawMaze - Draws the maze with white lines representing horizontal connections, red squares representing upward connections, and blue squares representing downward connections.
; CountEstablishedMazeCells - Counts the number of cells that have been added to the established maze structure. Just used for debugging, but I've left it in as it shows how to iterate the maze structure.
; 
; NOTES:-
; The maze is a connected graph so there will be a path between any two cells in the maze. For the beginning and end of the maze just pick any two cells.
; The number of cells in the array (width * height * depth) set in 'SetupMaze' must be larger than the value set for 'start_limit' in 'GenerateMaze'.
; Note that 0, 0, 0 in the array is at the left-bottom-back position in the maze. Looking at the maze face-on the front is the side nearest the observer. This means that the 3D world Z axis will need to be inverted when translating into 3D space (the front will be Z+ and the back will be Z- in 3D world space).
; 
; REFERENCES:-
; Wilson’s algorithm
; <a href="http://bl.ocks.org/mbostock/11357811" target="_blank">http://bl.ocks.org/mbostock/11357811</a>
; <a href="http://www.pixieland.org.uk/2014/wilsons-algorithm/" target="_blank">http://www.pixieland.org.uk/2014/wilsons-algorithm/</a>
; <a href="https://eventuallyalmosteverywhere.wordpress.com/tag/wilsons-algorithm/" target="_blank">https://eventuallyalmosteverywhere.wordpress.com/tag/wilsons-algorithm/</a>
; <a href="http://en.wikipedia.org/wiki/Loop-erased_random_walk" target="_blank">http://en.wikipedia.org/wiki/Loop-erased_random_walk</a>
; 
; Minimum spanning tree (with decent definitions and summary) (BlitzMax code)
; <a href="http://www.blitzbasic.com/codearcs/codearcs.php?code=2870" target="_blank">http://www.blitzbasic.com/codearcs/codearcs.php?code=2870</a>
; 
; Some interesting summaries of maze algorithms
; <a href="http://www.astrolog.org/labyrnth/algrithm.htm" target="_blank">http://www.astrolog.org/labyrnth/algrithm.htm</a>



;----------



; Declare the constants used to index directional connections between maze cells.
Const C_RIGHT = 0 ; X+
Const C_LEFT = 1 ; X-
Const C_TOP = 2 ; Y+
Const C_BOTTOM = 3 ; Y-
Const C_FRONT = 4 ; Z+ (Note that the 3D world Z axis will need to be inverted when translating the maze into 3D world space (positioning 3D mesh models, etc).
Const C_BACK = 5 ; Z-


; Declare the type definition for the maze cells
Type T_maze_cell
	Field cell_type ; 0 = undefined. 1 = part of the established maze. 2 = part of a random walk path.
	Field x, y, z ; The coordinate of the cell within the maze array.
	Field connections.T_maze_cell[ 5 ] ; Connections with adjoining cells (Null = no connection). Slots: 0 = right, 1 = left, 2 = top, 3 = bottom, 4 = front, 5 = back.
	Field previous_cell.T_maze_cell ; The previous cell in a random walk path. Used to backtrack when erasing loops and adding a walk path to the maze.
End Type

; Declare the array used to store the maze cells. Note that 0, 0, 0 is at the left-bottom-back position in the maze. Looking at the maze face-on the front is the side nearest the observer.
Dim A_maze.T_maze_cell( 0, 0, 0 )

Global G_maze_width, G_maze_height, G_maze_depth ; Hold the width, height, and depth of the maze.



Function SetupMaze( width, height, depth, seed = 0 )
	; Creates and initializes the data objects that the 3D maze will be stored in.
	; No actual maze structure is created by this function. 'GenerateMaze' should be called after this function to generate the maze structure.

	; PARAMETERS:-
	; width - The width of the maze (the total number of cells on the X axis of the maze array).
	; height - The height of the maze (the total number of cells on the Y axis of the maze array).
	; depth - The height of the maze (the total number of cells on the Z axis of the maze array).
	; seed - The value to use when seeding the random number generator. 0 = Don't set a new random seed.

	; RETURNS:-
	; Nothing is returned by this function.
	
	; NOTES:-
	; This function can be called with an existing maze to clear all its data and resize the maze (if required) in preparation for generating a new maze.

	If seed Then SeedRnd seed ; Seed the random number generator if 'seed' is non-zero.
	Delete Each T_maze_cell ; Delete any existing maze cells from a previously created maze.
	G_maze_width = width
	G_maze_height = height
	G_maze_depth = depth
	Local xmax = width - 1, ymax = height - 1, zmax = depth - 1
	Local x, y, z, maze_cell.T_maze_cell	
	Dim A_maze( xmax, ymax, zmax ) ; Dimension the array used to store the maze cells.
	
	; Setup and initialize the maze array.
	For z = 0 To zmax
		For y = 0 To ymax
			For x = 0 To xmax
				maze_cell = New T_maze_cell
				A_maze( x, y, z ) = maze_cell
				maze_cell\x = x
				maze_cell\y = y
				maze_cell\z = z
			Next
		Next
	Next
End Function



Function GenerateMaze( start_limit = 100, mode = 0 )
; Generates the structure of the 3d maze.
; The 'SetupMaze' function or a substitute helper function should have been called first to create the maze.
; If you want to generate a new maze to overwrite an existing one then 'SetupMaze' should be called first to clear the data in the existing maze. Calling 'GenerateMaze' directly won't work as the maze will still have data left over from the previous maze.

; PARAMETERS:-
; start_limit - The length of the starting path. Must be less than the total number of cells in the array. If this is a zero then its value will be set using the width parameter. If this is a negative number then it will be assumed that the starting path has been created by a helper function and that this contains the length of that starting path as a negative number.
; mode - 0 = Randomly select the start point for the walk paths. 1 = Search for the first undefined cell found for the walk paths. Mode 1 seems to be several times faster (with debug mode disabled).

; RETURNS:-
; Nothing is returned by this function.


Local xmax = G_maze_width - 1, ymax = G_maze_height - 1, zmax = G_maze_depth - 1, sx, sy, sz, x, y, z, do_exit

Local num_undefined_cells = G_maze_width * G_maze_height * G_maze_depth ; Calculate and store the total number of cells in the array. Once this counts down to zero the function is finished.

If start_limit = 0 Then start_limit = G_maze_width ; If start_limit is a zero then set its value using the width parameter.

If start_limit > 0 ; start_limit is a positive number so the starting path has not yet been created by a helper function.
	Select mode
		Case 0 ; Start the first path from a random point.
			sx = Rand( 0, xmax ) : sy = Rand( 0, ymax ) : sz = Rand( 0, zmax )  ; You can replace this select block with this line if you just want to start the path from a random point.
		Case 1 ; Start the first path from the top-left corner (0, 0).
			sx = 0 : sy = 0 : sz = 0 ; You can replace this select block with this line if you just want to start the path from the top-left corner.
	End Select	
	; Generate a starting walk path with a specific number of cells.
	num_undefined_cells = num_undefined_cells - DoRandomWalk( sx, sy, sz, start_limit )
Else ; start_limit is a negative number so the starting path has already been created by a helper function.
	num_undefined_cells = num_undefined_cells + start_limit ; start_limit holds the length of the starting path created by a helper function as a negative number, so we just add it to num_undefined_cells.
EndIf

Local search_x = 0, search_y = 0, search_z = 0 ; Variables used to store the start of a new search for a start point the new walk path.

While num_undefined_cells > 0

	Select mode
	
		Case 0 ; Start the new path from a randomly selected undefined cell.
			; -- You can replace this select block with the code below if you just want to start the new path from a randomly selected undefined cell.
			Repeat
				sx = Rand( 0, xmax ) : sy = Rand( 0, ymax ) : sz = Rand( 0, zmax )
			Until A_maze( sx, sy, sz )\cell_type = 0
			;---
			
		Case 1 ; Start the new path from the first undefined cell found in the array.
			 ; -- You can replace this select block with the code below if you just want to start the new path from the first undefined cell found in the array.
			do_exit = False
			For z = search_z To zmax
				For y = search_y To ymax
					For x = search_x To xmax
						If A_maze( x, y, z )\cell_type = 0
							sx = x : sy = y : sz = z
							search_x = x : search_y = y : search_z = z
							do_exit = True
							Exit
						EndIf
					Next
					If do_exit
						Exit
					Else
						search_x = 0
					EndIf
				Next				
				If do_exit
					Exit
				Else
					search_y = 0
				EndIf
			Next
			;---
			
	End Select
		
	; Do the random walk until the path reconnects with the established maze.
	num_undefined_cells = num_undefined_cells - DoRandomWalk( sx, sy, sz )
Wend

; At this point the maze should be finished.

End Function



Function DoRandomWalk( x, y, z, limit = 0 )
	; This function does a loop-erased random walk operation.
	; Called by 'GenerateMaze' when generating the structure of the maze.
	
	; PARAMETERS:-
	; x, y, z - The coordinates of the maze cell to begin the random walk operation at. It will be assumed that this cell has already been confirmed as being undefined.
	; limit - (0 = unlimited) The limit on the number of cells the path can grow to. Once this limit is reached the function exits. This is used when establishing the first path in the maze.
	
	; RETURNS:-
	; (Int) The number of new cells added to the maze is returned.

	Local xmax = G_maze_width - 1
	Local ymax = G_maze_height - 1
	Local zmax = G_maze_depth - 1
	Local nx, ny, nz, nextcell_id, cell_type
	Local current_cell.T_maze_cell, prev_cell.T_maze_cell, restart_cell.T_maze_cell
	
	Local num_cells = 1 ; Set the cell counter to one to factor in the starting cell.
	
	A_maze( x, y, z )\cell_type = 2 ; Set the starting cell type to be a walk path type.
	
	Repeat
			
		
		nextcell_id = Rand( 0, 5 )
		Select nextcell_id
			Case C_RIGHT ; Right adjoining cell.
				nx = x + 1
				ny = y
				nz = z
			Case C_LEFT ; Left adjoining cell.
				nx = x - 1
				ny = y
				nz = z
			Case C_TOP; Top adjoining cell.
				nx = x
				ny = y + 1
				nz = z
			Case C_BOTTOM ; Bottom adjoining cell.
				nx = x
				ny = y - 1
				nz = z
			Case C_FRONT; Front adjoining cell.
				nx = x
				ny = y
				nz = z + 1
			Case C_BACK ; Back adjoining cell.
				nx = x
				ny = y
				nz = z - 1
		End Select
	
		If ( ( nx >= 0 ) And ( nx <= xmax ) ) And ( ( ny >= 0 ) And ( ny <= ymax ) ) And ( ( nz >= 0 ) And ( nz <= zmax ) ) ; If the coordinates for the new adjoining cell are within the bounds of the array...
		
			If A_maze( nx, ny, nz ) <> A_maze( x, y, z )\previous_cell ; If the new adjoining cell is not a double-back to the cell on the path before the current one...
			
				cell_type = A_maze( nx, ny, nz )\cell_type
	
				; - Manage the cell count limiter for the first path set in the maze.
				If limit ; If the specified limit is non-zero (a zero limit flags that there is no limit).
					If cell_type <> 2 ; If the path hasn't looped...
						If num_cells = limit - 1 ; If the specified cell count limit has been reached... (The limit needs to be -1 as the current cell has not yet been added to the count.)
							cell_type = 1 ; Force the path to be set as the beginning of the established maze.
							num_cells = num_cells + 1 ; Add the current cell to the count. This needs to be added here instead of in 'Case 1' below as additional random walks will add the cell from the established maze to the walk path - which would throw off the count. 
						EndIf
					EndIf
				EndIf
				
				Select cell_type ; Select an action depending on the cell type of the selected adjoining cell.
				
					Case 0 ; New cell type is undefined.
						; Add the new cell to the walk path.
						A_maze( nx, ny, nz )\cell_type = 2 ; Set the cell type to be a walk path type.
						A_maze( nx, ny, nz )\previous_cell = A_maze( x, y, z ) ; Store a link back to the current (now previous) cell in the walk path.
						x = nx : y = ny : z = nz ; Set the new cell to be the current cell.
						num_cells = num_cells + 1 ; Increment the cell count for the walk path.
						
					Case 1 ; New cell type is part of the established maze.
						; Set all the cells in the walk path to be part of the established maze and then set a flag to exit the function.
						A_maze( nx, ny, nz )\previous_cell = A_maze( x, y, z ) ; Link the cell found from the established maze to the walk path so that its connections will be updated to join with the path.
						current_cell = A_maze( nx, ny, nz ) ; Set the walk path integration to start with the cell found from the established maze.					
						Repeat ; Work back along the walk path while integrating the cells in the walk path with the established maze.
							prev_cell = current_cell\previous_cell ; Grab the link to the previous cell. This can potentially be a null link.
							current_cell\previous_cell = Null ; Null the pointer to the previous cell to avoid conflicts.
							current_cell\cell_type = 1 ; Set the cell type to be part of the established maze.
							If prev_cell <> Null Then ConnectMazeCells( current_cell, prev_cell ) ; If we're not at the end of the path then connect the current cell with the previos cell in the walk path.
							current_cell = prev_cell ; Move to the next cell back along the walk path. If the cell doesn't exist then 'current_cell' will end up with a null value.
						Until current_cell = Null ; The starting cell in the walk path has been found and updated, so exit the loop.
						Exit ; Exit the loop and function.; The adjoining cell was within the array bounds and not a double-back so exit the current loop.
						
					Case 2 ; New cell type is part of a random walk path.
						; Erase the resulting loop.
						; Note that nx and ny will hold the index to the cell that was looped back onto (the random walk will begin again from this cell once the loop has been erased).
						; Note that no connections will have been set for cells in the walk path yet, so there is no need to erase them.
						current_cell = A_maze( x, y, z ) ; Set the loop erasure to start with the current cell.
						restart_cell = A_maze( nx, ny, nz ) ; Grab the link to the cell to restart the walk operation at. Mostly because it's quicker and cleaner using this than an array access.
						x = nx : y = ny : z = nz ; Set the coordinates of the cell to restart the walk operation at.
						Repeat
							prev_cell = current_cell\previous_cell ; Grab the link to the previous cell.
							current_cell\previous_cell = Null ; Null the pointer to the previous cell to avoid conflicts.
							current_cell\cell_type = 0 ; Set the cell type back to undefined.
							current_cell = prev_cell ; Move to the next cell back along the walk path.
							num_cells = num_cells - 1 ; Decrement the cell count for the walk path.
						Until current_cell = restart_cell ; All the cells in the looped section of the walk path have been erased, so exit the loop.
				End Select
				
			EndIf
			
		EndIf
		
	Forever
	
	
	Return num_cells
End Function



Function ConnectMazeCells( cell_1.T_maze_cell, cell_2.T_maze_cell )
	Local x1 = cell_1\x, y1 = cell_1\y, z1 = cell_1\z
	Local x2 = cell_2\x, y2 = cell_2\y, z2 = cell_2\z
	
	If ( x2 > x1 ) And ( y2 = y1 ) And ( z2 = z1 ) ; cell_2 is to the right of cell_1 (X+).
		cell_1\connections[ C_RIGHT ] = cell_2
		cell_2\connections[ C_LEFT ] = cell_1
		Return
	EndIf
	
	If ( x2 < x1 ) And ( y2 = y1 ) And ( z2 = z1 ) ; cell_2 is to the left of cell_1 (X-).
		cell_1\connections[ C_LEFT ] = cell_2
		cell_2\connections[ C_RIGHT ] = cell_1
		Return
	EndIf
	
	If ( x2 = x1 ) And ( y2 > y1 ) And ( z2 = z1 ) ; cell_2 is on top of cell_1 (Y+).
		cell_1\connections[ C_TOP ] = cell_2
		cell_2\connections[ C_BOTTOM ] = cell_1
		Return
	EndIf
	
	If ( x2 = x1 ) And ( y2 < y1 ) And ( z2 = z1 ) ; cell_2 is on the bottom of cell_1 (Y-).
		cell_1\connections[ C_BOTTOM ] = cell_2
		cell_2\connections[ C_TOP ] = cell_1
		Return
	EndIf
	
	If ( x2 = x1 ) And ( y2 = y1 ) And ( z2 > z1 ) ; cell_2 is in front of cell_1 (Z+).
		cell_1\connections[ C_FRONT ] = cell_2
		cell_2\connections[ C_BACK ] = cell_1
		Return
	EndIf
	
	If ( x2 = x1 ) And ( y2 = y1 ) And ( z2 < z1 ) ; cell_2 is at the back of cell_1 (Z-).
		cell_1\connections[ C_BACK ] = cell_2
		cell_2\connections[ C_FRONT ] = cell_1
		Return
	EndIf
End Function



Function DestroyMaze()
	; Destroys the maze to free up the memory used by it.
	; This function can be called irregardless of whether a maze was previously created.

	Delete Each T_maze_cell ; Delete all the maze cells.
	Dim A_maze( 0, 0, 0 ) ; Re-dimension the maze array back to its minimum size.
End Function



; === DEMO and HELPER FUNCTIONS ===



Function SaveMaze( filepath$ )
	; Saves the maze to the specified file as binary data.
	; Returns a zero if there was a file error, or non-zero for a successful operation.
	; The first integer holds the maze width. The second integer holds the maze height. The third integer holds the maze depth.
	; The remaining byte values hold the connections from the current maze cell to its adjoining cells.
	; Bit 0 (value=1) - Connection exists to cell to the right of the current one (x+1, y, z).
	; Bit 1 (value=2) - Connection exists to cell to the left of the current one (x-1, y, z).
	; Bit 2 (value=4) - Connection exists to cell above the current one (x, y+1, z).
	; Bit 3 (value=8) - Connection exists to cell below the current one (x, y-1, z).
	; Bit 4 (value=16) - Connection exists to cell in front of the current one (x, y, z+1).
	; Bit 5 (value=32) - Connection exists to cell behind of the current one (x, y, z-1).
	; Note that for a hyperthetical observer viewing the maze array face-on the front of the maze (Z+) would be the side directly facing them, the back (Z-) would be the side facing away from them, and the 0, 0, 0 block in the maze would be in the left-bottom-back corner.
	
	
	Local xmax = G_maze_width - 1
	Local ymax = G_maze_height - 1
	Local zmax = G_maze_depth - 1
	Local x, y, z, file, v
	
	file = WriteFile( filepath$ )
	If file
		WriteInt file, G_maze_width ; Store the maze width.
		WriteInt file, G_maze_height ; Store the maze height.
		WriteInt file, G_maze_depth ; Store the maze depth.
		; Store the maze cell connections.
		For z = 0 To zmax
			For y = 0 To ymax
				For x = 0 To xmax
					v = 0
					If A_maze( x, y, z )\connections[ 0 ] <> Null Then v = v + 1 ; right
					If A_maze( x, y, z )\connections[ 1 ] <> Null Then v = v + 2 ; left
					If A_maze( x, y, z )\connections[ 2 ] <> Null Then v = v + 4 ; up
					If A_maze( x, y, z )\connections[ 3 ] <> Null Then v = v + 8 ; down
					If A_maze( x, y, z )\connections[ 4 ] <> Null Then v = v + 16 ; front
					If A_maze( x, y, z )\connections[ 5 ] <> Null Then v = v + 32 ; back
					WriteByte( file, v )
				Next
			Next
		Next
		CloseFile file
	EndIf
	Return file
End Function



Function LoadMaze( filepath$ )
	; Loads the maze data from the specified file and uses it to create the maze.
	; The maze data file is in the format described in the 'SaveMaze' function.
	; Returns a zero if there was a file error, or non-zero for a successful operation.
	
	Local xmax, ymax, zmax, x, y, z, file, v

	file = ReadFile( filepath$ )
	If file
		xmax = ReadInt( file ) ; Load the maze width.
		ymax = ReadInt( file ) ; Load the maze height.
		zmax = ReadInt( file ) ; Load the maze depth.
		
		SetupMaze( xmax, ymax, zmax )
		
		xmax = G_maze_width - 1
		ymax = G_maze_height - 1
		zmax = G_maze_depth - 1
		
		For z = 0 To zmax
			For y = 0 To ymax
				For x = 0 To xmax
					v = ReadByte( file )
					If v And 1 Then A_maze( x, y, z )\connections[ 0 ] = A_maze( x + 1, y, z ) ; right
					If v And 2 Then A_maze( x, y, z )\connections[ 1 ] = A_maze( x - 1, y, z ) ; left
					If v And 4 Then A_maze( x, y, z )\connections[ 2 ] = A_maze( x, y + 1, z ) ; up
					If v And 8 Then A_maze( x, y, z )\connections[ 3 ] = A_maze( x, y - 1, z ) ; down
					If v And 16 Then A_maze( x, y, z )\connections[ 4 ] = A_maze( x, y, z + 1 ) ; front
					If v And 32 Then A_maze( x, y, z )\connections[ 5 ] = A_maze( x, y, z - 1 ) ; back
					A_maze( x, y, z )\cell_type = 1
					A_maze( x, y, z )\x = x
					A_maze( x, y, z )\y = y
					A_maze( x, y, z )\z = z
				Next
			Next
		Next
		CloseFile file
	EndIf
	Return file
End Function



Function DrawMaze( layer )
	; Draws the maze.
	; Note that this function draws the maze structure as a set of lines. The lines are the maze structure, not the space between the lines.
	; White lines show horizontal maze connections.
	; Red squares show upward maze connections. Blue dots show downward maze connections.

	Local xmax = G_maze_width - 1
	Local zmax = G_maze_depth - 1
	Local dx, dz
	Local x1, z1, x2, z2

	; -- Draw horizontal connections.
	Color 255,255,255	
	For z = 0 To zmax
		For x = 0 To xmax
			dx = x * 13 + 6
			dz = z * 13 + 6
			
			If A_maze( x, layer, z )\connections[ 0 ] <> Null ; right (X+)
				Line dx, dz, dx + 13, dz
			EndIf
			
			If A_maze( x, layer, z )\connections[ 1 ] <> Null ; left (X-)
				Line dx, dz, dx - 13, dz
			EndIf
			
			If A_maze( x, layer, z )\connections[ 4 ] <> Null ; front (Z+)
				Line dx, dz, dx, dz + 13
			EndIf
			
			If A_maze( x, layer, z )\connections[ 5 ] <> Null ; back (Z-)
				Line dx, dz, dx, dz - 13
			EndIf
		Next
	Next
	;------

	; -- Draw vertical connections.
	For z = 0 To zmax
		For x = 0 To xmax
			dx = x * 13 + 6
			dz = z * 13 + 6
			
			If A_maze( x, layer, z )\connections[ 2 ] <> Null ; up (Y+)
				Color 255,0,0
				Rect dx - 4, dz - 4, 9, 9, False
			EndIf
			
			If A_maze( x, layer, z )\connections[ 3 ] <> Null ; down (Y-)
				Color 0,128,255
				Rect dx - 2, dz - 2, 5, 5, True
			EndIf
		Next
	Next
	;------
End Function



Function CountEstablishedMazeCells()
	; Counts the number of maze cells that have been set as part of the established maze and returns the count.
	
	Local xmax = G_maze_width - 1
	Local ymax = G_maze_height - 1
	Local zmax = G_maze_depth - 1
	Local counter = 0, x, y, z

	For z = 0 To zmax
		For y = 0 To ymax
			For x = 0 To xmax
				If A_maze( x, y, z )\cell_type = 1 Then counter = counter + 1
			Next
		Next
	Next
	Return counter
End Function



; === DEMO CODE ===



Global G_timer = CreateTimer( 60 )

; Set the width, height, and depth of the maze.
maze_width = 32
maze_height = 32
maze_depth = 32


Graphics 800, 600, 0, 2

; Setup and initialize the maze (no structure is created for the maze). Run this before 'GenerateMaze'.
SetupMaze( maze_width, maze_height, maze_depth, MilliSecs() ) ; width, height, depth, random seed

; Generate the structure of the maze. Run this after 'SetupMaze'.
GenerateMaze( 100, 1 ) ; length of starting path, path start point mode

; -- Draw the maze for the demo.
layer = 0
SetBuffer BackBuffer()
Repeat
	
	If KeyHit( 200 ) ; Up
		layer = layer + 1
		If layer > ( maze_width - 1 ) Then layer = 0
	EndIf
	If KeyHit( 208 ) ; Down
		layer = layer - 1
		If layer < 0 Then layer = maze_height - 1
	EndIf
	
	Cls
	DrawMaze( layer )
	Color 255,255,255
	linepos = maze_depth * 13 + 10
	Text 10, linepos, "Layer: " + layer : linepos = linepos + 20
	Text 10, linepos, "The diagram above shows the structure and connections of the generated 3D maze." : linepos = linepos + 20
	Text 10, linepos, "Use the UP and DOWN cursor keys to move up and down the displayed maze layers." : linepos = linepos + 20
	Text 10, linepos, "Note that layer 0 is the bottom layer and layer " + ( maze_height - 1 ) + " is the top layer." : linepos = linepos + 20
	Text 10, linepos, "White lines show horizontal maze connections." : linepos = linepos + 20
	Text 10, linepos, "Red squares show upward maze connections. Blue dots show downward maze connections." : linepos = linepos + 20
	
	Flip
	WaitTimer G_timer
Until KeyHit( 1 )
;------

; Loads a saved maze.
;LoadMaze( "mymaze.dat" )

; Saves an existing maze.
;SaveMaze( "mymaze.dat" )

; Destroys the maze to free up the memory used by it.
;DestroyMaze()

;WaitKey
End

Code can be found at: http://www.blitzbasic.com/codearcs/codearcs.php?code=3179

Comments

virtlands

2015

Your 3D maze code is fascinating...

Here are 4 sample screenshots taken (out of a possible 32 levels deep) ::

Red squares show upward maze connections.
Blue dots show downward maze connections.
White lines are horizontalish.

videz

2015

Looks interesting and it works now.

Code Archives Forum