Maze Generator with notes for using and Game example

[bplus]

This maze maker creates path all through maze, you might want to knock more walls down to have alternate ways to go through maze. I am working that aspect with a game I am cloning.

I left notes so it will be easier for me to pickup and use in future, or by you all ;)

Code: QB64: [Select]

1. OPTION _EXPLICIT
2. _TITLE "Maze Generator" 'B+
3. ' 2019-09-02 isolated and updated generator code for OPTION _EXPLICIT
4. ' from trans 2018-06-15 for Amazing Rat.bas (QB64)
5. ' From SmallBASIC code written by Chris WS developer
6. ' Backtracking maze generator by chrisws 2016-06-30 now found at
7. ' https://github.com/smallbasic/smallbasic.github.io/blob/5601c8bc1d794c5b143d863555bb7c15a5966a3c/samples/node/1623.bas
8. '
9. ' Chris notes:
10. ' https://en.wikipedia.org/wiki/Maze_generation_algorithm
11. ' - Starting from a random cell,
12. ' - Selects a random neighbouring cell that has not been visited.
13. ' - Remove the wall between the two cells and marks the new cell as visited,
14. '   and adds it to the stack to facilitate backtracking.
15. ' - Continues with a cell that has no unvisited neighbours being considered a dead-end.
16. '   When at a dead-end it backtracks through the path until it reaches a cell with an
17. '   unvisited neighbour, continuing the path generation by visiting this new,
18. '   unvisited cell (creating a new junction).
19. '   This process continues until every cell has been visited, backtracking all the
20. '   way back to the beginning cell. We can be sure every cell is visited.
21. '
22.  
23. 'B+ notes for using:
24. ' The most important item is that the maze uses 2 arrays one for vertical walls the other for horizontal
25. ' CONST xmax, ymax is pixel size used in maze coder, using SW, SH for screen dimensions
26. ' Maze should mount in top left corner of screen with min border space around it at left and top at least.
27. ' CONST W, H - number of cells Wide and High you can specify.
28. ' CONST wallThk - adjusts thickness of walls
29. ' CONST mazeClr - colors walls made with BF in LINE statement
30. ' CONST border - will create a space around the maze
31. ' SHARED cellW, cellH - are pixels sizes for cell, see calcs before SCREEN command
32. ' SHARED  h_walls(W, H) AS INTEGER, v_walls(W, H) AS INTEGER - these are your Maze, 0 no wall, 1 = wall
33. ' When player occupies cell x, y that cell may v_wall that blocks player going left;
34. ' a cell v_wall(x+1, y) = 1 will block a player going right;
35. ' cell (x, y) may have an h_wall that stops player from going up;
36. ' cell (x, y+1) may have h_wall that stops player at x, y from going down.
37. ' Cells at (W, y) should not be occupied with W cells wide and array base 0 only W-1 can be occupied
38. ' unless game needs something special.
39. ' Likewise cells at (x, H) should only provide wall to stop player from going out of box.
40.  
41. CONST xmax = 800, ymax = 600, SW = 1200, SH = 700 'maze pixels from 0,0 and screen SH, SW
42. CONST W = 40, H = 30, border = 25, wallThk = 5 'maze cells wide and high
43. CONST mazeClr = &HFFFF8800
44.  
45. TYPE cell
46.     x AS INTEGER
47.     y AS INTEGER
48. END TYPE
49.  
50. DIM SHARED cellW AS SINGLE, cellH AS SINGLE, h_walls(W, H) AS INTEGER, v_walls(W, H) AS INTEGER
51. cellW = (xmax - 2 * border - wallThk) / W
52. cellH = (ymax - 2 * border - wallThk) / H
53.  
54. RANDOMIZE TIMER
55. SCREEN _NEWIMAGE(SW, SH, 32)
56. _SCREENMOVE 100, 20
57. LINE (0, 0)-(xmax, ymax), &HFFFFFF00, B
58. init_walls
59. generate_maze
60. show_maze
61. SLEEP
62.  
63. SUB init_walls ()
64.     DIM x AS INTEGER, y AS INTEGER
65.     FOR x = 0 TO W
66.         FOR y = 0 TO H
67.             v_walls(x, y) = 1
68.             h_walls(x, y) = 1
69.         NEXT
70.     NEXT
71. END SUB
72.  
73. SUB show_maze ()
74.     DIM py AS SINGLE, px AS SINGLE, y AS INTEGER, x AS INTEGER
75.     py = border
76.     FOR y = 0 TO H
77.         px = border
78.         FOR x = 0 TO W
79.             IF x < W AND h_walls(x, y) = 1 THEN
80.                 LINE (px, py)-STEP(cellW + wallThk, wallThk), mazeClr, BF
81.             END IF
82.             IF y < H AND v_walls(x, y) = 1 THEN
83.                 LINE (px, py)-STEP(wallThk, cellH + wallThk), mazeClr, BF
84.             END IF
85.             px = px + cellW
86.         NEXT
87.         py = py + cellH
88.     NEXT
89. END SUB
90.  
91. SUB rand_cell (rWx, rHy)
92.     rWx = INT(RND * 1000) MOD W
93.     rHy = INT(RND * 1000) MOD H
94. END SUB
95.  
96. SUB get_unvisited (visited() AS INTEGER, current AS cell, unvisited() AS cell, uvi AS INTEGER)
97.     REDIM unvisited(0) AS cell
98.     DIM x AS INTEGER, y AS INTEGER
99.     x = current.x
100.     y = current.y
101.     uvi = 0
102.     IF x > 0 THEN
103.         IF visited(x - 1, y) = 0 THEN
104.             uvi = uvi + 1
105.             REDIM _PRESERVE unvisited(uvi) AS cell
106.             unvisited(uvi).x = x - 1
107.             unvisited(uvi).y = y
108.         END IF
109.     END IF
110.     IF x < W - 1 THEN
111.         IF visited(x + 1, y) = 0 THEN
112.             uvi = uvi + 1
113.             REDIM _PRESERVE unvisited(uvi) AS cell
114.             unvisited(uvi).x = x + 1
115.             unvisited(uvi).y = y
116.         END IF
117.     END IF
118.     IF y > 0 THEN
119.         IF visited(x, y - 1) = 0 THEN
120.             uvi = uvi + 1
121.             REDIM _PRESERVE unvisited(uvi) AS cell
122.             unvisited(uvi).x = x
123.             unvisited(uvi).y = y - 1
124.         END IF
125.     END IF
126.     IF y < H - 1 THEN
127.         IF visited(x, y + 1) = 0 THEN
128.             uvi = uvi + 1
129.             REDIM _PRESERVE unvisited(uvi) AS cell
130.             unvisited(uvi).x = x
131.             unvisited(uvi).y = y + 1
132.         END IF
133.     END IF
134. END SUB
135.  
136. SUB generate_maze ()
137.     DIM visited(W, H) AS INTEGER
138.     DIM num_visited AS INTEGER, num_cells AS INTEGER, si AS INTEGER
139.     DIM cnt AS INTEGER, rc AS INTEGER, x AS INTEGER, y AS INTEGER
140.     REDIM stack(0) AS cell
141.     DIM curr_cell AS cell, next_cell AS cell, cur_cell AS cell
142.  
143.     rand_cell cur_cell.x, cur_cell.y
144.     visited(curr_cell.x, curr_cell.y) = 1
145.     num_visited = 1
146.     num_cells = W * H
147.     si = 0
148.     WHILE num_visited < num_cells
149.         REDIM cells(0) AS cell
150.         cnt = 0
151.         get_unvisited visited(), curr_cell, cells(), cnt
152.         IF cnt > 0 THEN
153.  
154.             ' choose randomly one of the current cell's unvisited neighbours
155.             rc = INT(RND * 100) MOD cnt + 1
156.             next_cell.x = cells(rc).x
157.             next_cell.y = cells(rc).y
158.  
159.             ' push the current cell to the stack
160.             si = si + 1
161.             REDIM _PRESERVE stack(si) AS cell
162.             stack(si).x = curr_cell.x
163.             stack(si).y = curr_cell.y
164.  
165.             ' remove the wall between the current cell and the chosen cell
166.             IF next_cell.x = curr_cell.x THEN
167.                 x = next_cell.x
168.                 y = max(next_cell.y, curr_cell.y)
169.                 h_walls(x, y) = 0
170.             ELSE
171.                 x = max(next_cell.x, curr_cell.x)
172.                 y = next_cell.y
173.                 v_walls(x, y) = 0
174.             END IF
175.  
176.             ' make the chosen cell the current cell and mark it as visited
177.             curr_cell.x = next_cell.x
178.             curr_cell.y = next_cell.y
179.             visited(curr_cell.x, curr_cell.y) = 1
180.             num_visited = num_visited + 1
181.  
182.         ELSEIF si > 0 THEN
183.  
184.             ' pop a cell from the stack and make it the current cell
185.             curr_cell.x = stack(si).x
186.             curr_cell.y = stack(si).y
187.             si = si - 1
188.             REDIM _PRESERVE stack(si) AS cell
189.  
190.         ELSE
191.             EXIT WHILE
192.         END IF
193.     WEND
194. END SUB
195.  
196. FUNCTION max (a, b)
197.     IF a > b THEN max = a ELSE max = b
198. END FUNCTION
199.  

