--- deliantra/server/random_maps/layout.C	2010/07/03 01:49:18	1.12
+++ deliantra/server/random_maps/layout.C	2010/07/03 11:52:11	1.16
@@ -36,13 +36,12 @@
   // we store the layout in a single contiguous memory layout
   // first part consists of pointers to each column, followed
   // by the actual columns (not rows!)
-  int size = (sizeof (cell *) + sizeof (cell) * h) * w;
-
+  size = (sizeof (cell *) + sizeof (cell) * h) * w;
   data = (cell **)salloc<char> (size);
 
   cell *p = (cell *)(data + w);
 
-  for (int x = w; x--; )
+  for (int x = 0; x < w; ++x)
     data [x] = p + x * h;
 }
 
@@ -58,17 +57,30 @@
   memcpy (data [0], copy.data [0], sizeof (cell) * h * w);
 }
 
-layout::~layout ()
+layout::layout (layout &orig, int x1, int y1, int x2, int y2)
 {
-  int size = (sizeof (cell *) + sizeof (cell) * h) * w;
+  w = x2 - x1;
+  h = y2 - y1;
+
+  // we only allocate space for the pointers
+  size = sizeof (cell *) * w;
+  data = (cell **)salloc<char> (size);
 
+  // and now we point back into the original layout
+  for (int x = 0; x < w; ++x)
+    data [x] = orig.data [x + x1] + y1;
+}
+
+layout::~layout ()
+{
   sfree ((char *)data, size);
 }
 
 void
 layout::fill (char fill)
 {
-  memset (data [0], fill, w * h);
+  //memset (data [0], fill, w * h); // only when contiguous :/
+  fill_rect (0, 0, w, h, fill);
 }
 
 void
@@ -218,12 +230,10 @@
       point neigh[4];
       int ncnt = 0;
 
-      if (x >          1 && U8 (dist [x - 1][y]) <= d && dist [x - 1][y] > 1) neigh [ncnt++] = point (x - 1, y);
-      if (x < dist.w - 2 && U8 (dist [x + 1][y]) <= d && dist [x + 1][y] > 1) neigh [ncnt++] = point (x + 1, y);
-      if (y >          1 && U8 (dist [x][y - 1]) <= d && dist [x][y - 1] > 1) neigh [ncnt++] = point (x, y - 1);
-      if (y < dist.h - 2 && U8 (dist [x][y + 1]) <= d && dist [x][y + 1] > 1) neigh [ncnt++] = point (x, y + 1);
-
-      printf ("tunnel %d+%d ncnt %d\n", x, y, ncnt);//D
+      if (x >          0 && U8 (dist [x - 1][y]) <= d && dist [x - 1][y] > 1) neigh [ncnt++] = point (x - 1, y);
+      if (x < dist.w - 1 && U8 (dist [x + 1][y]) <= d && dist [x + 1][y] > 1) neigh [ncnt++] = point (x + 1, y);
+      if (y >          0 && U8 (dist [x][y - 1]) <= d && dist [x][y - 1] > 1) neigh [ncnt++] = point (x, y - 1);
+      if (y < dist.h - 1 && U8 (dist [x][y + 1]) <= d && dist [x][y + 1] > 1) neigh [ncnt++] = point (x, y + 1);
 
       if (!ncnt)
         return;
@@ -277,7 +287,6 @@
       // map is completely massive, this is not good,
       // so make it empty instead.
       dist.fill (1);
-      dist.border (255);
       return;
     }
 
@@ -311,10 +320,10 @@
           // nothing here, continue to expand
           U8 d = U8 (dist [x][y]) + 1;
 
-          if (x < dist.w - 2) maybe_push (dist, seeds, x + 1, y, d);
-          if (x >          1) maybe_push (dist, seeds, x - 1, y, d);
-          if (y < dist.h - 2) maybe_push (dist, seeds, x, y + 1, d);
-          if (y >          1) maybe_push (dist, seeds, x, y - 1, d);
+          if (x < dist.w - 1) maybe_push (dist, seeds, x + 1, y, d);
+          if (x >          0) maybe_push (dist, seeds, x - 1, y, d);
+          if (y < dist.h - 1) maybe_push (dist, seeds, x, y + 1, d);
+          if (y >          0) maybe_push (dist, seeds, x, y - 1, d);
         }
     }
 }
@@ -322,63 +331,23 @@
 void
 layout::isolation_remover ()
 {
-  layout dist (w, h);
+  layout dist (w - 2, h - 2); // map without border
 
   for (int x = 1; x < w - 1; ++x)
     for (int y = 1; y < h - 1; ++y)
-      dist [x][y] = data [x][y] == '#' ? U8 (255) : 0;
+      dist [x - 1][y - 1] = data [x][y] == '#' ? U8 (255) : 0;
 
   ::isolation_remover (dist);
 
   // now copy the tunnels over
   for (int x = 1; x < w - 1; ++x)
     for (int y = 1; y < h - 1; ++y)
-      if (data [x][y] == '#' && dist [x][y] == 1)
+      if (data [x][y] == '#' && dist [x - 1][y - 1] == 1)
         data [x][y] = 0;
 }
 
 /////////////////////////////////////////////////////////////////////////////
 
