Trying to force turtle back to beginning of maze after collides with wall

[Denis McMahon]

On Sun, 13 Oct 2013 15:26:03 -0700, baujacob wrote:

> Hi everyone, I'm trying to create a simple maze program. When the user
> finishes the maze, I want to print in big letters "You Win!" and when
> the user hits a wall, I want the user to go back to the beginning of the
> maze. The problem is "collision detection" which is an advanced topic
> and I'm only in a beginning programming class. Is there anyway I can
> force the user back to the starting point when the turtle hits the wall?

OK

My first observation is that "maze" could be an array of "rooms" each of 
which starts life with 4 exits.

Generating the maze would involve turning exits into walls.

You could create a set maze, or you could randomly generate a maze at the 
start of each "game".

Once you have created a maze, define your start and end points.

If you want to apply your logic, then if the "solver" turtle enters a 
"room" with only one exit, it is in a dead end.

The "solver" turtle would probably need to store which paths led to dead 
ends to ensure it did not follow them again. This extends back to any 
exit that only leads to dead ends.

Let's consider a simple maze, 2x2 so 4 rooms. Room 0 is the top left (nw) 
room, and rooms are numbered across, down. Each room number has 4 exit 
directions, nesw. 'x' is an external exit, a number is an internal room, 
None is no exit (ie a wall).

maze = { 0: { 'n': 'x', 'e': 1, 's': None, w: None }, 
         1: { 'n': None, 'e': None, 's': 3, w: 0 }, 
         2: { 'n': None, 'e': 3, 's': 'x', w: None }, 
         3: { 'n': 1, 'e': None, 's': None, w: 2 } }

Room 0 (nw) has an exit (or entrance) to the north and an internal path 
to the east (rm 1).

Room 1 (ne) has internal paths to the west (rm 0) and south (rm 3).

Room 2 (sw) has an entrance (or exit) to the south and an internal path 
to the east (rm 3).

Room 3 (se) has internal links to the north (rm 1) and west (rm 2).

The data structure shown (a dictionary of dictionaries) is just one way 
of holding the maze data, and perhaps not the most elegant. The maze 
could be stored as a dictionary of tuples thus:

maze = { 0: ( 'x', 1, None, None ), 
         1: ( None, None, 3, 0 ), 
         2: ( None, 3, 'x', None ), 
         3: ( 1, None, None, 2 ) }

Drawing such a maze graphically would require allocating co-ordinates in 
some drawing space to the vertices of each room, and drawing lines along 
the edges that represent walls.

Navigating such a maze graphically would require allocating co-ordinates 
in the same drawing space to the centres of the rooms, and moving between 
adjacent room centres provided the exit was "open".

-- 
Denis McMahon, denismfmcmahon at gmail.com