server/random_maps/random_map.C

/*
 * This file is part of Deliantra, the Roguelike Realtime MMORPG.
 * 
 * Copyright (©) 2005,2006,2007,2008,2009,2010 Marc Alexander Lehmann / Robin Redeker / the Deliantra team
 * Copyright (©) 2001 Mark Wedel & Crossfire Development Team
 * Copyright (©) 1992 Frank Tore Johansen
 * 
 * Deliantra is free software: you can redistribute it and/or modify it under
 * the terms of the Affero GNU General Public License as published by the
 * Free Software Foundation, either version 3 of the License, or (at your
 * option) any later version.
 * 
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 * 
 * You should have received a copy of the Affero GNU General Public License
 * and the GNU General Public License along with this program. If not, see
 * <http://www.gnu.org/licenses/>.
 * 
 * The authors can be reached via e-mail to <support@deliantra.net>
 */

#include <time.h>
#include <stdio.h>
#include <global.h>
#include <random_map.h>
#include <rproto.h>
#include <sproto.h>

#define CEDE coroapi::cede_to_tick ()

static void symmetrize_layout (Layout maze, random_map_params *RP);
static void rotate_layout (Layout maze, int rotation);

void
dump_layout (Layout layout)
{
  for (int j = 0; j < layout->h; j++)
    {
      for (int i = 0; i < layout->w; i++)
        putc (layout[i][j] ? layout[i][j] : ' ', stdout);

      putc ('\n', stdout);
    }

  putc ('\n', stdout);
}

/* takes a map and makes it symmetric: adjusts Xsize and
 * Ysize to produce a symmetric map.
 */
static void
symmetrize_layout (Layout layout, random_map_params *RP)
{
  if (RP->symmetry_used == SYMMETRY_NONE)
    return;

  Layout sym_layout (
    RP->symmetry_used == SYMMETRY_X || RP->symmetry_used == SYMMETRY_XY ? layout->w * 2 - 3 : layout->w,
    RP->symmetry_used == SYMMETRY_Y || RP->symmetry_used == SYMMETRY_XY ? layout->h * 2 - 3 : layout->h
  );

  if (RP->symmetry_used == SYMMETRY_X)
    for (int i = 0; i < sym_layout->w / 2 + 1; i++)
      for (int j = 0; j < sym_layout->h; j++)
        {
          sym_layout[i                  ][j] =
          sym_layout[sym_layout->w - i - 1][j] = layout[i][j];
        }

  if (RP->symmetry_used == SYMMETRY_Y)
    for (int i = 0; i < sym_layout->w; i++)
      for (int j = 0; j < sym_layout->h / 2 + 1; j++)
        {
          sym_layout[i][j                  ] =
          sym_layout[i][sym_layout->h - j - 1] = layout[i][j];
        }

  if (RP->symmetry_used == SYMMETRY_XY)
    for (int i = 0; i < sym_layout->w / 2 + 1; i++)
      for (int j = 0; j < sym_layout->h / 2 + 1; j++)
        {
          sym_layout[i                  ][j                  ] =
          sym_layout[i                  ][sym_layout->h - j - 1] =
          sym_layout[sym_layout->w - i - 1][j                  ] =
          sym_layout[sym_layout->w - i - 1][sym_layout->h - j - 1] = layout[i][j];
        }

  layout.swap (sym_layout);
  sym_layout.free ();

  /* reconnect disjointed spirals */
  /* reconnect disjointed nethacklayouts:  the routine for
     spirals will do the trick? */
  if (RP->map_layout_style == LAYOUT_SPIRAL
      || RP->map_layout_style == LAYOUT_ROGUELIKE)
    connect_spirals (layout->w, layout->h, RP->symmetry_used, layout);
}

/*  takes  a map and rotates it.  This completes the
    onion layouts, making them possibly centered on any wall. 
    It'll modify Xsize and Ysize if they're swapped.
*/
static void
rotate_layout (Layout layout, int rotation)
{
  int w = layout->w;
  int h = layout->h;

  switch (rotation)
    {
      case 2:                  /* a reflection */
        {
          Layout new_layout (w, h);

          for (int i = 0; i < w; i++)                   /* copy a reflection back */
            for (int j = 0; j < h; j++)
              new_layout[i][j] = layout[w - i - 1][h - j - 1];

          layout.swap (new_layout);
          new_layout.free ();
        }
        break;

      case 1:
      case 3:
        {
          Layout new_layout (h, w);

          if (rotation == 1)    /* swap x and y */
            for (int i = 0; i < w; i++)
              for (int j = 0; j < h; j++)
                new_layout[j][i] = layout[i][j];

          if (rotation == 3) /* swap x and y */
            for (int i = 0; i < w; i++)
              for (int j = 0; j < h; j++)
                new_layout[j][i] = layout[w - i - 1][h - j - 1];

          layout.swap (new_layout);
          new_layout.free ();
        }
        break;
    }
}

/*  checks the layout to see if I can stick a horizontal(dir = 0) wall
    (or vertical, dir == 1)
    here which ends up on other walls sensibly.  */
static int
can_make_wall (char **maze, int dx, int dy, int dir, random_map_params *RP)
{
  int i1;
  int length = 0;

  /* dont make walls if we're on the edge. */
  if (dx == 0 || dx == (RP->Xsize - 1) || dy == 0 || dy == (RP->Ysize - 1))
    return -1;

  /* don't make walls if we're ON a wall. */
  if (maze[dx][dy] != 0)
    return -1;

  if (dir == 0)                 /* horizontal */
    {
      int y = dy;

      for (i1 = dx - 1; i1 > 0; i1--)
        {
          int sindex = surround_flag2 (maze, i1, y, RP);

          if (sindex == 1)
            break;
          if (sindex != 0)
            return -1;          /* can't make horiz.  wall here */
          if (maze[i1][y] != 0)
            return -1;          /* can't make horiz.  wall here */
          length++;
        }

      for (i1 = dx + 1; i1 < RP->Xsize - 1; i1++)
        {
          int sindex = surround_flag2 (maze, i1, y, RP);

          if (sindex == 2)
            break;
          if (sindex != 0)
            return -1;          /* can't make horiz.  wall here */
          if (maze[i1][y] != 0)
            return -1;          /* can't make horiz.  wall here */
          length++;
        }
      return length;
    }
  else
    {                           /* vertical */
      int x = dx;

      for (i1 = dy - 1; i1 > 0; i1--)
        {
          int sindex = surround_flag2 (maze, x, i1, RP);

          if (sindex == 4)
            break;
          if (sindex != 0)
            return -1;          /* can't make vert. wall here */
          if (maze[x][i1] != 0)
            return -1;          /* can't make horiz.  wall here */
          length++;
        }

      for (i1 = dy + 1; i1 < RP->Ysize - 1; i1++)
        {
          int sindex = surround_flag2 (maze, x, i1, RP);

          if (sindex == 8)
            break;
          if (sindex != 0)
            return -1;          /* can't make verti. wall here */
          if (maze[x][i1] != 0)
            return -1;          /* can't make horiz.  wall here */
          length++;
        }

      return length;
    }

  return -1;
}

