Maze Generators

[TerryRitchie]

In another thread I posted a maze generator I created many years ago. Here it is again:

Code: QB64: [Select]

1. '**
2. '** MAZEGEN by Terry Ritchie
3. '**
4. '** Creates random 20x16 braided mazes (or perfect mazes with modification)
5. '**
6. '** This code was created from pseudo-code obtained at MAZEWORKS.COM
7. '**
8. '** This code could be easily modified to create any size maze and cell size
9. '**
10. '** If you use this code in your program please credit me and MAZEWORKS.COM
11. '**
12. '** Code last modified 02/23/09
13. '**
14. '** This maze generating code was created to use in a MEGABUG (Tandy/Radio
15. '** Shack game from 1982) clone to teach introductory programming. The
16. '** original game used a 20x16 maze grid. This is why the maze generator has
17. '** been hard coded to only use a 16x20 grid. A little modification would
18. '** allow this code to generate any size maze with any size cell.
19. '**
20.  
21. CONST false = 0, true = NOT false
22. CONST totalcells = 320
23.  
24. TYPE cell
25.   walls AS INTEGER
26.   x AS INTEGER
27.   y AS INTEGER
28. END TYPE
29.  
30. TYPE stack
31.   x AS INTEGER
32.   y AS INTEGER
33. END TYPE
34.  
35. DECLARE SUB CreateRandomMaze ()
36. DECLARE SUB DrawMaze ()
37. DECLARE SUB DrawCell (cellx AS INTEGER, celly AS INTEGER)
38. DECLARE SUB RemoveWall (cellx AS INTEGER, celly AS INTEGER, dir AS INTEGER)
39.  
40. DIM SHARED maze(0 TO 19, 0 TO 15) AS cell
41.  
42. SCREEN 7, 0, 1, 0
43.  
44. DO
45.   LINE (81, 37)-(239, 163), 0, BF   'faster than CLS
46.   CreateRandomMaze
47.   DrawMaze
48.   PCOPY 1, 0
49.   SLEEP 1               '**rem this line out to see how fast it is!
50. LOOP UNTIL INKEY$ <> ""
51.  
52. END
53.  
54. SUB CreateRandomMaze
55. '**
56. '** Creates a random 20x16 braided (looping) maze by first creating a perfect
57. '** maze (a maze with no loops) then visiting each dead end and randomly
58. '** opening them to create loops.
59. '**
60. '** vcells stores valid next maze cell moves in binary (bit) format
61. '** if all adjacent cell walls are turned on then that cell is saved in vcells
62. '** as follows:
63. '**             bit 1 (2^0) = north cell has all walls on
64. '**             bit 2 (2^1) = east  cell has all walls on
65. '**             bit 3 (2^2) = south cell has all walls on
66. '**             bit 4 (2^3) = west  cell has all walls on
67. '**
68.   DIM stack(totalcells) AS stack            '** maze generation LIFO stack
69.   DIM cellx, celly, counter AS INTEGER      '** general counters
70.   DIM cell AS stack                         '** current cell being created
71.   DIM pointer AS INTEGER                    '** pointer for use in LIFO stack
72.   DIM vcells AS INTEGER                     '** which cells are valid moves?
73.   DIM randomwall AS INTEGER                 '** random valid mover
74.   DIM forward AS INTEGER                    '** movement indicator
75.   RANDOMIZE TIMER                           '** seed random number generator
76.   FOR cellx = 0 TO 19                       '** initialize maze grid
77.     FOR celly = 0 TO 15
78.       maze(cellx, celly).walls = 15         '** turn all walls on
79.       maze(cellx, celly).x = 80 + cellx * 8 '** x coordinate upper left cell
80.       maze(cellx, celly).y = 36 + celly * 8 '** y coordinate upper left cell
81.     NEXT celly
82.   NEXT cellx
83.   cell.x = INT(RND(1) * 19)                 '** random x location
84.   cell.y = INT(RND(1) * 15)                 '** random y location
85.   visitedcells = 1                          '** initialize counter
86.   pointer = 0                               '** initialize LIFO stack pointer
87.   forward = false                           '** initialize movement indicator
88.   WHILE visitedcells < totalcells           '** continue until all cells made
89.     vcells = 0                              '** initialize valid move check
90.     IF cell.y <> 0 THEN IF maze(cell.x, cell.y - 1).walls = 15 THEN vcells = vcells + 1
91.     IF cell.x <> 19 THEN IF maze(cell.x + 1, cell.y).walls = 15 THEN vcells = vcells + 2
92.     IF cell.y <> 15 THEN IF maze(cell.x, cell.y + 1).walls = 15 THEN vcells = vcells + 4
93.     IF cell.x <> 0 THEN IF maze(cell.x - 1, cell.y).walls = 15 THEN vcells = vcells + 8
94.     IF vcells <> 0 THEN                     '** at least 1 cell has all walls
95.       DO                                    '** find a random move direction
96.         randomwall = INT(RND(1) * 4)        '** 0=North 1=East 2=South 3=West
97.       LOOP UNTIL vcells AND 2 ^ randomwall  '** is random direction valid?
98.       stack(pointer).x = cell.x             '** save current cell position in
99.       stack(pointer).y = cell.y             '** the stack
100.       pointer = pointer + 1                 '** increment stack pointer
101.       visitedcells = visitedcells + 1       '** increment cell counter
102.       forward = true                        '** forward movement indicated
103.       CALL RemoveWall(cell.x, cell.y, randomwall) '** remove random wall
104.       SELECT CASE randomwall                '** which direction forward?
105.         CASE 0
106.           cell.y = cell.y - 1               '** move north
107.         CASE 1
108.           cell.x = cell.x + 1               '** move east
109.         CASE 2
110.           cell.y = cell.y + 1               '** move south
111.         CASE 3
112.           cell.x = cell.x - 1               '** move west
113.       END SELECT
114.     ELSE                                    '** no cells have all walls
115.      
116. '****** remark the lines below to create perfect mazes (no loops) ***********
117. '****** the code below creates braided mazes (contains loops)     ***********
118.  
119.       IF forward THEN                       '** we hit a dead end!
120.         forward = false                     '** forward movement stops here
121.         IF INT(RND(1) * 2) = 1 THEN         '** 50% chance of wall removal
122.           SELECT CASE randomwall            '** which wall?
123.             CASE 0                          '** remove north wall
124.               IF cell.y <> 0 THEN           '** unless it's a border
125.                 CALL RemoveWall(cell.x, cell.y, randomwall)
126.               END IF
127.             CASE 1                          '** remove east wall
128.               IF cell.x <> 19 THEN          '** unless it's a border
129.                 CALL RemoveWall(cell.x, cell.y, randomwall)
130.               END IF
131.             CASE 2                          '** remove south wall
132.               IF cell.y <> 15 THEN          '** unless it's a border
133.                 CALL RemoveWall(cell.x, cell.y, randomwall)
134.               END IF
135.             CASE 3                          '** remove west wall
136.               IF cell.x <> 0 THEN           '** unless it's a border
137.                 CALL RemoveWall(cell.x, cell.y, randomwall)
138.               END IF
139.           END SELECT
140.         END IF
141.       END IF
142.      
143. '****** remark the lines above to create perfect mazes (no loops) ***********
144. '****** the code above creates braided mazes (contains loops)     ***********
145.  
146.       pointer = pointer - 1                 '** decrement stack pointer
147.       cell.x = stack(pointer).x             '** go back to previous cell
148.       cell.y = stack(pointer).y             '** go back to previous cell
149.     END IF
150.   WEND                                      '** exit when all cells visited
151.  
152. END SUB
153.  
154. SUB DrawCell (cellx AS INTEGER, celly AS INTEGER)
155.  
156. '****************************************************************************
157. '** draw cell to graphics screen                                            *
158. '****************************************************************************
159.  
160.   IF maze(cellx, celly).walls AND 1 THEN LINE (maze(cellx, celly).x, maze(cellx, celly).y)-(maze(cellx, celly).x + 8, maze(cellx, celly).y), 1
161.   IF maze(cellx, celly).walls AND 2 THEN LINE (maze(cellx, celly).x + 8, maze(cellx, celly).y)-(maze(cellx, celly).x + 8, maze(cellx, celly).y + 8), 1
162.   IF maze(cellx, celly).walls AND 4 THEN LINE (maze(cellx, celly).x, maze(cellx, celly).y + 8)-(maze(cellx, celly).x + 8, maze(cellx, celly).y + 8), 1
163.   IF maze(cellx, celly).walls AND 8 THEN LINE (maze(cellx, celly).x, maze(cellx, celly).y)-(maze(cellx, celly).x, maze(cellx, celly).y + 8), 1
164.  
165. END SUB
166.  
167. SUB DrawMaze
168.  
169. '****************************************************************************
170. '* Draws the entire maze to the graphics screen                             *
171. '****************************************************************************
172.  
173.   DIM x AS INTEGER                          '** holds x location of maze cell
174.   DIM y AS INTEGER                          '** holds y location of maze cell
175.  
176.   FOR x = 0 TO 19                           '** cycle through all cells
177.     FOR y = 0 TO 15
178.       CALL DrawCell(x, y)                   '** draw each cell to the screen
179.     NEXT y
180.   NEXT x
181.   LINE (79, 35)-(241, 165), 1, B            '** draw border around maze
182.  
183. END SUB
184.  
185. SUB RemoveWall (cellx AS INTEGER, celly AS INTEGER, dir AS INTEGER)
186.  
187. '****************************************************************************
188. '* Removes the walls between to adjoining cells based on the direction of
189. '* movement.                                                                *
190. '****************************************************************************
191.  
192.   SELECT CASE dir                           '** which direction?
193.     CASE 0                                  '** remove north/south walls
194.       maze(cellx, celly).walls = maze(cellx, celly).walls - 1
195.       maze(cellx, celly - 1).walls = maze(cellx, celly - 1).walls - 4
196.     CASE 1                                  '** remove east/west walls
197.       maze(cellx, celly).walls = maze(cellx, celly).walls - 2
198.       maze(cellx + 1, celly).walls = maze(cellx + 1, celly).walls - 8
199.     CASE 2                                  '** remove south/north walls
200.       maze(cellx, celly).walls = maze(cellx, celly).walls - 4
201.       maze(cellx, celly + 1).walls = maze(cellx, celly + 1).walls - 1
202.     CASE 3                                  '** remove west/east walls
203.       maze(cellx, celly).walls = maze(cellx, celly).walls - 8
204.       maze(cellx - 1, celly).walls = maze(cellx - 1, celly).walls - 2
205.   END SELECT
206.  
207. END SUB

