Maze Generation code

Monkey Forums/Monkey Code/Maze Generation code

Grey Alien

(Posted 2013) [#1]

I added maze generation to my latest minigame and have posted up all the code in my blog: http://greyaliengames.com/blog/maze-generation-code-in-monkey/

Paul - Taiphoz

(Posted 2013) [#2]

Left you a comment Jake.

therevills

(Posted 2013) [#3]

Nice - I think it would be better to post the code here ;)

Also when posting code on your site, can't you use the <code> tags?

(PS The language is now called Monkey X and I think BRL wants people to use the www.monkey-x.com domain from now on... ;))

AdamRedwoods

(Posted 2013) [#4]

nice!
here was mine:
http://monkeycoder.co.nz/Community/posts.php?topic=4536

impixi

(Posted 2013) [#5]

Well, a quick glance at Jake's code tells me it wouldn't be runnable as is: ccRand isn't a Monkey (or a Jake-provided) function - erm, is it? EDIT: Which is probably why he did not paste the code in this thread.

PS: My own maze generation code is in the archives too. Inside a function tucked away here: http://www.monkeycoder.co.nz/Community/posts.php?topic=374&post=49039

SLotman

(Posted 2013) [#6]

Why do walls are 'double sided'? (at least on the image posted, they all look like '##')
Isn't a waste of space/memory?

Also, I wouldn't use an 'ArrayUtil' - just array[x+y*width] to access the data ^_^

impixi

(Posted 2013) [#7]

Also, I wouldn't use an 'ArrayUtil' - just array[x+y*width] to access the data ^_^

He's using arrays of arrays to store the maze rooms, not a single dimensional array.

impixi

(Posted 2013) [#8]

Okay, here's Jake's code in a runnable example (a rough hack with fixed errors. Only works in RELEASE mode, otherwise my browser throws a syntax error on the generated JS code - that I don't have time to investigate right now):

Strict

Function Main:Int()

	Local maze:Level = New Level(16, 22)
	maze.ToString()

	Return 0
End

Class Level

	Field rooms:TRoom[][]
	Field width:Int = 10
	Field height:Int = 10
		
	Method New(width:Int, height:Int)
	
		self.width = width
		self.height = height
		GenerateRooms()
	
	End	
		
	Method GenerateRooms:Void()
		
		rooms = ArrayUtil<TRoom>.CreateArray(width, height) 'This makes a 2D Array
		
		'Create a room For each Array slot.
		For Local x:Int = 0 To width - 1
			For Local y:Int = 0 To height - 1
				Local r:TRoom = New TRoom
				r.x = x
				r.y = y
				rooms[x][y] = r
			Next
		Next
		
		'Make a maze
		Local x:Int = 0
		Local y:Int = 1
		Local roomStack:Stack<TRoom> = New Stack<TRoom>() 'stores rooms that have unvisited neighbours
		
		'Get a starting room
		Local r:TRoom = rooms[x][y]
		r.startRoom = 1
		
		'Create an exit room on an edge (after we’ve marked the start room)
		'First pick an an edge
		Local loop:Int = 1
		
		While loop
		
			Local edge:Int = Floor(Rnd(0, 3)) 'ccRand(0, 3) 'clockwise with 0 = North
			'Now pick a position on the edge. MarkAsExit returns false if the chosen room is the start room.
			Select edge
				Case 0
					If rooms[Floor(Rnd(0, width))][0].MarkAsExit(edge) Then loop = 0
				Case 1
					If rooms[width - 1][Floor(Rnd(0, height))].MarkAsExit(edge) Then loop = 0
				Case 2
					If rooms[Floor(Rnd(0, width))][height - 1].MarkAsExit(edge) Then loop = 0
				Case 3
				
				If rooms[0][Floor(Rnd(0, height))].MarkAsExit(edge) Then loop = 0
			End Select
		End While
		
		loop = 1
		While loop = 1
			r.generated = 1 'Mark this room as visited this room during the generation process.
		
			'Build list of ungenerated neighbours
			Local possibleRooms:List<TRoom> = New List<TRoom>()
			If x > 0 And rooms[x - 1][y].generated = 0 Then possibleRooms.AddLast(rooms[x - 1][y])
			If x < width - 1 And rooms[x + 1][y].generated = 0 Then possibleRooms.AddLast(rooms[x + 1][y])
			If y > 0 And rooms[x][y - 1].generated = 0 Then possibleRooms.AddLast(rooms[x][y - 1])
			If y < height - 1 And rooms[x][y + 1].generated = 0 Then possibleRooms.AddLast(rooms[x][y + 1])
		
			'Pick a destination room randomly
			If possibleRooms.Count() > 0 Then
			'Remove the wall (wall indexes are clockwise starting from 0=North)
			Local newRoom:TRoom = possibleRooms.ToArray()[Floor(Rnd(0, possibleRooms.Count()))]
			If x > newRoom.x Then
				r.walls[3] = 0
				newRoom.walls[1] = 0
			Elseif x < newRoom.x Then
				r.walls[1] = 0
				newRoom.walls[3] = 0
			Elseif y > newRoom.y Then
				r.walls[0] = 0
				newRoom.walls[2] = 0
				Elseif y < newRoom.y Then
				r.walls[2] = 0
				newRoom.walls[0] = 0
			Endif
		
		'Only store the current room if it has more than one desintation
		If possibleRooms.Count() > 1 Then roomStack.Push(r)
			r = newRoom
			x = r.x
			y = r.y
			'continue looping
		Else
		'There are no possible destinations so go back And get a room from the stack.
			If roomStack.Length() > 0 Then
				r = roomStack.Pop()
				x = r.x
				y = r.y
				'continue looping
			Else
			'We’ve run out of previous rooms so stop looping.
				loop = 0
			Endif
		Endif
		Wend
	End Method
	
	Method ToString:Void()	
	
		Print "MAZE GENERATED:"
		Local rows:String[height * 3]
		For Local y:Int = 0 To height - 1
			For Local x:Int = 0 To width - 1
				Local r:TRoom = rooms[x][y]
				If r.walls[0] Then
					rows[y * 3] += "###"
				Else
					rows[y * 3] += "# #"
				Endif
				If r.walls[3] Then
					rows[y * 3 + 1] += "#"
				Else
					rows[y * 3 + 1] += " "
				Endif
				If r.exitRoom > - 1 Then
					rows[y * 3 + 1] += "E"
				Else
					rows[y * 3 + 1] += " "
				Endif
				If r.walls[1] Then
					rows[y * 3 + 1] += "#"
				Else
					rows[y * 3 + 1] += " "
				Endif
				If r.walls[2] Then
					rows[y * 3 + 2] += "###"
				Else
					rows[y * 3 + 2] += "# #"
				Endif
			Next
			Print rows[y * 3]
			Print rows[y * 3 + 1]
			Print rows[y * 3 + 2]
		Next	
	End Method	
		
End Class


Class TRoom	
	Field exitRoom:Int
	Field generated:Int
	Field startRoom:Int
	Field x:Int
	Field y:Int
	Field walls:Int[] 'clockwise starting with North.

	Method MarkAsExit:Int(edge:Int)
		'Is this a start room? If so abort.
		If startRoom Then Return 0

		'Edge is clockwise And 0=North
		exitRoom = edge
		walls[edge] = 0
		Return 1
	End Method

	Method New()
		'Create 4 walls
		walls = New Int[4]
		For Local i:Int = 0 To 3
			walls[i] = 1
		Next
		exitRoom = -1
	End Method
End Class


Class ArrayUtil<T>

	Function CreateArray:T[][] (rows:Int, cols:Int) 'by muddy_shoes
		Local a:T[][] = New T[rows][]
		For Local i:Int = 0 Until rows
			a[i] = New T[cols]
		Next

		Return a
	End Function
	
End Class

therevills

(Posted 2013) [#9]

Looks like Jake and Impixi have found a little Monkey bug. The Debug code generates the following line:

				dbg_array(t_rows,)[dbg_index]=dbg_array(t_rows,)[dbg_index]+"###"

Which is incorrect (there is a comma then a bracket). I'll post it in the Bugs forum.

SLotman

(Posted 2013) [#10]

He's using arrays of arrays to store the maze rooms, not a single dimensional array.

That's the point I'm making - I'd use a 1D array, which is faster than 'array of arrays', hence using array[x+y*width] instead of 'ArrayUtils' (which I understand is only there to correctly initialize the fake 2D array).

AdamRedwoods

(Posted 2013) [#11]

I'd use a 1D array, which is faster than 'array of arrays'

depends. there is almost no notable difference in most platforms, and i would not waste time on this type of optimization.
http://stackoverflow.com/questions/2512082/java-multi-dimensional-array-vs-one-dimensional
http://stackoverflow.com/questions/5476000/c-multi-dimensional-array-vs-one-dimensional

impixi

(Posted 2013) [#12]

@Slotman: Personally, in Monkey, I use single dimensional arrays as you suggest, if only to eliminate the additional initialization procedure. As for the performance aspect, that's something I'm not sure about. Though it would not be too difficult to write a comparative benchmark (perhaps by modifying Jake's maze gen code?)...

Grey Alien

(Posted 2014) [#13]

@therevills yeah I wasn't sure about posting it here as it wasn't runnable, just potentially usefully snippets. OK I'll try to use the new domain now (I searched for it but somehow it came up with the old co.nz domain). Is "Monkey X" the official new name for the language too? Should I use that when talking about it. Oh I didn't know <code> works in wordpress. Guess I should try that!

@SLotman The walls are only double sided on the printout as it was easier to quickly write the printing code like that. Well I guess each room has 4 walls and I found it easier to remove those as needed instead of having a separate array of just walls as well as the rooms array.

Yes I could have made the array 1D, in fact back in my assembly days 2D arrays were always 1D and using y*width+x But I like the ease of use/comprehendabililty (that's not a real word) of 2D arrays.

@impixi Wow thanks for turning it into a working example, that's great!

Also GREAT find with the bug (and thanks to @therevills for posting in bugs). I actually saw something like that when I tried to compile it as Debug for Flash (worked fine as Debug for GLFW btw). Got some kind of error regarding the 2D array but I was in a rush last night to get the game onto #1gameamonth and so just compiled as release in Flash (which worked).

Also thanks @adam and @impixi for posting your own maze gen examples too!

Jesse

(Posted 2014) [#14]

here is my contribution:
http://www.monkeycoder.co.nz/Community/posts.php?topic=7723#75089

Gerry Quinn

(Posted 2014) [#15]

If you're doing complicated stuff with mazes involving solving them repeatedly, in my experience the single-dimensional array will be faster, but by a linear factor. I.e. something will take twice as long, maybe even in some cases three times as long, but most of the time that will be 2 ms vs 1 ms.

In other words it's unlikely to matter.

SLotman

(Posted 2014) [#16]

Well, call me insane, but I really prefer (even for readability) x+y*width :)
When a programmer uses 2D arrays, I never now if it's been used as array[x][y] or array[y][x] ^_^

Paul - Taiphoz

(Posted 2014) [#17]

Call me crazy but I have an idea with all this maze talk, what if we setup a testing framework with two exposed functions, one for creating a maze and one for solving it on a frame by frame basis.

Imagine if you will a setup where each forum poster submitted his own include which had these two functions, that all these submitted includes were pulled into this little test framework and run, I have this image of tons of little coloured AI roaming around trying to solve the maze, could be really cool .

I think the only rule might be that your solver function can only use a few grid area's in diameter around its current position, possibly 5 or 6 squares around, if it could see the full grid you could just use A* or some other path finding to solve it.

just a thought.

computercoder

(Posted 2014) [#18]

@Paul

That actually sounds kinda fun :) I've been dorking about remaking simple games from the old Commodore VIC-20 days and was thinking about something else to mess with. Just building upon my abilities with Monkey X and game dev in general.

Paul - Taiphoz

(Posted 2014) [#19]

OK, finally had some spare time, so here is my effort, I am a very visual person so love to see things happening so the generation of the maze is timed so you can sit and watch it work itself out rather than just blanking for a second as it works in the background.

at the moment it's a straight up maze, but I have some lose code in the project folder locally for creating rooms which I am still playing with, but its looking cool so far.

There might be the odd bit of code here or there that's not being called , just ignore it its stuff I am playing with atm.

See it run Here

#Rem
header:
<div class="quote"> 

<b>Project</b>
[list]
[*] Project 		: Maze
[*] Project Lead	: Paul 'Taiphoz' Grayston
[*] Website			: [a Htpp://www.littleember.com]Little Ember Games[/a]
[/list]

<b>The Team</b>
	[list]
	[*] Art 		: Paul Grayston
	[*] Audio 		: Paul Grayston
	[*] Code 		: Paul Grayston
	[/list]

<b>Comment's</b>
[list]
	...
[/list]

 
</div>
#end


Import Maze




Global Board:emMaze = New emMaze()
Const MAZEHALL:Int = 0
Const MAZEWALL:Int = 1
Const MAZESTART:Int = 2
Const MAZEEND:Int = 3



Const NORTH:Int = 0
Const SOUTH:Int = 1
Const EAST:Int = 2
Const WEST:Int = 3

Global Timer:Int
Global Delay:Int

Const SEEKING:Int = 0
Const TRACKING:Int = 1
Const ENDING:Int = 2
Const FINISHED:Int = 3

Class emMaze
	Field MazeArray:Int[5001]
	Field MovesArray:Int[5001]
	
	Field Moves:Int = 0
	
	Field MazeHeight:Int = 60
	Field MazeWidth:Int = 80

	Field CellWidth:Int = 10
	Field CellHeight:int = 10
	
	Field gx:Int
	Field gy:Int
	Field dir:Int
	Field dist:int
	
	Field Complete:Bool

	Field state:int
		
	Method New()

		Self.Complete = False
		Self.gx = Self.MazeWidth / 2
		Self.gy = Self.MazeHeight / 2

		For Local col:Int = 0 To Self.MazeHeight - 1
			For Local row:Int = 0 To Self.MazeWidth - 1
				Self.MazeArray[col + (Self.MazeHeight * row)] = MAZEWALL
				Self.MovesArray[col + (Self.MazeHeight * row)] = -1
			Next
		Next			
			
		Timer = Millisecs()
		Delay = 0
		Self.state = SEEKING
		
	End Method
	
	Method Render()

		
		For Local col:Int = 0 To Self.MazeHeight - 1
			For Local row:Int = 0 To Self.MazeWidth - 1
			
				SetColor(10, 10, 10)
				DrawRect( (row * Self.CellHeight), (col * Self.CellWidth), Self.CellWidth, Self.CellHeight)
				
				Select Self.MazeArray[col + (Self.MazeHeight * row)]
					Case MAZEHALL
						SetColor(255, 255, 255)
						DrawRect( (row * Self.CellWidth), (col * Self.CellHeight), Self.CellWidth - 2, Self.CellHeight - 2)
					Case MAZEWALL
						SetColor(0, 0, 0)
						DrawRect( (row * Self.CellWidth), (col * Self.CellHeight), Self.CellWidth - 2, Self.CellHeight - 2)
					Case MAZESTART
						SetColor(0, 255, 0)
						DrawRect( (row * Self.CellWidth), (col * Self.CellHeight), Self.CellWidth - 2, Self.CellHeight - 2)
					Case MAZEEND
						SetColor(255, 0, 0)
						DrawRect( (row * Self.CellWidth), (col * Self.CellHeight), Self.CellWidth - 2, Self.CellHeight - 2)
				End Select
			Next
		Next
		
		SetColor(0, 150, 0)
		DrawRect(1 + (Self.gx * Self.CellWidth), 1 + (Self.gy * Self.CellHeight), Self.CellWidth - 2, Self.CellHeight - 2)
		
		If Self.state <> FINISHED
			If Self.IsClear(NORTH) = False
				SetColor(255, 150, 0)
				DrawRect(1 + (Self.gx * Self.CellWidth), 1 + ( (Self.gy - 1) * Self.CellHeight), Self.CellWidth - 2, Self.CellHeight - 2)
			EndIf	
			If Self.IsClear(SOUTH) = False
				SetColor(255, 150, 0)
				DrawRect(1 + (Self.gx * Self.CellWidth), 1 + ( (Self.gy + 1) * Self.CellHeight), Self.CellWidth - 2, Self.CellHeight - 2)
			EndIf
			If Self.IsClear(EAST) = False
				SetColor(255, 150, 0)
				DrawRect(1 + ( (Self.gx + 1) * Self.CellWidth), 1 + ( (Self.gy) * Self.CellHeight), Self.CellWidth - 2, Self.CellHeight - 2)
			EndIf	
			If Self.IsClear(WEST) = False
				SetColor(255, 150, 0)
				DrawRect(1 + ( (Self.gx - 1) * Self.CellWidth), 1 + ( (Self.gy) * Self.CellHeight), Self.CellWidth - 2, Self.CellHeight - 2)
			EndIf
		EndIf

		
		SetColor 255, 255, 255
	End Method
	
	Method Update()

		If Timer + Delay < Millisecs()
			
			Select Self.state
				Case SEEKING
					Self.SeekMaze()
				Case TRACKING
					Self.TrackMaze()
				Case ENDING
					Self.SetStart(0, 1)
					Self.SetEnd(Self.MazeWidth - 1, Self.MazeHeight - 1)
				Case FINISHED
			End Select
			
			Timer = Millisecs()
		EndIf

		If KeyHit(KEY_UP) Then Self.North(1)
		If KeyHit(KEY_DOWN) Then Self.South(1)
		If KeyHit(KEY_RIGHT) Then Self.East(1)
		If KeyHit(KEY_LEFT) Then Self.West(1)
				
	End Method
	

		
	
	Method North(_steps:Int = 1)
		For Local l:Int = 1 To _steps
			If Self.IsClear(NORTH)
				Self.gy -= 1
				Self.MazeArray[Self.gy + (Self.gx * Self.MazeHeight)] = MAZEHALL
				Self.MovesArray[Self.gy + (Self.gx * Self.MazeHeight)] = Moves
				Self.Moves += 1
			EndIf
		Next
	End Method
	
	Method South(_steps:Int = 1)
		For Local l:Int = 1 To _steps
			If Self.IsClear(SOUTH)
				Self.gy += 1
				Self.MazeArray[Self.gy + (Self.gx * Self.MazeHeight)] = MAZEHALL
				Self.MovesArray[Self.gy + (Self.gx * Self.MazeHeight)] = Moves
				Self.Moves += 1
			EndIf
		Next
	End Method

	Method East(_steps:Int = 1)
		For Local l:Int = 1 To _steps
			If Self.IsClear(EAST)
				Self.gx += 1
				Self.MazeArray[Self.gy + (Self.gx * Self.MazeHeight)] = MAZEHALL
				Self.MovesArray[Self.gy + (Self.gx * Self.MazeHeight)] = Moves
				Self.Moves += 1
				
			EndIf
		Next
	End Method
	
	Method West(_steps:Int = 1)
		For Local l:Int = 1 To _steps
			If Self.IsClear(WEST)
			'Print "Moving West : "+Self.Moves
				Self.gx -= 1
				Self.MazeArray[Self.gy + (Self.gx * Self.MazeHeight)] = MAZEHALL
				Self.MovesArray[Self.gy + (Self.gx * Self.MazeHeight)] = Moves
				Self.Moves += 1
				
			EndIf
		Next
	End Method
	

	
	Method TrackNorth(_steps:Int = 1)
		For Local l:Int = 1 To _steps
			'If Self.IsClear(NORTH)
				Self.gy -= 1
				Self.MazeArray[Self.gy + (Self.gx * Self.MazeHeight)] = MAZEHALL
				'Self.MovesArray[Self.gy + (Self.gx * Self.MazeHeight)] = Moves
				'Self.Moves += 1
			'EndIf
		Next
	End Method
	
	Method TrackSouth(_steps:Int = 1)
		For Local l:Int = 1 To _steps
			'If Self.IsClear(SOUTH)
				Self.gy += 1
				Self.MazeArray[Self.gy + (Self.gx * Self.MazeHeight)] = MAZEHALL
				'Self.MovesArray[Self.gy + (Self.gx * Self.MazeHeight)] = Moves
				'Self.Moves += 1
			'EndIf
		Next
	End Method

	Method TrackEast(_steps:Int = 1)
		For Local l:Int = 1 To _steps
			'If Self.IsClear(EAST)
				Self.gx += 1
				Self.MazeArray[Self.gy + (Self.gx * Self.MazeHeight)] = MAZEHALL
				'Self.MovesArray[Self.gy + (Self.gx * Self.MazeHeight)] = Moves
				'Self.Moves += 1
				
			'EndIf
		Next
	End Method
	
	Method TrackWest(_steps:Int = 1)
		For Local l:Int = 1 To _steps
			'If Self.IsClear(WEST)
				Self.gx -= 1
				Self.MazeArray[Self.gy + (Self.gx * Self.MazeHeight)] = MAZEHALL
				'Self.MovesArray[Self.gy + (Self.gx * Self.MazeHeight)] = Moves
				'Self.Moves += 1
				
			'EndIf
		Next
	End Method	
	
	
	
		
	Method MoveAvailable:bool()
		
		If Self.IsClear(NORTH) = True
			Return True
		ElseIf Self.IsClear(SOUTH) = True
			Return True
		ElseIf Self.IsClear(EAST) = True
			Return True
		ElseIf Self.IsClear(WEST) = True
			Return True
		Else
			Return False
		EndIf
		
	End Method
	
	Method DeadEnd:bool()
		Local possmov:Int = 4
		If Self.IsClear(NORTH) = False
			possmov -= 1
		EndIf	
		If Self.IsClear(SOUTH) = False
			possmov -= 1
		EndIf
		If Self.IsClear(EAST) = False
			possmov -= 1
		EndIf	
		If Self.IsClear(WEST) = False
			possmov -= 1
		EndIf
		
		If possmov > 0
			Return False
			'Print possmov
		Else
			'Print "No more moves"
			Return True
		EndIf
		
	End Method
	
	Method SeekMaze:Void()
		
		
		If Self.DeadEnd() = True
			Self.state = TRACKING
		Else
			Local moved:Bool = False
			Repeat
				Self.dir = Rand(0, 5)
				Select Self.dir
					Case NORTH
						If Self.IsClear(NORTH)
							Self.North(4)
							moved = True
						EndIf
					Case SOUTH
						If Self.IsClear(SOUTH)
							Self.South(4)
							moved = True
						EndIf
					Case EAST
						If Self.IsClear(EAST)
							Self.East(4)
							moved = True
						EndIf
					Case WEST
						If Self.IsClear(WEST)
							Self.West(4)
							moved = True
						EndIf
				End Select
			Until moved = True
		EndIf
	End Method
	

	Method TrackMaze:Void()
		Self.Trackback()
		If Self.MoveAvailable() = True
			'Print "Found Fresh Moves"
			Self.state = SEEKING
		EndIf
		If Self.MovesArray[ (Self.gy) + (Self.gx * Self.MazeHeight)] = 0 Then Self.state = ENDING
	End Method	
	
	
	Method Trackback()
		Local score:Int
		Local curscore:int
		'north
		curscore = Self.MovesArray[ (Self.gy) + (Self.gx * Self.MazeHeight)]
		
		score = Self.MovesArray[ (Self.gy - 1) + (Self.gx * Self.MazeHeight)]
			If score <> - 1 And score < curscore
				Self.TrackNorth(1)
			EndIf
		score = Self.MovesArray[ (Self.gy + 1) + (Self.gx * Self.MazeHeight)]
			If score <> - 1 And score < curscore
				Self.TrackSouth(1)
			EndIf
		score = Self.MovesArray[ (Self.gy) + ( (Self.gx + 1) * Self.MazeHeight)]
			If score <> - 1 And score < curscore
				Self.TrackEast(1)
			EndIf
		score = Self.MovesArray[ (Self.gy) + ( (Self.gx - 1) * Self.MazeHeight)]
			If score <> - 1 And score < curscore
				Self.TrackWest(1)
			EndIf									
		
	End Method
		
	Method IsClear:bool(_dir:Int = NORTH)
		Select _dir
			Case NORTH
				If Self.gy >= 2
					If Self.MazeArray[ (Self.gy - 1) + ( (Self.gx) * Self.MazeHeight)] = MAZEWALL and
						Self.MazeArray[ (Self.gy - 1) + ( (Self.gx + 1) * Self.MazeHeight)] = MAZEWALL and
						Self.MazeArray[ (Self.gy - 1) + ( (Self.gx - 1) * Self.MazeHeight)] = MAZEWALL And
						Self.MazeArray[ (Self.gy - 2) + ( (Self.gx) * Self.MazeHeight)] = MAZEWALL and
						Self.MazeArray[ (Self.gy - 2) + ( (Self.gx + 1) * Self.MazeHeight)] = MAZEWALL and
						Self.MazeArray[ (Self.gy - 2) + ( (Self.gx - 1) * Self.MazeHeight)] = MAZEWALL Then
							
						'If Self.MovesArray[ (Self.gy - 1) + (Self.gx * Self.MazeHeight)] = -1 and or Self.MovesArray[ (Self.gy - 1) + (Self.gx * Self.MazeHeight)] < Self.MovesArray[ (Self.gy) + (Self.gx * Self.MazeHeight)]
						
						If Self.MazeArray[ (Self.gy - 1) + ( (Self.gx) * Self.MazeHeight)] = MAZEWALL
							Return True
						EndIf
						'EndIf
							
					End If				
				EndIf
			Case SOUTH

				If Self.gy <= Self.MazeHeight - 3
					If Self.MazeArray[ (Self.gy + 1) + ( (Self.gx) * Self.MazeHeight)] = MAZEWALL and
						Self.MazeArray[ (Self.gy + 1) + ( (Self.gx + 1) * Self.MazeHeight)] = MAZEWALL and
						Self.MazeArray[ (Self.gy + 1) + ( (Self.gx - 1) * Self.MazeHeight)] = MAZEWALL And
						Self.MazeArray[ (Self.gy + 2) + ( (Self.gx) * Self.MazeHeight)] = MAZEWALL and
						Self.MazeArray[ (Self.gy + 2) + ( (Self.gx + 1) * Self.MazeHeight)] = MAZEWALL and
						Self.MazeArray[ (Self.gy + 2) + ( (Self.gx - 1) * Self.MazeHeight)] = MAZEWALL Then
						'If Self.MovesArray[ (Self.gy + 1) + (Self.gx * Self.MazeHeight)] = -1 or Self.MovesArray[ (Self.gy - 1) + (Self.gx * Self.MazeHeight)] < Self.MovesArray[ (Self.gy) + (Self.gx * Self.MazeHeight)]
						If Self.MazeArray[ (Self.gy + 1) + ( (Self.gx) * Self.MazeHeight)] = MAZEWALL
							Return True
						EndIf
						'EndIf

					End If
					
				EndIf
			Case EAST

				If Self.gx <= Self.MazeWidth - 3
					If Self.MazeArray[ (Self.gy) + ( (Self.gx + 1) * Self.MazeHeight)] = MAZEWALL and
						Self.MazeArray[ (Self.gy - 1) + ( (Self.gx + 1) * Self.MazeHeight)] = MAZEWALL and
						Self.MazeArray[ (Self.gy + 1) + ( (Self.gx + 1) * Self.MazeHeight)] = MAZEWALL And
						Self.MazeArray[ (Self.gy) + ( (Self.gx + 2) * Self.MazeHeight)] = MAZEWALL and
						Self.MazeArray[ (Self.gy - 1) + ( (Self.gx + 2) * Self.MazeHeight)] = MAZEWALL and
						Self.MazeArray[ (Self.gy + 1) + ( (Self.gx + 2) * Self.MazeHeight)] = MAZEWALL Then
						'If Self.MovesArray[ (Self.gy) + ( (Self.gx + 1) * Self.MazeHeight)] = -1 or Self.MovesArray[ (Self.gy - 1) + (Self.gx * Self.MazeHeight)] < Self.MovesArray[ (Self.gy) + (Self.gx * Self.MazeHeight)]
						If Self.MazeArray[ (Self.gy) + ( (Self.gx + 1) * Self.MazeHeight)] = MAZEWALL
							Return True
						EndIf
						'EndIf

					End If
				EndIf

			Case WEST
					
				If Self.gx >= 2
					If Self.MazeArray[ (Self.gy) + ( (Self.gx - 1) * Self.MazeHeight)] = MAZEWALL and
						Self.MazeArray[ (Self.gy - 1) + ( (Self.gx - 1) * Self.MazeHeight)] = MAZEWALL and
						Self.MazeArray[ (Self.gy + 1) + ( (Self.gx - 1) * Self.MazeHeight)] = MAZEWALL And
						Self.MazeArray[ (Self.gy) + ( (Self.gx - 2) * Self.MazeHeight)] = MAZEWALL and
						Self.MazeArray[ (Self.gy - 1) + ( (Self.gx - 2) * Self.MazeHeight)] = MAZEWALL and
						Self.MazeArray[ (Self.gy + 1) + ( (Self.gx - 2) * Self.MazeHeight)] = MAZEWALL Then
						'If Self.MovesArray[ (Self.gy) + ( (Self.gx + 1) * Self.MazeHeight)] = -1 or Self.MovesArray[ (Self.gy - 1) + (Self.gx * Self.MazeHeight)] < Self.MovesArray[ (Self.gy) + (Self.gx * Self.MazeHeight)]
						If Self.MazeArray[ (Self.gy) + ( (Self.gx - 1) * Self.MazeHeight)] = MAZEWALL
							Return True
						EndIf
						'EndIf

					End If
				EndIf
				
		End Select
	
		Return False
		
	End Method
	
	Method Edge:bool()
		If (Self.gx > 1 And Self.gx < Self.MazeHeight - 2) And (Self.gy > 1 And Self.gy < Self.MazeWidth - 2)
			Return False
		Else
			Return True
		EndIf
	End Method
	
	
	Method SetStart(_x:Int, _y:int)
		Local c:Int = -1
		
		Repeat
			c += 1
		Until Self.MazeArray[ (_y + c) + ( (_x + 1) * Self.MazeHeight)] = MAZEHALL
		
		Self.MazeArray[ (_y + c) + ( (_x) * Self.MazeHeight)] = MAZESTART
	End Method

	Method SetEnd(_x:Int, _y:int)
		Local c:Int = -1
		
		Repeat
			c += 1
		Until Self.MazeArray[ (_y - c) + ( (_x) * Self.MazeHeight)] = MAZEHALL
		
		Self.MazeArray[ (_y - c) + ( (_x + 1) * Self.MazeHeight)] = MAZEEND
		Self.state = 3
		
	End Method	
	
	
End Class
#Rem
footer:
<div class="quote"> 
[a Htpp://www.littleember.com]Little Ember Games[/a] - {PROJECTLEAD}
 
</div>
#end

Paul - Taiphoz

(Posted 2014) [#20]

Oh yeah ignore all that header footer crap, I have a tool that creates new projects from a template..