EDIT (already, oops I meant to eliminate margin and just use border, no sense in both. While at it I fixed a few notes hopefully clearer and mounted maze onto larger screen SW, SH to show how to do that too, see screen shot)

Dang, I posted screen shot and noticed tiny little squares missing in bottom right corners. OK fixed and added a wallThk CONST so you can adjust wall size and still mount maze centered in xmax, ymax pixel area.
(new screen shot)

[Petr]

Very nice, BPlus!

I see that the walls and the gaps are on the same scale. I'll try to do something about it in own way (it won't be today). Thanks for sharing!

[bplus]

Hi Petr,

I hope to have game up using generator soon, it's sorta working now but needs some work.

I am trying to clone this:
https://easylang.online/games/
click game then maze

[Petr]

Thank you for link, BPlus! Very nice game!

[bplus]

Hi Petr, for you a sneak preview!

My mouse action isn't as smooth as EasyLang's but so far I have 16 lines of code to add to catch up to theirs in size ;D (but their code is making faces, nice!)

Code: QB64: [Select]

1. OPTION _EXPLICIT
2. _TITLE "Escape from Monster Maze" 'B+ 2019-09-03
3. ' 2019-08-31 attempt a better, smoother mouser
4. ' 2019-09-03 Maze geneartion, nice mouse and arrow key action,
5. '            momentum removed, just cant turn corners that fast.
6. ' 2019-09-03 Troubles
7. ' I either have to loose arrow keys or deactivate mouse or something
8. ' so arrow key presses are defeated by mouse presence. :-P
9. ' and still not 100% happy with mouse action. ;(
10. ' I kicked out walls randomly several for each new monster but not effective for creating
11. ' alternate paths when dang monsters are ganging up at upper left corner, yikes! no escape!!!
12. ' to fix that
13. ' 1. lay out another generated maze over top of current that will create meaningfull alternate route
14. ' 2. relocate monsters when my guy gets back to start!
15.  
16.  
17. CONST xmax = 800, ymax = 600 'screen
18. CONST W = 15, H = 15, border = 50 'maze cells wide and high
19. CONST mazeClr = &HFFFF8800
20.  
21. TYPE cell
22.     x AS INTEGER
23.     y AS INTEGER
24. END TYPE
25.  
26. DIM SHARED cellW AS SINGLE, cellH AS SINGLE, h_walls(W, H) AS INTEGER, v_walls(W, H) AS INTEGER
27. cellW = (xmax - 2 * border) / W
28. cellH = (ymax - 2 * border) / H
29.  
30. '        Locals for Main module code
31. 'DIM x, y
32. DIM px, py, mx, my, k$, d, a, start, i, nMonsters, test AS cell
33.  
34. 'RANDOMIZE TIMER
35. SCREEN _NEWIMAGE(xmax, ymax, 32)
36. _SCREENMOVE 100, 20
37. nMonsters = 3
38. DO
39.     init_walls
40.     generate_maze
41.     'open gate a bottom right corner to esacpe
42.     h_walls(W - 1, H) = 0
43.     nMonsters = nMonsters + 1
44.     REDIM m(1 TO nMonsters) AS cell
45.     FOR i = 1 TO nMonsters
46.         m(i).x = RND * 7 * W / 8 + W / 8 - 1: m(i).y = RND * 7 * H / 8 + H / 8 - 1
47.         'for every monster make 2 escape hatches
48.         test.x = INT(RND * (W - 2)) + 1: test.y = INT(RND * (H - 2)) + 1
49.         WHILE h_walls(test.x, test.y) = 0
50.             test.x = INT(RND * (W - 2)) + 1: test.y = INT(RND * (H - 2)) + 1
51.         WEND
52.         h_walls(test.x, test.y) = 0
53.         test.x = INT(RND * (W - 2)) + 1: test.y = INT(RND * (H - 2)) + 1
54.         WHILE v_walls(test.x, test.y) = 0
55.             test.x = INT(RND * (W - 2)) + 1: test.y = INT(RND * (H - 2)) + 1
56.         WEND
57.         v_walls(test.x, test.y) = 0
58.         test.x = INT(RND * (W - 2)) + 1: test.y = INT(RND * (H - 2)) + 1
59.         WHILE h_walls(test.x, test.y) = 0
60.             test.x = INT(RND * (W - 2)) + 1: test.y = INT(RND * (H - 2)) + 1
61.         WEND
62.         h_walls(test.x, test.y) = 0
63.         test.x = INT(RND * (W - 2)) + 1: test.y = INT(RND * (H - 2)) + 1
64.         WHILE v_walls(test.x, test.y) = 0
65.             test.x = INT(RND * (W - 2)) + 1: test.y = INT(RND * (H - 2)) + 1
66.         WEND
67.         v_walls(test.x, test.y) = 0
68.     NEXT
69.     px = 0: py = 0: start = TIMER
70.     WHILE 1
71.         CLS
72.  
73.         show_maze
74.  
75.         FOR i = 1 TO nMonsters
76.             fcirc (m(i).x + .5) * cellW + border, (m(i).y + .5) * cellH + border, cellH / 3, &HFFFF0000
77.             d = INT(RND * 4) + 1
78.             SELECT CASE d
79.                 CASE 1 'up
80.                     IF m(i).y - 1 >= 0 THEN
81.                         IF h_walls(m(i).x, m(i).y) = 0 THEN m(i).y = m(i).y - 1
82.                     END IF
83.                 CASE 2 'down
84.                     IF m(i).y + 1 <= H - 1 THEN
85.                         IF h_walls(m(i).x, m(i).y + 1) = 0 THEN m(i).y = m(i).y + 1
86.                     END IF
87.                 CASE 3 'right
88.                     IF m(i).x + 1 <= W - 1 THEN
89.                         IF v_walls(m(i).x + 1, m(i).y) = 0 THEN m(i).x = m(i).x + 1
90.                     END IF
91.                 CASE 4 'left
92.                     IF m(i).x - 1 >= 0 THEN
93.                         IF v_walls(m(i).x, m(i).y) = 0 THEN m(i).x = m(i).x - 1
94.                     END IF
95.             END SELECT
96.             IF m(i).x = px AND m(i).y = py THEN
97.                 fcirc (px + .5) * cellW + border, (py + .5) * cellH + border, cellH / 3, &HFFFFFFFF 'draw player
98.                 _DISPLAY
99.                 _DELAY 1
100.                 px = 0: py = 0
101.             END IF
102.         NEXT
103.         d = 0
104.         WHILE _MOUSEINPUT: WEND
105.         mx = INT((_MOUSEX - border) / cellW): my = INT((_MOUSEY - border) / cellH) 'offset by 1/2 character size
106.         LOCATE 1, 1: PRINT SPACE$(10)
107.         LOCATE 1, 1: PRINT px, py, mx, my
108.         'if the mouse is near the player then it will act as magnet drawing player to it unless wall in way
109.         'IF ABS(mx - px) >= 1 AND ABS(my - py) = 0 OR ABS(mx - px) = 0 AND ABS(my - py) >= 1 THEN
110.         IF ABS(mx - px) <> 0 OR ABS(my - py) <> 0 THEN
111.             a = _R2D(_ATAN2(my - py, mx - px))
112.             IF a < 0 THEN a = a + 360
113.             IF a > 250 AND a < 290 THEN d = 1
114.             IF a > 70 AND a < 110 THEN d = 2
115.             IF (a >= 0 AND a < 20) OR (a > 340 AND a <= 360) THEN d = 3
116.             IF a > 160 AND a < 200 THEN d = 4
117.         END IF
118.  
119.         k$ = INKEY$ 'key press takes precedence over mouse
120.  
121.         IF LEN(k$) = 2 THEN
122.             SELECT CASE ASC(k$, 2)
123.                 CASE 72: d = 1 'up
124.                 CASE 80: d = 2 'down
125.                 CASE 77: d = 3 'right
126.                 CASE 75: d = 4 'left
127.             END SELECT
128.         END IF
129.         '  _____     ________
130.         '  |x, y     |x+1, y        the walls of the cell x, y are at right and above,
131.         '  ________                 x+1 has the next wall and y+1 is the next horizontal separator
132.         '  |x, y+1
133.         SELECT CASE d
134.             CASE 1 'up
135.                 IF py - 1 >= 0 THEN
136.                     IF h_walls(px, py) = 0 THEN py = py - 1
137.                 END IF
138.             CASE 2 'down
139.                 IF py + 1 <= H THEN
140.                     IF h_walls(px, py + 1) = 0 THEN py = py + 1
141.                 END IF
142.             CASE 3 'right
143.                 IF px + 1 <= W - 1 THEN
144.                     IF v_walls(px + 1, py) = 0 THEN px = px + 1
145.                 END IF
146.             CASE 4 'left
147.                 IF px - 1 >= 0 THEN
148.                     IF v_walls(px, py) = 0 THEN px = px - 1
149.                 END IF
150.         END SELECT
151.         fcirc (px + .5) * cellW + border, (py + .5) * cellH + border, cellH / 3, &HFF0000FF 'draw player
152.         _DISPLAY
153.         _LIMIT 5
154.         IF px = W - 1 AND py = H THEN EXIT WHILE
155.     WEND
156.     _PRINTSTRING (xmax - 580, ymax - 20), "You escaped in" + STR$((TIMER - start) \ 1) + " secs, press any to continue"
157.     _DISPLAY
158.     SLEEP
159. LOOP
160. END
161.  
162.  
163. SUB fcirc (CX AS INTEGER, CY AS INTEGER, R AS INTEGER, C AS _UNSIGNED LONG)
164.     DIM Radius AS INTEGER, RadiusError AS INTEGER
165.     DIM X AS INTEGER, Y AS INTEGER
166.     Radius = ABS(R): RadiusError = -Radius: X = Radius: Y = 0
167.     IF Radius = 0 THEN PSET (CX, CY), C: EXIT SUB
168.     LINE (CX - X, CY)-(CX + X, CY), C, BF
169.     WHILE X > Y
170.         RadiusError = RadiusError + Y * 2 + 1
171.         IF RadiusError >= 0 THEN
172.             IF X <> Y + 1 THEN
173.                 LINE (CX - Y, CY - X)-(CX + Y, CY - X), C, BF
174.                 LINE (CX - Y, CY + X)-(CX + Y, CY + X), C, BF
175.             END IF
176.             X = X - 1
177.             RadiusError = RadiusError - X * 2
178.         END IF
179.         Y = Y + 1
180.         LINE (CX - X, CY - Y)-(CX + X, CY - Y), C, BF
181.         LINE (CX - X, CY + Y)-(CX + X, CY + Y), C, BF
182.     WEND
183. END SUB
184.  
185. ' From SmallBASIC code written by Chris WS developer
186. ' Backtracking maze generator by chrisws 2016-06-30 now found at
187. ' https://github.com/smallbasic/smallbasic.github.io/blob/5601c8bc1d794c5b143d863555bb7c15a5966a3c/samples/node/1623.bas
188. '
189. ' Chris notes:
190. ' https://en.wikipedia.org/wiki/Maze_generation_algorithm
191. ' - Starting from a random cell,
192. ' - Selects a random neighbouring cell that has not been visited.
193. ' - Remove the wall between the two cells and marks the new cell as visited,
194. '   and adds it to the stack to facilitate backtracking.
195. ' - Continues with a cell that has no unvisited neighbours being considered a dead-end.
196. '   When at a dead-end it backtracks through the path until it reaches a cell with an
197. '   unvisited neighbour, continuing the path generation by visiting this new,
198. '   unvisited cell (creating a new junction).
199. '   This process continues until every cell has been visited, backtracking all the
200. '   way back to the beginning cell. We can be sure every cell is visited.
201.  
202. SUB init_walls ()
203.     DIM x AS INTEGER, y AS INTEGER
204.     FOR x = 0 TO W
205.         FOR y = 0 TO H
206.             v_walls(x, y) = 1
207.             h_walls(x, y) = 1
208.         NEXT
209.     NEXT
210. END SUB
211.  
212. SUB show_maze ()
213.     DIM py AS SINGLE, px AS SINGLE, y AS INTEGER, x AS INTEGER
214.     py = border
215.     FOR y = 0 TO H
216.         px = border
217.         FOR x = 0 TO W
218.             IF x < W AND h_walls(x, y) = 1 THEN
219.                 LINE (px, py)-STEP(cellW, 2), mazeClr, BF
220.             END IF
221.             IF y < H AND v_walls(x, y) = 1 THEN
222.                 LINE (px, py)-STEP(2, cellH), mazeClr, BF
223.             END IF
224.             px = px + cellW
225.         NEXT
226.         py = py + cellH
227.     NEXT
228. END SUB
229.  
230. SUB rand_cell (rWx, rHy)
231.     rWx = INT(RND * 1000) MOD W
232.     rHy = INT(RND * 1000) MOD H
233. END SUB
234.  
235. SUB get_unvisited (visited() AS INTEGER, current AS cell, unvisited() AS cell, uvi AS INTEGER)
236.     REDIM unvisited(0) AS cell
237.     DIM x AS INTEGER, y AS INTEGER
238.     x = current.x
239.     y = current.y
240.     uvi = 0
241.     IF x > 0 THEN
242.         IF visited(x - 1, y) = 0 THEN
243.             uvi = uvi + 1
244.             REDIM _PRESERVE unvisited(uvi) AS cell
245.             unvisited(uvi).x = x - 1
246.             unvisited(uvi).y = y
247.         END IF
248.     END IF
249.     IF x < W - 1 THEN
250.         IF visited(x + 1, y) = 0 THEN
251.             uvi = uvi + 1
252.             REDIM _PRESERVE unvisited(uvi) AS cell
253.             unvisited(uvi).x = x + 1
254.             unvisited(uvi).y = y
255.         END IF
256.     END IF
257.     IF y > 0 THEN
258.         IF visited(x, y - 1) = 0 THEN
259.             uvi = uvi + 1
260.             REDIM _PRESERVE unvisited(uvi) AS cell
261.             unvisited(uvi).x = x
262.             unvisited(uvi).y = y - 1
263.         END IF
264.     END IF
265.     IF y < H - 1 THEN
266.         IF visited(x, y + 1) = 0 THEN
267.             uvi = uvi + 1
268.             REDIM _PRESERVE unvisited(uvi) AS cell
269.             unvisited(uvi).x = x
270.             unvisited(uvi).y = y + 1
271.         END IF
272.     END IF
273. END SUB
274.  
275. SUB generate_maze ()
276.     DIM visited(W, H) AS INTEGER
277.     DIM num_visited AS INTEGER, num_cells AS INTEGER, si AS INTEGER
278.     DIM cnt AS INTEGER, rc AS INTEGER, x AS INTEGER, y AS INTEGER
279.     REDIM stack(0) AS cell
280.     DIM curr_cell AS cell, next_cell AS cell, cur_cell AS cell
281.  
282.     rand_cell cur_cell.x, cur_cell.y
283.     visited(curr_cell.x, curr_cell.y) = 1
284.     num_visited = 1
285.     num_cells = W * H
286.     si = 0
287.     WHILE num_visited < num_cells
288.         REDIM cells(0) AS cell
289.         cnt = 0
290.         get_unvisited visited(), curr_cell, cells(), cnt
291.         IF cnt > 0 THEN
292.  
293.             ' choose randomly one of the current cell's unvisited neighbours
294.             rc = INT(RND * 100) MOD cnt + 1
295.             next_cell.x = cells(rc).x
296.             next_cell.y = cells(rc).y
297.  
298.             ' push the current cell to the stack
299.             si = si + 1
300.             REDIM _PRESERVE stack(si) AS cell
301.             stack(si).x = curr_cell.x
302.             stack(si).y = curr_cell.y
303.  
304.             ' remove the wall between the current cell and the chosen cell
305.             IF next_cell.x = curr_cell.x THEN
306.                 x = next_cell.x
307.                 y = max(next_cell.y, curr_cell.y)
308.                 h_walls(x, y) = 0
309.             ELSE
310.                 x = max(next_cell.x, curr_cell.x)
311.                 y = next_cell.y
312.                 v_walls(x, y) = 0
313.             END IF
314.  
315.             ' make the chosen cell the current cell and mark it as visited
316.             curr_cell.x = next_cell.x
317.             curr_cell.y = next_cell.y
318.             visited(curr_cell.x, curr_cell.y) = 1
319.             num_visited = num_visited + 1
320.  
321.         ELSEIF si > 0 THEN
322.  
323.             ' pop a cell from the stack and make it the current cell
324.             curr_cell.x = stack(si).x
325.             curr_cell.y = stack(si).y
326.             si = si - 1
327.             REDIM _PRESERVE stack(si) AS cell
328.  
329.         ELSE
330.             EXIT WHILE
331.         END IF
332.     WEND
333. END SUB
334.  
335. FUNCTION max (a, b)
336.     IF a > b THEN max = a ELSE max = b
337. END FUNCTION
338.  

