--- deliantra/server/random_maps/maze_gen.C	2007/01/18 19:42:10	1.6
+++ deliantra/server/random_maps/maze_gen.C	2008/04/14 22:41:17	1.9
@@ -15,17 +15,10 @@
    reasonable mazes:  a straightforward recursive random walk maze
    generator would generate a map with a trivial circle-the-outer-wall solution */
 
-#include <stdio.h>
 #include <global.h>
 
-/*#include <random_map.h>*/
-#include <maze_gen.h>
-#include <time.h>
-
-
-/* this include solely, and only, is needed for the definition of RANDOM */
-
-
+#include "random_map.h"
+#include "rproto.h"
 
 /* global variables that everyone needs:  don't want to pass them in
    as parameters every time. */
@@ -41,60 +34,43 @@
 /* the outsize interface routine:  accepts sizes, returns a char
 ** maze.  option is a flag for either a sparse or a full maze. Sparse
 mazes have sizable rooms. option = 1, full, 0, sparse.*/
-
-char **
-maze_gen (int xsize, int ysize, int option)
+void
+maze_gen (Maze maze, int option)
 {
-  int i, j;
-
-  /* allocate that array, set it up */
-  char **maze = (char **) calloc (sizeof (char *), xsize);
-
-  for (i = 0; i < xsize; i++)
-    {
-      maze[i] = (char *) calloc (sizeof (char), ysize);
-    }
-
-  /* write the outer walls */
-  for (i = 0; i < xsize; i++)
-    maze[i][0] = maze[i][ysize - 1] = '#';
-  for (j = 0; j < ysize; j++)
-    maze[0][j] = maze[xsize - 1][j] = '#';
-
+  maze->clear ();
+  maze->border ();
 
   /* find how many free wall spots there are */
-  wall_free_size = 2 * (xsize - 4) + 2 * (ysize - 4);
+  wall_free_size = 2 * (maze->w - 4) + 2 * (maze->h - 4);
 
-  make_wall_free_list (xsize, ysize);
+  make_wall_free_list (maze->w, maze->h);
 
   /* return the empty maze */
   if (wall_free_size <= 0)
-    return maze;
+    return;
 
   /* recursively generate the walls of the maze */
   /* first pop a random starting point */
   while (wall_free_size > 0)
     {
+      int i, j;
+
       pop_wall_point (&i, &j);
+
       if (option)
-        fill_maze_full (maze, i, j, xsize, ysize);
+        fill_maze_full (maze, i, j, maze->w, maze->h);
       else
-        fill_maze_sparse (maze, i, j, xsize, ysize);
+        fill_maze_sparse (maze, i, j, maze->w, maze->h);
     }
 
   /* clean up our intermediate data structures. */
 
   free (wall_x_list);
   free (wall_y_list);
-
-  return maze;
 }
 
-
-
 /*  the free wall points are those outer points which aren't corners or
     near corners, and don't have a maze wall growing out of them already. */
-
 void
 make_wall_free_list (int xsize, int ysize)
 {
@@ -104,9 +80,9 @@
   /*allocate it */
   if (wall_free_size < 0)
     return;
-  wall_x_list = (int *) calloc (sizeof (int), wall_free_size);
-  wall_y_list = (int *) calloc (sizeof (int), wall_free_size);
 
+  wall_x_list = (int *)calloc (sizeof (int), wall_free_size);
+  wall_y_list = (int *)calloc (sizeof (int), wall_free_size);
 
   /* top and bottom wall */
   for (i = 2; i < xsize - 2; i++)
@@ -131,14 +107,11 @@
     }
 }
 
-
-
 /* randomly returns one of the elements from the wall point list */
-
 void
 pop_wall_point (int *x, int *y)
 {
-  int index = RANDOM () % wall_free_size;
+  int index = rndm (wall_free_size);
 
   *x = wall_x_list[index];
   *y = wall_y_list[index];
@@ -148,12 +121,9 @@
   wall_free_size--;
 }
 
-
-
 /* find free point:  randomly look for a square adjacent to this one where
 we can place a new block without closing a path.  We may only look
 up, down, right, or left. */
-
 int
 find_free_point (char **maze, int *x, int *y, int xc, int yc, int xsize, int ysize)
 {
@@ -176,7 +146,6 @@
         }
     }
 
-
   /* look down */
   if (yc > 2 && xc > 2 && xc < xsize - 2)       /* it is valid to look down */
     {
@@ -191,7 +160,6 @@
         }
     }
 
-
   /* look right */
   if (xc < xsize - 2 && yc > 2 && yc < ysize - 2)       /* it is valid to look left */
     {
@@ -206,7 +174,6 @@
         }
     }
 
-
   /* look left */
   if (xc > 2 && yc > 2 && yc < ysize - 2)       /* it is valid to look down */
     {
@@ -226,9 +193,10 @@
 
   /* choose a random direction */
   if (count > 1)
-    count = RANDOM () % count;
+    count = rndm (count);
   else
     count = 0;
+
   switch (dirlist[count])
     {
       case 1:                  /* up */
@@ -256,16 +224,14 @@
           break;
         }
       default:                 /* ??? */
-        {
-          return -1;
-        }
+        return -1;
+
     }
   return 1;
 }
 
 /* recursive routine which will fill every available space in the maze
         with walls*/
-
 void
 fill_maze_full (char **maze, int x, int y, int xsize, int ysize)
 {
@@ -288,10 +254,8 @@
     }
 }
 
-
 /* recursive routine which will fill much of the maze, but will leave
         some free spots (possibly large) toward the center.*/
-
 void
 fill_maze_sparse (char **maze, int x, int y, int xsize, int ysize)
 {
@@ -309,7 +273,5 @@
 
   /* change the if to a while for a complete maze.  */
   if (find_free_point (maze, &xc, &yc, x, y, xsize, ysize) != -1)
-    {
-      fill_maze_sparse (maze, xc, yc, xsize, ysize);
-    }
+    fill_maze_sparse (maze, xc, yc, xsize, ysize);
 }