+ if(s1<s2)
+ st->sets[s2] = s1;
+ else
+ st->sets[s1] = s2;
+}
+
+/* Exitialise the sets. */
+static void
+exit_sets(struct state *st)
+{
+ if(st->hedges)
+ free(st->hedges);
+ st->hedges = 0;
+ if(st->sets)
+ free(st->sets);
+ st->sets = 0;
+}
+
+#if DEBUG_SETS
+/* Temporary hack. */
+static void
+show_set(int num, GC gc)
+{
+ int st->x, st->y, set;
+
+ set = get_set(num);
+
+ for(st->x = 0; st->x < st->maze_size_x; st->x++)
+ for(st->y = 0; st->y < st->maze_size_y; st->y++)
+ {
+ if(get_set(st->x+st->y*st->maze_size_x)==set)
+ {
+ XFillRectangle(st->dpy, st->window, st->gc, border_x + st->bw + st->grid_width * st->x,
+ border_y + st->bw + st->grid_height * st->y,
+ st->grid_width-2*st->bw , st->grid_height-2*st->bw);
+ }
+ }
+}
+#endif
+
+/* Second alternative maze creator: Put each square in the maze in a
+ * separate set. Also, make a list of all the hedges. Randomize that list.
+ * Walk through the list. If, for a certain hedge, the two squares on both
+ * sides of it are in different sets, union the sets and remove the hedge.
+ * Continue until all hedges have been processed or only one set remains.
+ */
+static void
+set_create_maze(struct state *st)
+{
+ int i, h, xx, yy, dir, v, w;
+#if DEBUG_SETS
+ int cont = 0;
+ char c;
+#endif
+
+ /* Do almost all the setup. */
+ init_sets(st);
+
+ /* Start running through the hedges. */
+ for(i = 0; i < 2*st->maze_size_x*st->maze_size_y; i++)
+ {
+ h = st->hedges[i];
+
+ /* This one is in the logo or outside border. */
+ if(h==-1)
+ continue;
+
+ dir = h%2?1:2;
+ xx = (h>>1)%st->maze_size_x;
+ yy = (h>>1)/st->maze_size_x;
+
+ v = xx;
+ w = yy;
+ switch(dir)
+ {
+ case 1:
+ v++;
+ break;
+ case 2:
+ w++;
+ break;
+ }
+
+#if DEBUG_SETS
+ show_set(st, xx+yy*st->maze_size_x, st->logo_gc);
+ show_set(st, v+w*st->maze_size_x, st->tgc);
+#endif
+ if(get_set(st, xx+yy*st->maze_size_x)!=get_set(st, v+w*st->maze_size_x))
+ {
+#if DEBUG_SETS
+ printf("Join!");
+#endif
+ join_sets(st, xx+yy*st->maze_size_x, v+w*st->maze_size_x);
+ /* Don't draw the wall. */
+ }
+ else
+ {
+#if DEBUG_SETS
+ printf("Build.");
+#endif
+ /* Don't join the sets. */
+ build_wall(st, xx, yy, dir);
+ }
+#if DEBUG_SETS
+ if(!cont)
+ {
+ XSync(st->dpy, False);
+ c = getchar();
+ if(c=='c')
+ cont = 1;
+ }
+ show_set(xx+yy*st->maze_size_x, st->erase_gc);
+ show_set(v+w*st->maze_size_x, st->erase_gc);
+#endif
+ }
+
+ /* Free some memory. */
+ exit_sets(st);
+}
+
+/* First alternative maze creator: Pick a random, empty corner in the maze.
+ * Pick a random direction. Draw a wall in that direction, from that corner
+ * until we hit a wall. Option: Only draw the wall if it's going to be
+ * shorter than a certain length. Otherwise we get lots of long walls.
+ */
+static void
+alt_create_maze(struct state *st)
+{
+ char *corners;
+ int *c_idx;
+ int i, j, height, width, open_corners, k, dir, xx, yy;
+
+ height = st->maze_size_y+1;
+ width = st->maze_size_x+1;
+
+ /* Allocate and clear some mem. */
+ corners = (char *)calloc(height*width, 1);
+ if(!corners)
+ return;
+
+ /* Set up the indexing array. */
+ c_idx = (int *)malloc(sizeof(int)*height*width);
+ if(!c_idx)
+ {
+ free(corners);
+ return;
+ }
+ for(i = 0; i < height*width; i++)
+ c_idx[i] = i;
+ for(i = 0; i < height*width; i++)
+ {
+ j = c_idx[i];
+ k = random()%(height*width);
+ c_idx[i] = c_idx[k];
+ c_idx[k] = j;
+ }
+
+ /* Set up some initial walls. */
+ /* Outside walls. */
+ for(i = 0; i < width; i++)
+ {
+ corners[i] = 1;
+ corners[i+width*(height-1)] = 1;
+ }
+ for(i = 0; i < height; i++)
+ {
+ corners[i*width] = 1;
+ corners[i*width+width-1] = 1;
+ }
+ /* Walls around logo. In fact, inside the logo, too. */
+ /* Also draw the walls. */
+ if(st->logo_x!=-1)
+ {
+ int logow = 1 + st->logo_width / st->grid_width;
+ int logoh = 1 + st->logo_height / st->grid_height;
+ int bridge_dir, bridge_c;
+
+ if(st->bridge_p && logoh>=3 && logow>=3)
+ {
+ bridge_dir = 1+random()%2;
+ if(bridge_dir==1)
+ {
+ bridge_c = st->logo_y+random()%(logoh-2)+1;
+ }
+ else
+ {
+ bridge_c = st->logo_x+random()%(logow-2)+1;
+ }
+ }
+ else
+ {
+ bridge_dir = 0;
+ bridge_c = -1;
+ }
+ for(i = st->logo_x; i <= st->logo_x + logow; i++)
+ {
+ for(j = st->logo_y; j <= st->logo_y + logoh; j++)
+ {
+ corners[i+width*j] = 1;
+ }
+ }
+ for(xx = st->logo_x; xx < st->logo_x+logow; xx++)
+ {
+ if(!(bridge_dir==2 && xx==bridge_c))
+ {
+ build_wall(st, xx, st->logo_y, 0);
+ build_wall(st, xx, st->logo_y+logoh, 0);
+ }
+ if(bridge_dir==1)
+ {
+ build_wall(st, xx, bridge_c, 0);
+ build_wall(st, xx, bridge_c, 2);
+ }
+ }
+ for(yy = st->logo_y; yy < st->logo_y+logoh; yy++)
+ {
+ if(!(bridge_dir==1 && yy==bridge_c))
+ {
+ build_wall(st, st->logo_x, yy, 3);
+ build_wall(st, st->logo_x+logow, yy, 3);
+ }
+ if(bridge_dir==2)
+ {
+ build_wall(st, bridge_c, yy, 1);
+ build_wall(st, bridge_c, yy, 3);
+ }
+ }
+ /* Connect one wall of the logo with an outside wall. */
+ if(st->bridge_p)
+ dir = (bridge_dir+1)%4;
+ else
+ dir = random()%4;
+ switch(dir)
+ {
+ case 0:
+ xx = st->logo_x+(random()%(logow+1));
+ yy = st->logo_y;
+ break;
+ case 1:
+ xx = st->logo_x+logow;
+ yy = st->logo_y+(random()%(logoh+1));
+ break;
+ case 2:
+ xx = st->logo_x+(random()%(logow+1));
+ yy = st->logo_y+logoh;
+ break;
+ case 3:
+ xx = st->logo_x;
+ yy = st->logo_y+(random()%(logoh+1));
+ break;
+ }
+ do
+ {
+ corners[xx+width*yy] = 1;
+ switch(dir)
+ {
+ case 0:
+ build_wall(st, xx-1, yy-1, 1);
+ yy--;
+ break;
+ case 1:
+ build_wall(st, xx, yy, 0);
+ xx++;
+ break;
+ case 2:
+ build_wall(st, xx, yy, 3);
+ yy++;
+ break;
+ case 3:
+ build_wall(st, xx-1, yy-1, 2);
+ xx--;
+ break;
+ }
+ }
+ while(!corners[xx+width*yy]);
+ if(st->bridge_p)
+ {
+ dir = (dir+2)%4;
+ switch(dir)
+ {
+ case 0:
+ xx = st->logo_x+(random()%(logow+1));
+ yy = st->logo_y;
+ break;
+ case 1:
+ xx = st->logo_x+logow;
+ yy = st->logo_y+(random()%(logoh+1));
+ break;
+ case 2:
+ xx = st->logo_x+(random()%(logow+1));
+ yy = st->logo_y+logoh;
+ break;
+ case 3:
+ xx = st->logo_x;
+ yy = st->logo_y+(random()%(logoh+1));
+ break;
+ }
+ do
+ {
+ corners[xx+width*yy] = 1;
+ switch(dir)
+ {
+ case 0:
+ build_wall(st, xx-1, yy-1, 1);
+ yy--;
+ break;
+ case 1:
+ build_wall(st, xx, yy, 0);
+ xx++;
+ break;
+ case 2:
+ build_wall(st, xx, yy, 3);
+ yy++;
+ break;
+ case 3:
+ build_wall(st, xx-1, yy-1, 2);
+ xx--;
+ break;
+ }
+ }
+ while(!corners[xx+width*yy]);
+ }
+ }
+
+ /* Count open gridpoints. */
+ open_corners = 0;
+ for(i = 0; i < width; i++)
+ for(j = 0; j < height; j++)
+ if(!corners[i+width*j])
+ open_corners++;
+
+ /* Now do actual maze generation. */
+ while(open_corners>0)
+ {
+ for(i = 0; i < width*height; i++)
+ {
+ if(!corners[c_idx[i]])
+ {
+ xx = c_idx[i]%width;
+ yy = c_idx[i]/width;
+ /* Choose a random direction. */
+ dir = random()%4;
+
+ k = 0;
+ /* Measure the length of the wall we'd draw. */
+ while(!corners[xx+width*yy])
+ {
+ k++;
+ switch(dir)
+ {
+ case 0:
+ yy--;
+ break;
+ case 1:
+ xx++;
+ break;
+ case 2:
+ yy++;
+ break;
+ case 3:
+ xx--;
+ break;
+ }
+ }
+
+ if(k<=st->max_length)
+ {
+ xx = c_idx[i]%width;
+ yy = c_idx[i]/width;
+
+ /* Draw a wall until we hit something. */
+ while(!corners[xx+width*yy])
+ {
+ open_corners--;
+ corners[xx+width*yy] = 1;
+ switch(dir)
+ {
+ case 0:
+ build_wall(st, xx-1, yy-1, 1);
+ yy--;
+ break;
+ case 1:
+ build_wall(st, xx, yy, 0);
+ xx++;
+ break;
+ case 2:
+ build_wall(st, xx, yy, 3);
+ yy++;
+ break;
+ case 3:
+ build_wall(st, xx-1, yy-1, 2);
+ xx--;
+ break;
+ }
+ }
+ }
+ }
+ }
+ }
+
+ /* Free some memory we used. */
+ free(corners);
+ free(c_idx);
+}
+
+/* The original maze creator. Start somewhere. Take a step in a random
+ * direction. Keep doing this until we hit a wall. Then, backtrack until
+ * we find a point where we can go in another direction.
+ */
+static void
+create_maze (struct state *st) /* create a maze layout given the initialized maze */
+{
+ register int i, newdoor = 0;
+ int logow = 1 + st->logo_width / st->grid_width;
+ int logoh = 1 + st->logo_height / st->grid_height;
+
+ /* Maybe we should make a bridge? */
+ if(st->bridge_p && st->logo_x >= 0 && logow>=3 && logoh>=3)
+ {
+ int bridge_dir, bridge_c;
+
+ bridge_dir = 1+random()%2;
+ if(bridge_dir==1)
+ {
+ if(logoh>=3)
+ bridge_c = st->logo_y+random()%(logoh-2)+1;
+ else
+ bridge_c = st->logo_y+random()%logoh;
+ }
+ else
+ {
+ if(logow>=3)
+ bridge_c = st->logo_x+random()%(logow-2)+1;
+ else
+ bridge_c = st->logo_x+random()%logow;
+ }
+
+ if(bridge_dir==1)
+ {
+ for(i = st->logo_x; i < st->logo_x+logow; i++)
+ {
+ st->maze[i][bridge_c] &= ~DOOR_IN_TOP;
+ }
+ }
+ else
+ {
+ for(i = st->logo_y; i < st->logo_y+logoh; i++)
+ {
+ st->maze[bridge_c][i] &= ~DOOR_IN_TOP;
+ }
+ }
+ }
+