[Petr]

Very nice, BPlus! Just recalculate the maze cell into graphical coordinates and then use them to move and the movement will be smooth. I tried it, it's not as easy as writing it...

[bplus]

Well so far my record is 14 monsters in 48 secs :D

[bplus]

Escape from Monster Maze:

We made some faces, used XOR to smooth mouse action a tiny bit, and Luke's timestamp to time deactivation of mouse so it doesn't counteract arrow key presses.

Code: QB64: [Select]

1. OPTION _EXPLICIT
2. _TITLE "Escape from Monster Maze" 'B+ 2019-09-03
3. ' 2019-08-31 attempt a better, smoother mouser
4. ' 2019-09-03 Maze geneartion, nice mouse and arrow key action,
5. '            momentum removed, just cant turn corners that fast.
6. ' 2019-09-03 Troubles
7. ' I either have to loose arrow keys or deactivate mouse or something
8. ' so arrow key presses are defeated by mouse presence. :-P
9. ' and still not 100% happy with mouse action. ;(
10. ' I kicked out walls randomly several for each new monster but not effective for creating
11. ' alternate paths when dang monsters are ganging up at upper left corner, yikes! no escape!!!
12. ' to fix that
13. ' 1. lay out another generated maze over top of current that will create meaningfull alternate route
14. ' 2. relocate monsters when my guy gets back to start!
15.  
16. ' Ok I fixed it so if you start using arrow keys the mouse is disabled for 3 seconds from last arrow press
17. ' using Luke's time stamp.  This way the mouse position wont counteract arrow key presses.
18. ' HEY I think XOR smoothed out the mouse action a tiny bit!!! and so did opening up angles
19. ' directions from mouse to full 90 degrees around 0, 90, 180, 270.
20.  
21.  
22. DECLARE LIBRARY 'give Lukes' timesstamp function a test drive!
23.     FUNCTION time& (BYVAL null&)
24. END DECLARE
25.  
26. CONST xmax = 700, ymax = 700 'screen
27. CONST W = 15, H = 15, border = 50 'maze cells wide and high
28. CONST mazeClr = &HFFFF8800
29.  
30. TYPE cell
31.     x AS INTEGER
32.     y AS INTEGER
33. END TYPE
34.  
35. DIM SHARED stopTime& 'disable mouse influence of player position for 3 sec from last arrow key
36. DIM SHARED cellW AS SINGLE, cellH AS SINGLE, h_walls(W, H) AS INTEGER, v_walls(W, H) AS INTEGER
37. cellW = (xmax - 2 * border) / W
38. cellH = (ymax - 2 * border) / H
39.  
40. '        Locals for Main module code
41. DIM px, py, mx, my, k$, d, a, start, i, j, nMonsters, test AS cell, tmp AS LONG, wayt
42.  
43. RANDOMIZE TIMER
44. SCREEN _NEWIMAGE(xmax, ymax, 32)
45. _SCREENMOVE 100, 20
46. nMonsters = 3
47. DO
48.     init_walls
49.     generate_maze
50.     'open gate a bottom right corner to esacpe
51.     h_walls(W - 1, H) = 0
52.     nMonsters = nMonsters + 1
53.     REDIM m(1 TO nMonsters) AS cell
54.     FOR i = 1 TO nMonsters
55.         m(i).x = RND * 7 * W / 8 + W / 8 - 1: m(i).y = RND * 7 * H / 8 + H / 8 - 1
56.         FOR j = 1 TO 2 'for every monster make 4 escape hatches
57.             test.x = INT(RND * (W - 2)) + 1: test.y = INT(RND * (H - 2)) + 1
58.             WHILE h_walls(test.x, test.y) = 0
59.                 test.x = INT(RND * (W - 2)) + 1: test.y = INT(RND * (H - 2)) + 1
60.             WEND
61.             h_walls(test.x, test.y) = 0
62.             test.x = INT(RND * (W - 2)) + 1: test.y = INT(RND * (H - 2)) + 1
63.             WHILE v_walls(test.x, test.y) = 0
64.                 test.x = INT(RND * (W - 2)) + 1: test.y = INT(RND * (H - 2)) + 1
65.             WEND
66.             v_walls(test.x, test.y) = 0
67.         NEXT
68.     NEXT
69.     px = 0: py = 0: start = TIMER
70.     WHILE 1
71.         CLS
72.         show_maze
73.         FOR i = 1 TO nMonsters
74.             'fcirc (m(i).x + .5) * cellW + border, (m(i).y + .5) * cellH + border, cellH / 3, &HFFFF0000
75.             IF RND < .5 THEN
76.                 monster1 (m(i).x + .5) * cellW + border, (m(i).y + .5) * cellH + border
77.             ELSE
78.                 monster2 (m(i).x + .5) * cellW + border, (m(i).y + .5) * cellH + border
79.             END IF
80.             d = INT(RND * 4) + 1
81.             SELECT CASE d
82.                 CASE 1 'up
83.                     IF m(i).y - 1 >= 0 THEN
84.                         IF h_walls(m(i).x, m(i).y) = 0 THEN m(i).y = m(i).y - 1
85.                     END IF
86.                 CASE 2 'down
87.                     IF m(i).y + 1 <= H - 1 THEN
88.                         IF h_walls(m(i).x, m(i).y + 1) = 0 THEN m(i).y = m(i).y + 1
89.                     END IF
90.                 CASE 3 'right
91.                     IF m(i).x + 1 <= W - 1 THEN
92.                         IF v_walls(m(i).x + 1, m(i).y) = 0 THEN m(i).x = m(i).x + 1
93.                     END IF
94.                 CASE 4 'left
95.                     IF m(i).x - 1 >= 0 THEN
96.                         IF v_walls(m(i).x, m(i).y) = 0 THEN m(i).x = m(i).x - 1
97.                     END IF
98.             END SELECT
99.             IF m(i).x = px AND m(i).y = py THEN
100.                 'fcirc (px + .5) * cellW + border, (py + .5) * cellH + border, cellH / 3, &HFFFFFFFF 'draw player
101.                 makeFace (px + .5) * cellW + border, (py + .5) * cellH + border, 1
102.                 _DISPLAY
103.                 _DELAY 1
104.                 px = 0: py = 0
105.             END IF
106.         NEXT
107.         d = 0
108.         IF mouseOK(0) = -1 THEN
109.             WHILE _MOUSEINPUT: WEND
110.             mx = INT((_MOUSEX - border) / cellW): my = INT((_MOUSEY - border) / cellH) 'convert to maze cell
111.  
112.             'if the mouse is near the player then it will act as magnet drawing player to it unless wall in way
113.             IF ABS(mx - px) <> 0 XOR ABS(my - py) <> 0 THEN 'ah ha XOR smooths it out a bit
114.                 a = _R2D(_ATAN2(my - py, mx - px))
115.                 IF a < 0 THEN a = a + 360
116.                 IF a > 225 AND a < 315 THEN d = 1
117.                 IF a > 45 AND a < 135 THEN d = 2
118.                 IF (a >= 0 AND a < 45) OR (a > 315 AND a <= 360) THEN d = 3
119.                 IF a > 135 AND a < 225 THEN d = 4
120.             ELSE
121.                 d = 0
122.             END IF
123.         END IF
124.  
125.         'debug
126.         'LOCATE 1, 1: PRINT SPACE$(100)
127.         'LOCATE 1, 1: PRINT px, py, mx, my, mouseOK(0), timestamp&, stopTime&
128.  
129.         k$ = INKEY$ 'key press takes precedence over mouse
130.         IF LEN(k$) = 2 THEN
131.             SELECT CASE ASC(k$, 2) 'turn off mouse control for 3 secs after arrow press
132.                 CASE 72: d = 1: tmp = mouseOK(1) 'up
133.                 CASE 80: d = 2: tmp = mouseOK(1) 'down
134.                 CASE 77: d = 3: tmp = mouseOK(1) 'right
135.                 CASE 75: d = 4: tmp = mouseOK(1) 'left
136.             END SELECT
137.         END IF
138.         '  _____     ________
139.         '  |x, y     |x+1, y        the walls of the cell x, y are at right and above,
140.         '  ________                 x+1 has the next wall and y+1 is the next horizontal separator
141.         '  |x, y+1
142.         SELECT CASE d
143.             CASE 1 'up
144.                 IF py - 1 >= 0 THEN
145.                     IF h_walls(px, py) = 0 THEN py = py - 1
146.                 END IF
147.             CASE 2 'down
148.                 IF py + 1 <= H THEN
149.                     IF h_walls(px, py + 1) = 0 THEN py = py + 1
150.                 END IF
151.             CASE 3 'right
152.                 IF px + 1 <= W - 1 THEN
153.                     IF v_walls(px + 1, py) = 0 THEN px = px + 1
154.                 END IF
155.             CASE 4 'left
156.                 IF px - 1 >= 0 THEN
157.                     IF v_walls(px, py) = 0 THEN px = px - 1
158.                 END IF
159.         END SELECT
160.         'fcirc (px + .5) * cellW + border, (py + .5) * cellH + border, cellH / 3, &HFF0000FF 'draw player
161.         makeFace (px + .5) * cellW + border, (py + .5) * cellH + border, 0
162.         _DISPLAY
163.         _LIMIT 5
164.         IF px = W - 1 AND py = H THEN EXIT WHILE
165.     WEND
166.     _PRINTSTRING (xmax - 580, ymax - 20), "You escaped in" + STR$((TIMER - start) \ 1) + " secs, press any to continue"
167.     _DISPLAY
168.     wayt = 1
169.     WHILE wayt
170.         WHILE _MOUSEINPUT: WEND
171.         IF _MOUSEBUTTON(1) THEN wayt = 0
172.         IF LEN(INKEY$) THEN wayt = 0
173.     WEND
174. LOOP
175.  
176. FUNCTION mouseOK% (mode%) '1 set, 0 checks if time is up yes -1, no 0
177.     IF mode% > 0 THEN 'set
178.         stopTime& = timestamp& + 3 '3 secs before mouse access
179.     ELSE
180.         IF timestamp& - stopTime& > 0 THEN mouseOK% = -1 ELSE mouseOK% = 0
181.     END IF
182. END FUNCTION
183.  
184. FUNCTION timestamp& 'try Luke's Timestamp for checking times
185.     timestamp& = time&(0)
186. END FUNCTION
187.  
188. SUB makeFace (x, y, white)
189.     IF white THEN fcirc x, y, cellW / 3, &HFF994422 ELSE fcirc x, y, cellW / 3, &HFFAABBFF
190.     fcirc x - 3 * cellW / 24, y, cellW / 14, &HFF0000FF
191.     fcirc x + 3 * cellW / 24, y, cellW / 14, &HFF0000FF
192.     fcirc x - 3 * cellW / 24, y + 1, cellW / 28, &HFF000000
193.     fcirc x + 3 * cellW / 24, y + 1, cellW / 28, &HFF000000
194.     LINE (x - cellW / 12, y + cellW / 6)-STEP(cellW / 6, 2), &HFFFF4444, BF
195. END SUB
196.  
197. SUB monster1 (x, y)
198.     fcirc x, y, cellW / 2.5, &HFF990000
199.     LINE (x - cellW / 6, y - 2)-STEP(cellW / 18, 1), &HFF000000, BF
200.     LINE (x + cellW / 12, y - 2)-STEP(cellW / 18, 1), &HFF000000, BF
201.     LINE (x - cellW / 12, y + cellW / 6)-STEP(cellW / 6, 2), &HFF000000, BF
202. END SUB
203.  
204. SUB monster2 (x, y)
205.     fcirc x, y, cellW / 2.5, &HFF990000
206.     LINE (x - cellW / 6, y - 6)-STEP(cellW / 18, 1), &HFF000000, BF
207.     LINE (x + cellW / 12, y - 6)-STEP(cellW / 18, 1), &HFF000000, BF
208.     fcirc x, y + cellW / 6, cellW / 6, &HFF000000
209. END SUB
210.  
211. SUB fcirc (CX AS INTEGER, CY AS INTEGER, R AS INTEGER, C AS _UNSIGNED LONG)
212.     DIM Radius AS INTEGER, RadiusError AS INTEGER
213.     DIM X AS INTEGER, Y AS INTEGER
214.     Radius = ABS(R): RadiusError = -Radius: X = Radius: Y = 0
215.     IF Radius = 0 THEN PSET (CX, CY), C: EXIT SUB
216.     LINE (CX - X, CY)-(CX + X, CY), C, BF
217.     WHILE X > Y
218.         RadiusError = RadiusError + Y * 2 + 1
219.         IF RadiusError >= 0 THEN
220.             IF X <> Y + 1 THEN
221.                 LINE (CX - Y, CY - X)-(CX + Y, CY - X), C, BF
222.                 LINE (CX - Y, CY + X)-(CX + Y, CY + X), C, BF
223.             END IF
224.             X = X - 1
225.             RadiusError = RadiusError - X * 2
226.         END IF
227.         Y = Y + 1
228.         LINE (CX - X, CY - Y)-(CX + X, CY - Y), C, BF
229.         LINE (CX - X, CY + Y)-(CX + X, CY + Y), C, BF
230.     WEND
231. END SUB
232.  
233. ' From SmallBASIC code written by Chris WS developer
234. ' Backtracking maze generator by chrisws 2016-06-30 now found at
235. ' https://github.com/smallbasic/smallbasic.github.io/blob/5601c8bc1d794c5b143d863555bb7c15a5966a3c/samples/node/1623.bas
236. '
237. ' Chris notes:
238. ' https://en.wikipedia.org/wiki/Maze_generation_algorithm
239. ' - Starting from a random cell,
240. ' - Selects a random neighbouring cell that has not been visited.
241. ' - Remove the wall between the two cells and marks the new cell as visited,
242. '   and adds it to the stack to facilitate backtracking.
243. ' - Continues with a cell that has no unvisited neighbours being considered a dead-end.
244. '   When at a dead-end it backtracks through the path until it reaches a cell with an
245. '   unvisited neighbour, continuing the path generation by visiting this new,
246. '   unvisited cell (creating a new junction).
247. '   This process continues until every cell has been visited, backtracking all the
248. '   way back to the beginning cell. We can be sure every cell is visited.
249.  
250. SUB init_walls ()
251.     DIM x AS INTEGER, y AS INTEGER
252.     FOR x = 0 TO W
253.         FOR y = 0 TO H
254.             v_walls(x, y) = 1
255.             h_walls(x, y) = 1
256.         NEXT
257.     NEXT
258. END SUB
259.  
260. SUB show_maze ()
261.     DIM py AS SINGLE, px AS SINGLE, y AS INTEGER, x AS INTEGER
262.     py = border
263.     FOR y = 0 TO H
264.         px = border
265.         FOR x = 0 TO W
266.             IF x < W AND h_walls(x, y) = 1 THEN
267.                 LINE (px, py)-STEP(cellW, 2), mazeClr, BF
268.             END IF
269.             IF y < H AND v_walls(x, y) = 1 THEN
270.                 LINE (px, py)-STEP(2, cellH), mazeClr, BF
271.             END IF
272.             px = px + cellW
273.         NEXT
274.         py = py + cellH
275.     NEXT
276. END SUB
277.  
278. SUB rand_cell (rWx, rHy)
279.     rWx = INT(RND * 1000) MOD W: rHy = INT(RND * 1000) MOD H
280. END SUB
281.  
282. SUB get_unvisited (visited() AS INTEGER, current AS cell, unvisited() AS cell, uvi AS INTEGER)
283.     REDIM unvisited(0) AS cell
284.     DIM x AS INTEGER, y AS INTEGER
285.     x = current.x: y = current.y: uvi = 0
286.     IF x > 0 THEN
287.         IF visited(x - 1, y) = 0 THEN
288.             uvi = uvi + 1
289.             REDIM _PRESERVE unvisited(uvi) AS cell
290.             unvisited(uvi).x = x - 1: unvisited(uvi).y = y
291.         END IF
292.     END IF
293.     IF x < W - 1 THEN
294.         IF visited(x + 1, y) = 0 THEN
295.             uvi = uvi + 1
296.             REDIM _PRESERVE unvisited(uvi) AS cell
297.             unvisited(uvi).x = x + 1: unvisited(uvi).y = y
298.         END IF
299.     END IF
300.     IF y > 0 THEN
301.         IF visited(x, y - 1) = 0 THEN
302.             uvi = uvi + 1
303.             REDIM _PRESERVE unvisited(uvi) AS cell
304.             unvisited(uvi).x = x: unvisited(uvi).y = y - 1
305.         END IF
306.     END IF
307.     IF y < H - 1 THEN
308.         IF visited(x, y + 1) = 0 THEN
309.             uvi = uvi + 1
310.             REDIM _PRESERVE unvisited(uvi) AS cell
311.             unvisited(uvi).x = x: unvisited(uvi).y = y + 1
312.         END IF
313.     END IF
314. END SUB
315.  
316. SUB generate_maze ()
317.     DIM visited(W, H) AS INTEGER
318.     DIM num_visited AS INTEGER, num_cells AS INTEGER, si AS INTEGER
319.     DIM cnt AS INTEGER, rc AS INTEGER, x AS INTEGER, y AS INTEGER
320.     REDIM stack(0) AS cell
321.     DIM curr_cell AS cell, next_cell AS cell, cur_cell AS cell
322.  
323.     rand_cell cur_cell.x, cur_cell.y
324.     visited(curr_cell.x, curr_cell.y) = 1
325.     num_visited = 1: num_cells = W * H: si = 0
326.     WHILE num_visited < num_cells
327.         REDIM cells(0) AS cell
328.         cnt = 0
329.         get_unvisited visited(), curr_cell, cells(), cnt
330.         IF cnt > 0 THEN
331.             ' choose randomly one of the current cell's unvisited neighbours
332.             rc = INT(RND * 100) MOD cnt + 1
333.             next_cell.x = cells(rc).x: next_cell.y = cells(rc).y
334.             ' push the current cell to the stack
335.             si = si + 1
336.             REDIM _PRESERVE stack(si) AS cell
337.             stack(si).x = curr_cell.x: stack(si).y = curr_cell.y
338.             ' remove the wall between the current cell and the chosen cell
339.             IF next_cell.x = curr_cell.x THEN
340.                 x = next_cell.x: y = max(next_cell.y, curr_cell.y)
341.                 h_walls(x, y) = 0
342.             ELSE
343.                 x = max(next_cell.x, curr_cell.x): y = next_cell.y
344.                 v_walls(x, y) = 0
345.             END IF
346.             ' make the chosen cell the current cell and mark it as visited
347.             curr_cell.x = next_cell.x: curr_cell.y = next_cell.y
348.             visited(curr_cell.x, curr_cell.y) = 1
349.             num_visited = num_visited + 1
350.         ELSEIF si > 0 THEN
351.             ' pop a cell from the stack and make it the current cell
352.             curr_cell.x = stack(si).x: curr_cell.y = stack(si).y
353.             si = si - 1
354.             REDIM _PRESERVE stack(si) AS cell
355.         ELSE
356.             EXIT WHILE
357.         END IF
358.     WEND
359. END SUB
360.  
361. FUNCTION max (a, b)
362.     IF a > b THEN max = a ELSE max = b
363. END FUNCTION
364.  