/*  take a layout and make some rooms in it. 
    --works best on onions.*/
static void
roomify_layout (char **maze, random_map_params *RP)
{
  int tries = RP->Xsize * RP->Ysize / 30;
  int ti;

  for (ti = 0; ti < tries; ti++)
    {
      int dx, dy;               /* starting location for looking at creating a door */
      int cx, cy;               /* results of checking on creating walls. */

      dx = rmg_rndm (RP->Xsize);
      dy = rmg_rndm (RP->Ysize);

      cx = can_make_wall (maze, dx, dy, 0, RP); /* horizontal */
      cy = can_make_wall (maze, dx, dy, 1, RP); /* vertical */
      if (cx == -1)
        {
          if (cy != -1)
            make_wall (maze, dx, dy, 1);

          continue;
        }

      if (cy == -1)
        {
          make_wall (maze, dx, dy, 0);
          continue;
        }

      if (cx < cy)
        make_wall (maze, dx, dy, 0);
      else
        make_wall (maze, dx, dy, 1);
    }
}

int
make_wall (char **maze, int x, int y, int dir)
{
  maze[x][y] = 'D';             /* mark a door */
  switch (dir)
    {
      case 0:                  /* horizontal */
        {
          int i1;

          for (i1 = x - 1; maze[i1][y] == 0; i1--)
            maze[i1][y] = '#';
          for (i1 = x + 1; maze[i1][y] == 0; i1++)
            maze[i1][y] = '#';
          break;
        }
      case 1:                  /* vertical */
        {
          int i1;

          for (i1 = y - 1; maze[x][i1] == 0; i1--)
            maze[x][i1] = '#';
          for (i1 = y + 1; maze[x][i1] == 0; i1++)
            maze[x][i1] = '#';
          break;
        }
    }

  return 0;
}

/*  puts doors at appropriate locations in a layout. */
static void
doorify_layout (char **maze, random_map_params *RP)
{
  int ndoors = RP->Xsize * RP->Ysize / 60;      /* reasonable number of doors. */
  int doorlocs = 0;             /* # of available doorlocations */

  uint16 *doorlist_x = salloc<uint16> (RP->Xsize * RP->Ysize);
  uint16 *doorlist_y = salloc<uint16> (RP->Xsize * RP->Ysize);

  /* make a list of possible door locations */
  for (int i = 1; i < RP->Xsize - 1; i++)
    for (int j = 1; j < RP->Ysize - 1; j++)
      {
        int sindex = surround_flag (maze, i, j, RP);

        if (sindex == 3 || sindex == 12)        /* these are possible door sindex */
          {
            doorlist_x[doorlocs] = i;
            doorlist_y[doorlocs] = j;
            doorlocs++;
          }
      }

  while (ndoors > 0 && doorlocs > 0)
    {
      int di = rmg_rndm (doorlocs);
      int i = doorlist_x[di];
      int j = doorlist_y[di];
      int sindex = surround_flag (maze, i, j, RP);

      if (sindex == 3 || sindex == 12)  /* these are possible door sindex */
        {
          maze[i][j] = 'D';
          ndoors--;
        }

      /* reduce the size of the list */
      doorlocs--;
      doorlist_x[di] = doorlist_x[doorlocs];
      doorlist_y[di] = doorlist_y[doorlocs];
    }

  sfree (doorlist_x, RP->Xsize * RP->Ysize);
  sfree (doorlist_y, RP->Xsize * RP->Ysize);
}

