/*
* This file is part of Deliantra, the Roguelike Realtime MMORPG.
*
* Copyright (©) 2005,2006,2007,2008 Marc Alexander Lehmann / Robin Redeker / the Deliantra team
* Copyright (©) 2001,2007 Mark Wedel & Crossfire Development Team
* Copyright (©) 1992,2007 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
* .
*
* The authors can be reached via e-mail to
*/
#include
#include
#include
#include
#include
#include
#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);
}
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);
/* 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;
}
/* function selects the layout function and gives it whatever
arguments it needs. */
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;
}
/* 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;
}
}
/* take a layout and make some rooms in it.
--works best on onions.*/
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);
}
}
/* 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. */
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;
}
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. */
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 (RP->Xsize * RP->Ysize);
uint16 *doorlist_y = salloc (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->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 (RP->difficulty_increase != 1.0)
{
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);
}
}
void
write_parameters_to_string (char *buf,
int xsize_n,
int ysize_n,
const char *wallstyle_n,
const char *floorstyle_n,
const char *monsterstyle_n,
const char *treasurestyle_n,
const char *layoutstyle_n,
const char *decorstyle_n,
const char *doorstyle_n,
const char *exitstyle_n,
const char *final_map_n,
const char *exit_on_final_map_n,
const char *this_map_n,
int layoutoptions1_n,
int layoutoptions2_n,
int layoutoptions3_n,
int symmetry_n,
int dungeon_depth_n,
int dungeon_level_n,
int difficulty_n,
int difficulty_given_n,
int decoroptions_n,
int orientation_n,
int origin_x_n,
int origin_y_n,
uint32_t random_seed_n,
int treasureoptions_n,
float difficulty_increase)
{
char small_buf[16384];
sprintf (buf, "xsize %d\nysize %d\n", xsize_n, ysize_n);
if (wallstyle_n && wallstyle_n[0])
{
sprintf (small_buf, "wallstyle %s\n", wallstyle_n);
strcat (buf, small_buf);
}
if (floorstyle_n && floorstyle_n[0])
{
sprintf (small_buf, "floorstyle %s\n", floorstyle_n);
strcat (buf, small_buf);
}
if (monsterstyle_n && monsterstyle_n[0])
{
sprintf (small_buf, "monsterstyle %s\n", monsterstyle_n);
strcat (buf, small_buf);
}
if (treasurestyle_n && treasurestyle_n[0])
{
sprintf (small_buf, "treasurestyle %s\n", treasurestyle_n);
strcat (buf, small_buf);
}
if (layoutstyle_n && layoutstyle_n[0])
{
sprintf (small_buf, "layoutstyle %s\n", layoutstyle_n);
strcat (buf, small_buf);
}
if (decorstyle_n && decorstyle_n[0])
{
sprintf (small_buf, "decorstyle %s\n", decorstyle_n);
strcat (buf, small_buf);
}
if (doorstyle_n && doorstyle_n[0])
{
sprintf (small_buf, "doorstyle %s\n", doorstyle_n);
strcat (buf, small_buf);
}
if (exitstyle_n && exitstyle_n[0])
{
sprintf (small_buf, "exitstyle %s\n", exitstyle_n);
strcat (buf, small_buf);
}
if (final_map_n && final_map_n[0])
{
sprintf (small_buf, "final_map %s\n", final_map_n);
strcat (buf, small_buf);
}
if (exit_on_final_map_n && exit_on_final_map_n[0])
{
sprintf (small_buf, "exit_on_final_map %s\n", exit_on_final_map_n);
strcat (buf, small_buf);
}
if (this_map_n && this_map_n[0])
{
sprintf (small_buf, "origin_map %s\n", this_map_n);
strcat (buf, small_buf);
}
if (layoutoptions1_n)
{
sprintf (small_buf, "layoutoptions1 %d\n", layoutoptions1_n);
strcat (buf, small_buf);
}
if (layoutoptions2_n)
{
sprintf (small_buf, "layoutoptions2 %d\n", layoutoptions2_n);
strcat (buf, small_buf);
}
if (layoutoptions3_n)
{
sprintf (small_buf, "layoutoptions3 %d\n", layoutoptions3_n);
strcat (buf, small_buf);
}
if (symmetry_n)
{
sprintf (small_buf, "symmetry %d\n", symmetry_n);
strcat (buf, small_buf);
}
if (difficulty_n && difficulty_given_n)
{
sprintf (small_buf, "difficulty %d\n", difficulty_n);
strcat (buf, small_buf);
}
if (difficulty_increase > 0.001)
{
sprintf (small_buf, "difficulty_increase %f\n", difficulty_increase);
strcat (buf, small_buf);
}
sprintf (small_buf, "dungeon_level %d\n", dungeon_level_n);
strcat (buf, small_buf);
if (dungeon_depth_n)
{
sprintf (small_buf, "dungeon_depth %d\n", dungeon_depth_n);
strcat (buf, small_buf);
}
if (decoroptions_n)
{
sprintf (small_buf, "decoroptions %d\n", decoroptions_n);
strcat (buf, small_buf);
}
if (orientation_n)
{
sprintf (small_buf, "orientation %d\n", orientation_n);
strcat (buf, small_buf);
}
if (origin_x_n)
{
sprintf (small_buf, "origin_x %d\n", origin_x_n);
strcat (buf, small_buf);
}
if (origin_y_n)
{
sprintf (small_buf, "origin_y %d\n", origin_y_n);
strcat (buf, small_buf);
}
if (random_seed_n)
{
/* Add one so that the next map is a bit different */
sprintf (small_buf, "random_seed %u\n", random_seed_n + 1);
strcat (buf, small_buf);
}
if (treasureoptions_n)
{
sprintf (small_buf, "treasureoptions %d\n", treasureoptions_n);
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 (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;
}