Currently marked best answer because example application of getting new mazes to play in AND it's got faces now! :D

[bplus]

Oh man! do I have an idea to improve mouse action! :)

[SMcNeill]

For a long time, I've considered making a Rogue-like game, but I never really got around to it.  The idea of being able to zap out random levels at the drop of a hat always seemed a little daunting to me, so I never really bothered to try and do it -- until this morning!

Here's my first run at a little "maze/level generator", which I might just end up using to finally create that little Rogue-like that I've always wanted to make.  It's not quite a maze generator like yours, but it works nicely enough for my needs, and was actually a lot simpler to create than I'd first imagined.

Code: QB64: [Select]

1. SCREEN _NEWIMAGE(800, 600, 32)
2. REDIM SHARED MapArray(0, 0) AS _BYTE
3. RANDOMIZE TIMER
4. _FONT 8
5.  
6. DO
7.     CLS
8.     CreateMap 99, 74, 10, 1
9.     DrawMap
10.     SLEEP
11. LOOP
12.  
13.  
14.  
15. SUB DrawMap
16.     FOR y = 0 TO UBOUND(MapArray, 2)
17.         FOR x = 0 TO UBOUND(MapArray, 1)
18.             LOCATE y + 1, x + 1
19.             SELECT CASE MapArray(x, y)
20.                 CASE -1
21.                     COLOR 0, &HFF000000
22.                     PRINT CHR$(219);
23.                 CASE 2
24.                     COLOR &HFF000000, &HFF777777
25.                     PRINT ".";
26.                 CASE ELSE
27.                     COLOR &HFF0000FF, &HFF000000
28.                     PRINT CHR$(219);
29.             END SELECT
30.  
31.         NEXT
32.     NEXT
33. END SUB
34.  
35.  
36.  
37.  
38.  
39. SUB CreateMap (XLimit, YLimit, Rooms, Level)
40.     ERASE MapArray 'clear the old map and reset everything to 0
41.     REDIM MapArray(XLimit, YLimit) AS _BYTE
42.  
43.     DIM RoomCenterX(Rooms) AS _BYTE, RoomCenterY(Rooms) AS _BYTE
44.  
45.     FOR i = 1 TO Rooms
46.         DO
47.             RoomSize = INT(RND * 9) + 2
48.             RoomX = INT(RND * (XLimit - RoomSize))
49.             RoomY = INT(RND * (YLimit - RoomSize))
50.             'test for positioning
51.             good = -1 'it's good starting out
52.             FOR y = 0 TO RoomSize: FOR x = 0 TO RoomSize
53.                     IF MapArray(RoomX + x, RoomY + y) = -1 THEN good = 0: EXIT FOR 'don't draw a room on a room
54.             NEXT x, y
55.         LOOP UNTIL good
56.         FOR y = 0 TO RoomSize: FOR x = 0 TO RoomSize
57.                 MapArray(RoomX + x, RoomY + y) = -1 'go ahead and draw a room
58.         NEXT x, y
59.         RoomCenterX(i) = RoomX + .5 * RoomSize
60.         RoomCenterY(i) = RoomY + .5 * RoomSize
61.     NEXT
62.     FOR i = 1 TO Rooms - 1
63.         StartX = RoomCenterX(i): StartY = RoomCenterY(i)
64.         EndX = RoomCenterX(i + 1): EndY = RoomCenterY(i + 1)
65.         DO UNTIL StartX = EndX AND StartY = EndY
66.             CoinToss = INT(RND * 100) 'Coin toss to move left/right or up/down, to go towards room, or wander a bit.
67.             Meander = 20
68.             IF CoinToss MOD 2 THEN 'even or odd, so we only walk vertical or hortizontal and not diagional
69.                 IF CoinToss < 100 - Meander THEN 'Lower values meander less and go directly to the target.
70.                     XChange = SGN(EndX - StartX) '-1,0,1, drawn always towards the mouse
71.                     Ychange = 0
72.                 ELSE
73.                     XChange = INT(RND * 3) - 1 '-1, 0, or 1, drawn in a random direction to let the lightning wander
74.                     Ychange = 0
75.                 END IF
76.             ELSE
77.                 IF CoinToss < 100 - Meander THEN 'Lower values meander less and go directly to the target.
78.                     Ychange = SGN(EndY - StartY)
79.                     XChange = 0
80.                 ELSE
81.                     Ychange = INT(RND * 3) - 1
82.                     XChange = 0
83.                 END IF
84.             END IF
85.             StartX = StartX + XChange
86.             StartY = StartY + Ychange
87.             IF StartX < 0 THEN StartX = 0
88.             IF StartY < 0 THEN StartY = 0
89.             IF StartX > UBOUND(MapArray, 1) THEN StartX = UBOUND(MapArray, 1)
90.             IF StartY > UBOUND(MapArray, 2) THEN StartY = UBOUND(MapArray, 2)
91.             IF MapArray(StartX, StartY) = 0 THEN MapArray(StartX, StartY) = 2
92.         LOOP
93.     NEXT
94. END SUB

[bplus]

For those interested, the game I started is further developed here:
https://www.qb64.org/forum/index.php?topic=1690.0

with two versions, both have smoother mouse action and more developed game.

I look forward to seeing what Steve comes up with for his, at least the basic navigation in his maze.