void
write_map_parameters_to_string (char *buf, random_map_params *RP)
{
  char small_buf[16384];

  sprintf (buf, "xsize %d\nysize %d\n", RP->xsize, RP->ysize);

  if (RP->wallstyle[0])
    {
      sprintf (small_buf, "wallstyle %s\n", RP->wallstyle);
      strcat (buf, small_buf);
    }

  if (RP->miningstyle[0])
    {
      sprintf (small_buf, "miningstyle %s\n", RP->miningstyle);
      strcat (buf, small_buf);
    }

  if (RP->floorstyle[0])
    {
      sprintf (small_buf, "floorstyle %s\n", RP->floorstyle);
      strcat (buf, small_buf);
    }

  if (RP->monsterstyle[0])
    {
      sprintf (small_buf, "monsterstyle %s\n", RP->monsterstyle);
      strcat (buf, small_buf);
    }

  if (RP->treasurestyle[0])
    {
      sprintf (small_buf, "treasurestyle %s\n", RP->treasurestyle);
      strcat (buf, small_buf);
    }

  if (RP->layoutstyle[0])
    {
      sprintf (small_buf, "layoutstyle %s\n", RP->layoutstyle);
      strcat (buf, small_buf);
    }

  if (RP->decorstyle[0])
    {
      sprintf (small_buf, "decorstyle %s\n", RP->decorstyle);
      strcat (buf, small_buf);
    }

  if (RP->doorstyle[0])
    {
      sprintf (small_buf, "doorstyle %s\n", RP->doorstyle);
      strcat (buf, small_buf);
    }

  if (RP->exitstyle[0])
    {
      sprintf (small_buf, "exitstyle %s\n", RP->exitstyle);
      strcat (buf, small_buf);
    }

  if (RP->final_map.length ())
    {
      sprintf (small_buf, "final_map %s\n", &RP->final_map);
      strcat (buf, small_buf);
    }

  if (RP->exit_on_final_map[0])
    {
      sprintf (small_buf, "exit_on_final_map %s\n", RP->exit_on_final_map);
      strcat (buf, small_buf);
    }

  if (RP->this_map.length ())
    {
      sprintf (small_buf, "origin_map %s\n", &RP->this_map);
      strcat (buf, small_buf);
    }

  if (RP->expand2x)
    {
      sprintf (small_buf, "expand2x %d\n", RP->expand2x);
      strcat (buf, small_buf);
    }

  if (RP->layoutoptions1)
    {
      sprintf (small_buf, "layoutoptions1 %d\n", RP->layoutoptions1);
      strcat (buf, small_buf);
    }

  if (RP->layoutoptions2)
    {
      sprintf (small_buf, "layoutoptions2 %d\n", RP->layoutoptions2);
      strcat (buf, small_buf);
    }

  if (RP->layoutoptions3)
    {
      sprintf (small_buf, "layoutoptions3 %d\n", RP->layoutoptions3);
      strcat (buf, small_buf);
    }

  if (RP->symmetry)
    {
      sprintf (small_buf, "symmetry %d\n", RP->symmetry);
      strcat (buf, small_buf);
    }

  if (RP->difficulty && RP->difficulty_given)
    {
      sprintf (small_buf, "difficulty %d\n", RP->difficulty);
      strcat (buf, small_buf);
    }

  if (fabs (RP->difficulty_increase - 1.f) >= (1.f / 1024.f))
    {
      sprintf (small_buf, "difficulty_increase %f\n", RP->difficulty_increase);
      strcat (buf, small_buf);
    }

  sprintf (small_buf, "dungeon_level %d\n", RP->dungeon_level);
  strcat (buf, small_buf);

  if (RP->dungeon_depth)
    {
      sprintf (small_buf, "dungeon_depth %d\n", RP->dungeon_depth);
      strcat (buf, small_buf);
    }

  if (RP->decoroptions)
    {
      sprintf (small_buf, "decoroptions %d\n", RP->decoroptions);
      strcat (buf, small_buf);
    }

  if (RP->orientation)
    {
      sprintf (small_buf, "orientation %d\n", RP->orientation);
      strcat (buf, small_buf);
    }

  if (RP->origin_x)
    {
      sprintf (small_buf, "origin_x %d\n", RP->origin_x);
      strcat (buf, small_buf);
    }

  if (RP->origin_y)
    {
      sprintf (small_buf, "origin_y %d\n", RP->origin_y);
      strcat (buf, small_buf);
    }

  if (RP->treasureoptions)
    {
      sprintf (small_buf, "treasureoptions %d\n", RP->treasureoptions);
      strcat (buf, small_buf);
    }

  if (RP->random_seed)
    {
      sprintf (small_buf, "random_seed %u\n", RP->random_seed);
      strcat (buf, small_buf);
    }

  if (RP->custom)
    {
      sprintf (small_buf, "custom %s\n", RP->custom);
      strcat (buf, small_buf);
    }
}

/////////////////////////////////////////////////////////////////////////////

LayoutData::LayoutData (int w, int h)
: w(w), h(h)
{
  int size = (sizeof (char *) + sizeof (char) * h) * w;

  col = (char **)salloc<char> (size);

  char *data = (char *)(col + w);

  for (int x = w; x--; )
    col [x] = data + x * h;
}

LayoutData::~LayoutData ()
{
  int size = (sizeof (char *) + sizeof (char) * h) * w;

  sfree ((char *)col, size);
}

void LayoutData::clear (char fill)
{
  memset (col [0], fill, w * h);
}

void LayoutData::border (char fill)
{
  for (int i = 0; i < w; i++) col [i][0] = col [i][h - 1] = fill;
  for (int j = 0; j < h; j++) col [0][j] = col [w - 1][j] = fill;
}

/*  function selects the layout function and gives it whatever
    arguments it needs.  */
static Layout
layoutgen (random_map_params *RP)
{
  Layout layout (RP);

  switch (RP->map_layout_style)
    {
      case LAYOUT_ONION:
        map_gen_onion (layout, RP->layoutoptions1, RP->layoutoptions2);

        if (!(rmg_rndm (3)) && !(RP->layoutoptions1 & RMOPT_WALLS_ONLY))
          roomify_layout (layout, RP);

        break;

      case LAYOUT_MAZE:
        maze_gen (layout, rmg_rndm (2));

        if (!(rmg_rndm (2)))
          doorify_layout (layout, RP);

        break;

      case LAYOUT_SPIRAL:
        map_gen_spiral (layout, RP->layoutoptions1);

        if (!(rmg_rndm (2)))
          doorify_layout (layout, RP);

        break;

      case LAYOUT_ROGUELIKE:
        /* Don't put symmetry in rogue maps.  There isn't much reason to
         * do so in the first place (doesn't make it any more interesting),
         * but more importantly, the symmetry code presumes we are symmetrizing
         * spirals, or maps with lots of passages - making a symmetric rogue
         * map fails because its likely that the passages the symmetry process
         * creates may not connect the rooms.
         */
        RP->symmetry_used = SYMMETRY_NONE;
        roguelike_layout_gen (layout, RP->layoutoptions1);
        /* no doorifying...  done already */
        break;

      case LAYOUT_SNAKE:
        make_snake_layout (layout, RP->layoutoptions1);

        if (rmg_rndm (2))
          roomify_layout (layout, RP);

        break;

      case LAYOUT_SQUARE_SPIRAL:
        make_square_spiral_layout (layout, RP->layoutoptions1);

        if (rmg_rndm (2))
          roomify_layout (layout, RP);

        break;

      default:
        abort ();
    }

  /*  rotate the layout randomly */
  rotate_layout (layout, rmg_rndm (4));

  symmetrize_layout (layout, RP);

#ifdef RMAP_DEBUG
  dump_layout (layout);
#endif

  if (RP->expand2x)
    expand2x (layout);

  return layout;
}