-// inspired mostly by http://www.jimrandomh.org/misc/caves.txt
-void
-layout::gen_cave (int subtype)
-{
-  switch (subtype)
-    {
-      // a rough cave
-      case 0:
-        fill_rand (rmg_rndm (85, 97));
-        break;
-
-      // corridors
-      case 1:
-        fill_rand (rmg_rndm (5, 40));
-        erode_1_2 (5,  2, 10);
-        erode_1_2 (5, -1, 10);
-        erode_1_2 (5,  2, 1);
-        break;
-
-      // somewhat open, roundish
-      case 2:
-        fill_rand (45);
-        erode_1_2 (5,  0, 5);
-        erode_1_2 (5, 1, 1);
-        break;
-
-      // wide open, some room-like structures
-      case 3:
-        fill_rand (45);
-        erode_1_2 (5,  2, 4);
-        erode_1_2 (5, -1, 3);
-        break;
-    }
-
-  border ();
-  isolation_remover ();
-}
-
-/////////////////////////////////////////////////////////////////////////////
-
 //+GPL
 
 /*  puts doors at appropriate locations in a maze. */
@@ -806,6 +775,87 @@
 
 /////////////////////////////////////////////////////////////////////////////
 
+// inspired mostly by http://www.jimrandomh.org/misc/caves.txt
+void
+layout::gen_cave (int subtype)
+{
+  switch (subtype)
+    {
+      // a rough cave
+      case 0:
+        fill_rand (rmg_rndm (85, 97));
+        break;
+
+      // corridors
+      case 1:
+        fill_rand (rmg_rndm (5, 40));
+        erode_1_2 (5,  2, 10);
+        erode_1_2 (5, -1, 10);
+        erode_1_2 (5,  2, 1);
+        break;
+
+      // somewhat open, roundish
+      case 2:
+        fill_rand (45);
+        erode_1_2 (5,  0, 5);
+        erode_1_2 (5, 1, 1);
+        break;
+
+      // wide open, some room-like structures
+      case 3:
+        fill_rand (45);
+        erode_1_2 (5,  2, 4);
+        erode_1_2 (5, -1, 3);
+        break;
+    }
+
+  border ();
+  isolation_remover ();
+}
+
+static void
+gen_mixed_ (layout &maze, random_map_params *RP, int dir)
+{
+  if (maze.w < 20 && maze.h < 20 && !rmg_rndm (3))
+    dir = 2; // stop recursion randomly
+
+  if (dir == 0 && maze.w > 16)
+    {
+      int m = rmg_rndm (8, maze.w - 8);
+
+      layout m1 (maze, 0, 0, m     , maze.h); gen_mixed_ (m1, RP, !dir);
+      layout m2 (maze, m, 0, maze.w, maze.h); gen_mixed_ (m2, RP, !dir);
+    }
+  else if (dir == 1 && maze.h > 16)
+    {
+      int m = rmg_rndm (8, maze.h - 8);
+
+      layout m1 (maze, 0, 0, maze.w, m     ); gen_mixed_ (m1, RP, !dir);
+      layout m2 (maze, 0, m, maze.w, maze.h); gen_mixed_ (m2, RP, !dir);
+    }
+  else
+    {
+      RP->map_layout_style = rmg_rndm (NROFLAYOUTS - 2) + 1;
+
+      if (RP->map_layout_style == LAYOUT_MULTIPLE)
+        ++RP->map_layout_style;
+
+      maze.generate (RP);
+    }
+}
+
+// recursive subdivision with random sublayouts
+static void
+gen_mixed (layout &maze, random_map_params *RP)
+{
+  random_map_params &rp = *new random_map_params (RP);
+  gen_mixed_ (maze, &rp, rmg_rndm (2));
+  delete &rp;
+
+  maze.border ();
+  maze.isolation_remover ();
+}
+
 /*  function selects the maze function and gives it whatever
     arguments it needs.  */
 void
@@ -874,21 +924,13 @@
 
         break;
 
+      case LAYOUT_MULTIPLE:
+        gen_mixed (*this, RP);
+        break;
+
       default:
         abort ();
     }
-
-  /*  rotate the maze randomly */
-  rotate (rmg_rndm (4));
-
-  symmetrize (RP->symmetry_used);
-
-#if 0
-  print ();//D
-#endif
-
-  if (RP->expand2x)
-    expand2x ();
 }
 
 //-GPL