However, while organizing my code snippets I found this second maze generator I created some years later. I completely forget I made this and can't even remember why any longer. It has many features for making, saving, and loading random and custom mazes.

Code: QB64: [Select]

1. '**
2. '** Maze Generator V1.0
3. '**
4. '** by Terry Ritchie - 02/06/13
5. '**
6. '** This code can generate random braided looping, non-looping or custom mazes by supplying a string of HEX characters.
7. '**
8. '** Mazes can be saved and loaded using the SAVEMAZE and LOADMAZE commands.
9. '**
10. '** An example of how to draw mazes is included as DRAWMAZE. The syntax for drawmaze is as follows:
11. '**
12. '** DRAWMAZE MazeType%, Thickness%, MazeColor~&
13. '**
14. '** - MazeType%  : 0 (or constant SQUARE) for a square maze, 1 (or constant ROUND) for a round maze
15. '** - Thickness% : the wall thickness of the maze
16. '** - MazeColor~&: the color of the maze walls
17. '**
18. '**   DRAWMAZE draws the maze image to the image handle MazeImage&
19. '**
20. '** To generate a random maze use the MAKEMAZE command as follows:
21. '**
22. '**                         +--------- R specifies a random maze
23. '** MAKEMAZE "RL0A0A15"     |+-------- L specifies a looping maze (use N for non-looping maze)
24. '** +-------------------+   || +------ 0A the next two characters in HEX specifies the horizontal width of maze, in this case 10
25. '** | the command above |   || |
26. '** | will produce a    |   vv v       The largest HEX value that can be used is FF, or 255, therefore the maximum width and height
27. '** | random maze of 20 |   RL0A0A15   of the maze can't exceed 255x255 and the maximum cell size can't exceed 255.
28. '** | cells wide by 20  |        ^ ^
29. '** | cells high with   |        | |
30. '** | each cell being   |        | +-- 15 the last two characters in HEX specifies the size of each cell in maze, in this case 21
31. '** | 21 pixels in size |        +---- 0A the next two characters in HEX specifies the vertical height of maze, in this case 10
32. '** +-------------------+
33. '**
34. '** To generate a maze of your own design use the MAKEMAZE command as follows:
35. '**
36. '** MAKEMAZE "050515<maze_string>"
37. '** +-------------------+    +------- 05 the first two HEX digits specifies the horizontal width of the maze, in this case 5
38. '** | the command above |    | +----- 05 the second two HEX digits specifies the vertical height of the maze, in this case 5
39. '** | will produce a    |    | |
40. '** | custom maze of 5  |    v v                  A sample maze string that creates a spiraling inward maze would be:
41. '** | cells wide by 5   |   050515<maze_string>
42. '** | cells high with   |        ^ ^                             "0505152AAAC6AAC55685553A953AAA9"
43. '** | each cell being   |        | |
44. '** | 21 pixels in size |        | +- <maze_string> is a string of HEX digits that describes the actual maze (see illustration below)
45. '** +-------------------+        +--- 15 the last two HEX digits specifies the size of each pixel in the maze, in this case 21
46. '**
47. '** NOTE: Round mazes will look best if you keep the size of the cells at ODD numbers. The included DRAWMAZE example
48. '**       subroutine was optimized to make sure that round mazes have a definite center line inside the maze, because these maze
49. '**       rotuines are a spinoff of a game in progress that needs random round maze generation with defined center lines.
50. '**
51. '** After you have created a maze with MAKEMAZE you can use the SAVEMAZE command to save the maze to a file.  This will allow you to
52. '** use the generated mazes in your own programs. The SAVEMAZE command is used as follows:
53. '**
54. '** SAVEMAZE "mymaze"
55. '**
56. '** There is no need to supply an extension. ".MAZ" will automagically be added to the name you gave your maze.
57. '**
58. '** You can load a previously saved maze using LOADMAZE as follows:
59. '**
60. '** LOADMAZE "mymaze", mymaze$
61. '**
62. '** The maze will be loaded and placed into the variable specified, in this case mymaze$
63. '**
64. '*****************************************************************************************************************************************
65. '**                                                                                                                                      *
66. '**                 The following is an illustration of the 16 cell conditions and their corresponding HEX values:                       *
67. '**                                                                                                                                      *
68. '*****************************************************************************************************************************************
69. '**   |     |     Cell 1            *   |     |     Cell 2           *   |     |     Cell 3            *   |     |     Cell 4            *
70. '** --|     |--   North door open   * --+--------   East door open   * --|     +--   North door open   * --+-----+--   South door open   *
71. '**   |     |                       *   |                            *   |           East door open    *   |     |                       *
72. '**   |     |                       *   |                            *   |                             *   |     |                       *
73. '** --+-----+--                     * --+--------                    * --+--------                     * --|     |--                     *
74. '**   |     |     HEX - 1           *   |     |     HEX - 2          *   |     |     HEX - 3           *   |     |     HEX - 4           *
75. '*****************************************************************************************************************************************
76. '**   |     |     Cell 5            *   |     |     Cell 6           *   |     |     Cell 7            *   |     |     Cell 8            *
77. '** --|     |--   North door open   * --+--------   East door open   * --|     +--   North door open   * --------+--   West door open    *
78. '**   |     |     South door open   *   |           South door open  *   |           South door open   *         |                       *
79. '**   |     |                       *   |                            *   |           East door open    *         |                       *
80. '** --|     |--                     * --|     +--                    * --|     +--                     * --------+--                     *
81. '**   |     |     HEX - 5           *   |     |     HEX - 6          *   |     |     HEX - 7           *   |     |     HEX - 8           *
82. '*****************************************************************************************************************************************
83. '**   |     |     Cell 9            *   |     |     Cell 10          *   |     |     Cell 11           *   |     |     Cell 12           *
84. '** --+     |--   North door open   * -----------   East door open   * --+     +--   North door open   * --+-----+--   South door open   *
85. '**         |     West door open    *               West door open   *               East door open    *         |     West door open    *
86. '**         |                       *                                *               West door open    *         |                       *
87. '** --------+--                     * -----------                    * -----------                     * --+     +--                     *
88. '**   |     |     HEX - 9           *   |     |     HEX - A          *   |     |     HEX - B           *   |     |     HEX - C           *
89. '*****************************************************************************************************************************************
90. '**   |     |     Cell 13           *   |     |     Cell 14          *   |     |     Cell 15           * \ |     | /   Cell 0            *
91. '** --+     |--   North door open   * -----------   East door open   * --+     +--   North door open   * --+-----+--   No doors open     *
92. '**         |     South door open   *               South door open  *               East door open    *   | \ / |     (nothing will be  *
93. '**         |     West door open    *               West door open   *               South door open   *   | / \ |      drawn to the     *
94. '** --+     |--                     * --+     +--                    * --+     +--   West door open    * --+-----+--    maze image)      *
95. '**   |     |     HEX - D           *   |     |     HEX - E          *   |     |     HEX - F           * / |     | \   HEX - 0           *
96. '*****************************************************************************************************************************************
97. '**                                                                                                                                      *
98. '** Each open door is treated as a digit in a binary nibble:  North = 2^0  East = 2^1  South = 2^2  West = 2^3                           *
99. '**                                                                                                                                      *
100. '** Therefore, one hexadecimal digit can store the state of all four doors of a cell. i.e. F = 2^0+2^1+2^2+2^3 = 15 = all doors open.    *
101. '**                                                                                                                                      *
102. '*****************************************************************************************************************************************
103.  
104. CONST FALSE = 0, TRUE = NOT FALSE '           boolean truth testers
105. CONST PI = 3.1415926 '                        would you like a piece?
106. CONST PIUP = 1.5707963 '                      radian pointing up
107. CONST PIDOWN = 4.7123889 '                    radian pointing down
108. CONST SQUARE = 0
109. CONST ROUND = 1
110.  
111. TYPE CELL
112.     Xpos AS INTEGER '                         the X screen coordinate of this cell
113.     Ypos AS INTEGER '                         the Y screen coordinate of this cell
114.     Doors AS INTEGER '                        the doors that are open in this cell (1-up, 2-right, 4-down, 8-left)
115. END TYPE
116.  
117. TYPE LOCATION
118.     Hor AS INTEGER '                          horizontal X position of this cell
119.     Ver AS INTEGER '                          vertical Y position of this cell
120. END TYPE
121.  
122. TYPE STACK
123.     Xpos AS INTEGER '                         horizontal X position of cell in stack
124.     Ypos AS INTEGER '                         vertical Y position of cell in stack
125. END TYPE
126.  
127. TYPE MAZE
128.     Hcell AS INTEGER '                        number of horizontal cells in maze
129.     Vcell AS INTEGER '                        number of vertical cells in maze
130.     CellSize AS INTEGER '                     the size of each maze cell
131.     Thickness AS INTEGER '                    the wall thickness of the maze
132.     Colour AS _UNSIGNED LONG '                the maze wall color
133.     MazeType AS INTEGER '                     the type of maze (0-square, 1-round)
134.     Looping AS INTEGER '                      0 for non looping, 1 for looping
135. END TYPE
136.  
137. REDIM Cell(0, 0) AS CELL '                    an array of maze cells
138. DIM Maze AS MAZE '                            the maze properties
139. DIM MazeImage& '                              the maze image holder
140. DIM MyMaze$
141.  
142. RANDOMIZE TIMER '                             seed the random number generator
143.  
144. SCREEN _NEWIMAGE(1280, 720, 32)
145. _SCREENMOVE _MIDDLE
146. CLS
147.  
148. MAKEMAZE "0505152AAAC6AAC55685553A953AAA9" ' create a custom maze
149. DRAWMAZE ROUND, 6, _RGB32(64, 64, 64) '      draw the custom round maze to the screen
150. SAVEMAZE "mymaze" '                          save the maze as MYMAZE.MAZ
151. _PUTIMAGE (0, 0), MazeImage& '               this puts maze on screen in real size
152. LOCATE 2, 2: PRINT " A custom maze - saved to HDD"
153. SLEEP '                                      wait for a key press
154. CLS
155. MAKEMAZE "RL141429" '                        create a 20 x 20 random looping maze with a cell size of 41 pixels
156. DRAWMAZE SQUARE, 6, _RGB32(64, 64, 64) '     draw the random square maze to the screen
157. _PUTIMAGE (0, 0), MazeImage& '               this puts maze on screen in real size
158. LOCATE 2, 2: PRINT " A random 20x20 square looping maze with 41 pixel sized cells (too big for screen)"
159. SLEEP '                                      wait for a keypress
160. CLS
161. MAKEMAZE "RN0A0A1F" '                        create a 10 x 10 random non-looping maze with a cell size of 31 pixels
162. DRAWMAZE ROUND, 6, _RGB32(64, 64, 64) '      draw the random round maze to the screen
163. _PUTIMAGE (0, 0), MazeImage& '               this puts maze on screen in real size
164. LOCATE 2, 2: PRINT " A random 10x10 round non-looping maze with 31 pixel sized cells"
165. SLEEP '                                      wait for a keypress
166. CLS
167. LOADMAZE "mymaze", MyMaze$ '                 load previously saved maze and place maze in MyMaze$
168. MAKEMAZE MyMaze$ '                           create the loaded maze
169. DRAWMAZE SQUARE, 6, _RGB32(64, 64, 64) '     draw the loaded maze, this time in square style
170. _PUTIMAGE (0, 0), MazeImage& '               this puts maze on screen in real size
171. LOCATE 2, 2: PRINT " The first maze loaded from HDD and now displayed as a square maze"
172. SLEEP '                                      wait for a keypress
173. SYSTEM '                                     return to OS
174.  
175.  
176. '** NOTE:    _PUTIMAGE , MazeImage& '        this will always squeeze maze onto screen
177.  
178. '----------------------------------------------------------------------------------------------------------------------
179.  
180. SUB LOADMAZE (MazeFile$, MazeString$)
181.  
182. '**
183. '** Loads a maze from HDD
184. '**
185.  
186. OPEN MazeFile$ + ".MAZ" FOR INPUT AS #1 '                                      open the maze file for input
187. LINE INPUT #1, MazeString$ '                                                   get the maze string from the file
188. CLOSE #1 '                                                                     close the file
189.  
190. END SUB
191.  
192. '----------------------------------------------------------------------------------------------------------------------
193.  
194. SUB SAVEMAZE (MazeFile$)
195.  
196. '**
197. '** Saves a maze to HDD
198. '**
199.  
200. SHARED Cell() AS CELL '  we need access to the cell array
201. SHARED Maze AS MAZE '    we need access to the maze properties
202.  
203. DIM v%, h% '             generic counters to keep track of current cell
204. DIM MazeString$ '        the string generated that represents the maze
205.  
206. '**
207. '** save the number of horizontal cells, vertical cells and cell size to the maze string
208. '** make sure that each HEX value saved is at least two digits in length by padding a zero at the
209. '** beginning of each HEX value
210. '**
211. MazeString$ = RIGHT$("0" + HEX$(Maze.Hcell), 2) + RIGHT$("0" + HEX$(Maze.Vcell), 2) + RIGHT$("0" + HEX$(Maze.CellSize), 2)
212. FOR v% = 1 TO Maze.Vcell '                                                     cycle through all vertical cells
213.     FOR h% = 1 TO Maze.Hcell '                                                 cycle through all horizontal cells
214.         MazeString$ = MazeString$ + HEX$(Cell(h%, v%).Doors) '                 save this cell's door conditions to maze string
215.     NEXT h%
216. NEXT v%
217. OPEN MazeFile$ + ".MAZ" FOR OUTPUT AS #1 '                                     open the maze file for output
218. PRINT #1, MazeString$ '                                                        write the maze string to the file
219. CLOSE #1 '                                                                     close the maze file
220.  
221. END SUB
222.  
223. '----------------------------------------------------------------------------------------------------------------------
224.  
225. SUB DRAWMAZE (Mtype%, Thick%, Mcolor~&)
226.  
227. '**
228. '** Draws the maze to the maze image holder
229. '**
230. '** This command is included as an example of how you can draw custom or random mazes for use in your own programs.
231. '** See the DRAWCELL subroutine for the complete picture.
232. '**
233.  
234. SHARED Cell() AS CELL '  we need access to the cell array
235. SHARED MazeImage& '      we need access to the maze image holder
236. SHARED Maze AS MAZE '    we need access to the maze properties
237.  
238. DIM OriginalDest& '      the saved destination of the calling routine
239. DIM v%, h% '             current horizontal and vertical cell being drawn
240.  
241.  
242. Maze.Thickness = Thick% '                                                      wall thickness of maze
243. Maze.Colour = Mcolor~& '                                                       maze wall color
244. Maze.MazeType = Mtype% '                                                       type of maze
245. IF MazeImage& THEN _FREEIMAGE MazeImage& '                                     free previous maze image created if one exists
246. MazeImage& = _NEWIMAGE(Maze.CellSize * (Maze.Hcell + 1.5) * 2, Maze.CellSize * (Maze.Vcell + 1.5) * 2, 32) ' calculate maze image size
247. OriginalDest& = _DEST '                                                        save calling routine destination
248. _DEST MazeImage& '                                                             maze image is new destination
249. FOR v% = 1 TO Maze.Vcell '                                                     cycle through all cell vertical locations
250.     FOR h% = 1 TO Maze.Hcell '                                                 cycle through all cell horizontal locations
251.         DRAWCELL Cell(h%, v%).Xpos, Cell(h%, v%).Ypos, Cell(h%, v%).Doors '    draw the cell at this location
252.     NEXT h%
253. NEXT v%
254. _DEST OriginalDest& '                                                          restore calling routine destination
255.  
256. END SUB
257.  
258. '----------------------------------------------------------------------------------------------------------------------
259.  
260. SUB MAKEMAZE (Maze$)
261.  
262. '**
263. '** Creates a random braided optional-looping maze
264. '**
265.  
266. SHARED Cell() AS CELL '     we need access to the cell array
267. SHARED Maze AS MAZE '       we need access to the maze properties
268.  
269. DIM CurrentCell AS STACK '  the current cell we are working with
270. DIM Pointer% '              the stack pointer
271. DIM ValidCells% '           contains the valid adjacent cells we can move to
272. DIM RandomDir% '            a random direction to move
273. DIM Forward% '              TRUE if we are moving forward through the maze
274. DIM CellX% '                generic counter used to initiate cells
275. DIM CellY% '                generic counter used to initiate cells
276. DIM VisitedCells% '         number of cells visited by subroutine
277. DIM Remove% '               TRUE if it's ok to open a looping door
278. DIM Mz$ '                   the string holding the maze
279. DIM Custom% '               -1 (TRUE) if custom maze, 0 (FALSE) if random
280. DIM Mzpointer% '            maze string position pointer
281.  
282. Mz$ = UCASE$(Maze$) '                                                          convert passed maze string to uppercase
283. Mzpointer% = 0 '                                                               reset maze string position pointer
284. Custom% = -1 '                                                                 assume this will be a custom maze
285. IF LEFT$(Mz$, 1) = "R" THEN '                                                  should we create a random maze?
286.     Custom% = 0 '                                                              yes, remove custom flag
287.     IF MID$(Mz$, 2, 1) = "L" THEN '                                            should this be a looping maze?
288.         Maze.Looping = 1 '                                                     yes, make it so number one
289.     ELSE '                                                                     no
290.         Maze.Looping = 0 '                                                     this will not be a looping maze
291.     END IF
292.     Mz$ = RIGHT$(Mz$, LEN(Mz$) - 2) '                                          remove the first two characters from maze string
293. END IF
294. Maze.Hcell = VAL("&H" + LEFT$(Mz$, 2)) '                                       set the number of horizontal cells in maze
295. Maze.Vcell = VAL("&H" + MID$(Mz$, 3, 2)) '                                     set the number of vertical cells in maze
296. Maze.CellSize = VAL("&H" + MID$(Mz$, 5, 2)) '                                  set the size of each cell
297. REDIM Cell(Maze.Hcell, Maze.Vcell) AS CELL '                                   create an array of maze cells
298. IF Custom% THEN '                                                              are we creating a custom maze?
299.     Mz$ = RIGHT$(Mz$, LEN(Mz$) - 6) '                                          yes, remove first six characters from maze string
300. ELSE '                                                                         no, we are creating a random maze
301.     DIM Stack(Maze.Hcell * Maze.Vcell) AS STACK '                              create a LIFO stack array
302. END IF
303. FOR CellY% = 1 TO Maze.Hcell '                                                 cycle through all vertical cells
304.     FOR CellX% = 1 TO Maze.Vcell '                                             cycle through all horizontal cells
305.         Mzpointer% = Mzpointer% + 1 '                                          increment the maze string position pointer
306.         Cell(CellX%, CellY%).Xpos = CellX% * Maze.CellSize * 2 '               upper left X location of this cell
307.         Cell(CellX%, CellY%).Ypos = CellY% * Maze.CellSize * 2 '               upper left Y location of this cell
308.         IF Custom% THEN '                                                      is this a custom maze?
309.             Cell(CellX%, CellY%).Doors = VAL("&H" + MID$(Mz$, Mzpointer%, 1)) 'yes, get this cell's door conditions from maze string
310.         ELSE '                                                                 no, this will be a random maze
311.             Cell(CellX%, CellY%).Doors = 0 '                                   set all cell doors closed
312.         END IF
313.     NEXT CellX%
314. NEXT CellY%
315. IF Custom% THEN EXIT SUB '                                                     no need to go further if this is a custom maze
316. '**
317. '** Start of random maze generation algorithm *********************************
318. '**
319. CurrentCell.Xpos = INT(RND(1) * Maze.Hcell) + 1 '                              random horizontal position of cell to start at
320. CurrentCell.Ypos = INT(RND(1) * Maze.Vcell) + 1 '                              random vertical position of cell to start at
321. VisitedCells% = 1 '                                                            keep track of how many cells visited
322. Pointer% = 0 '                                                                 initiate the stack pointer
323. Forward% = 0 '                                                                 not moving forward through maze yet
324. WHILE VisitedCells% < Maze.Hcell * Maze.Vcell '                                make sure we visit all cells
325.     ValidCells% = 0 '                                                          initiate number of valid neighbor cells
326.     IF CurrentCell.Ypos <> 1 THEN '                                            are we at top of maze?
327.         IF Cell(CurrentCell.Xpos, CurrentCell.Ypos - 1).Doors = 0 THEN '       no, does cell above have all doors closed?
328.             ValidCells% = ValidCells% + 1 '                                    yes, remember this cell
329.         END IF
330.     END IF
331.     IF CurrentCell.Xpos <> Maze.Hcell THEN '                                   are we at right side of maze?
332.         IF Cell(CurrentCell.Xpos + 1, CurrentCell.Ypos).Doors = 0 THEN '       no, does cell to right have all doors closed?
333.             ValidCells% = ValidCells% + 2 '                                    yes, remember this cell
334.         END IF
335.     END IF
336.     IF CurrentCell.Ypos <> Maze.Vcell THEN '                                   are we at bottom of maze?
337.         IF Cell(CurrentCell.Xpos, CurrentCell.Ypos + 1).Doors = 0 THEN '       no, does cell below have all doors closed?
338.             ValidCells% = ValidCells% + 4 '                                    yes, remember this cell
339.         END IF
340.     END IF
341.     IF CurrentCell.Xpos <> 1 THEN '                                            are we at left side of maze?
342.         IF Cell(CurrentCell.Xpos - 1, CurrentCell.Ypos).Doors = 0 THEN '       no, does cell to left have all doors closed?
343.             ValidCells% = ValidCells% + 8 '                                    yes, remember this cell
344.         END IF
345.     END IF
346.     IF ValidCells% <> 0 THEN '                                                 did at least one cell have all doors closed?
347.         DO '                                                                   yes, one or more of the cells have all doors closed
348.             RandomDir% = INT(RND(1) * 4) '                                     choose a random cell direction
349.         LOOP UNTIL ValidCells% AND 2 ^ RandomDir% '                            continue if this is a valid move
350.         Stack(Pointer%) = CurrentCell '                                        push our current location into the LIFO stack
351.         Pointer% = Pointer% + 1 '                                              increment the stack pointer
352.         VisitedCells% = VisitedCells% + 1 '                                    increment the number of cells visited so far
353.         Forward% = -1 '                                                        we are moving forward in the maze
354.         OPENDOORS CurrentCell.Xpos, CurrentCell.Ypos, RandomDir% '             open current and adjacent cell doors
355.         SELECT CASE RandomDir% '                                               which direction did we move forward?
356.             CASE 0 '                                                           up/north
357.                 CurrentCell.Ypos = CurrentCell.Ypos - 1 '                      make this the new current cell
358.             CASE 1 '                                                           right/east
359.                 CurrentCell.Xpos = CurrentCell.Xpos + 1 '                      make this the new current cell
360.             CASE 2 '                                                           down/south
361.                 CurrentCell.Ypos = CurrentCell.Ypos + 1 '                      make this the new current cell
362.             CASE 3 '                                                           left/west
363.                 CurrentCell.Xpos = CurrentCell.Xpos - 1 '                      make this the new current cell
364.         END SELECT
365.     ELSE '                                                                     no, all adjacent cells had at least one door open
366.         IF Forward% THEN '                                                     were we previously moving forward in the maze?
367.             Forward% = 0 '                                                     yes, we are not any longer
368.             IF Maze.Looping = 1 THEN '                                         should this be a looping maze?
369.                 'IF INT(RND(1) * 2) = 1 THEN '                                 yes, flip a coin to see if a loop structure built here
370.                 Remove% = 0 '                                                  assume no doors will be opened
371.                 SELECT CASE RandomDir% '                                       which direction were we traveling in?
372.                     CASE 0 '                                                   up/north
373.                         IF CurrentCell.Ypos <> 1 THEN Remove% = -1 '           if not at top of maze upper door can be opened
374.                     CASE 1 '                                                   right/east
375.                         IF CurrentCell.Xpos <> Maze.Hcell THEN Remove% = -1 '  if not at right side of maze right door can be opened
376.                     CASE 2 '                                                   down/south
377.                         IF CurrentCell.Ypos <> Maze.Vcell THEN Remove% = -1 '  if not at bottom of maze bottom door can be opened
378.                     CASE 3 '                                                   left/west
379.                         IF CurrentCell.Xpos <> 1 THEN Remove% = -1 '           if not at left side of maze left door can be opened
380.                 END SELECT
381.                 IF Remove% THEN '                                              is it ok to open a door?
382.                     OPENDOORS CurrentCell.Xpos, CurrentCell.Ypos, RandomDir% ' yes, open current and adjacent cell doors
383.                 END IF
384.                 'END IF
385.             END IF
386.         END IF
387.         Pointer% = Pointer% - 1 '                                              decrement the stack pointer
388.         CurrentCell = Stack(Pointer%) '                                        pop the previous cell position from the LIFO stack
389.     END IF
390. WEND
391. REDIM Stack(0) AS STACK '                                                      clear the memory used by the stack
392.  
393. END SUB
394.  
395. '----------------------------------------------------------------------------------------------------------------------
396.  
397. SUB OPENDOORS (x%, y%, Direction%)
398.  
399. '**
400. '** Opens a door in the current cell and the corresponding door in the adjacent cell
401. '**
402.  
403. SHARED Cell() AS CELL '   we need access to the cell array
404.  
405. SELECT CASE Direction% '                                                       which direction are we going?
406.     CASE 0 '                                                                   up/north
407.         Cell(x%, y%).Doors = Cell(x%, y%).Doors + 1 '                          open the current cell's up door
408.         Cell(x%, y% - 1).Doors = Cell(x%, y% - 1).Doors + 4 '                  open the adjacent cell's south door
409.     CASE 1 '                                                                   right/east
410.         Cell(x%, y%).Doors = Cell(x%, y%).Doors + 2 '                          open the current cell's right door
411.         Cell(x% + 1, y%).Doors = Cell(x% + 1, y%).Doors + 8 '                  open the adjacent cell's left door
412.     CASE 2 '                                                                   down/south
413.         Cell(x%, y%).Doors = Cell(x%, y%).Doors + 4 '                          open the current cell's down door
414.         Cell(x%, y% + 1).Doors = Cell(x%, y% + 1).Doors + 1 '                  open the adjacent cell's up door
415.     CASE 3 '                                                                   left/west
416.         Cell(x%, y%).Doors = Cell(x%, y%).Doors + 8 '                          open this cell's left door
417.         Cell(x% - 1, y%).Doors = Cell(x% - 1, y%).Doors + 2 '                  open the adjacent cell's right door
418. END SELECT
419.  
420. END SUB
421.  
422. '----------------------------------------------------------------------------------------------------------------------
423.  
424. SUB DRAWCELL (x%, y%, n%)
425.  
426. '**
427. '** Draws a maze cell
428. '**
429. '** The drawing routines below can produce either a square maze (0) or a round maze (1) as defined by Maze.MazeType
430. '** These drawing routines are included to act as an example of how you can create custom maze drawing routines for
431. '** the mazes you generate and use in your programs.
432. '**
433.  
434. SHARED Maze AS MAZE '        we need access to the maze properties
435.  
436. DIM xc% '                    center X coordinate of cell
437. DIM yc% '                    center Y coordiante of cell
438. DIM Radius! '                radius of various maze corners
439.  
440. xc% = x% + Maze.CellSize \ 2 '                                                 calculate center X coordinate of cell
441. yc% = y% + Maze.CellSize \ 2 '                                                 calculate center Y coordinate of cell
442.  
443. SELECT CASE n% '                                                               which cell to draw?
444.     CASE 1 '                                                                   ** up door open
445.         IF Maze.MazeType = 0 THEN
446.             FOR Radius! = 1 TO Maze.Thickness - .5 STEP .5
447.                 CIRCLES x% - 1, y% + Maze.CellSize, Radius!, Maze.Colour, PI, PIDOWN, 0
448.                 CIRCLES x% + Maze.CellSize, y% + Maze.CellSize, Radius!, Maze.Colour, PIDOWN, 0, 0
449.             NEXT Radius!
450.             LINE (x% - 1, y% + Maze.CellSize)-(x% - Maze.Thickness, yc% - Maze.CellSize), Maze.Colour, BF
451.             LINE (x% + Maze.CellSize, y% + Maze.CellSize)-(x% + Maze.CellSize + Maze.Thickness - 1, yc% - Maze.CellSize), Maze.Colour, BF
452.             LINE (x% - 1, y% + Maze.CellSize)-(x% + Maze.CellSize, y% + Maze.CellSize + Maze.Thickness - 1), Maze.Colour, BF
453.         ELSE '                                                                 ** round maze
454.             FOR Radius! = Maze.CellSize / 2 + 1 TO Maze.CellSize / 2 + Maze.Thickness STEP .5
455.                 CIRCLES xc%, yc%, Radius!, Maze.Colour, PI, 0, 0
456.             NEXT Radius!
457.             LINE (x% - 1, yc%)-(x% - Maze.Thickness, yc% - Maze.CellSize), Maze.Colour, BF
458.             LINE (x% + Maze.CellSize, yc%)-(x% + Maze.CellSize + Maze.Thickness - 1, yc% - Maze.CellSize), Maze.Colour, BF
459.         END IF
460.     CASE 2 '                                                                   ** right door open
461.         IF Maze.MazeType = 0 THEN
462.             FOR Radius! = 1 TO Maze.Thickness - .5 STEP .5
463.                 CIRCLES x% - 1, y% - 1, Radius!, Maze.Colour, PIUP, PI, 0
464.                 CIRCLES x% - 1, y% + Maze.CellSize, Radius!, Maze.Colour, PI, PIDOWN, 0
465.             NEXT Radius!
466.             LINE (x% - 1, y% - 1)-(xc% + Maze.CellSize, y% - Maze.Thickness), Maze.Colour, BF
467.             LINE (x% - 1, y% + Maze.CellSize)-(xc% + Maze.CellSize, y% + Maze.CellSize + Maze.Thickness - 1), Maze.Colour, BF
468.             LINE (x% - 1, y% - 1)-(x% - Maze.Thickness, y% + Maze.CellSize), Maze.Colour, BF
469.         ELSE
470.             FOR Radius! = Maze.CellSize / 2 + 1 TO Maze.CellSize / 2 + Maze.Thickness STEP .5
471.                 CIRCLES xc%, yc%, Radius!, Maze.Colour, PIUP, PIDOWN, 0
472.             NEXT Radius!
473.             LINE (xc%, y% - 1)-(xc% + Maze.CellSize, y% - Maze.Thickness), Maze.Colour, BF
474.             LINE (xc%, y% + Maze.CellSize)-(xc% + Maze.CellSize, y% + Maze.CellSize + Maze.Thickness - 1), Maze.Colour, BF
475.         END IF
476.     CASE 3 '                                                                   ** up and right doors open
477.         IF Maze.MazeType = 0 THEN
478.             FOR Radius! = 1 TO Maze.Thickness - .5 STEP .5
479.                 CIRCLES x% + Maze.CellSize + Maze.Thickness - 1, y% - Maze.Thickness, Radius!, Maze.Colour, PI, PIDOWN, 0
480.                 CIRCLES x% - 1, y% + Maze.CellSize, Radius!, Maze.Colour, PI, PIDOWN, 0
481.             NEXT Radius!
482.             LINE (x% - 1, y% + Maze.CellSize)-(x% - Maze.Thickness, yc% - Maze.CellSize), Maze.Colour, BF
483.             LINE (x% - 1, y% + Maze.CellSize)-(xc% + Maze.CellSize, y% + Maze.CellSize + Maze.Thickness - 1), Maze.Colour, BF
484.             LINE (x% + Maze.CellSize, yc% - Maze.CellSize)-(x% + Maze.CellSize + Maze.Thickness - 1, y% - Maze.Thickness), Maze.Colour, BF
485.             LINE (x% + Maze.CellSize + Maze.Thickness - 1, y% - 1)-(xc% + Maze.CellSize, y% - Maze.Thickness), Maze.Colour, BF
486.         ELSE
487.             FOR Radius! = Maze.CellSize / 2 - Maze.Thickness TO Maze.CellSize / 2 STEP .5
488.                 CIRCLES xc% + Maze.CellSize, yc% - Maze.CellSize, Radius!, Maze.Colour, PI, PIDOWN, 0
489.             NEXT Radius!
490.             FOR Radius! = Maze.CellSize * 1.5 + Maze.Thickness TO Maze.CellSize * 1.5 + 1 STEP -.5
491.                 CIRCLES xc% + Maze.CellSize, yc% - Maze.CellSize, Radius!, Maze.Colour, PI, PIDOWN, 0
492.             NEXT Radius!
493.         END IF
494.     CASE 4 '                                                                   ** down door open
495.         IF Maze.MazeType = 0 THEN
496.             FOR Radius! = 1 TO Maze.Thickness - .5 STEP .5
497.                 CIRCLES x% - 1, y% - 1, Radius!, Maze.Colour, PIUP, PI, 0
498.                 CIRCLES x% + Maze.CellSize, y% - 1, Radius!, Maze.Colour, 0, PIUP, 0
499.             NEXT Radius!
500.             LINE (x% - 1, y% - 1)-(x% - Maze.Thickness, yc% + Maze.CellSize), Maze.Colour, BF
501.             LINE (x% + Maze.CellSize, y% - 1)-(x% + Maze.CellSize + Maze.Thickness - 1, yc% + Maze.CellSize), Maze.Colour, BF
502.             LINE (x% - 1, y% - 1)-(x% + Maze.CellSize, y% - Maze.Thickness), Maze.Colour, BF
503.         ELSE
504.             FOR Radius! = Maze.CellSize / 2 + 1 TO Maze.CellSize / 2 + Maze.Thickness STEP .5
505.                 CIRCLES xc%, yc%, Radius!, Maze.Colour, 0, PI, 0
506.             NEXT Radius!
507.             LINE (x% - 1, yc%)-(x% - Maze.Thickness, yc% + Maze.CellSize), Maze.Colour, BF
508.             LINE (x% + Maze.CellSize, yc%)-(x% + Maze.CellSize + Maze.Thickness - 1, yc% + Maze.CellSize), Maze.Colour, BF
509.         END IF
510.     CASE 5 '                                                                   **  up and down doors open
511.         LINE (x% - 1, yc% - Maze.CellSize)-(x% - Maze.Thickness, yc% + Maze.CellSize), Maze.Colour, BF
512.         LINE (x% + Maze.CellSize, yc% - Maze.CellSize)-(x% + Maze.CellSize + Maze.Thickness - 1, yc% + Maze.CellSize), Maze.Colour, BF
513.     CASE 6 '                                                                   ** down and right doors open
514.         IF Maze.MazeType = 0 THEN
515.             FOR Radius! = 1 TO Maze.Thickness - .5 STEP .5
516.                 CIRCLES x% - 1, y% - 1, Radius!, Maze.Colour, PIUP, PI, 0
517.                 CIRCLES x% + Maze.CellSize + Maze.Thickness - 1, y% + Maze.CellSize + Maze.Thickness - 1, Radius!, Maze.Colour, PIUP, PI, 0
518.             NEXT Radius!
519.             LINE (x% - 1, y% - 1)-(x% - Maze.Thickness, yc% + Maze.CellSize), Maze.Colour, BF
520.             LINE (x% - 1, y% - 1)-(xc% + Maze.CellSize, y% - Maze.Thickness), Maze.Colour, BF
521.             LINE (x% + Maze.CellSize + Maze.Thickness - 1, y% + Maze.CellSize)-(xc% + Maze.CellSize, y% + Maze.CellSize + Maze.Thickness - 1), Maze.Colour, BF
522.             LINE (x% + Maze.CellSize, y% + Maze.CellSize + Maze.Thickness - 1)-(x% + Maze.CellSize + Maze.Thickness - 1, yc% + Maze.CellSize), Maze.Colour, BF
523.         ELSE
524.             FOR Radius! = Maze.CellSize / 2 - Maze.Thickness TO Maze.CellSize / 2 STEP .5
525.                 CIRCLES xc% + Maze.CellSize, yc% + Maze.CellSize, Radius!, Maze.Colour, PIUP, PI, 0
526.             NEXT Radius!
527.             FOR Radius! = Maze.CellSize * 1.5 + Maze.Thickness TO Maze.CellSize * 1.5 + 1 STEP -.5
528.                 CIRCLES xc% + Maze.CellSize, yc% + Maze.CellSize, Radius!, Maze.Colour, PIUP, PI, 0
529.             NEXT Radius!
530.         END IF
531.     CASE 7 '                                                                   ** up and down and right doors open
532.         IF Maze.MazeType = 0 THEN
533.             FOR Radius! = 1 TO Maze.Thickness - .5 STEP .5
534.                 CIRCLES x% + Maze.CellSize + Maze.Thickness - 1, y% - Maze.Thickness, Radius!, Maze.Colour, PI, PIDOWN, 0
535.                 CIRCLES x% + Maze.CellSize + Maze.Thickness - 1, y% + Maze.CellSize + Maze.Thickness - 1, Radius!, Maze.Colour, PIUP, PI, 0
536.             NEXT Radius!
537.             LINE (x% - 1, yc% - Maze.CellSize)-(x% - Maze.Thickness, yc% + Maze.CellSize), Maze.Colour, BF
538.             LINE (x% + Maze.CellSize + Maze.Thickness - 1, y% + Maze.CellSize)-(xc% + Maze.CellSize, y% + Maze.CellSize + Maze.Thickness - 1), Maze.Colour, BF
539.             LINE (x% + Maze.CellSize, y% + Maze.CellSize + Maze.Thickness - 1)-(x% + Maze.CellSize + Maze.Thickness - 1, yc% + Maze.CellSize), Maze.Colour, BF
540.             LINE (x% + Maze.CellSize, yc% - Maze.CellSize)-(x% + Maze.CellSize + Maze.Thickness - 1, y% - Maze.Thickness), Maze.Colour, BF
541.             LINE (xc% + Maze.CellSize, y% - 1)-(x% + Maze.CellSize + Maze.Thickness - 1, y% - Maze.Thickness), Maze.Colour, BF
542.         ELSE
543.             FOR Radius! = Maze.CellSize / 2 - Maze.Thickness TO Maze.CellSize / 2 STEP .5
544.                 CIRCLES xc% + Maze.CellSize, yc% - Maze.CellSize, Radius!, Maze.Colour, PI, PIDOWN, 0
545.                 CIRCLES xc% + Maze.CellSize, yc% + Maze.CellSize, Radius!, Maze.Colour, PIUP, PI, 0
546.             NEXT Radius!
547.             LINE (x% - 1, yc% - Maze.CellSize)-(x% - Maze.Thickness, yc% + Maze.CellSize), Maze.Colour, BF
548.         END IF
549.     CASE 8 '                                                                   ** left door open
550.         IF Maze.MazeType = 0 THEN
551.             FOR Radius! = 1 TO Maze.Thickness - .5 STEP .5
552.                 CIRCLES x% + Maze.CellSize, y% - 1, Radius!, Maze.Colour, 0, PIUP, 0
553.                 CIRCLES x% + Maze.CellSize, y% + Maze.CellSize, Radius!, Maze.Colour, PIDOWN, 0, 0
554.             NEXT Radius!
555.             LINE (xc% - Maze.CellSize, y% - 1)-(x% + Maze.CellSize, y% - Maze.Thickness), Maze.Colour, BF
556.             LINE (xc% - Maze.CellSize, y% + Maze.CellSize)-(x% + Maze.CellSize, y% + Maze.CellSize + Maze.Thickness - 1), Maze.Colour, BF
557.             LINE (x% + Maze.CellSize, y% - 1)-(x% + Maze.CellSize + Maze.Thickness - 1, y% + Maze.CellSize), Maze.Colour, BF
558.         ELSE
559.             FOR Radius! = Maze.CellSize / 2 + 1 TO Maze.CellSize / 2 + Maze.Thickness STEP .5
560.                 CIRCLES xc%, yc%, Radius!, Maze.Colour, PIDOWN, PIUP, 0
561.             NEXT Radius!
562.             LINE (xc% - Maze.CellSize, y% - 1)-(xc%, y% - Maze.Thickness), Maze.Colour, BF
563.             LINE (xc% - Maze.CellSize, y% + Maze.CellSize)-(xc%, y% + Maze.CellSize + Maze.Thickness - 1), Maze.Colour, BF
564.         END IF
565.     CASE 9 '                                                                   ** up and left doors open
566.         IF Maze.MazeType = 0 THEN
567.             FOR Radius! = 1 TO Maze.Thickness - .5 STEP .5
568.                 CIRCLES x% - Maze.Thickness, y% - Maze.Thickness, Radius!, Maze.Colour, PIDOWN, 0, 0
569.                 CIRCLES x% + Maze.CellSize, y% + Maze.CellSize, Radius!, Maze.Colour, PIDOWN, 0, 0
570.             NEXT Radius!
571.             LINE (xc% - Maze.CellSize, y% + Maze.CellSize)-(x% + Maze.CellSize, y% + Maze.CellSize + Maze.Thickness - 1), Maze.Colour, BF
572.             LINE (x% + Maze.CellSize, yc% - Maze.CellSize)-(x% + Maze.CellSize + Maze.Thickness - 1, y% + Maze.CellSize), Maze.Colour, BF
573.             LINE (xc% - Maze.CellSize, y% - 1)-(x% - Maze.Thickness, y% - Maze.Thickness), Maze.Colour, BF
574.             LINE (x% - 1, yc% - Maze.CellSize)-(x% - Maze.Thickness, y% - Maze.Thickness), Maze.Colour, BF
575.         ELSE
576.             FOR Radius! = Maze.CellSize / 2 - Maze.Thickness TO Maze.CellSize / 2 STEP .5
577.                 CIRCLES xc% - Maze.CellSize, yc% - Maze.CellSize, Radius!, Maze.Colour, PIDOWN, 0, 0
578.             NEXT Radius!
579.             FOR Radius! = Maze.CellSize * 1.5 + Maze.Thickness TO Maze.CellSize * 1.5 + 1 STEP -.5
580.                 CIRCLES xc% - Maze.CellSize, yc% - Maze.CellSize, Radius!, Maze.Colour, PIDOWN, 0, 0
581.             NEXT Radius!
582.         END IF
583.     CASE 10 '                                                                  ** left and right doors open
584.         LINE (xc% - Maze.CellSize, y% - 1)-(xc% + Maze.CellSize, y% - Maze.Thickness), Maze.Colour, BF
585.         LINE (xc% - Maze.CellSize, y% + Maze.CellSize)-(xc% + Maze.CellSize, y% + Maze.CellSize + Maze.Thickness - 1), Maze.Colour, BF
586.     CASE 11 '                                                                  ** up and left and right doors open
587.         IF Maze.MazeType = 0 THEN
588.             FOR Radius! = 1 TO Maze.Thickness - .5 STEP .5
589.                 CIRCLES x% - Maze.Thickness, y% - Maze.Thickness, Radius!, Maze.Colour, PIDOWN, 0, 0
590.                 CIRCLES x% + Maze.CellSize + Maze.Thickness - 1, y% - Maze.Thickness, Radius!, Maze.Colour, PI, PIDOWN, 0
591.             NEXT Radius!
592.             LINE (xc% - Maze.CellSize, y% + Maze.CellSize)-(xc% + Maze.CellSize, y% + Maze.CellSize + Maze.Thickness - 1), Maze.Colour, BF
593.             LINE (xc% - Maze.CellSize, y% - 1)-(x% - Maze.Thickness, y% - Maze.Thickness), Maze.Colour, BF
594.             LINE (x% - 1, yc% - Maze.CellSize)-(x% - Maze.Thickness, y% - Maze.Thickness), Maze.Colour, BF
595.             LINE (x% + Maze.CellSize, yc% - Maze.CellSize)-(x% + Maze.CellSize + Maze.Thickness - 1, y% - Maze.Thickness), Maze.Colour, BF
596.             LINE (xc% + Maze.CellSize, y% - 1)-(x% + Maze.CellSize + Maze.Thickness - 1, y% - Maze.Thickness), Maze.Colour, BF
597.         ELSE
598.             FOR Radius! = Maze.CellSize / 2 - Maze.Thickness TO Maze.CellSize / 2 STEP .5
599.                 CIRCLES xc% - Maze.CellSize, yc% - Maze.CellSize, Radius!, Maze.Colour, PIDOWN, 0, 0
600.                 CIRCLES xc% + Maze.CellSize, yc% - Maze.CellSize, Radius!, Maze.Colour, PI, PIDOWN, 0
601.             NEXT Radius!
602.             LINE (xc% - Maze.CellSize, y% + Maze.CellSize)-(xc% + Maze.CellSize, y% + Maze.CellSize + Maze.Thickness - 1), Maze.Colour, BF
603.         END IF
604.     CASE 12 '                                                                  ** down and left doors open
605.         IF Maze.MazeType = 0 THEN
606.             FOR Radius! = 1 TO Maze.Thickness - .5 STEP .5
607.                 CIRCLES x% + Maze.CellSize, y% - 1, Radius!, Maze.Colour, 0, PIUP, 0
608.                 CIRCLES x% - Maze.Thickness, y% + Maze.CellSize + Maze.Thickness - 1, Radius!, Maze.Colour, 0, PIUP, 0
609.             NEXT Radius!
610.             LINE (xc% - Maze.CellSize, y% - 1)-(x% + Maze.CellSize, y% - Maze.Thickness), Maze.Colour, BF
611.             LINE (x% + Maze.CellSize, y% - 1)-(x% + Maze.CellSize + Maze.Thickness - 1, yc% + Maze.CellSize), Maze.Colour, BF
612.             LINE (xc% - Maze.CellSize, y% + Maze.CellSize)-(x% - Maze.Thickness, y% + Maze.CellSize + Maze.Thickness - 1), Maze.Colour, BF
613.             LINE (x% - 1, yc% + Maze.CellSize)-(x% - Maze.Thickness, y% + Maze.CellSize + Maze.Thickness - 1), Maze.Colour, BF
614.         ELSE
615.             FOR Radius! = Maze.CellSize / 2 - Maze.Thickness TO Maze.CellSize / 2 STEP .5
616.                 CIRCLES xc% - Maze.CellSize, yc% + Maze.CellSize, Radius!, Maze.Colour, 0, PIUP, 0
617.             NEXT Radius!
618.             FOR Radius! = Maze.CellSize * 1.5 + Maze.Thickness TO Maze.CellSize * 1.5 + 1 STEP -.5
619.                 CIRCLES xc% - Maze.CellSize, yc% + Maze.CellSize, Radius!, Maze.Colour, 0, PIUP, 0
620.             NEXT Radius!
621.         END IF
622.     CASE 13 '                                                                  ** up and down and left doors open
623.         IF Maze.MazeType = 0 THEN
624.             FOR Radius! = 1 TO Maze.Thickness - .5 STEP .5
625.                 CIRCLES x% - Maze.Thickness, y% - Maze.Thickness, Radius!, Maze.Colour, PIDOWN, 0, 0
626.                 CIRCLES x% - Maze.Thickness, y% + Maze.CellSize + Maze.Thickness - 1, Radius!, Maze.Colour, 0, PIUP, 0
627.             NEXT Radius!
628.             LINE (x% + Maze.CellSize, yc% - Maze.CellSize)-(x% + Maze.CellSize + Maze.Thickness - 1, yc% + Maze.CellSize), Maze.Colour, BF
629.             LINE (xc% - Maze.CellSize, y% - 1)-(x% - Maze.Thickness, y% - Maze.Thickness), Maze.Colour, BF
630.             LINE (x% - 1, yc% - Maze.CellSize)-(x% - Maze.Thickness, y% - Maze.Thickness), Maze.Colour, BF
631.             LINE (xc% - Maze.CellSize, y% + Maze.CellSize)-(x% - Maze.Thickness, y% + Maze.CellSize + Maze.Thickness - 1), Maze.Colour, BF
632.             LINE (x% - 1, yc% + Maze.CellSize)-(x% - Maze.Thickness, y% + Maze.CellSize + Maze.Thickness - 1), Maze.Colour, BF
633.         ELSE
634.             FOR Radius! = Maze.CellSize / 2 - Maze.Thickness TO Maze.CellSize / 2 STEP .5
635.                 CIRCLES xc% - Maze.CellSize, yc% + Maze.CellSize, Radius!, Maze.Colour, 0, PIUP, 0
636.                 CIRCLES xc% - Maze.CellSize, yc% - Maze.CellSize, Radius!, Maze.Colour, PIDOWN, 0, 0
637.             NEXT Radius!
638.             LINE (x% + Maze.CellSize, yc% - Maze.CellSize)-(x% + Maze.CellSize + Maze.Thickness - 1, yc% + Maze.CellSize), Maze.Colour, BF
639.         END IF
640.     CASE 14 '                                                                  ** down and left and right doors open
641.         IF Maze.MazeType = 0 THEN
642.             FOR Radius! = 1 TO Maze.Thickness - .5 STEP .5
643.                 CIRCLES x% + Maze.CellSize + Maze.Thickness - 1, y% + Maze.CellSize + Maze.Thickness - 1, Radius!, Maze.Colour, PIUP, PI, 0
644.                 CIRCLES x% - Maze.Thickness, y% + Maze.CellSize + Maze.Thickness - 1, Radius!, Maze.Colour, 0, PIUP, 0
645.             NEXT Radius!
646.             LINE (xc% - Maze.CellSize, y% - 1)-(xc% + Maze.CellSize, y% - Maze.Thickness), Maze.Colour, BF
647.             LINE (xc% - Maze.CellSize, y% + Maze.CellSize)-(x% - Maze.Thickness, y% + Maze.CellSize + Maze.Thickness - 1), Maze.Colour, BF
648.             LINE (xc% + Maze.CellSize, y% + Maze.CellSize)-(x% + Maze.CellSize + Maze.Thickness - 1, y% + Maze.CellSize + Maze.Thickness - 1), Maze.Colour, BF
649.             LINE (x% - 1, yc% + Maze.CellSize)-(x% - Maze.Thickness, y% + Maze.CellSize + Maze.Thickness - 1), Maze.Colour, BF
650.             LINE (x% + Maze.CellSize, yc% + Maze.CellSize)-(x% + Maze.CellSize + Maze.Thickness - 1, y% + Maze.CellSize + Maze.Thickness - 1), Maze.Colour, BF
651.         ELSE
652.             FOR Radius! = Maze.CellSize / 2 - Maze.Thickness TO Maze.CellSize / 2 STEP .5
653.                 CIRCLES xc% - Maze.CellSize, yc% + Maze.CellSize, Radius!, Maze.Colour, 0, PIUP, 0
654.                 CIRCLES xc% + Maze.CellSize, yc% + Maze.CellSize, Radius!, Maze.Colour, PIUP, PI, 0
655.             NEXT Radius!
656.             LINE (xc% - Maze.CellSize, y% - 1)-(xc% + Maze.CellSize, y% - Maze.Thickness), Maze.Colour, BF
657.         END IF
658.     CASE 15 '                                                                  ** all doors open
659.         IF Maze.MazeType = 0 THEN
660.             FOR Radius! = 1 TO Maze.Thickness - .5 STEP .5
661.                 CIRCLES x% - Maze.Thickness, y% - Maze.Thickness, Radius!, Maze.Colour, PIDOWN, 0, 0
662.                 CIRCLES x% + Maze.CellSize + Maze.Thickness - 1, y% - Maze.Thickness, Radius!, Maze.Colour, PI, PIDOWN, 0
663.                 CIRCLES x% + Maze.CellSize + Maze.Thickness - 1, y% + Maze.CellSize + Maze.Thickness - 1, Radius!, Maze.Colour, PIUP, PI, 0
664.                 CIRCLES x% - Maze.Thickness, y% + Maze.CellSize + Maze.Thickness - 1, Radius!, Maze.Colour, 0, PIUP, 0
665.             NEXT Radius!
666.             LINE (xc% - Maze.CellSize, y% - 1)-(x% - Maze.Thickness, y% - Maze.Thickness), Maze.Colour, BF
667.             LINE (x% - 1, yc% - Maze.CellSize)-(x% - Maze.Thickness, y% - Maze.Thickness), Maze.Colour, BF
668.             LINE (x% + Maze.CellSize, yc% - Maze.CellSize)-(x% + Maze.CellSize + Maze.Thickness - 1, y% - Maze.Thickness), Maze.Colour, BF
669.             LINE (xc% + Maze.CellSize, y% - 1)-(x% + Maze.CellSize + Maze.Thickness - 1, y% - Maze.Thickness), Maze.Colour, BF
670.             LINE (xc% - Maze.CellSize, y% + Maze.CellSize)-(x% - Maze.Thickness, y% + Maze.CellSize + Maze.Thickness - 1), Maze.Colour, BF
671.             LINE (xc% + Maze.CellSize, y% + Maze.CellSize)-(x% + Maze.CellSize + Maze.Thickness - 1, y% + Maze.CellSize + Maze.Thickness - 1), Maze.Colour, BF
672.             LINE (x% - 1, yc% + Maze.CellSize)-(x% - Maze.Thickness, y% + Maze.CellSize + Maze.Thickness - 1), Maze.Colour, BF
673.             LINE (x% + Maze.CellSize, yc% + Maze.CellSize)-(x% + Maze.CellSize + Maze.Thickness - 1, y% + Maze.CellSize + Maze.Thickness - 1), Maze.Colour, BF
674.         ELSE
675.             FOR Radius! = Maze.CellSize / 2 - Maze.Thickness TO Maze.CellSize / 2 STEP .5
676.                 CIRCLES xc% - Maze.CellSize, yc% - Maze.CellSize, Radius!, Maze.Colour, PIDOWN, 0, 0
677.                 CIRCLES xc% - Maze.CellSize, yc% + Maze.CellSize, Radius!, Maze.Colour, 0, PIUP, 0
678.                 CIRCLES xc% + Maze.CellSize, yc% - Maze.CellSize, Radius!, Maze.Colour, PI, PIDOWN, 0
679.                 CIRCLES xc% + Maze.CellSize, yc% + Maze.CellSize, Radius!, Maze.Colour, PIUP, PI, 0
680.             NEXT Radius!
681.         END IF
682. END SELECT
683.  
684. END SUB
685.  
686. '----------------------------------------------------------------------------------------------------------------------
687.  
688. SUB CIRCLES (cx%, cy%, r!, c~&, s!, e!, a!)
689.  
690. '**
691. '** QB64 temporary replacement CIRCLE command.
692. '**
693. '** The CIRCLE command in QB64 has a few bugs listed below:
694. '**
695. '** - radian end points are not calculate properly when creating arcs
696. '** - center line to radian end points do not close properly due to previous bug listed
697. '**
698. '** This circle command replacement works very similiarly to the native CIRCLE command:
699. '**
700. '** SYNTAX: CIRCLES x%, y%, radius!, color~&, start_radian!, end_radian!, aspect_ratio!
701. '**
702. '**   x%            - center X coordinate of circle
703. '**   y%            - center Y coordinate of circle
704. '**   radius!       - the radius of the circle
705. '**   color~&       - the circle's color
706. '**   start_radian! - the radian on circle curcunference to begin drawing at
707. '**   end_radian!   - the radian on circle circumference to end drawing at
708. '**   aspect_ratio! - the aspect ratio of the circle
709. '**
710. '** NOTE: unlike the native CIRCLE command, all arguments MUST be supplied. For example,
711. '**       with the native command this will draw a perfect circle with the default color,
712. '**       start radian, end radian and aspect ratio:
713. '**
714. '**       CIRCLE (319, 239), 100
715. '**
716. '**       To do the same thing with this replacement command you must supply everything:
717. '**
718. '**       CIRCLES 319, 239, 100, _RGB32(255, 255, 255), 0, 0, 0
719. '**
720. '** ACKNOWLEGEMENTS: The FOR/NEXT step formula was was written by Codeguy for Unseen
721. '**                  Machine's Visual library EllipseXS command. Specifically:
722. '**                         MinStep! = 1 / (2 * PI535 * Radius!)
723. '**            NOTE: The FOR/NEXT loop was replaced with a DO/LOOP by SMcNeill - 02/02/-13
724. '**
725. '** Includes performance tweaks made by SMcNeill on 02/02/13 - specifically removing a few redundant * -1
726. '** statements and converting the FOR/NEXT loop to a DO loop for a ~3% increase in performance.
727. '**
728. '** Corrected bug in which variables being passed in were being modified and passed back - 02/02/13
729. '**
730.  
731. DIM s%, e%, nx%, ny%, xr!, yr!, st!, en!, asp! '     local variables used
732.  
733. st! = s! '                                           copy start radian to local variable
734. en! = e! '                                           copy end radian to local variable
735. asp! = a! '                                          copy aspect ratio to local variable
736. IF asp! <= 0 THEN asp! = 1 '                         keep aspect ratio between 0 and 4
737. IF asp! > 4 THEN asp! = 4
738. IF asp! < 1 THEN xr! = r! * asp! * 4 ELSE xr! = r! ' calculate x/y radius based on aspect ratio
739. IF asp! > 1 THEN yr! = r! * asp! ELSE yr! = r!
740. IF st! < 0 THEN s% = -1: st! = -st! '                remember if line needs drawn from center to start radian
741. IF en! < 0 THEN e% = -1: en! = -en! '                remember if line needs drawn from center to end radian
742. IF s% THEN '                                         draw line from center to start radian?
743.     nx% = cx% + xr! * COS(st!) '                     yes, compute starting point on circle's circumference
744.     ny% = cy% + yr! * -SIN(st!)
745.     LINE (cx%, cy%)-(nx%, ny%), c~& '                draw line from center to radian
746. END IF
747. IF en! <= st! THEN en! = en! + 6.2831852 '           come back around to proper location (draw counterclockwise)
748. stepp! = 0.159154945806 / r!
749. c! = st! '                                           cycle from start radian to end radian
750. DO
751.     nx% = cx% + xr! * COS(c!) '                      compute next point on circle's circumfrerence
752.     ny% = cy% + yr! * -SIN(c!)
753.     PSET (nx%, ny%), c~& '                           draw the point
754.     c! = c! + stepp!
755. LOOP UNTIL c! >= en!
756. IF e% THEN LINE -(cx%, cy%), c~& '                   draw line from center to end radian if needed
757.  
758. END SUB
759.  
760. '----------------------------------------------------------------------------------------------------------------------
761.