bool
maptile::generate_random_map (random_map_params *RP)
{
  char buf[16384];
  int i;

  RP->Xsize = RP->xsize;
  RP->Ysize = RP->ysize;

  /* pick a random seed, or use the one from the input file */
  RP->random_seed = RP->random_seed
                       ? RP->random_seed + RP->dungeon_level
                       : time (0);

  // we run "single-threaded"
  rmg_rndm.seed (RP->random_seed);

  write_map_parameters_to_string (buf, RP);

  if (RP->difficulty == 0)
    {
      RP->difficulty = RP->dungeon_level;       /* use this instead of a map difficulty  */

      if (RP->difficulty_increase > 0.001)
        RP->difficulty = (int) ((float) RP->dungeon_level * RP->difficulty_increase);

      if (RP->difficulty < 1)
        RP->difficulty = 1;
    }
  else
    RP->difficulty_given = 1;

  if (RP->Xsize < MIN_RANDOM_MAP_SIZE)
    RP->Xsize = MIN_RANDOM_MAP_SIZE + rmg_rndm (25) + 5;

  if (RP->Ysize < MIN_RANDOM_MAP_SIZE)
    RP->Ysize = MIN_RANDOM_MAP_SIZE + rmg_rndm (25) + 5;

  if (RP->symmetry == SYMMETRY_RANDOM)
    RP->symmetry_used = rmg_rndm (SYMMETRY_XY) + 1;
  else
    RP->symmetry_used = RP->symmetry;

  if (RP->symmetry_used == SYMMETRY_Y || RP->symmetry_used == SYMMETRY_XY)
    RP->Ysize = RP->Ysize / 2 + 1;

  if (RP->symmetry_used == SYMMETRY_X || RP->symmetry_used == SYMMETRY_XY)
    RP->Xsize = RP->Xsize / 2 + 1;

  if (RP->expand2x > 0)
    {
      RP->Xsize /= 2;
      RP->Ysize /= 2;
    }

  RP->map_layout_style = LAYOUT_NONE;

  /* Redo this - there was a lot of redundant code of checking for preset
   * layout style and then random layout style.  Instead, figure out
   * the numeric layoutstyle, so there is only one area that actually
   * calls the code to make the maps.
   */
  if (strstr (RP->layoutstyle, "onion"))
    RP->map_layout_style = LAYOUT_ONION;
  else if (strstr (RP->layoutstyle, "maze"))
    RP->map_layout_style = LAYOUT_MAZE;
  else if (strstr (RP->layoutstyle, "spiral"))
    RP->map_layout_style = LAYOUT_SPIRAL;
  else if (strstr (RP->layoutstyle, "rogue"))
    RP->map_layout_style = LAYOUT_ROGUELIKE;
  else if (strstr (RP->layoutstyle, "snake"))
    RP->map_layout_style = LAYOUT_SNAKE;
  else if (strstr (RP->layoutstyle, "squarespiral"))
    RP->map_layout_style = LAYOUT_SQUARE_SPIRAL;
  else if (RP->map_layout_style == LAYOUT_NONE)
    RP->map_layout_style = rmg_rndm (NROFLAYOUTS - 1) + 1; /* No style found - choose one randomly */
  else
    abort ();

  Layout layout = layoutgen (RP);

#ifdef RMAP_DEBUG
  dump_layout (layout);
#endif

  /* increment these for the current map */
  ++RP->dungeon_level;

  // need to patch RP becasue following code doesn't use the Layout object
  RP->Xsize = layout->w;
  RP->Ysize = layout->h;

  /* allocate the map and set the floor */
  make_map_floor (layout, RP->floorstyle, RP);

  /* set region */
  default_region = RP->region;

  CEDE;

  place_specials_in_map (this, layout, RP);

  CEDE;

  /* create walls unless the wallstyle is "none" */
  if (strcmp (RP->wallstyle, "none"))
    {
      make_map_walls (this, layout, RP->wallstyle, RP->miningstyle, RP);

      /* place doors unless doorstyle or wallstyle is "none" */
      if (strcmp (RP->doorstyle, "none"))
        put_doors (this, layout, RP->doorstyle, RP);
    }

  CEDE;

  /* create exits unless the exitstyle is "none" */
  if (strcmp (RP->exitstyle, "none"))
    place_exits (this, layout, RP->exitstyle, RP->orientation, RP);

  CEDE;

  /* create monsters unless the monsterstyle is "none" */
  if (strcmp (RP->monsterstyle, "none"))
    place_monsters (this, RP->monsterstyle, RP->difficulty, RP);

  CEDE;

  /* treasures needs to have a proper difficulty set for the map. */
  difficulty = estimate_difficulty ();

  CEDE;

  /* create treasure unless the treasurestyle is "none" */
  place_treasure (this, layout, RP->treasurestyle, RP->treasureoptions, RP);

  CEDE;

  /* create decor unless the decorstyle is "none" */
  if (strcmp (RP->decorstyle, "none"))
    put_decor (this, layout, RP->decorstyle, RP->decoroptions, RP);

  CEDE;

  /* generate treasures, etc. */
  fix_auto_apply ();

  CEDE;

  unblock_exits (this, layout, RP);

  msg = strdup (buf);
  in_memory = MAP_ACTIVE;

  CEDE;

  return 1;
}

