http://www.jwz.org/xscreensaver/xscreensaver-5.13.tar.gz
[xscreensaver] / hacks / maze.c
1 /******************************************************************************
2  * [ maze ] ...
3  *
4  * modified:  [ 13-08-08 ] Jamie Zawinski <jwz@jwz.org>
5  *              Removed the bridge option: it didn't look good, and it made
6  *              the code a lot harder to understand.
7  *              Made the maze stay out of the area used for the -fps display.
8  *              Cleaned up and commented.
9  *
10  * modified:  [ 1-04-00 ]  Johannes Keukelaar <johannes@nada.kth.se>
11  *              Added -ignorant option (not the default) to remove knowlege
12  *              of the direction in which the exit lies.
13  *
14  * modified:  [ 6-28-98 ]  Zack Weinberg <zack@rabi.phys.columbia.edu>
15  *
16  *              Made the maze-solver somewhat more intelligent.  There are
17  *              three optimizations:
18  *
19  *              - Straight-line lookahead: the solver does not enter dead-end
20  *                corridors.  This is a win with all maze generators.
21  *
22  *              - First order direction choice: the solver knows where the
23  *                exit is in relation to itself, and will try paths leading in
24  *                that direction first. This is a major win on maze generator 1
25  *                which tends to offer direct routes to the exit.
26  *
27  *              - Dead region elimination: the solver already has a map of
28  *                all squares visited.  Whenever it starts to backtrack, it
29  *                consults this map and marks off all squares that cannot be
30  *                reached from the exit without crossing a square already
31  *                visited.  Those squares can never contribute to the path to
32  *                the exit, so it doesn't bother checking them.  This helps a
33  *                lot with maze generator 2 and somewhat less with generator 1.
34  *
35  *              Further improvements would require knowledge of the wall map
36  *              as well as the position of the exit and the squares visited.
37  *              I would consider that to be cheating.  Generator 0 makes
38  *              mazes which are remarkably difficult to solve mechanically --
39  *              even with these optimizations the solver generally must visit
40  *              at least two-thirds of the squares.  This is partially
41  *              because generator 0's mazes have longer paths to the exit.
42  *
43  * modified:  [ 4-10-97 ]  Johannes Keukelaar <johannes@nada.kth.se>
44  *              Added multiple maze creators. Robustified solver.
45  *              Added bridge option.
46  * modified:  [ 8-11-95 ] Ed James <james@mml.mmc.com>
47  *              added fill of dead-end box to solve_maze while loop.
48  * modified:  [ 3-7-93 ]  Jamie Zawinski <jwz@jwz.org>
49  *              added the XRoger logo, cleaned up resources, made
50  *              grid size a parameter.
51  * modified:  [ 3-3-93 ]  Jim Randell <jmr@mddjmr.fc.hp.com>
52  *              Added the colour stuff and integrated it with jwz's
53  *              screenhack stuff.  There's still some work that could
54  *              be done on this, particularly allowing a resource to
55  *              specify how big the squares are.
56  * modified:  [ 10-4-88 ]  Richard Hess    ...!uunet!cimshop!rhess  
57  *              [ Revised primary execution loop within main()...
58  *              [ Extended X event handler, check_events()...
59  * modified:  [ 1-29-88 ]  Dave Lemke      lemke@sun.com  
60  *              [ Hacked for X11...
61  *              [  Note the word "hacked" -- this is extremely ugly, but at 
62  *              [   least it does the job.  NOT a good programming example 
63  *              [   for X.
64  * original:  [ 6/21/85 ]  Martin Weiss    Sun Microsystems  [ SunView ]
65  *
66  ******************************************************************************
67  Copyright 1988 by Sun Microsystems, Inc. Mountain View, CA.
68   
69  All Rights Reserved
70   
71  Permission to use, copy, modify, and distribute this software and its
72  documentation for any purpose and without fee is hereby granted, 
73  provided that the above copyright notice appear in all copies and that
74  both that copyright notice and this permission notice appear in 
75  supporting documentation, and that the names of Sun or MIT not be
76  used in advertising or publicity pertaining to distribution of the
77  software without specific prior written permission. Sun and M.I.T. 
78  make no representations about the suitability of this software for 
79  any purpose. It is provided "as is" without any express or implied warranty.
80  
81  SUN DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
82  ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
83  PURPOSE. IN NO EVENT SHALL SUN BE LIABLE FOR ANY SPECIAL, INDIRECT
84  OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS
85  OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE 
86  OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE
87  OR PERFORMANCE OF THIS SOFTWARE.
88  *****************************************************************************/
89
90 #include "screenhack.h"
91 #include "erase.h"
92
93 #include  <stdio.h>
94
95 /* #include  <X11/bitmaps/gray1> */
96 #define gray1_width  2
97 #define gray1_height 2
98 static const char gray1_bits[] = { 0x01, 0x02 };
99
100
101 #define MAX_MAZE_SIZE_X 1000
102 #define MAX_MAZE_SIZE_Y 1000
103
104 #define MOVE_LIST_SIZE  (MAX_MAZE_SIZE_X * MAX_MAZE_SIZE_Y)
105
106 #define NOT_DEAD        0x8000
107 #define SOLVER_VISIT    0x4000
108 #define START_SQUARE    0x2000
109 #define END_SQUARE      0x1000
110
111 #define WALL_TOP        0x8
112 #define WALL_RIGHT      0x4
113 #define WALL_BOTTOM     0x2
114 #define WALL_LEFT       0x1
115 #define WALL_ANY        0xF
116
117 #define DOOR_IN_TOP     0x800
118 #define DOOR_IN_RIGHT   0x400
119 #define DOOR_IN_BOTTOM  0x200
120 #define DOOR_IN_LEFT    0x100
121 #define DOOR_IN_ANY     0xF00
122
123 #define DOOR_OUT_TOP    0x80
124 #define DOOR_OUT_RIGHT  0x40
125 #define DOOR_OUT_BOTTOM 0x20
126 #define DOOR_OUT_LEFT   0x10
127
128
129 #define border_x        (0)
130 #define border_y        (0)
131
132 #define get_random(x)   (random() % (x))
133
134
135 struct move_list_struct {
136   unsigned short x;
137   unsigned short y;
138   unsigned char dir, ways;
139 };
140
141 struct solve_state {
142   int running;
143   int i, x, y, bt;
144 };
145
146
147 struct state {
148   Display *dpy;
149   Window window;
150
151   GC    gc, cgc, tgc, sgc, ugc, logo_gc, erase_gc;
152   Pixmap logo_map;
153
154   int logo_x, logo_y;           /* in grid cells (or -1) */
155   int logo_width, logo_height;  /* in pixels */
156   int fps_width, fps_height;    /* in pixels */
157
158   int solve_delay, pre_solve_delay, post_solve_delay;
159
160   unsigned short maze[MAX_MAZE_SIZE_X][MAX_MAZE_SIZE_Y];
161
162   struct move_list_struct move_list[MOVE_LIST_SIZE];
163   struct move_list_struct save_path[MOVE_LIST_SIZE];
164   struct move_list_struct path[MOVE_LIST_SIZE];
165
166   int maze_size_x, maze_size_y;
167   int sqnum, cur_sq_x, cur_sq_y, path_length;
168   int start_x, start_y, start_dir, end_x, end_y, end_dir;
169   int grid_width, grid_height;
170   int bw;
171
172   int x, y, restart, stop, state, max_length;
173   int sync_p, sync_tick;
174   int ignorant_p;
175
176   struct solve_state *solve_state;
177
178   int *sets;            /* The sets that our squares are in. */
179   int *hedges;          /* The `list' of hedges. */
180
181   int this_gen;
182   int erase_window;
183   eraser_state *eraser;
184
185   int ifrandom;
186   int ifinit;
187
188 };
189
190
191 static void draw_wall (struct state *, int, int, int, GC);
192 static void draw_solid_square (struct state *, int, int, int, GC);
193 static void build_wall (struct state *, int, int, int);
194
195
196 static void
197 set_maze_sizes (struct state *st, int width, int height)
198 {
199   st->maze_size_x = width / st->grid_width;
200   st->maze_size_y = height / st->grid_height;
201
202   if (st->maze_size_x < 4) st->maze_size_x = 4;
203   if (st->maze_size_y < 4) st->maze_size_y = 4;
204 }
205
206
207 /* Resets the maze grid, picks the starting and ending points,
208    and the position of the logo, if any.
209  */
210 static void
211 initialize_maze (struct state *st)
212 {
213   int retry_count = 0;
214   int i, j, wall;
215   int logow = 1 + st->logo_width / st->grid_width;
216   int logoh = 1 + st->logo_height / st->grid_height;
217   
218  AGAIN:
219
220   /* This can happen if the window is really small. Let's not sweat it. */
221   if (++retry_count > 100) return;
222
223
224   /* initialize all squares */
225   for ( i=0; i<st->maze_size_x; i++) {
226     for ( j=0; j<st->maze_size_y; j++) {
227       st->maze[i][j] = 0;
228     }
229   }
230   
231   /* top wall */
232   for ( i=0; i<st->maze_size_x; i++ ) {
233     st->maze[i][0] |= WALL_TOP;
234   }
235   
236   /* right wall */
237   for ( j=0; j<st->maze_size_y; j++ ) {
238     st->maze[st->maze_size_x-1][j] |= WALL_RIGHT;
239   }
240   
241   /* bottom wall */
242   for ( i=0; i<st->maze_size_x; i++ ) {
243     st->maze[i][st->maze_size_y-1] |= WALL_BOTTOM;
244   }
245   
246   /* left wall */
247   for ( j=0; j<st->maze_size_y; j++ ) {
248     st->maze[0][j] |= WALL_LEFT;
249   }
250   
251   /* set start square */
252   wall = get_random(4);
253   switch (wall) {
254   case 0:       
255     i = get_random(st->maze_size_x);
256     j = 0;
257     break;
258   case 1:       
259     i = st->maze_size_x - 1;
260     j = get_random(st->maze_size_y);
261     break;
262   case 2:       
263     i = get_random(st->maze_size_x);
264     j = st->maze_size_y - 1;
265     break;
266   case 3:       
267     i = 0;
268     j = get_random(st->maze_size_y);
269     break;
270   }
271   st->maze[i][j] |= START_SQUARE;
272   st->maze[i][j] |= ( DOOR_IN_TOP >> wall );
273   st->maze[i][j] &= ~( WALL_TOP >> wall );
274   st->cur_sq_x = i;
275   st->cur_sq_y = j;
276   st->start_x = i;
277   st->start_y = j;
278   st->start_dir = wall;
279   st->sqnum = 0;
280   
281   /* set end square */
282   wall = (wall + 2)%4;
283   switch (wall) {
284   case 0:
285     i = get_random(st->maze_size_x);
286     j = 0;
287     break;
288   case 1:
289     i = st->maze_size_x - 1;
290     j = get_random(st->maze_size_y);
291     break;
292   case 2:
293     i = get_random(st->maze_size_x);
294     j = st->maze_size_y - 1;
295     break;
296   case 3:
297     i = 0;
298     j = get_random(st->maze_size_y);
299     break;
300   }
301   st->maze[i][j] |= END_SQUARE;
302   st->maze[i][j] |= ( DOOR_OUT_TOP >> wall );
303   st->maze[i][j] &= ~( WALL_TOP >> wall );
304   st->end_x = i;
305   st->end_y = j;
306   st->end_dir = wall;
307   
308   /* set logo */
309   if ((st->maze_size_x-logow >= 6) && (st->maze_size_y-logoh >= 6))
310     {
311       /* not closer than 3 grid units from a wall, to ensure that it
312          won't overlap the entrance or exit. */
313       st->logo_x = get_random (st->maze_size_x - logow - 5) + 3;
314       st->logo_y = get_random (st->maze_size_y - logoh - 5) + 3;
315       for (i=0; i<logow; i++)
316         for (j=0; j<logoh; j++)
317           /* mark as having doors to prevent these cells being used in maze. */
318           st->maze[st->logo_x + i][st->logo_y + j] |= DOOR_IN_ANY;
319     }
320   else
321     st->logo_y = st->logo_x = -1;
322
323   /* mask out the fps area */
324   if (st->fps_width > 0)
325     {
326       int fpsw = 1 + st->fps_width  / st->grid_width;
327       int fpsh = 1 + st->fps_height / st->grid_width;
328
329       /* if the chosen logo position overlapped the fps area, try again! */
330       if (st->logo_x < fpsw+3 && st->logo_y+logoh > st->maze_size_y-fpsh-4)
331         goto AGAIN;
332
333       /* if the start or end point is inside the fps area, try again! */
334       if ((st->start_x <= fpsw && st->start_y >= st->maze_size_y-fpsh-1) ||
335           (st->end_x   <= fpsw && st->end_y   >= st->maze_size_y-fpsh-1))
336         goto AGAIN;
337
338       for (i=0; i<fpsw; i++)
339         for (j=0; j<fpsh; j++) {
340           /* mark as having doors to prevent these cells being used in maze.
341              mark as visit to prevent it being colored "unreachable". */
342           st->maze[i][st->maze_size_y - j - 1] |= DOOR_IN_ANY|SOLVER_VISIT;
343           /* take off left/bottom wall or the FPS text overlaps it */
344           st->maze[i][st->maze_size_y - j - 1] &= ~(WALL_BOTTOM|WALL_LEFT);
345         }
346     }
347 }
348
349
350 /****************************************************************************
351  Generator 2: Set-based maze generator.
352
353  Put each square in the maze in a separate set.  Also, make a list of all the
354  hedges.  Randomize that list.  Walk through the list. If, for a certain
355  hedge, the two squares on both sides of it are in different sets, union the
356  sets and remove the hedge.  Continue until all hedges have been processed or
357  only one set remains.
358
359  This is essentially the "Kruskal" algorithm.
360
361  ****************************************************************************/
362
363 static void mask_out_set_rect(struct state *st, int x, int y, int w, int h);
364
365 /* Initialise the sets. */
366 static void 
367 init_sets(struct state *st)
368 {
369   int i, t, r;
370
371   if(st->sets)
372     free(st->sets);
373   st->sets = (int *)malloc(st->maze_size_x*st->maze_size_y*sizeof(int));
374   if(!st->sets)
375     abort();
376   for(i = 0; i < st->maze_size_x*st->maze_size_y; i++)
377     {
378       st->sets[i] = i;
379     }
380   
381   if(st->hedges)
382     free(st->hedges);
383   st->hedges = (int *)malloc(st->maze_size_x*st->maze_size_y*2*sizeof(int));
384   if(!st->hedges)
385     abort();
386   for(i = 0; i < st->maze_size_x*st->maze_size_y*2; i++)
387     {
388       st->hedges[i] = i;
389     }
390   /* Mask out outside walls. */
391   for(i = 0; i < st->maze_size_y; i++)
392     {
393       st->hedges[2*((st->maze_size_x)*i+st->maze_size_x-1)+1] = -1;
394     }
395   for(i = 0; i < st->maze_size_x; i++)
396     {
397       st->hedges[2*((st->maze_size_y-1)*st->maze_size_x+i)] = -1;
398     }
399
400   /* Mask out the logo area. */
401   if(st->logo_x!=-1)
402     {
403       int logow = 1 + st->logo_width  / st->grid_width;
404       int logoh = 1 + st->logo_height / st->grid_height;
405       mask_out_set_rect(st, st->logo_x, st->logo_y, logow, logoh);
406     }
407
408   /* Mask out the FPS area. */
409   if(st->fps_width > 0)
410     {
411       int fpsw = 1 + st->fps_width  / st->grid_width;
412       int fpsh = 1 + st->fps_height / st->grid_height;
413       mask_out_set_rect(st, 0, st->maze_size_y-fpsh, fpsw, fpsh);
414     }
415
416   for(i = 0; i < st->maze_size_x*st->maze_size_y*2; i++)
417     {
418       t = st->hedges[i];
419       r = random()%(st->maze_size_x*st->maze_size_y*2);
420       st->hedges[i] = st->hedges[r];
421       st->hedges[r] = t;
422     }
423 }
424
425 /* Get the representative of a set. */
426 static int
427 get_set(struct state *st, int num)
428 {
429   int s;
430
431   if(st->sets[num]==num)
432     return num;
433   else
434     {
435       s = get_set(st, st->sets[num]);
436       st->sets[num] = s;
437       return s;
438     }
439 }
440
441 /* Join two sets together. */
442 static void
443 join_sets(struct state *st, int num1, int num2)
444 {
445   int s1, s2;
446
447   s1 = get_set(st, num1);
448   s2 = get_set(st, num2);
449   
450   if(s1<s2)
451     st->sets[s2] = s1;
452   else
453     st->sets[s1] = s2;
454 }
455
456 /* Exitialise the sets. */
457 static void
458 exit_sets(struct state *st)
459 {
460   if(st->hedges)
461     free(st->hedges);
462   st->hedges = 0;
463   if(st->sets)
464     free(st->sets);
465   st->sets = 0;
466 }
467
468
469 static void
470 set_create_maze(struct state *st)
471 {
472   int i, h, xx, yy, dir, v, w;
473
474   /* Do almost all the setup. */
475   init_sets(st);
476
477   /* Start running through the hedges. */
478   for(i = 0; i < 2*st->maze_size_x*st->maze_size_y; i++)
479     { 
480       h = st->hedges[i];
481
482       /* This one is in the logo or outside border. */
483       if(h==-1)
484         continue;
485
486       dir = h%2?1:2;
487       xx = (h>>1)%st->maze_size_x;
488       yy = (h>>1)/st->maze_size_x;
489
490       v = xx;
491       w = yy;
492       switch(dir)
493         {
494         case 1:
495           v++;
496           break;
497         case 2:
498           w++;
499           break;
500         }
501
502       if(get_set(st, xx+yy*st->maze_size_x)!=get_set(st, v+w*st->maze_size_x))
503         {
504           join_sets(st, xx+yy*st->maze_size_x, v+w*st->maze_size_x);
505           /* Don't draw the wall. */
506         }
507       else
508         {
509           /* Don't join the sets. */
510           build_wall(st, xx, yy, dir); 
511         }
512     }
513
514   /* Free some memory. */
515   exit_sets(st);
516 }
517
518 /* mark a rectangle as being unavailable for usage in the maze */
519 static void
520 mask_out_set_rect(struct state *st, int x, int y, int w, int h)
521 {
522   int xx, yy;
523   for(xx = x; xx < x+w; xx++)
524     for(yy = y; yy < y+h; yy++)
525       {
526         st->hedges[2*(xx+st->maze_size_x*yy)+1] = -1;
527         st->hedges[2*(xx+st->maze_size_x*yy)] = -1;
528       }
529   for(xx = x; xx < x+w; xx++)
530     {
531       build_wall(st, xx, y, 0);
532       build_wall(st, xx, y+h, 0);
533       st->hedges[2*(xx+st->maze_size_x*(y-1))] = -1;
534     }
535   for(yy = y; yy < y+h; yy++)
536     {
537       build_wall(st, x, yy, 3);
538       build_wall(st, x+w, yy, 3);
539       st->hedges[2*(x-1+st->maze_size_x*yy)+1] = -1;
540     }
541 }
542
543
544 /****************************************************************************
545  Generator 1: Wall-building maze generator.
546
547  Pick a random, empty corner in the maze.  Pick a random direction. Draw a
548  wall in that direction, from that corner until we hit a wall.  Option: Only
549  draw the wall if it's going to be shorter than a certain length.  Otherwise
550  we get lots of long walls.
551
552  This is essentially the "Prim" algorithm.
553  ****************************************************************************/
554
555 static void alt_mask_out_rect(struct state *st, char *corners, 
556                               int x, int y, int w, int h);
557
558 static void
559 alt_create_maze(struct state *st)
560 {
561   char *corners;
562   int *c_idx;
563   int i, j, height, width, open_corners, k, dir, xx, yy;
564
565   height = st->maze_size_y+1;
566   width = st->maze_size_x+1;
567
568   /* Allocate and clear some mem. */
569   corners = (char *)calloc(height*width, 1);
570   if(!corners)
571     return;
572
573   /* Set up the indexing array. */
574   c_idx = (int *)malloc(sizeof(int)*height*width);
575   if(!c_idx)
576     {
577       free(corners);
578       return;
579     }
580   for(i = 0; i < height*width; i++)
581     c_idx[i] = i;
582   for(i = 0; i < height*width; i++)
583     {
584       j = c_idx[i];
585       k = random()%(height*width);
586       c_idx[i] = c_idx[k];
587       c_idx[k] = j;
588     }
589
590   /* Set up some initial walls. */
591   /* Outside walls. */
592   for(i = 0; i < width; i++)
593     {
594       corners[i] = 1;
595       corners[i+width*(height-1)] = 1;
596     }
597   for(i = 0; i < height; i++)
598     {
599       corners[i*width] = 1;
600       corners[i*width+width-1] = 1;
601     }
602
603   /* mask out the logo area */
604   if(st->logo_x!=-1)
605     {
606       int logow = 1 + st->logo_width / st->grid_width;
607       int logoh = 1 + st->logo_height / st->grid_height;
608       alt_mask_out_rect (st, corners, st->logo_x, st->logo_y, logow, logoh);
609     }
610
611   /* mask out the FPS area */
612   if(st->fps_width>0)
613     {
614       int fpsw = 1 + st->fps_width  / st->grid_width;
615       int fpsh = 1 + st->fps_height / st->grid_height;
616       alt_mask_out_rect (st, corners, 0, st->maze_size_y-fpsh, fpsw, fpsh);
617     }
618
619   /* Count open gridpoints. */
620   open_corners = 0;
621   for(i = 0; i < width; i++)
622     for(j = 0; j < height; j++)
623       if(!corners[i+width*j])
624         open_corners++;
625
626   /* Now do actual maze generation. */
627   while(open_corners>0)
628     {
629       for(i = 0; i < width*height; i++)
630         {
631           if(!corners[c_idx[i]])
632             {
633               xx = c_idx[i]%width;
634               yy = c_idx[i]/width;
635               /* Choose a random direction. */
636               dir = random()%4;
637               
638               k = 0;
639               /* Measure the length of the wall we'd draw. */
640               while(!corners[xx+width*yy])
641                 {
642                   k++;
643                   switch(dir)
644                     {
645                     case 0:
646                       yy--;
647                       break;
648                     case 1:
649                       xx++;
650                       break;
651                     case 2:
652                       yy++;
653                       break;
654                     case 3:
655                       xx--;
656                       break;
657                     }
658                 }
659               
660               if(k<=st->max_length)
661                 {
662                   xx = c_idx[i]%width;
663                   yy = c_idx[i]/width;
664                   
665                   /* Draw a wall until we hit something. */
666                   while(!corners[xx+width*yy])
667                     {
668                       open_corners--;
669                       corners[xx+width*yy] = 1;
670                       switch(dir)
671                         {
672                         case 0:
673                           build_wall(st, xx-1, yy-1, 1);
674                           yy--;
675                           break;
676                         case 1:
677                           build_wall(st, xx, yy, 0);
678                           xx++;
679                           break;
680                         case 2:
681                           build_wall(st, xx, yy, 3);
682                           yy++;
683                           break;
684                         case 3:
685                           build_wall(st, xx-1, yy-1, 2);
686                           xx--;
687                           break;
688                         }
689                     }
690                 }
691             }
692         }
693     }
694
695   /* Free some memory we used. */
696   free(corners);
697   free(c_idx);
698 }
699
700
701 /* mark a rectangle as being unavailable for usage in the maze */
702 static void
703 alt_mask_out_rect(struct state *st, char *corners, int x, int y, int w, int h)
704 {
705   int i, j, xx, yy;
706   int mazew = st->maze_size_x+1;
707
708   for(i = x; i <= x+w; i++)
709     for(j = y; j <= y+h; j++)
710       corners[i+mazew*j] = 1;
711
712   for(xx = x; xx < x+w; xx++)
713     {
714       build_wall(st, xx, y, 0);
715       if (y+h < st->maze_size_y)
716         build_wall(st, xx, y+h, 0);
717     }
718   for(yy = y; yy < y+h; yy++)
719     {
720       if (x > 0)
721         build_wall(st, x, yy, 3);
722       build_wall(st, x+w, yy, 3);
723     }
724 }
725
726
727 /****************************************************************************
728  Generator 0: The original maze generator.
729
730  Start somewhere.  Take a step in a random direction.  Keep doing this until
731  we hit a wall.  Then, backtrack until we find a point where we can go in
732  another direction.
733
734  This is essentially the "depth-first recursive backtracker" algorithm.
735  ****************************************************************************/
736
737 static int choose_door (struct state *st);
738 static int backup (struct state *st);
739
740 static void
741 create_maze (struct state *st)    /* create a maze layout given the initialized maze */
742 {
743   int i, newdoor = 0;
744   
745   do {
746     st->move_list[st->sqnum].x = st->cur_sq_x;
747     st->move_list[st->sqnum].y = st->cur_sq_y;
748     st->move_list[st->sqnum].dir = newdoor;
749     while ( ( newdoor = choose_door(st) ) == -1 ) { /* pick a door */
750       if ( backup(st) == -1 ) { /* no more doors ... backup */
751         return; /* done ... return */
752       }
753     }
754     
755     /* mark the out door */
756     st->maze[st->cur_sq_x][st->cur_sq_y] |= ( DOOR_OUT_TOP >> newdoor );
757     
758     switch (newdoor) {
759     case 0: st->cur_sq_y--;
760       break;
761     case 1: st->cur_sq_x++;
762       break;
763     case 2: st->cur_sq_y++;
764       break;
765     case 3: st->cur_sq_x--;
766       break;
767     }
768     st->sqnum++;
769     
770     /* mark the in door */
771     st->maze[st->cur_sq_x][st->cur_sq_y] |= ( DOOR_IN_TOP >> ((newdoor+2)%4) );
772     
773     /* if end square set path length and save path */
774     if ( st->maze[st->cur_sq_x][st->cur_sq_y] & END_SQUARE ) {
775       st->path_length = st->sqnum;
776       for ( i=0; i<st->path_length; i++) {
777         st->save_path[i].x = st->move_list[i].x;
778         st->save_path[i].y = st->move_list[i].y;
779         st->save_path[i].dir = st->move_list[i].dir;
780       }
781     }
782     
783   } while (1);
784   
785 }
786
787
788 static int
789 choose_door (struct state *st)                                   /* pick a new path */
790 {
791   int candidates[3];
792   int num_candidates;
793   
794   num_candidates = 0;
795   
796   /* top wall */
797   if ( st->maze[st->cur_sq_x][st->cur_sq_y] & DOOR_IN_TOP )
798     goto rightwall;
799   if ( st->maze[st->cur_sq_x][st->cur_sq_y] & DOOR_OUT_TOP )
800     goto rightwall;
801   if ( st->maze[st->cur_sq_x][st->cur_sq_y] & WALL_TOP )
802     goto rightwall;
803   if ( st->maze[st->cur_sq_x][st->cur_sq_y - 1] & DOOR_IN_ANY ) {
804     st->maze[st->cur_sq_x][st->cur_sq_y] |= WALL_TOP;
805     st->maze[st->cur_sq_x][st->cur_sq_y - 1] |= WALL_BOTTOM;
806     draw_wall(st, st->cur_sq_x, st->cur_sq_y, 0, st->gc);
807     goto rightwall;
808   }
809   candidates[num_candidates++] = 0;
810   
811  rightwall:
812   /* right wall */
813   if ( st->maze[st->cur_sq_x][st->cur_sq_y] & DOOR_IN_RIGHT )
814     goto bottomwall;
815   if ( st->maze[st->cur_sq_x][st->cur_sq_y] & DOOR_OUT_RIGHT )
816     goto bottomwall;
817   if ( st->maze[st->cur_sq_x][st->cur_sq_y] & WALL_RIGHT )
818     goto bottomwall;
819   if ( st->maze[st->cur_sq_x + 1][st->cur_sq_y] & DOOR_IN_ANY ) {
820     st->maze[st->cur_sq_x][st->cur_sq_y] |= WALL_RIGHT;
821     st->maze[st->cur_sq_x + 1][st->cur_sq_y] |= WALL_LEFT;
822     draw_wall(st, st->cur_sq_x, st->cur_sq_y, 1, st->gc);
823     goto bottomwall;
824   }
825   candidates[num_candidates++] = 1;
826   
827  bottomwall:
828   /* bottom wall */
829   if ( st->maze[st->cur_sq_x][st->cur_sq_y] & DOOR_IN_BOTTOM )
830     goto leftwall;
831   if ( st->maze[st->cur_sq_x][st->cur_sq_y] & DOOR_OUT_BOTTOM )
832     goto leftwall;
833   if ( st->maze[st->cur_sq_x][st->cur_sq_y] & WALL_BOTTOM )
834     goto leftwall;
835   if ( st->maze[st->cur_sq_x][st->cur_sq_y + 1] & DOOR_IN_ANY ) {
836     st->maze[st->cur_sq_x][st->cur_sq_y] |= WALL_BOTTOM;
837     st->maze[st->cur_sq_x][st->cur_sq_y + 1] |= WALL_TOP;
838     draw_wall(st, st->cur_sq_x, st->cur_sq_y, 2, st->gc);
839     goto leftwall;
840   }
841   candidates[num_candidates++] = 2;
842   
843  leftwall:
844   /* left wall */
845   if ( st->maze[st->cur_sq_x][st->cur_sq_y] & DOOR_IN_LEFT )
846     goto donewall;
847   if ( st->maze[st->cur_sq_x][st->cur_sq_y] & DOOR_OUT_LEFT )
848     goto donewall;
849   if ( st->maze[st->cur_sq_x][st->cur_sq_y] & WALL_LEFT )
850     goto donewall;
851   if ( st->maze[st->cur_sq_x - 1][st->cur_sq_y] & DOOR_IN_ANY ) {
852     st->maze[st->cur_sq_x][st->cur_sq_y] |= WALL_LEFT;
853     st->maze[st->cur_sq_x - 1][st->cur_sq_y] |= WALL_RIGHT;
854     draw_wall(st, st->cur_sq_x, st->cur_sq_y, 3, st->gc);
855     goto donewall;
856   }
857   candidates[num_candidates++] = 3;
858   
859  donewall:
860   if (num_candidates == 0)
861     return ( -1 );
862   if (num_candidates == 1)
863     return ( candidates[0] );
864   return ( candidates[ get_random(num_candidates) ] );
865   
866 }
867
868
869 static int
870 backup (struct state *st)                                          /* back up a move */
871 {
872   st->sqnum--;
873   st->cur_sq_x = st->move_list[st->sqnum].x;
874   st->cur_sq_y = st->move_list[st->sqnum].y;
875   return ( st->sqnum );
876 }
877
878
879 /****************************************************************************
880  Drawing the maze
881  ****************************************************************************/
882
883 /* draws the maze outline, and the logo */
884 static void
885 draw_maze_border (struct state *st)
886 {
887   int i, j;
888
889   for ( i=0; i<st->maze_size_x; i++) {
890     if ( st->maze[i][0] & WALL_TOP ) {
891       XDrawLine(st->dpy, st->window, st->gc,
892                 border_x + st->grid_width * i,
893                 border_y,
894                 border_x + st->grid_width * (i+1) - 1,
895                 border_y);
896     }
897     if ((st->maze[i][st->maze_size_y - 1] & WALL_BOTTOM)) {
898       XDrawLine(st->dpy, st->window, st->gc,
899                 border_x + st->grid_width * i,
900                 border_y + st->grid_height * (st->maze_size_y) - 1,
901                 border_x + st->grid_width * (i+1) - 1,
902                 border_y + st->grid_height * (st->maze_size_y) - 1);
903     }
904   }
905   for ( j=0; j<st->maze_size_y; j++) {
906     if ( st->maze[st->maze_size_x - 1][j] & WALL_RIGHT ) {
907       XDrawLine(st->dpy, st->window, st->gc,
908                 border_x + st->grid_width * st->maze_size_x - 1,
909                 border_y + st->grid_height * j,
910                 border_x + st->grid_width * st->maze_size_x - 1,
911                 border_y + st->grid_height * (j+1) - 1);
912     }
913     if ( st->maze[0][j] & WALL_LEFT ) {
914       XDrawLine(st->dpy, st->window, st->gc,
915                 border_x,
916                 border_y + st->grid_height * j,
917                 border_x,
918                 border_y + st->grid_height * (j+1) - 1);
919     }
920   }
921   
922   if (st->logo_x != -1)
923     {
924       Window r;
925       int xx, yy;
926       unsigned int w, h, bbw, d;
927
928       /* round up to grid size */
929       int ww = ((st->logo_width  / st->grid_width) + 1)  * st->grid_width;
930       int hh = ((st->logo_height / st->grid_height) + 1) * st->grid_height;
931       int lx, ly;
932
933       XGetGeometry (st->dpy, st->logo_map, &r, &xx, &yy, &w, &h, &bbw, &d);
934
935       /* kludge: if the logo "hole" is around the same size as the logo,
936          don't center it (since the xscreensaver logo image is a little
937          off center...  But do center it if the hole/gridsize is large. */
938       if (ww < st->logo_width  + 5) ww = w; 
939       if (hh < st->logo_height + 5) hh = h; 
940
941
942       lx = border_x + 3 + st->grid_width  * st->logo_x + ((ww - w) / 2);
943       ly = border_y + 3 + st->grid_height * st->logo_y + ((hh - h) / 2);
944
945       /* Fill the background of the logo box with the "unreachable" color */
946       XFillRectangle (st->dpy, st->window, st->ugc, 
947                       border_x + 3 + st->grid_width  * st->logo_x,
948                       border_y + 3 + st->grid_height * st->logo_y,
949                       ww, hh);
950
951       XSetClipOrigin (st->dpy, st->logo_gc, lx, ly);
952       if (d == 1)
953         XCopyPlane (st->dpy, st->logo_map, st->window, st->logo_gc,
954                     0, 0, w, h, lx, ly, 1);
955       else
956         XCopyArea (st->dpy, st->logo_map, st->window, st->logo_gc,
957                    0, 0, w, h, lx, ly);
958     }
959   draw_solid_square (st, st->start_x, st->start_y, WALL_TOP >> st->start_dir, st->tgc);
960   draw_solid_square (st, st->end_x, st->end_y, WALL_TOP >> st->end_dir, st->tgc);
961 }
962
963
964 /* Mark the maze grid as having a wall at the given coordinate,
965    and draw that wall on the screen. */
966 static void
967 build_wall(struct state *st, int i, int j, int dir)
968 {
969   /* Draw it on the screen. */
970   draw_wall(st, i, j, dir, st->gc);
971   /* Put it in the maze. */
972   switch(dir)
973     {
974     case 0:
975       st->maze[i][j] |= WALL_TOP;
976       if(j>0)
977         st->maze[i][j-1] |= WALL_BOTTOM;
978       break;
979     case 1:
980       st->maze[i][j] |= WALL_RIGHT;
981       if(i<st->maze_size_x-1)
982         st->maze[i+1][j] |= WALL_LEFT;
983       break;
984     case 2:
985       st->maze[i][j] |= WALL_BOTTOM;
986       if(j<st->maze_size_y-1)
987         st->maze[i][j+1] |= WALL_TOP;
988       break;
989     case 3:
990       st->maze[i][j] |= WALL_LEFT;
991       if(i>0)
992         st->maze[i-1][j] |= WALL_RIGHT;
993       break;
994     }
995 }
996
997
998 static void
999 draw_wall(struct state *st, int i, int j, int dir, GC with_gc)                /* draw a single wall */
1000 {
1001   switch (dir) {
1002   case 0:
1003     XDrawLine(st->dpy, st->window, with_gc,
1004               border_x + st->grid_width * i, 
1005               border_y + st->grid_height * j,
1006               border_x + st->grid_width * (i+1), 
1007               border_y + st->grid_height * j);
1008     break;
1009   case 1:
1010     XDrawLine(st->dpy, st->window, with_gc,
1011               border_x + st->grid_width * (i+1), 
1012               border_y + st->grid_height * j,
1013               border_x + st->grid_width * (i+1), 
1014               border_y + st->grid_height * (j+1));
1015     break;
1016   case 2:
1017     XDrawLine(st->dpy, st->window, with_gc,
1018               border_x + st->grid_width * i, 
1019               border_y + st->grid_height * (j+1),
1020               border_x + st->grid_width * (i+1), 
1021               border_y + st->grid_height * (j+1));
1022     break;
1023   case 3:
1024     XDrawLine(st->dpy, st->window, with_gc,
1025               border_x + st->grid_width * i, 
1026               border_y + st->grid_height * j,
1027               border_x + st->grid_width * i, 
1028               border_y + st->grid_height * (j+1));
1029     break;
1030   }
1031
1032   if(st->sync_p) {
1033     /* too slow if we sync on every wall, so only sync about ten times
1034        during the maze-creation process. 
1035      */
1036     st->sync_tick--;
1037     if (st->sync_tick <= 0) {
1038       XSync(st->dpy, False);
1039       st->sync_tick = st->maze_size_x * st->maze_size_x / 10;
1040     }
1041   }
1042 }
1043
1044
1045 static void
1046 draw_solid_square(struct state *st, 
1047                   int i, int j,
1048                   int dir, GC with_gc)
1049 {
1050   switch (dir) {
1051   case WALL_TOP:
1052       XFillRectangle(st->dpy, st->window, with_gc,
1053                      border_x + st->bw+(st->bw==0?1:0) + st->grid_width * i, 
1054                      border_y - st->bw-(st->bw==0?1:0) + st->grid_height * j, 
1055                      st->grid_width - (st->bw+st->bw+(st->bw==0?1:0)), st->grid_height);
1056       break;
1057   case WALL_RIGHT:
1058       XFillRectangle(st->dpy, st->window, with_gc,
1059                      border_x + st->bw+(st->bw==0?1:0) + st->grid_width * i, 
1060                      border_y + st->bw+(st->bw==0?1:0) + st->grid_height * j, 
1061                      st->grid_width, st->grid_height - (st->bw+st->bw+(st->bw==0?1:0)));
1062       break;
1063   case WALL_BOTTOM:
1064       XFillRectangle(st->dpy, st->window, with_gc,
1065                      border_x + st->bw+(st->bw==0?1:0) + st->grid_width * i, 
1066                      border_y + st->bw+(st->bw==0?1:0) + st->grid_height * j, 
1067                      st->grid_width - (st->bw+st->bw+(st->bw==0?1:0)), st->grid_height);
1068       break;
1069   case WALL_LEFT:
1070       XFillRectangle(st->dpy, st->window, with_gc,
1071                      border_x - st->bw-(st->bw==0?1:0) + st->grid_width * i, 
1072                      border_y + st->bw+(st->bw==0?1:0) + st->grid_height * j, 
1073                      st->grid_width, st->grid_height - (st->bw+st->bw+(st->bw==0?1:0)));
1074       break;
1075   }
1076 }
1077
1078 /****************************************************************************
1079  Solving the maze
1080  ****************************************************************************/
1081
1082 static int
1083 longdeadend_p(struct state *st, int x1, int y1, int x2, int y2, int endwall)
1084 {
1085     int dx = x2 - x1, dy = y2 - y1;
1086     int sidewalls;
1087
1088     sidewalls = endwall | (endwall >> 2 | endwall << 2);
1089     sidewalls = ~sidewalls & WALL_ANY;
1090
1091     while((st->maze[x2][y2] & WALL_ANY) == sidewalls)
1092     {
1093         if (x2 + dx < 0 || x2 + dx >= st->maze_size_x ||
1094             y2 + dy < 0 || y2 + dy >= st->maze_size_y)
1095           break;
1096         x2 += dx;
1097         y2 += dy;
1098     }
1099
1100     if((st->maze[x2][y2] & WALL_ANY) == (sidewalls | endwall))
1101     {
1102         endwall = (endwall >> 2 | endwall << 2) & WALL_ANY;
1103         while(x1 != x2 || y1 != y2)
1104         {
1105             x1 += dx;
1106             y1 += dy;
1107             draw_solid_square(st, x1, y1, endwall, st->sgc);
1108             st->maze[x1][y1] |= SOLVER_VISIT;
1109         }
1110         return 1;
1111     }
1112     else
1113         return 0;
1114 }
1115
1116 /* Find all dead regions -- areas from which the goal cannot be reached --
1117    and mark them visited. */
1118 static void
1119 find_dead_regions(struct state *st)
1120 {
1121     int xx, yy, flipped;
1122
1123     /* Find all not SOLVER_VISIT squares bordering NOT_DEAD squares
1124        and mark them NOT_DEAD also.  Repeat until no more such squares. */
1125     st->maze[st->start_x][st->start_y] |= NOT_DEAD;
1126     
1127     do
1128     {
1129         flipped = 0;
1130         for(xx = 0; xx < st->maze_size_x; xx++)
1131             for(yy = 0; yy < st->maze_size_y; yy++)
1132                 if(!(st->maze[xx][yy] & (SOLVER_VISIT | NOT_DEAD))
1133                    && (   (xx && (st->maze[xx-1][yy] & NOT_DEAD))
1134                        || (yy && (st->maze[xx][yy-1] & NOT_DEAD))))
1135                 {
1136                     flipped = 1;
1137                     st->maze[xx][yy] |= NOT_DEAD;
1138                 }
1139         for(xx = st->maze_size_x-1; xx >= 0; xx--)
1140             for(yy = st->maze_size_y-1; yy >= 0; yy--)
1141                 if(!(st->maze[xx][yy] & (SOLVER_VISIT | NOT_DEAD))
1142                    && (   (xx != st->maze_size_x-1 && (st->maze[xx+1][yy] & NOT_DEAD))
1143                        || (yy != st->maze_size_y-1 && (st->maze[xx][yy+1] & NOT_DEAD))))
1144                 {
1145                     flipped = 1;
1146                     st->maze[xx][yy] |= NOT_DEAD;
1147                 }
1148     }
1149     while(flipped);
1150
1151     for (yy = 0; yy < st->maze_size_y; yy++)
1152       for (xx = 0; xx < st->maze_size_x; xx++)
1153       {
1154         if (st->maze[xx][yy] & NOT_DEAD)
1155           st->maze[xx][yy] &= ~NOT_DEAD;
1156         else if (!(st->maze[xx][yy] & SOLVER_VISIT))
1157         {
1158           st->maze[xx][yy] |= SOLVER_VISIT;
1159           if((xx < st->logo_x || xx > st->logo_x + st->logo_width / st->grid_width) ||
1160              (yy < st->logo_y || yy > st->logo_y + st->logo_height / st->grid_height))
1161           {
1162             /* if we are completely surrounded by walls, just draw the
1163                inside part */
1164             if ((st->maze[xx][yy] & WALL_ANY) == WALL_ANY)
1165               XFillRectangle(st->dpy, st->window, st->ugc,
1166                              border_x + st->bw + st->grid_width * xx,
1167                              border_y + st->bw + st->grid_height * yy,
1168                              st->grid_width - (st->bw+st->bw), st->grid_height - (st->bw+st->bw));
1169             else
1170             {
1171               if (! (st->maze[xx][yy] & WALL_LEFT))
1172                 draw_solid_square(st, xx, yy, WALL_LEFT, st->ugc);
1173               if (! (st->maze[xx][yy] & WALL_RIGHT))
1174                 draw_solid_square(st, xx, yy, WALL_RIGHT, st->ugc);
1175               if (! (st->maze[xx][yy] & WALL_TOP))
1176                 draw_solid_square(st, xx, yy, WALL_TOP, st->ugc);
1177               if (! (st->maze[xx][yy] & WALL_BOTTOM))
1178                 draw_solid_square(st, xx, yy, WALL_BOTTOM, st->ugc);
1179             }
1180           }
1181         }
1182       }
1183 }
1184
1185 /* solve the maze by one more tick */
1186 static int
1187 solve_maze (struct state *st)
1188 {
1189   struct solve_state *ss = st->solve_state;
1190   if (!ss)
1191     ss = st->solve_state = (struct solve_state *) calloc (1, sizeof(*ss));
1192
1193   if (!ss->running) {
1194     /* plug up the surrounding wall */
1195     st->maze[st->end_x][st->end_y] |= (WALL_TOP >> st->end_dir);
1196     
1197     /* initialize search path */
1198     ss->i = 0;
1199     st->path[ss->i].x = st->end_x;
1200     st->path[ss->i].y = st->end_y;
1201     st->path[ss->i].dir = 0;
1202     st->maze[st->end_x][st->end_y] |= SOLVER_VISIT;
1203
1204     ss->running = 1;
1205   }
1206     
1207     /* do it */
1208     /* while (1) */
1209     {
1210         int dir, from, ways;
1211
1212         if ( st->maze[st->path[ss->i].x][st->path[ss->i].y] & START_SQUARE )
1213           {
1214             ss->running = 0;
1215             return 1;
1216           }
1217
1218         if(!st->path[ss->i].dir)
1219         {
1220             ways = 0;
1221             /* First visit this square.  Which adjacent squares are open? */
1222             for(dir = WALL_TOP; dir & WALL_ANY; dir >>= 1)
1223             {
1224                 if(st->maze[st->path[ss->i].x][st->path[ss->i].y] & dir)
1225                     continue;
1226                 
1227                 ss->y = st->path[ss->i].y - !!(dir & WALL_TOP) + !!(dir & WALL_BOTTOM);
1228                 ss->x = st->path[ss->i].x + !!(dir & WALL_RIGHT) - !!(dir & WALL_LEFT);
1229                 
1230                 if(st->maze[ss->x][ss->y] & SOLVER_VISIT)
1231                   continue;
1232                 
1233                 from = (dir << 2 & WALL_ANY) | (dir >> 2 & WALL_ANY);
1234                 /* don't enter obvious dead ends */
1235                 if(((st->maze[ss->x][ss->y] & WALL_ANY) | from) != WALL_ANY)
1236                 {
1237                     if(!longdeadend_p(st, st->path[ss->i].x, st->path[ss->i].y, ss->x, ss->y, dir))
1238                         ways |= dir;
1239                 }
1240                 else
1241                 {
1242                     draw_solid_square(st, ss->x, ss->y, from, st->sgc);
1243                     st->maze[ss->x][ss->y] |= SOLVER_VISIT;
1244                 }
1245             }
1246         }
1247         else
1248             ways = st->path[ss->i].ways;
1249         /* ways now has a bitmask of open paths. */
1250         
1251         if(!ways)
1252             goto backtrack;
1253
1254         if (!st->ignorant_p)
1255           {
1256             ss->x = st->path[ss->i].x - st->start_x;
1257             ss->y = st->path[ss->i].y - st->start_y;
1258             /* choice one */
1259             if(abs(ss->y) <= abs(ss->x))
1260               dir = (ss->x > 0) ? WALL_LEFT : WALL_RIGHT;
1261             else
1262               dir = (ss->y > 0) ? WALL_TOP : WALL_BOTTOM;
1263             
1264             if(dir & ways)
1265               goto found;
1266             
1267             /* choice two */
1268             switch(dir)
1269               {
1270               case WALL_LEFT:
1271               case WALL_RIGHT:
1272                 dir = (ss->y > 0) ? WALL_TOP : WALL_BOTTOM; break;
1273               case WALL_TOP:
1274               case WALL_BOTTOM:
1275                 dir = (ss->x > 0) ? WALL_LEFT : WALL_RIGHT;
1276               }
1277             
1278             if(dir & ways)
1279               goto found;
1280             
1281             /* choice three */
1282             
1283             dir = (dir << 2 & WALL_ANY) | (dir >> 2 & WALL_ANY);
1284             if(dir & ways)
1285               goto found;
1286             
1287             /* choice four */
1288             dir = ways;
1289             if(!dir)
1290               goto backtrack;
1291             
1292           found: ;
1293           }
1294         else
1295           {
1296             if(ways&WALL_TOP)
1297               dir = WALL_TOP;
1298             else if(ways&WALL_LEFT)
1299               dir = WALL_LEFT;
1300             else if(ways&WALL_BOTTOM)
1301               dir = WALL_BOTTOM;
1302             else if(ways&WALL_RIGHT)
1303               dir = WALL_RIGHT;
1304             else
1305               goto backtrack;
1306           }
1307         ss->bt = 0;
1308         ways &= ~dir;  /* tried this one */
1309         
1310         ss->y = st->path[ss->i].y - !!(dir & WALL_TOP) + !!(dir & WALL_BOTTOM);
1311         ss->x = st->path[ss->i].x + !!(dir & WALL_RIGHT) - !!(dir & WALL_LEFT);
1312         
1313         /* advance in direction dir */
1314         st->path[ss->i].dir = dir;
1315         st->path[ss->i].ways = ways;
1316         draw_solid_square(st, st->path[ss->i].x, st->path[ss->i].y, dir, st->tgc);
1317         
1318         ss->i++;
1319         st->path[ss->i].dir = 0;
1320         st->path[ss->i].ways = 0;
1321         st->path[ss->i].x = ss->x;
1322         st->path[ss->i].y = ss->y;
1323         st->maze[ss->x][ss->y] |= SOLVER_VISIT;
1324         return 0;
1325         /* continue; */
1326
1327     backtrack:
1328         if(ss->i == 0)
1329         {
1330             printf("Unsolvable maze.\n");
1331             ss->running = 0;
1332             return 1;
1333         }
1334
1335         if(!ss->bt && !st->ignorant_p)
1336             find_dead_regions(st);
1337         ss->bt = 1;
1338         from = st->path[ss->i-1].dir;
1339         from = (from << 2 & WALL_ANY) | (from >> 2 & WALL_ANY);
1340         
1341         draw_solid_square(st, st->path[ss->i].x, st->path[ss->i].y, from, st->cgc);
1342         ss->i--;
1343     }
1344
1345     return 0;
1346
1347
1348
1349 /****************************************************************************
1350  XScreenSaver boilerplate: resources, command line options, and main loop.
1351  ****************************************************************************/
1352
1353 static const char *maze_defaults[] = {
1354   ".background:    black",
1355   ".foreground:    white",
1356   "*fpsSolid:      true",
1357   "*gridSize:      0",
1358   "*generator:     -1",
1359   "*maxLength:     5",
1360   "*ignorant:      False",
1361
1362   "*solveDelay:    10000",
1363   "*preDelay:      2000000",
1364   "*postDelay:     4000000",
1365
1366   "*liveColor:     #00FF00",
1367   "*deadColor:     #880000",
1368   "*skipColor:     #8B5A00",
1369   "*surroundColor: #220055",
1370
1371   0
1372 };
1373
1374 static XrmOptionDescRec maze_options[] = {
1375   { "-ignorant",        ".ignorant",    XrmoptionNoArg, "True" },
1376   { "-no-ignorant",     ".ignorant",    XrmoptionNoArg, "False" },
1377   { "-grid-size",       ".gridSize",    XrmoptionSepArg, 0 },
1378   { "-solve-delay",     ".solveDelay",  XrmoptionSepArg, 0 },
1379   { "-pre-delay",       ".preDelay",    XrmoptionSepArg, 0 },
1380   { "-post-delay",      ".postDelay",   XrmoptionSepArg, 0 },
1381   { "-bg-color",        ".background",  XrmoptionSepArg, 0 },
1382   { "-fg-color",        ".foreground",  XrmoptionSepArg, 0 },
1383   { "-live-color",      ".liveColor",   XrmoptionSepArg, 0 },
1384   { "-dead-color",      ".deadColor",   XrmoptionSepArg, 0 },
1385   { "-skip-color",      ".skipColor",   XrmoptionSepArg, 0 },
1386   { "-surround-color",  ".surroundColor",XrmoptionSepArg, 0 },
1387   { "-generator",       ".generator",   XrmoptionSepArg, 0 },
1388   { "-max-length",      ".maxLength",   XrmoptionSepArg, 0 },
1389   { 0, 0, 0, 0 }
1390 };
1391
1392 static int generator = 0;
1393
1394 static void *
1395 maze_init (Display *dpy_arg, Window window_arg)
1396 {
1397   struct state *st = (struct state *) calloc (1, sizeof(*st));
1398   int size;
1399   XWindowAttributes xgwa;
1400   unsigned long bg, fg, pfg, pbg, sfg, ufg;
1401
1402   st->dpy = dpy_arg; 
1403   st->window = window_arg;
1404
1405   st->stop = 0;
1406   st->state = 1;
1407   st->restart = 1;
1408
1409   st->ifrandom = 0;
1410   st->ifinit = 1;
1411
1412   size = get_integer_resource (st->dpy, "gridSize", "Dimension");
1413   st->solve_delay = get_integer_resource (st->dpy, "solveDelay", "Integer");
1414   st->pre_solve_delay = get_integer_resource (st->dpy, "preDelay", "Integer");
1415   st->post_solve_delay = get_integer_resource (st->dpy, "postDelay", "Integer");
1416   generator = get_integer_resource(st->dpy, "generator", "Integer");
1417   st->max_length = get_integer_resource(st->dpy, "maxLength", "Integer");
1418   st->ignorant_p = get_boolean_resource(st->dpy, "ignorant", "Boolean");
1419
1420   if (get_boolean_resource (st->dpy, "doFPS", "DoFPS"))
1421     {
1422       /* Just guess, rather than loading and measuring the "fpsFont"... */
1423       st->fps_width = 210;
1424       st->fps_height = 62;
1425     }
1426
1427   if (!size) st->ifrandom = 1;
1428
1429   if (size < 2) size = 7 + (random () % 30);
1430   st->grid_width = st->grid_height = size;
1431   st->bw = (size > 6 ? 3 : (size-1)/2);
1432
1433   XGetWindowAttributes (st->dpy, st->window, &xgwa);
1434
1435   st->x = 0;
1436   st->y = 0;
1437
1438   set_maze_sizes (st, xgwa.width, xgwa.height);
1439
1440   st->gc  = XCreateGC(st->dpy, st->window, 0, 0);
1441   st->cgc = XCreateGC(st->dpy, st->window, 0, 0);
1442   st->tgc = XCreateGC(st->dpy, st->window, 0, 0);
1443   st->sgc = XCreateGC(st->dpy, st->window, 0, 0);
1444   st->ugc = XCreateGC(st->dpy, st->window, 0, 0);
1445   st->logo_gc = XCreateGC(st->dpy, st->window, 0, 0);
1446   st->erase_gc = XCreateGC(st->dpy, st->window, 0, 0);
1447   
1448   bg  = get_pixel_resource (st->dpy, xgwa.colormap, "background","Background");
1449   fg  = get_pixel_resource (st->dpy, xgwa.colormap, "foreground","Foreground");
1450   pfg = get_pixel_resource (st->dpy, xgwa.colormap, "liveColor", "Foreground");
1451   pbg = get_pixel_resource (st->dpy, xgwa.colormap, "deadColor", "Foreground");
1452   sfg = get_pixel_resource (st->dpy, xgwa.colormap, "skipColor", "Foreground");
1453   ufg = get_pixel_resource (st->dpy, xgwa.colormap, "surroundColor", "Foreground");
1454
1455   XSetForeground (st->dpy, st->gc, fg);
1456   XSetBackground (st->dpy, st->gc, bg);
1457   XSetForeground (st->dpy, st->cgc, pbg);
1458   XSetBackground (st->dpy, st->cgc, bg);
1459   XSetForeground (st->dpy, st->tgc, pfg);
1460   XSetBackground (st->dpy, st->tgc, bg);
1461   XSetForeground (st->dpy, st->sgc, sfg);
1462   XSetBackground (st->dpy, st->sgc, bg);
1463   XSetForeground (st->dpy, st->ugc, ufg);
1464   XSetBackground (st->dpy, st->ugc, bg);
1465   XSetForeground (st->dpy, st->logo_gc, fg);
1466   XSetBackground (st->dpy, st->logo_gc, bg);
1467   XSetForeground (st->dpy, st->erase_gc, bg);
1468   XSetBackground (st->dpy, st->erase_gc, bg);
1469
1470   {
1471     Window r;
1472     int x, y;
1473     unsigned int w, h, bbw, d;
1474     unsigned long *pixels;
1475     int npixels;
1476     Pixmap logo_mask = 0;
1477     st->logo_map = xscreensaver_logo (xgwa.screen, xgwa.visual, st->window,
1478                                       xgwa.colormap, bg,
1479                                       &pixels, &npixels, &logo_mask,
1480                                       xgwa.width > 800);
1481     if (logo_mask) {
1482       XSetClipMask (st->dpy, st->logo_gc, logo_mask);
1483       XFreePixmap (st->dpy, logo_mask);
1484     }
1485     if (pixels) free (pixels);
1486     XGetGeometry (st->dpy, st->logo_map, &r, &x, &y, &w, &h, &bbw, &d);
1487     st->logo_width = w;
1488     st->logo_height = h;
1489   }
1490
1491
1492   st->restart = 0;
1493   st->sync_p = 1;
1494
1495   return st;
1496 }
1497
1498
1499 static void
1500 maze_reshape (Display *dpy, Window window, void *closure, 
1501                  unsigned int w, unsigned int h)
1502 {
1503   struct state *st = (struct state *) closure;
1504   st->restart = 1;
1505 }
1506
1507
1508 static unsigned long
1509 maze_draw (Display *dpy, Window window, void *closure)
1510 {
1511   struct state *st = (struct state *) closure;
1512   int this_delay = st->solve_delay;
1513
1514   if (st->eraser || st->erase_window)
1515     {
1516       st->erase_window = 0;
1517       st->eraser = erase_window (st->dpy, st->window, st->eraser);
1518       if (st->eraser)
1519         this_delay = 10000;
1520       else {
1521         this_delay = 1000000;
1522         if (this_delay > st->pre_solve_delay)
1523           this_delay = st->pre_solve_delay;
1524       }
1525       goto END;
1526     }
1527
1528     if (st->restart || st->stop) goto pop;
1529     switch (st->state) {
1530     case 1:
1531       initialize_maze(st);
1532       if (st->ifrandom && st->ifinit)
1533        {
1534          int size;
1535          size = 7 + (random () % 30);
1536          st->grid_width = st->grid_height = size;
1537          st->bw = (size > 6 ? 3 : (size-1)/2);
1538          st->ifinit = 0;
1539          st->restart = 1;
1540        }
1541       break;
1542     case 2:
1543       XClearWindow(st->dpy, st->window);
1544       draw_maze_border(st);
1545       break;
1546     case 3:
1547       st->this_gen = generator;
1548       if(st->this_gen<0 || st->this_gen>2)
1549         st->this_gen = random()%3;
1550
1551       switch(st->this_gen)
1552         {
1553         case 0:
1554           create_maze(st);
1555           break;
1556         case 1:
1557           alt_create_maze(st);
1558           break;
1559         case 2:
1560           set_create_maze(st);
1561           break;
1562         }
1563       break;
1564     case 4:
1565       this_delay = st->pre_solve_delay;
1566       break;
1567     case 5:
1568       if (! solve_maze(st))
1569         --st->state;  /* stay in state 5 */
1570       break;
1571     case 6:
1572       st->erase_window = 1;
1573       this_delay = st->post_solve_delay;
1574       st->state = 0 ;
1575       st->ifinit = 1;
1576       break;
1577     default:
1578       abort ();
1579     }
1580     ++st->state;
1581   pop:
1582     if (st->restart)
1583       {
1584         XWindowAttributes xgwa;
1585         int size;
1586
1587         st->restart = 0;
1588         st->stop = 0;
1589         st->state = 1;
1590
1591         st->sync_p = ((random() % 4) != 0);
1592
1593         size = get_integer_resource (st->dpy, "gridSize", "Dimension");
1594         if (size < 2) size = 7 + (random () % 30);
1595         st->grid_width = st->grid_height = size;
1596         st->bw = (size > 6 ? 3 : (size-1)/2);
1597
1598         XGetWindowAttributes (st->dpy, st->window, &xgwa);
1599         set_maze_sizes (st, xgwa.width, xgwa.height);
1600       }
1601
1602  END:
1603     return this_delay;
1604 }
1605
1606
1607 static Bool
1608 maze_event (Display *dpy, Window window, void *closure, XEvent *event)
1609 {
1610   struct state *st = (struct state *) closure;
1611   switch (event->type) 
1612     {
1613     case ButtonPress:
1614       switch (event->xbutton.button) 
1615         {
1616         case 2:
1617           st->stop = !st->stop ;
1618           if (st->state == 5) st->state = 4 ;
1619           else {
1620             st->restart = 1;
1621             st->stop = 0;
1622           }
1623           return True;
1624
1625         default:
1626           st->restart = 1 ;
1627           st->stop = 0 ;
1628           return True;
1629         }
1630       break;
1631
1632     case Expose:
1633       st->restart = 1;
1634       break;
1635
1636     default:
1637       break;
1638     }
1639   return False;
1640 }
1641
1642
1643 static void
1644 maze_free (Display *dpy, Window window, void *closure)
1645 {
1646   struct state *st = (struct state *) closure;
1647   free (st);
1648 }
1649
1650 XSCREENSAVER_MODULE ("Maze", maze)