Revision:	1.49
Committed:	Tue Apr 13 02:39:53 2010 UTC (14 years, 2 months ago) by root
Content type:	text/plain
Branch:	MAIN
Changes since 1.48:	+6 -199 lines
Log Message:	* empty log message *
#	Content
1	/*
2	* This file is part of Deliantra, the Roguelike Realtime MMORPG.
3	*
4	* Copyright (©) 2005,2006,2007,2008,2009,2010 Marc Alexander Lehmann / Robin Redeker / the Deliantra team
5	* Copyright (©) 2001 Mark Wedel & Crossfire Development Team
6	* Copyright (©) 1992 Frank Tore Johansen
7	*
8	* Deliantra is free software: you can redistribute it and/or modify it under
9	* the terms of the Affero GNU General Public License as published by the
10	* Free Software Foundation, either version 3 of the License, or (at your
11	* option) any later version.
12	*
13	* This program is distributed in the hope that it will be useful,
14	* but WITHOUT ANY WARRANTY; without even the implied warranty of
15	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16	* GNU General Public License for more details.
17	*
18	* You should have received a copy of the Affero GNU General Public License
19	* and the GNU General Public License along with this program. If not, see
20	* <http://www.gnu.org/licenses/>.
21	*
22	* The authors can be reached via e-mail to <support@deliantra.net>
23	*/
24
25	#include <time.h>
26	#include <stdio.h>
27	#include <global.h>
28	#include <random_map.h>
29	#include <rproto.h>
30	#include <sproto.h>
31
32	#define CEDE coroapi::cede_to_tick ()
33
34	static void symmetrize_layout (Layout maze, random_map_params *RP);
35	static void rotate_layout (Layout maze, int rotation);
36
37	void
38	dump_layout (Layout layout)
39	{
40	for (int j = 0; j < layout->h; j++)
41	{
42	for (int i = 0; i < layout->w; i++)
43	putc (layout[i][j] ? layout[i][j] : ' ', stdout);
44
45	putc ('\n', stdout);
46	}
47
48	putc ('\n', stdout);
49	}
50
51	/* takes a map and makes it symmetric: adjusts Xsize and
52	* Ysize to produce a symmetric map.
53	*/
54	static void
55	symmetrize_layout (Layout layout, random_map_params *RP)
56	{
57	if (RP->symmetry_used == SYMMETRY_NONE)
58	return;
59
60	Layout sym_layout (
61	RP->symmetry_used == SYMMETRY_X \|\| RP->symmetry_used == SYMMETRY_XY ? layout->w * 2 - 3 : layout->w,
62	RP->symmetry_used == SYMMETRY_Y \|\| RP->symmetry_used == SYMMETRY_XY ? layout->h * 2 - 3 : layout->h
63	);
64
65	if (RP->symmetry_used == SYMMETRY_X)
66	for (int i = 0; i < sym_layout->w / 2 + 1; i++)
67	for (int j = 0; j < sym_layout->h; j++)
68	{
69	sym_layout[i ][j] =
70	sym_layout[sym_layout->w - i - 1][j] = layout[i][j];
71	}
72
73	if (RP->symmetry_used == SYMMETRY_Y)
74	for (int i = 0; i < sym_layout->w; i++)
75	for (int j = 0; j < sym_layout->h / 2 + 1; j++)
76	{
77	sym_layout[i][j ] =
78	sym_layout[i][sym_layout->h - j - 1] = layout[i][j];
79	}
80
81	if (RP->symmetry_used == SYMMETRY_XY)
82	for (int i = 0; i < sym_layout->w / 2 + 1; i++)
83	for (int j = 0; j < sym_layout->h / 2 + 1; j++)
84	{
85	sym_layout[i ][j ] =
86	sym_layout[i ][sym_layout->h - j - 1] =
87	sym_layout[sym_layout->w - i - 1][j ] =
88	sym_layout[sym_layout->w - i - 1][sym_layout->h - j - 1] = layout[i][j];
89	}
90
91	layout.swap (sym_layout);
92	sym_layout.free ();
93
94	/* reconnect disjointed spirals */
95	/* reconnect disjointed nethacklayouts: the routine for
96	spirals will do the trick? */
97	if (RP->map_layout_style == LAYOUT_SPIRAL
98	\|\| RP->map_layout_style == LAYOUT_ROGUELIKE)
99	connect_spirals (layout->w, layout->h, RP->symmetry_used, layout);
100	}
101
102	/* takes a map and rotates it. This completes the
103	onion layouts, making them possibly centered on any wall.
104	It'll modify Xsize and Ysize if they're swapped.
105	*/
106	static void
107	rotate_layout (Layout layout, int rotation)
108	{
109	int w = layout->w;
110	int h = layout->h;
111
112	switch (rotation)
113	{
114	case 2: /* a reflection */
115	{
116	Layout new_layout (w, h);
117
118	for (int i = 0; i < w; i++) /* copy a reflection back */
119	for (int j = 0; j < h; j++)
120	new_layout[i][j] = layout[w - i - 1][h - j - 1];
121
122	layout.swap (new_layout);
123	new_layout.free ();
124	}
125	break;
126
127	case 1:
128	case 3:
129	{
130	Layout new_layout (h, w);
131
132	if (rotation == 1) /* swap x and y */
133	for (int i = 0; i < w; i++)
134	for (int j = 0; j < h; j++)
135	new_layout[j][i] = layout[i][j];
136
137	if (rotation == 3) /* swap x and y */
138	for (int i = 0; i < w; i++)
139	for (int j = 0; j < h; j++)
140	new_layout[j][i] = layout[w - i - 1][h - j - 1];
141
142	layout.swap (new_layout);
143	new_layout.free ();
144	}
145	break;
146	}
147	}
148
149	/* checks the layout to see if I can stick a horizontal(dir = 0) wall
150	(or vertical, dir == 1)
151	here which ends up on other walls sensibly. */
152	static int
153	can_make_wall (char *maze, int dx, int dy, int dir, random_map_params RP)
154	{
155	int i1;
156	int length = 0;
157
158	/* dont make walls if we're on the edge. */
159	if (dx == 0 \|\| dx == (RP->Xsize - 1) \|\| dy == 0 \|\| dy == (RP->Ysize - 1))
160	return -1;
161
162	/* don't make walls if we're ON a wall. */
163	if (maze[dx][dy] != 0)
164	return -1;
165
166	if (dir == 0) /* horizontal */
167	{
168	int y = dy;
169
170	for (i1 = dx - 1; i1 > 0; i1--)
171	{
172	int sindex = surround_flag2 (maze, i1, y, RP);
173
174	if (sindex == 1)
175	break;
176	if (sindex != 0)
177	return -1; /* can't make horiz. wall here */
178	if (maze[i1][y] != 0)
179	return -1; /* can't make horiz. wall here */
180	length++;
181	}
182
183	for (i1 = dx + 1; i1 < RP->Xsize - 1; i1++)
184	{
185	int sindex = surround_flag2 (maze, i1, y, RP);
186
187	if (sindex == 2)
188	break;
189	if (sindex != 0)
190	return -1; /* can't make horiz. wall here */
191	if (maze[i1][y] != 0)
192	return -1; /* can't make horiz. wall here */
193	length++;
194	}
195	return length;
196	}
197	else
198	{ /* vertical */
199	int x = dx;
200
201	for (i1 = dy - 1; i1 > 0; i1--)
202	{
203	int sindex = surround_flag2 (maze, x, i1, RP);
204
205	if (sindex == 4)
206	break;
207	if (sindex != 0)
208	return -1; /* can't make vert. wall here */
209	if (maze[x][i1] != 0)
210	return -1; /* can't make horiz. wall here */
211	length++;
212	}
213
214	for (i1 = dy + 1; i1 < RP->Ysize - 1; i1++)
215	{
216	int sindex = surround_flag2 (maze, x, i1, RP);
217
218	if (sindex == 8)
219	break;
220	if (sindex != 0)
221	return -1; /* can't make verti. wall here */
222	if (maze[x][i1] != 0)
223	return -1; /* can't make horiz. wall here */
224	length++;
225	}
226
227	return length;
228	}
229
230	return -1;
231	}
232
233	/* take a layout and make some rooms in it.
234	--works best on onions.*/
235	static void
236	roomify_layout (char *maze, random_map_params RP)
237	{
238	int tries = RP->Xsize * RP->Ysize / 30;
239	int ti;
240
241	for (ti = 0; ti < tries; ti++)
242	{
243	int dx, dy; /* starting location for looking at creating a door */
244	int cx, cy; /* results of checking on creating walls. */
245
246	dx = rmg_rndm (RP->Xsize);
247	dy = rmg_rndm (RP->Ysize);
248
249	cx = can_make_wall (maze, dx, dy, 0, RP); /* horizontal */
250	cy = can_make_wall (maze, dx, dy, 1, RP); /* vertical */
251	if (cx == -1)
252	{
253	if (cy != -1)
254	make_wall (maze, dx, dy, 1);
255
256	continue;
257	}
258
259	if (cy == -1)
260	{
261	make_wall (maze, dx, dy, 0);
262	continue;
263	}
264
265	if (cx < cy)
266	make_wall (maze, dx, dy, 0);
267	else
268	make_wall (maze, dx, dy, 1);
269	}
270	}
271
272	int
273	make_wall (char **maze, int x, int y, int dir)
274	{
275	maze[x][y] = 'D'; /* mark a door */
276	switch (dir)
277	{
278	case 0: /* horizontal */
279	{
280	int i1;
281
282	for (i1 = x - 1; maze[i1][y] == 0; i1--)
283	maze[i1][y] = '#';
284	for (i1 = x + 1; maze[i1][y] == 0; i1++)
285	maze[i1][y] = '#';
286	break;
287	}
288	case 1: /* vertical */
289	{
290	int i1;
291
292	for (i1 = y - 1; maze[x][i1] == 0; i1--)
293	maze[x][i1] = '#';
294	for (i1 = y + 1; maze[x][i1] == 0; i1++)
295	maze[x][i1] = '#';
296	break;
297	}
298	}
299
300	return 0;
301	}
302
303	/* puts doors at appropriate locations in a layout. */
304	static void
305	doorify_layout (char *maze, random_map_params RP)
306	{
307	int ndoors = RP->Xsize * RP->Ysize / 60; /* reasonable number of doors. */
308	int doorlocs = 0; /* # of available doorlocations */
309
310	uint16 doorlist_x = salloc<uint16> (RP->Xsize RP->Ysize);
311	uint16 doorlist_y = salloc<uint16> (RP->Xsize RP->Ysize);
312
313	/* make a list of possible door locations */
314	for (int i = 1; i < RP->Xsize - 1; i++)
315	for (int j = 1; j < RP->Ysize - 1; j++)
316	{
317	int sindex = surround_flag (maze, i, j, RP);
318
319	if (sindex == 3 \|\| sindex == 12) /* these are possible door sindex */
320	{
321	doorlist_x[doorlocs] = i;
322	doorlist_y[doorlocs] = j;
323	doorlocs++;
324	}
325	}
326
327	while (ndoors > 0 && doorlocs > 0)
328	{
329	int di = rmg_rndm (doorlocs);
330	int i = doorlist_x[di];
331	int j = doorlist_y[di];
332	int sindex = surround_flag (maze, i, j, RP);
333
334	if (sindex == 3 \|\| sindex == 12) /* these are possible door sindex */
335	{
336	maze[i][j] = 'D';
337	ndoors--;
338	}
339
340	/* reduce the size of the list */
341	doorlocs--;
342	doorlist_x[di] = doorlist_x[doorlocs];
343	doorlist_y[di] = doorlist_y[doorlocs];
344	}
345
346	sfree (doorlist_x, RP->Xsize * RP->Ysize);
347	sfree (doorlist_y, RP->Xsize * RP->Ysize);
348	}
349
350	void
351	write_map_parameters_to_string (char buf, random_map_params RP)
352	{
353	char small_buf[16384];
354
355	sprintf (buf, "xsize %d\nysize %d\n", RP->xsize, RP->ysize);
356
357	if (RP->wallstyle[0])
358	{
359	sprintf (small_buf, "wallstyle %s\n", RP->wallstyle);
360	strcat (buf, small_buf);
361	}
362
363	if (RP->miningstyle[0])
364	{
365	sprintf (small_buf, "miningstyle %s\n", RP->miningstyle);
366	strcat (buf, small_buf);
367	}
368
369	if (RP->floorstyle[0])
370	{
371	sprintf (small_buf, "floorstyle %s\n", RP->floorstyle);
372	strcat (buf, small_buf);
373	}
374
375	if (RP->monsterstyle[0])
376	{
377	sprintf (small_buf, "monsterstyle %s\n", RP->monsterstyle);
378	strcat (buf, small_buf);
379	}
380
381	if (RP->treasurestyle[0])
382	{
383	sprintf (small_buf, "treasurestyle %s\n", RP->treasurestyle);
384	strcat (buf, small_buf);
385	}
386
387	if (RP->layoutstyle[0])
388	{
389	sprintf (small_buf, "layoutstyle %s\n", RP->layoutstyle);
390	strcat (buf, small_buf);
391	}
392
393	if (RP->decorstyle[0])
394	{
395	sprintf (small_buf, "decorstyle %s\n", RP->decorstyle);
396	strcat (buf, small_buf);
397	}
398
399	if (RP->doorstyle[0])
400	{
401	sprintf (small_buf, "doorstyle %s\n", RP->doorstyle);
402	strcat (buf, small_buf);
403	}
404
405	if (RP->exitstyle[0])
406	{
407	sprintf (small_buf, "exitstyle %s\n", RP->exitstyle);
408	strcat (buf, small_buf);
409	}
410
411	if (RP->final_map.length ())
412	{
413	sprintf (small_buf, "final_map %s\n", &RP->final_map);
414	strcat (buf, small_buf);
415	}
416
417	if (RP->exit_on_final_map[0])
418	{
419	sprintf (small_buf, "exit_on_final_map %s\n", RP->exit_on_final_map);
420	strcat (buf, small_buf);
421	}
422
423	if (RP->this_map.length ())
424	{
425	sprintf (small_buf, "origin_map %s\n", &RP->this_map);
426	strcat (buf, small_buf);
427	}
428
429	if (RP->expand2x)
430	{
431	sprintf (small_buf, "expand2x %d\n", RP->expand2x);
432	strcat (buf, small_buf);
433	}
434
435	if (RP->layoutoptions1)
436	{
437	sprintf (small_buf, "layoutoptions1 %d\n", RP->layoutoptions1);
438	strcat (buf, small_buf);
439	}
440
441	if (RP->layoutoptions2)
442	{
443	sprintf (small_buf, "layoutoptions2 %d\n", RP->layoutoptions2);
444	strcat (buf, small_buf);
445	}
446
447	if (RP->layoutoptions3)
448	{
449	sprintf (small_buf, "layoutoptions3 %d\n", RP->layoutoptions3);
450	strcat (buf, small_buf);
451	}
452
453	if (RP->symmetry)
454	{
455	sprintf (small_buf, "symmetry %d\n", RP->symmetry);
456	strcat (buf, small_buf);
457	}
458
459	if (RP->difficulty && RP->difficulty_given)
460	{
461	sprintf (small_buf, "difficulty %d\n", RP->difficulty);
462	strcat (buf, small_buf);
463	}
464
465	if (fabs (RP->difficulty_increase - 1.f) >= (1.f / 1024.f))
466	{
467	sprintf (small_buf, "difficulty_increase %f\n", RP->difficulty_increase);
468	strcat (buf, small_buf);
469	}
470
471	sprintf (small_buf, "dungeon_level %d\n", RP->dungeon_level);
472	strcat (buf, small_buf);
473
474	if (RP->dungeon_depth)
475	{
476	sprintf (small_buf, "dungeon_depth %d\n", RP->dungeon_depth);
477	strcat (buf, small_buf);
478	}
479
480	if (RP->decoroptions)
481	{
482	sprintf (small_buf, "decoroptions %d\n", RP->decoroptions);
483	strcat (buf, small_buf);
484	}
485
486	if (RP->orientation)
487	{
488	sprintf (small_buf, "orientation %d\n", RP->orientation);
489	strcat (buf, small_buf);
490	}
491
492	if (RP->origin_x)
493	{
494	sprintf (small_buf, "origin_x %d\n", RP->origin_x);
495	strcat (buf, small_buf);
496	}
497
498	if (RP->origin_y)
499	{
500	sprintf (small_buf, "origin_y %d\n", RP->origin_y);
501	strcat (buf, small_buf);
502	}
503
504	if (RP->treasureoptions)
505	{
506	sprintf (small_buf, "treasureoptions %d\n", RP->treasureoptions);
507	strcat (buf, small_buf);
508	}
509
510	if (RP->random_seed)
511	{
512	sprintf (small_buf, "random_seed %u\n", RP->random_seed);
513	strcat (buf, small_buf);
514	}
515
516	if (RP->custom)
517	{
518	sprintf (small_buf, "custom %s\n", RP->custom);
519	strcat (buf, small_buf);
520	}
521	}
522
523	/////////////////////////////////////////////////////////////////////////////
524
525	LayoutData::LayoutData (int w, int h)
526	: w(w), h(h)
527	{
528	int size = (sizeof (char ) + sizeof (char) h) * w;
529
530	col = (char **)salloc<char> (size);
531
532	char data = (char )(col + w);
533
534	for (int x = w; x--; )
535	col [x] = data + x * h;
536	}
537
538	LayoutData::~LayoutData ()
539	{
540	int size = (sizeof (char ) + sizeof (char) h) * w;
541
542	sfree ((char *)col, size);
543	}
544
545	void LayoutData::clear (char fill)
546	{
547	memset (col [0], fill, w * h);
548	}
549
550	void LayoutData::border (char fill)
551	{
552	for (int i = 0; i < w; i++) col [i][0] = col [i][h - 1] = fill;
553	for (int j = 0; j < h; j++) col [0][j] = col [w - 1][j] = fill;
554	}
555
556	/* function selects the layout function and gives it whatever
557	arguments it needs. */
558	static Layout
559	layoutgen (random_map_params *RP)
560	{
561	Layout layout (RP);
562
563	switch (RP->map_layout_style)
564	{
565	case LAYOUT_ONION:
566	map_gen_onion (layout, RP->layoutoptions1, RP->layoutoptions2);
567
568	if (!(rmg_rndm (3)) && !(RP->layoutoptions1 & RMOPT_WALLS_ONLY))
569	roomify_layout (layout, RP);
570
571	break;
572
573	case LAYOUT_MAZE:
574	maze_gen (layout, rmg_rndm (2));
575
576	if (!(rmg_rndm (2)))
577	doorify_layout (layout, RP);
578
579	break;
580
581	case LAYOUT_SPIRAL:
582	map_gen_spiral (layout, RP->layoutoptions1);
583
584	if (!(rmg_rndm (2)))
585	doorify_layout (layout, RP);
586
587	break;
588
589	case LAYOUT_ROGUELIKE:
590	/* Don't put symmetry in rogue maps. There isn't much reason to
591	* do so in the first place (doesn't make it any more interesting),
592	* but more importantly, the symmetry code presumes we are symmetrizing
593	* spirals, or maps with lots of passages - making a symmetric rogue
594	* map fails because its likely that the passages the symmetry process
595	* creates may not connect the rooms.
596	*/
597	RP->symmetry_used = SYMMETRY_NONE;
598	roguelike_layout_gen (layout, RP->layoutoptions1);
599	/* no doorifying... done already */
600	break;
601
602	case LAYOUT_SNAKE:
603	make_snake_layout (layout, RP->layoutoptions1);
604
605	if (rmg_rndm (2))
606	roomify_layout (layout, RP);
607
608	break;
609
610	case LAYOUT_SQUARE_SPIRAL:
611	make_square_spiral_layout (layout, RP->layoutoptions1);
612
613	if (rmg_rndm (2))
614	roomify_layout (layout, RP);
615
616	break;
617
618	default:
619	abort ();
620	}
621
622	/* rotate the layout randomly */
623	rotate_layout (layout, rmg_rndm (4));
624
625	symmetrize_layout (layout, RP);
626
627	#ifdef RMAP_DEBUG
628	dump_layout (layout);
629	#endif
630
631	if (RP->expand2x)
632	expand2x (layout);
633
634	return layout;
635	}
636
637	bool
638	maptile::generate_random_map (random_map_params *RP)
639	{
640	char buf[16384];
641	int i;
642
643	RP->Xsize = RP->xsize;
644	RP->Ysize = RP->ysize;
645
646	/* pick a random seed, or use the one from the input file */
647	RP->random_seed = RP->random_seed
648	? RP->random_seed + RP->dungeon_level
649	: time (0);
650
651	// we run "single-threaded"
652	rmg_rndm.seed (RP->random_seed);
653
654	write_map_parameters_to_string (buf, RP);
655
656	if (RP->difficulty == 0)
657	{
658	RP->difficulty = RP->dungeon_level; /* use this instead of a map difficulty */
659
660	if (RP->difficulty_increase > 0.001)
661	RP->difficulty = (int) ((float) RP->dungeon_level * RP->difficulty_increase);
662
663	if (RP->difficulty < 1)
664	RP->difficulty = 1;
665	}
666	else
667	RP->difficulty_given = 1;
668
669	if (RP->Xsize < MIN_RANDOM_MAP_SIZE)
670	RP->Xsize = MIN_RANDOM_MAP_SIZE + rmg_rndm (25) + 5;
671
672	if (RP->Ysize < MIN_RANDOM_MAP_SIZE)
673	RP->Ysize = MIN_RANDOM_MAP_SIZE + rmg_rndm (25) + 5;
674
675	if (RP->symmetry == SYMMETRY_RANDOM)
676	RP->symmetry_used = rmg_rndm (SYMMETRY_XY) + 1;
677	else
678	RP->symmetry_used = RP->symmetry;
679
680	if (RP->symmetry_used == SYMMETRY_Y \|\| RP->symmetry_used == SYMMETRY_XY)
681	RP->Ysize = RP->Ysize / 2 + 1;
682
683	if (RP->symmetry_used == SYMMETRY_X \|\| RP->symmetry_used == SYMMETRY_XY)
684	RP->Xsize = RP->Xsize / 2 + 1;
685
686	if (RP->expand2x > 0)
687	{
688	RP->Xsize /= 2;
689	RP->Ysize /= 2;
690	}
691
692	RP->map_layout_style = LAYOUT_NONE;
693
694	/* Redo this - there was a lot of redundant code of checking for preset
695	* layout style and then random layout style. Instead, figure out
696	* the numeric layoutstyle, so there is only one area that actually
697	* calls the code to make the maps.
698	*/
699	if (strstr (RP->layoutstyle, "onion"))
700	RP->map_layout_style = LAYOUT_ONION;
701	else if (strstr (RP->layoutstyle, "maze"))
702	RP->map_layout_style = LAYOUT_MAZE;
703	else if (strstr (RP->layoutstyle, "spiral"))
704	RP->map_layout_style = LAYOUT_SPIRAL;
705	else if (strstr (RP->layoutstyle, "rogue"))
706	RP->map_layout_style = LAYOUT_ROGUELIKE;
707	else if (strstr (RP->layoutstyle, "snake"))
708	RP->map_layout_style = LAYOUT_SNAKE;
709	else if (strstr (RP->layoutstyle, "squarespiral"))
710	RP->map_layout_style = LAYOUT_SQUARE_SPIRAL;
711	else if (RP->map_layout_style == LAYOUT_NONE)
712	RP->map_layout_style = rmg_rndm (NROFLAYOUTS - 1) + 1; /* No style found - choose one randomly */
713	else
714	abort ();
715
716	Layout layout = layoutgen (RP);
717
718	#ifdef RMAP_DEBUG
719	dump_layout (layout);
720	#endif
721
722	/* increment these for the current map */
723	++RP->dungeon_level;
724
725	// need to patch RP becasue following code doesn't use the Layout object
726	RP->Xsize = layout->w;
727	RP->Ysize = layout->h;
728
729	/* allocate the map and set the floor */
730	make_map_floor (layout, RP->floorstyle, RP);
731
732	/* set region */
733	default_region = RP->region;
734
735	CEDE;
736
737	place_specials_in_map (this, layout, RP);
738
739	CEDE;
740
741	/* create walls unless the wallstyle is "none" */
742	if (strcmp (RP->wallstyle, "none"))
743	{
744	make_map_walls (this, layout, RP->wallstyle, RP->miningstyle, RP);
745
746	/* place doors unless doorstyle or wallstyle is "none" */
747	if (strcmp (RP->doorstyle, "none"))
748	put_doors (this, layout, RP->doorstyle, RP);
749	}
750
751	CEDE;
752
753	/* create exits unless the exitstyle is "none" */
754	if (strcmp (RP->exitstyle, "none"))
755	place_exits (this, layout, RP->exitstyle, RP->orientation, RP);
756
757	CEDE;
758
759	/* create monsters unless the monsterstyle is "none" */
760	if (strcmp (RP->monsterstyle, "none"))
761	place_monsters (this, RP->monsterstyle, RP->difficulty, RP);
762
763	CEDE;
764
765	/* treasures needs to have a proper difficulty set for the map. */
766	difficulty = estimate_difficulty ();
767
768	CEDE;
769
770	/* create treasure unless the treasurestyle is "none" */
771	place_treasure (this, layout, RP->treasurestyle, RP->treasureoptions, RP);
772
773	CEDE;
774
775	/* create decor unless the decorstyle is "none" */
776	if (strcmp (RP->decorstyle, "none"))
777	put_decor (this, layout, RP->decorstyle, RP->decoroptions, RP);
778
779	CEDE;
780
781	/* generate treasures, etc. */
782	fix_auto_apply ();
783
784	CEDE;
785
786	unblock_exits (this, layout, RP);
787
788	msg = strdup (buf);
789	in_memory = MAP_ACTIVE;
790
791	CEDE;
792
793	return 1;
794	}
795