ViewVC Help
View File | Revision Log | Show Annotations | Download File
/cvs/deliantra/server/random_maps/random_map.C
(Generate patch)

Comparing deliantra/server/random_maps/random_map.C (file contents):
Revision 1.7 by root, Tue Dec 12 21:39:56 2006 UTC vs.
Revision 1.51 by root, Sat Jun 26 22:10:18 2010 UTC

1/* 1/*
2 CrossFire, A Multiplayer game for X-windows 2 * This file is part of Deliantra, the Roguelike Realtime MMORPG.
3 3 *
4 * Copyright (©) 2005,2006,2007,2008,2009,2010 Marc Alexander Lehmann / Robin Redeker / the Deliantra team
4 Copyright (C) 2001 Mark Wedel & Crossfire Development Team 5 * Copyright (©) 2001 Mark Wedel & Crossfire Development Team
5 Copyright (C) 1992 Frank Tore Johansen 6 * Copyright (©) 1992 Frank Tore Johansen
6 7 *
7 This program is free software; you can redistribute it and/or modify 8 * Deliantra is free software: you can redistribute it and/or modify it under
8 it under the terms of the GNU General Public License as published by 9 * the terms of the Affero GNU General Public License as published by the
9 the Free Software Foundation; either version 2 of the License, or 10 * Free Software Foundation, either version 3 of the License, or (at your
10 (at your option) any later version. 11 * option) any later version.
11 12 *
12 This program is distributed in the hope that it will be useful, 13 * This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of 14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details. 16 * GNU General Public License for more details.
16 17 *
17 You should have received a copy of the GNU General Public License 18 * You should have received a copy of the Affero GNU General Public License
18 along with this program; if not, write to the Free Software 19 * and the GNU General Public License along with this program. If not, see
19 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 20 * <http://www.gnu.org/licenses/>.
20 21 *
21 The authors can be reached via e-mail at <crossfire@schmorp.de> 22 * The authors can be reached via e-mail to <support@deliantra.net>
22*/ 23 */
23 24
24#include <time.h> 25#include <time.h>
25#include <stdio.h> 26#include <stdio.h>
26#include <global.h> 27#include <global.h>
27#include <maze_gen.h>
28#include <room_gen.h>
29#include <random_map.h> 28#include <random_map.h>
30#include <rproto.h> 29#include <rproto.h>
31#include <sproto.h> 30#include <sproto.h>
32 31
32#define CEDE coroapi::cede_to_tick ()
33
34static void symmetrize_layout (Layout maze, random_map_params *RP);
35static void rotate_layout (Layout maze, int rotation);
36
37const_utf8_string
38random_map_params::get_str (const_utf8_string option, const_utf8_string fallback) const
39{
40 SV **he = hv_fetch (hv, option, strlen (option), 0);
41
42 return he ? cfSvPVutf8_nolen (*he) : fallback;
43}
44
45IV
46random_map_params::get_iv (const char *option, IV fallback) const
47{
48 SV **he = hv_fetch (hv, option, strlen (option), 0);
49
50 return he ? SvIV (*he) : fallback;
51}
52
53random_map_params::~random_map_params ()
54{
55 SvREFCNT_dec (hv);
56}
57
33void 58void
34dump_layout (char **layout, RMParms * RP) 59dump_layout (Layout layout)
35{ 60{
36 { 61 for (int j = 0; j < layout->h; j++)
37 int i, j;
38
39 for (i = 0; i < RP->Xsize; i++)
40 { 62 {
41 for (j = 0; j < RP->Ysize; j++) 63 for (int i = 0; i < layout->w; i++)
42 { 64 putc (layout[i][j] ? layout[i][j] : ' ', stdout);
43 if (layout[i][j] == 0) 65
44 layout[i][j] = ' '; 66 putc ('\n', stdout);
45 printf ("%c", layout[i][j]);
46 if (layout[i][j] == ' ')
47 layout[i][j] = 0;
48 }
49 printf ("\n");
50 } 67 }
51 }
52 printf ("\n");
53}
54EXTERN FILE *logfile;
55maptile *
56generate_random_map (const char *OutFileName, RMParms * RP)
57{
58 char **layout, buf[HUGE_BUF];
59 maptile *theMap;
60 int i;
61 68
62 /* pick a random seed, or use the one from the input file */ 69 putc ('\n', stdout);
63 if (RP->random_seed == 0)
64 RP->random_seed = time (0);
65
66 SRANDOM (RP->random_seed);
67
68 write_map_parameters_to_string (buf, RP);
69
70 if (RP->difficulty == 0)
71 {
72 RP->difficulty = RP->dungeon_level; /* use this instead of a map difficulty */
73
74 if (RP->difficulty_increase > 0.001)
75 RP->difficulty = (int) ((float) RP->dungeon_level * RP->difficulty_increase);
76
77 if (RP->difficulty < 1)
78 RP->difficulty = 1;
79 }
80 else
81 RP->difficulty_given = 1;
82
83 if (RP->Xsize < MIN_RANDOM_MAP_SIZE)
84 RP->Xsize = MIN_RANDOM_MAP_SIZE + RANDOM () % 25 + 5;
85
86 if (RP->Ysize < MIN_RANDOM_MAP_SIZE)
87 RP->Ysize = MIN_RANDOM_MAP_SIZE + RANDOM () % 25 + 5;
88
89 if (RP->expand2x > 0)
90 {
91 RP->Xsize /= 2;
92 RP->Ysize /= 2;
93 }
94
95 layout = layoutgen (RP);
96
97#ifdef RMAP_DEBUG
98 dump_layout (layout, RP);
99#endif
100
101 /* increment these for the current map */
102 RP->dungeon_level += 1;
103 /* allow constant-difficulty maps. */
104 /* difficulty+=1; */
105
106 /* rotate the layout randomly */
107 layout = rotate_layout (layout, RANDOM () % 4, RP);
108#ifdef RMAP_DEBUG
109 dump_layout (layout, RP);
110#endif
111
112 /* allocate the map and set the floor */
113 theMap = make_map_floor (layout, RP->floorstyle, RP);
114
115 /* set the name of the map. */
116 strcpy (theMap->path, OutFileName);
117
118 /* set region */
119 theMap->region = RP->region;
120
121 /* create walls unless the wallstyle is "none" */
122 if (strcmp (RP->wallstyle, "none"))
123 {
124 make_map_walls (theMap, layout, RP->wallstyle, RP);
125
126 /* place doors unless doorstyle or wallstyle is "none" */
127 if (strcmp (RP->doorstyle, "none"))
128 put_doors (theMap, layout, RP->doorstyle, RP);
129
130 }
131
132 /* create exits unless the exitstyle is "none" */
133 if (strcmp (RP->exitstyle, "none"))
134 place_exits (theMap, layout, RP->exitstyle, RP->orientation, RP);
135
136 place_specials_in_map (theMap, layout, RP);
137
138 /* create monsters unless the monsterstyle is "none" */
139 if (strcmp (RP->monsterstyle, "none"))
140 place_monsters (theMap, RP->monsterstyle, RP->difficulty, RP);
141
142 /* treasures needs to have a proper difficulty set for the map. */
143 theMap->difficulty = calculate_difficulty (theMap);
144
145 /* create treasure unless the treasurestyle is "none" */
146 if (strcmp (RP->treasurestyle, "none"))
147 place_treasure (theMap, layout, RP->treasurestyle, RP->treasureoptions, RP);
148
149 /* create decor unless the decorstyle is "none" */
150 if (strcmp (RP->decorstyle, "none"))
151 put_decor (theMap, layout, RP->decorstyle, RP->decoroptions, RP);
152
153 /* generate treasures, etc. */
154 fix_auto_apply (theMap);
155
156 unblock_exits (theMap, layout, RP);
157
158 /* free the layout */
159 for (i = 0; i < RP->Xsize; i++)
160 free (layout[i]);
161 free (layout);
162
163 theMap->msg = strdup_local (buf);
164
165 return theMap;
166} 70}
167 71
168/* function selects the layout function and gives it whatever
169 arguments it needs. */
170char **
171layoutgen (RMParms * RP)
172{
173 char **maze = 0;
174 int oxsize = RP->Xsize, oysize = RP->Ysize;
175
176 if (RP->symmetry == RANDOM_SYM)
177 RP->symmetry_used = (RANDOM () % (XY_SYM)) + 1;
178 else
179 RP->symmetry_used = RP->symmetry;
180
181 if (RP->symmetry_used == Y_SYM || RP->symmetry_used == XY_SYM)
182 RP->Ysize = RP->Ysize / 2 + 1;
183 if (RP->symmetry_used == X_SYM || RP->symmetry_used == XY_SYM)
184 RP->Xsize = RP->Xsize / 2 + 1;
185
186 if (RP->Xsize < MIN_RANDOM_MAP_SIZE)
187 RP->Xsize = MIN_RANDOM_MAP_SIZE + RANDOM () % 5;
188 if (RP->Ysize < MIN_RANDOM_MAP_SIZE)
189 RP->Ysize = MIN_RANDOM_MAP_SIZE + RANDOM () % 5;
190 RP->map_layout_style = 0;
191
192 /* Redo this - there was a lot of redundant code of checking for preset
193 * layout style and then random layout style. Instead, figure out
194 * the numeric layoutstyle, so there is only one area that actually
195 * calls the code to make the maps.
196 */
197 if (strstr (RP->layoutstyle, "onion"))
198 {
199 RP->map_layout_style = ONION_LAYOUT;
200 }
201
202 if (strstr (RP->layoutstyle, "maze"))
203 {
204 RP->map_layout_style = MAZE_LAYOUT;
205 }
206
207 if (strstr (RP->layoutstyle, "spiral"))
208 {
209 RP->map_layout_style = SPIRAL_LAYOUT;
210 }
211
212 if (strstr (RP->layoutstyle, "rogue"))
213 {
214 RP->map_layout_style = ROGUELIKE_LAYOUT;
215 }
216
217 if (strstr (RP->layoutstyle, "snake"))
218 {
219 RP->map_layout_style = SNAKE_LAYOUT;
220 }
221
222 if (strstr (RP->layoutstyle, "squarespiral"))
223 {
224 RP->map_layout_style = SQUARE_SPIRAL_LAYOUT;
225 }
226 /* No style found - choose one ranomdly */
227 if (RP->map_layout_style == 0)
228 {
229 RP->map_layout_style = (RANDOM () % NROFLAYOUTS) + 1;
230 }
231
232 switch (RP->map_layout_style)
233 {
234
235 case ONION_LAYOUT:
236 maze = map_gen_onion (RP->Xsize, RP->Ysize, RP->layoutoptions1, RP->layoutoptions2);
237 if (!(RANDOM () % 3) && !(RP->layoutoptions1 & OPT_WALLS_ONLY))
238 roomify_layout (maze, RP);
239 break;
240
241 case MAZE_LAYOUT:
242 maze = maze_gen (RP->Xsize, RP->Ysize, RANDOM () % 2);
243 if (!(RANDOM () % 2))
244 doorify_layout (maze, RP);
245 break;
246
247 case SPIRAL_LAYOUT:
248 maze = map_gen_spiral (RP->Xsize, RP->Ysize, RP->layoutoptions1);
249 if (!(RANDOM () % 2))
250 doorify_layout (maze, RP);
251 break;
252
253 case ROGUELIKE_LAYOUT:
254 /* Don't put symmetry in rogue maps. There isn't much reason to
255 * do so in the first place (doesn't make it any more interesting),
256 * but more importantly, the symmetry code presumes we are symmetrizing
257 * spirals, or maps with lots of passages - making a symmetric rogue
258 * map fails because its likely that the passages the symmetry process
259 * creates may not connect the rooms.
260 */
261 RP->symmetry_used = NO_SYM;
262 RP->Ysize = oysize;
263 RP->Xsize = oxsize;
264 maze = roguelike_layout_gen (RP->Xsize, RP->Ysize, RP->layoutoptions1);
265 /* no doorifying... done already */
266 break;
267
268 case SNAKE_LAYOUT:
269 maze = make_snake_layout (RP->Xsize, RP->Ysize, RP->layoutoptions1);
270 if (RANDOM () % 2)
271 roomify_layout (maze, RP);
272 break;
273
274 case SQUARE_SPIRAL_LAYOUT:
275 maze = make_square_spiral_layout (RP->Xsize, RP->Ysize, RP->layoutoptions1);
276 if (RANDOM () % 2)
277 roomify_layout (maze, RP);
278 break;
279 }
280
281 maze = symmetrize_layout (maze, RP->symmetry_used, RP);
282#ifdef RMAP_DEBUG
283 dump_layout (maze, RP);
284#endif
285 if (RP->expand2x)
286 {
287 maze = expand2x (maze, RP->Xsize, RP->Ysize);
288 RP->Xsize = RP->Xsize * 2 - 1;
289 RP->Ysize = RP->Ysize * 2 - 1;
290 }
291 return maze;
292}
293
294
295/* takes a map and makes it symmetric: adjusts Xsize and 72/* takes a map and makes it symmetric: adjusts Xsize and
296Ysize to produce a symmetric map. */ 73 * Ysize to produce a symmetric map.
297 74 */
298char ** 75static void
299symmetrize_layout (char **maze, int sym, RMParms * RP) 76symmetrize_layout (Layout layout, random_map_params *RP)
300{ 77{
301 int i, j; 78 if (RP->symmetry_used == SYMMETRY_NONE)
302 char **sym_maze;
303 int Xsize_orig, Ysize_orig;
304
305 Xsize_orig = RP->Xsize;
306 Ysize_orig = RP->Ysize;
307 RP->symmetry_used = sym; /* tell everyone else what sort of symmetry is used. */
308 if (sym == NO_SYM)
309 {
310 RP->Xsize = Xsize_orig;
311 RP->Ysize = Ysize_orig;
312 return maze; 79 return;
313 }
314 /* pick new sizes */
315 RP->Xsize = ((sym == X_SYM || sym == XY_SYM) ? RP->Xsize * 2 - 3 : RP->Xsize);
316 RP->Ysize = ((sym == Y_SYM || sym == XY_SYM) ? RP->Ysize * 2 - 3 : RP->Ysize);
317 80
318 sym_maze = (char **) calloc (sizeof (char *), RP->Xsize); 81 Layout sym_layout (
319 for (i = 0; i < RP->Xsize; i++) 82 RP->symmetry_used == SYMMETRY_X || RP->symmetry_used == SYMMETRY_XY ? layout->w * 2 - 3 : layout->w,
320 sym_maze[i] = (char *) calloc (sizeof (char), RP->Ysize); 83 RP->symmetry_used == SYMMETRY_Y || RP->symmetry_used == SYMMETRY_XY ? layout->h * 2 - 3 : layout->h
84 );
321 85
322 if (sym == X_SYM) 86 if (RP->symmetry_used == SYMMETRY_X)
323 for (i = 0; i < RP->Xsize / 2 + 1; i++) 87 for (int i = 0; i < sym_layout->w / 2 + 1; i++)
324 for (j = 0; j < RP->Ysize; j++) 88 for (int j = 0; j < sym_layout->h; j++)
325 { 89 {
326 sym_maze[i][j] = maze[i][j]; 90 sym_layout[i ][j] =
327 sym_maze[RP->Xsize - i - 1][j] = maze[i][j]; 91 sym_layout[sym_layout->w - i - 1][j] = layout[i][j];
328 }; 92 }
329 if (sym == Y_SYM) 93
330 for (i = 0; i < RP->Xsize; i++) 94 if (RP->symmetry_used == SYMMETRY_Y)
95 for (int i = 0; i < sym_layout->w; i++)
331 for (j = 0; j < RP->Ysize / 2 + 1; j++) 96 for (int j = 0; j < sym_layout->h / 2 + 1; j++)
332 {
333 sym_maze[i][j] = maze[i][j];
334 sym_maze[i][RP->Ysize - j - 1] = maze[i][j];
335 } 97 {
336 if (sym == XY_SYM) 98 sym_layout[i][j ] =
337 for (i = 0; i < RP->Xsize / 2 + 1; i++) 99 sym_layout[i][sym_layout->h - j - 1] = layout[i][j];
338 for (j = 0; j < RP->Ysize / 2 + 1; j++)
339 { 100 }
340 sym_maze[i][j] = maze[i][j]; 101
341 sym_maze[i][RP->Ysize - j - 1] = maze[i][j]; 102 if (RP->symmetry_used == SYMMETRY_XY)
342 sym_maze[RP->Xsize - i - 1][j] = maze[i][j]; 103 for (int i = 0; i < sym_layout->w / 2 + 1; i++)
343 sym_maze[RP->Xsize - i - 1][RP->Ysize - j - 1] = maze[i][j]; 104 for (int j = 0; j < sym_layout->h / 2 + 1; j++)
344 } 105 {
345 /* delete the old maze */ 106 sym_layout[i ][j ] =
346 for (i = 0; i < Xsize_orig; i++) 107 sym_layout[i ][sym_layout->h - j - 1] =
347 free (maze[i]); 108 sym_layout[sym_layout->w - i - 1][j ] =
348 free (maze); 109 sym_layout[sym_layout->w - i - 1][sym_layout->h - j - 1] = layout[i][j];
110 }
111
112 layout.swap (sym_layout);
113 sym_layout.free ();
114
349 /* reconnect disjointed spirals */ 115 /* reconnect disjointed spirals */
350 if (RP->map_layout_style == SPIRAL_LAYOUT)
351 connect_spirals (RP->Xsize, RP->Ysize, sym, sym_maze);
352 /* reconnect disjointed nethackmazes: the routine for 116 /* reconnect disjointed nethacklayouts: the routine for
353 spirals will do the trick? */ 117 spirals will do the trick? */
354 if (RP->map_layout_style == ROGUELIKE_LAYOUT) 118 if (RP->map_layout_style == LAYOUT_SPIRAL
355 connect_spirals (RP->Xsize, RP->Ysize, sym, sym_maze); 119 || RP->map_layout_style == LAYOUT_ROGUELIKE)
356 120 connect_spirals (layout->w, layout->h, RP->symmetry_used, layout);
357 return sym_maze;
358} 121}
359
360 122
361/* takes a map and rotates it. This completes the 123/* takes a map and rotates it. This completes the
362 onion layouts, making them possibly centered on any wall. 124 onion layouts, making them possibly centered on any wall.
363 It'll modify Xsize and Ysize if they're swapped. 125 It'll modify Xsize and Ysize if they're swapped.
364*/ 126*/
365 127static void
366char ** 128rotate_layout (Layout layout, int rotation)
367rotate_layout (char **maze, int rotation, RMParms * RP)
368{ 129{
369 char **new_maze; 130 int w = layout->w;
370 int i, j; 131 int h = layout->h;
371 132
372 switch (rotation) 133 switch (rotation)
373 { 134 {
374 case 0:
375 return maze;
376 break;
377 case 2: /* a reflection */ 135 case 2: /* a reflection */
378 { 136 {
379 char *newmaze = (char *) malloc (sizeof (char) * RP->Xsize * RP->Ysize); 137 Layout new_layout (w, h);
380 138
381 for (i = 0; i < RP->Xsize; i++) 139 for (int i = 0; i < w; i++) /* copy a reflection back */
382 { /* make a copy */
383 for (j = 0; j < RP->Ysize; j++) 140 for (int j = 0; j < h; j++)
384 { 141 new_layout[i][j] = layout[w - i - 1][h - j - 1];
385 newmaze[i * RP->Ysize + j] = maze[i][j]; 142
386 } 143 layout.swap (new_layout);
387 } 144 new_layout.free ();
388 for (i = 0; i < RP->Xsize; i++)
389 { /* copy a reflection back */
390 for (j = 0; j < RP->Ysize; j++)
391 {
392 maze[i][j] = newmaze[(RP->Xsize - i - 1) * RP->Ysize + RP->Ysize - j - 1];
393 }
394 }
395 free (newmaze);
396 return maze;
397 break;
398 } 145 }
146 break;
147
399 case 1: 148 case 1:
400 case 3: 149 case 3:
401 { 150 {
402 int swap; 151 Layout new_layout (h, w);
403 new_maze = (char **) calloc (sizeof (char *), RP->Ysize); 152
404 for (i = 0; i < RP->Ysize; i++)
405 {
406 new_maze[i] = (char *) calloc (sizeof (char), RP->Xsize);
407 }
408 if (rotation == 1) /* swap x and y */ 153 if (rotation == 1) /* swap x and y */
409 for (i = 0; i < RP->Xsize; i++)
410 for (j = 0; j < RP->Ysize; j++)
411 new_maze[j][i] = maze[i][j];
412
413 if (rotation == 3)
414 { /* swap x and y */
415 for (i = 0; i < RP->Xsize; i++)
416 for (j = 0; j < RP->Ysize; j++)
417 new_maze[j][i] = maze[RP->Xsize - i - 1][RP->Ysize - j - 1];
418 }
419
420 /* delete the old layout */
421 for (i = 0; i < RP->Xsize; i++) 154 for (int i = 0; i < w; i++)
422 free (maze[i]); 155 for (int j = 0; j < h; j++)
423 free (maze); 156 new_layout[j][i] = layout[i][j];
424 157
425 swap = RP->Ysize; 158 if (rotation == 3) /* swap x and y */
426 RP->Ysize = RP->Xsize; 159 for (int i = 0; i < w; i++)
427 RP->Xsize = swap; 160 for (int j = 0; j < h; j++)
428 return new_maze; 161 new_layout[j][i] = layout[w - i - 1][h - j - 1];
429 break; 162
163 layout.swap (new_layout);
164 new_layout.free ();
430 } 165 }
431 } 166 break;
432 return NULL;
433}
434
435/* take a layout and make some rooms in it.
436 --works best on onions.*/
437void
438roomify_layout (char **maze, RMParms * RP)
439{
440 int tries = RP->Xsize * RP->Ysize / 30;
441 int ti;
442
443 for (ti = 0; ti < tries; ti++)
444 {
445 int dx, dy; /* starting location for looking at creating a door */
446 int cx, cy; /* results of checking on creating walls. */
447
448 dx = RANDOM () % RP->Xsize;
449 dy = RANDOM () % RP->Ysize;
450 cx = can_make_wall (maze, dx, dy, 0, RP); /* horizontal */
451 cy = can_make_wall (maze, dx, dy, 1, RP); /* vertical */
452 if (cx == -1)
453 {
454 if (cy != -1)
455 make_wall (maze, dx, dy, 1);
456 continue;
457 }
458 if (cy == -1)
459 {
460 make_wall (maze, dx, dy, 0);
461 continue;
462 }
463 if (cx < cy)
464 make_wall (maze, dx, dy, 0);
465 else
466 make_wall (maze, dx, dy, 1);
467 } 167 }
468} 168}
469 169
470/* checks the layout to see if I can stick a horizontal(dir = 0) wall 170/* checks the layout to see if I can stick a horizontal(dir = 0) wall
471 (or vertical, dir == 1) 171 (or vertical, dir == 1)
472 here which ends up on other walls sensibly. */ 172 here which ends up on other walls sensibly. */
473 173static int
474int
475can_make_wall (char **maze, int dx, int dy, int dir, RMParms * RP) 174can_make_wall (char **maze, int dx, int dy, int dir, random_map_params *RP)
476{ 175{
477 int i1; 176 int i1;
478 int length = 0; 177 int length = 0;
479 178
480 /* dont make walls if we're on the edge. */ 179 /* dont make walls if we're on the edge. */
… …
543 return -1; /* can't make verti. wall here */ 242 return -1; /* can't make verti. wall here */
544 if (maze[x][i1] != 0) 243 if (maze[x][i1] != 0)
545 return -1; /* can't make horiz. wall here */ 244 return -1; /* can't make horiz. wall here */
546 length++; 245 length++;
547 } 246 }
247
548 return length; 248 return length;
549 } 249 }
250
550 return -1; 251 return -1;
551} 252}
552 253
254/* take a layout and make some rooms in it.
255 --works best on onions.*/
256static void
257roomify_layout (char **maze, random_map_params *RP)
258{
259 int tries = RP->Xsize * RP->Ysize / 30;
260
261 for (int ti = 0; ti < tries; ti++)
262 {
263 /* starting location for looking at creating a door */
264 int dx = rmg_rndm (RP->Xsize);
265 int dy = rmg_rndm (RP->Ysize);
266
267 /* results of checking on creating walls. */
268 int cx = can_make_wall (maze, dx, dy, 0, RP); /* horizontal */
269 int cy = can_make_wall (maze, dx, dy, 1, RP); /* vertical */
270
271 if (cx == -1)
272 {
273 if (cy != -1)
274 make_wall (maze, dx, dy, 1);
275
276 continue;
277 }
278
279 if (cy == -1)
280 {
281 make_wall (maze, dx, dy, 0);
282 continue;
283 }
284
285 if (cx < cy)
286 make_wall (maze, dx, dy, 0);
287 else
288 make_wall (maze, dx, dy, 1);
289 }
290}
553 291
554int 292int
555make_wall (char **maze, int x, int y, int dir) 293make_wall (char **maze, int x, int y, int dir)
556{ 294{
557 maze[x][y] = 'D'; /* mark a door */ 295 maze[x][y] = 'D'; /* mark a door */
296
558 switch (dir) 297 switch (dir)
559 { 298 {
560 case 0: /* horizontal */ 299 case 0: /* horizontal */
561 { 300 {
562 int i1;
563
564 for (i1 = x - 1; maze[i1][y] == 0; i1--) 301 for (int i1 = x - 1; maze[i1][y] == 0; --i1) maze[i1][y] = '#';
565 maze[i1][y] = '#';
566 for (i1 = x + 1; maze[i1][y] == 0; i1++) 302 for (int i1 = x + 1; maze[i1][y] == 0; ++i1) maze[i1][y] = '#';
567 maze[i1][y] = '#';
568 break; 303 break;
569 } 304 }
570 case 1: /* vertical */ 305 case 1: /* vertical */
571 { 306 {
572 int i1;
573
574 for (i1 = y - 1; maze[x][i1] == 0; i1--) 307 for (int i1 = y - 1; maze[x][i1] == 0; --i1) maze[x][i1] = '#';
575 maze[x][i1] = '#';
576 for (i1 = y + 1; maze[x][i1] == 0; i1++) 308 for (int i1 = y + 1; maze[x][i1] == 0; ++i1) maze[x][i1] = '#';
577 maze[x][i1] = '#';
578 break; 309 break;
579 } 310 }
580 } 311 }
581 312
582 return 0; 313 return 0;
583} 314}
584 315
585/* puts doors at appropriate locations in a layout. */ 316/* puts doors at appropriate locations in a layout. */
586 317static void
587void
588doorify_layout (char **maze, RMParms * RP) 318doorify_layout (char **maze, random_map_params *RP)
589{ 319{
590 int ndoors = RP->Xsize * RP->Ysize / 60; /* reasonable number of doors. */ 320 int ndoors = RP->Xsize * RP->Ysize / 60; /* reasonable number of doors. */
591 char *doorlist_x;
592 char *doorlist_y;
593 int doorlocs = 0; /* # of available doorlocations */ 321 int doorlocs = 0; /* # of available doorlocations */
594 int i, j;
595 322
596 doorlist_x = (char *) malloc (sizeof (int) * RP->Xsize * RP->Ysize); 323 uint16 *doorlist_x = salloc<uint16> (RP->Xsize * RP->Ysize);
597 doorlist_y = (char *) malloc (sizeof (int) * RP->Xsize * RP->Ysize); 324 uint16 *doorlist_y = salloc<uint16> (RP->Xsize * RP->Ysize);
598
599 325
600 /* make a list of possible door locations */ 326 /* make a list of possible door locations */
601 for (i = 1; i < RP->Xsize - 1; i++) 327 for (int i = 1; i < RP->Xsize - 1; i++)
602 for (j = 1; j < RP->Ysize - 1; j++) 328 for (int j = 1; j < RP->Ysize - 1; j++)
603 { 329 {
604 int sindex = surround_flag (maze, i, j, RP); 330 int sindex = surround_flag (maze, i, j, RP);
605 331
606 if (sindex == 3 || sindex == 12) /* these are possible door sindex */ 332 if (sindex == 3 || sindex == 12) /* these are possible door sindex */
607 { 333 {
608 doorlist_x[doorlocs] = i; 334 doorlist_x[doorlocs] = i;
609 doorlist_y[doorlocs] = j; 335 doorlist_y[doorlocs] = j;
610 doorlocs++; 336 doorlocs++;
611 } 337 }
612 } 338 }
339
613 while (ndoors > 0 && doorlocs > 0) 340 while (ndoors > 0 && doorlocs > 0)
614 { 341 {
615 int di; 342 int di = rmg_rndm (doorlocs);
616 int sindex;
617
618 di = RANDOM () % doorlocs;
619 i = doorlist_x[di]; 343 int i = doorlist_x[di];
620 j = doorlist_y[di]; 344 int j = doorlist_y[di];
621 sindex = surround_flag (maze, i, j, RP); 345 int sindex = surround_flag (maze, i, j, RP);
346
622 if (sindex == 3 || sindex == 12) /* these are possible door sindex */ 347 if (sindex == 3 || sindex == 12) /* these are possible door sindex */
623 { 348 {
624 maze[i][j] = 'D'; 349 maze[i][j] = 'D';
625 ndoors--; 350 ndoors--;
626 } 351 }
352
627 /* reduce the size of the list */ 353 /* reduce the size of the list */
628 doorlocs--; 354 doorlocs--;
629 doorlist_x[di] = doorlist_x[doorlocs]; 355 doorlist_x[di] = doorlist_x[doorlocs];
630 doorlist_y[di] = doorlist_y[doorlocs]; 356 doorlist_y[di] = doorlist_y[doorlocs];
631 } 357 }
632 free (doorlist_x);
633 free (doorlist_y);
634}
635 358
359 sfree (doorlist_x, RP->Xsize * RP->Ysize);
360 sfree (doorlist_y, RP->Xsize * RP->Ysize);
361}
636 362
637void 363void
638write_map_parameters_to_string (char *buf, RMParms * RP) 364write_map_parameters_to_string (dynbuf_text &buf, random_map_params *RP)
639{ 365{
366 hv_iterinit (RP->hv);
640 367
641 char small_buf[256]; 368 while (HE *he = hv_iternext (RP->hv))
369 buf << HePV (he, PL_na) << ' ' << cfSvPVutf8_nolen (HeVAL (he)) << '\n';
642 370
643 sprintf (buf, "xsize %d\nysize %d\n", RP->Xsize, RP->Ysize); 371 buf.printf ("xsize %d\nysize %d\n", RP->xsize, RP->ysize);
644 372
645 if (RP->wallstyle[0]) 373 if (RP->monsterstyle[0] ) buf.printf ("monsterstyle %s\n", RP->monsterstyle);
646 { 374 if (RP->treasurestyle[0] ) buf.printf ("treasurestyle %s\n", RP->treasurestyle);
647 sprintf (small_buf, "wallstyle %s\n", RP->wallstyle); 375 if (RP->layoutstyle[0] ) buf.printf ("layoutstyle %s\n", RP->layoutstyle);
648 strcat (buf, small_buf); 376 if (RP->decorstyle[0] ) buf.printf ("decorstyle %s\n", RP->decorstyle);
377 if (RP->doorstyle[0] ) buf.printf ("doorstyle %s\n", RP->doorstyle);
378 if (RP->final_map.length () ) buf.printf ("final_map %s\n", &RP->final_map);
379 if (RP->exit_on_final_map[0]) buf.printf ("exit_on_final_map %s\n", RP->exit_on_final_map);
380 if (RP->this_map.length () ) buf.printf ("origin_map %s\n", &RP->this_map);
381 if (RP->expand2x ) buf.printf ("expand2x %d\n", RP->expand2x);
382 if (RP->layoutoptions1 ) buf.printf ("layoutoptions1 %d\n", RP->layoutoptions1);
383 if (RP->layoutoptions2 ) buf.printf ("layoutoptions2 %d\n", RP->layoutoptions2);
384 if (RP->layoutoptions3 ) buf.printf ("layoutoptions3 %d\n", RP->layoutoptions3);
385 if (RP->symmetry ) buf.printf ("symmetry %d\n", RP->symmetry);
386
387 if (RP->difficulty && RP->difficulty_given)
388 buf.printf ("difficulty %d\n", RP->difficulty);
389
390 if (fabs (RP->difficulty_increase - 1.f) >= (1.f / 1024.f))
391 buf.printf ("difficulty_increase %f\n", RP->difficulty_increase);
392
393 buf.printf ("dungeon_level %d\n", RP->dungeon_level);
394
395 if (RP->dungeon_depth ) buf.printf ("dungeon_depth %d\n", RP->dungeon_depth);
396 if (RP->decoroptions ) buf.printf ("decoroptions %d\n", RP->decoroptions);
397 if (RP->orientation ) buf.printf ("orientation %d\n", RP->orientation);
398 if (RP->origin_x ) buf.printf ("origin_x %d\n", RP->origin_x);
399 if (RP->origin_y ) buf.printf ("origin_y %d\n", RP->origin_y);
400 if (RP->treasureoptions ) buf.printf ("treasureoptions %d\n", RP->treasureoptions);
401 if (RP->random_seed ) buf.printf ("random_seed %u\n", RP->random_seed);
402}
403
404/////////////////////////////////////////////////////////////////////////////
405
406LayoutData::LayoutData (int w, int h)
407: w(w), h(h)
408{
409 int size = (sizeof (char *) + sizeof (char) * h) * w;
410
411 col = (char **)salloc<char> (size);
412
413 char *data = (char *)(col + w);
414
415 for (int x = w; x--; )
416 col [x] = data + x * h;
417}
418
419LayoutData::~LayoutData ()
420{
421 int size = (sizeof (char *) + sizeof (char) * h) * w;
422
423 sfree ((char *)col, size);
424}
425
426void LayoutData::clear (char fill)
427{
428 memset (col [0], fill, w * h);
429}
430
431void LayoutData::border (char fill)
432{
433 for (int i = 0; i < w; i++) col [i][0] = col [i][h - 1] = fill;
434 for (int j = 0; j < h; j++) col [0][j] = col [w - 1][j] = fill;
435}
436
437/* function selects the layout function and gives it whatever
438 arguments it needs. */
439static Layout
440layoutgen (random_map_params *RP)
441{
442 Layout layout (RP);
443
444 switch (RP->map_layout_style)
649 } 445 {
446 case LAYOUT_ONION:
447 map_gen_onion (layout, RP->layoutoptions1, RP->layoutoptions2);
650 448
651 if (RP->floorstyle[0]) 449 if (!(rmg_rndm (3)) && !(RP->layoutoptions1 & (RMOPT_WALLS_ONLY | RMOPT_WALL_OFF)))
450 roomify_layout (layout, RP);
451
452 break;
453
454 case LAYOUT_MAZE:
455 maze_gen (layout, rmg_rndm (2));
456
457 if (!(rmg_rndm (2)))
458 doorify_layout (layout, RP);
459
460 break;
461
462 case LAYOUT_SPIRAL:
463 map_gen_spiral (layout, RP->layoutoptions1);
464
465 if (!(rmg_rndm (2)))
466 doorify_layout (layout, RP);
467
468 break;
469
470 case LAYOUT_ROGUELIKE:
471 /* Don't put symmetry in rogue maps. There isn't much reason to
472 * do so in the first place (doesn't make it any more interesting),
473 * but more importantly, the symmetry code presumes we are symmetrizing
474 * spirals, or maps with lots of passages - making a symmetric rogue
475 * map fails because its likely that the passages the symmetry process
476 * creates may not connect the rooms.
477 */
478 RP->symmetry_used = SYMMETRY_NONE;
479 roguelike_layout_gen (layout, RP->layoutoptions1);
480 /* no doorifying... done already */
481 break;
482
483 case LAYOUT_SNAKE:
484 make_snake_layout (layout, RP->layoutoptions1);
485
486 if (rmg_rndm (2))
487 roomify_layout (layout, RP);
488
489 break;
490
491 case LAYOUT_SQUARE_SPIRAL:
492 make_square_spiral_layout (layout, RP->layoutoptions1);
493
494 if (rmg_rndm (2))
495 roomify_layout (layout, RP);
496
497 break;
498
499 default:
500 abort ();
652 { 501 }
653 sprintf (small_buf, "floorstyle %s\n", RP->floorstyle);
654 strcat (buf, small_buf);
655 }
656 502
657 if (RP->monsterstyle[0]) 503 /* rotate the layout randomly */
658 { 504 rotate_layout (layout, rmg_rndm (4));
659 sprintf (small_buf, "monsterstyle %s\n", RP->monsterstyle);
660 strcat (buf, small_buf);
661 }
662 505
663 if (RP->treasurestyle[0]) 506 symmetrize_layout (layout, RP);
664 {
665 sprintf (small_buf, "treasurestyle %s\n", RP->treasurestyle);
666 strcat (buf, small_buf);
667 }
668 507
669 if (RP->layoutstyle[0]) 508#ifdef RMAP_DEBUG
670 { 509 dump_layout (layout);
671 sprintf (small_buf, "layoutstyle %s\n", RP->layoutstyle); 510#endif
672 strcat (buf, small_buf);
673 }
674
675 if (RP->decorstyle[0])
676 {
677 sprintf (small_buf, "decorstyle %s\n", RP->decorstyle);
678 strcat (buf, small_buf);
679 }
680
681 if (RP->doorstyle[0])
682 {
683 sprintf (small_buf, "doorstyle %s\n", RP->doorstyle);
684 strcat (buf, small_buf);
685 }
686
687 if (RP->exitstyle[0])
688 {
689 sprintf (small_buf, "exitstyle %s\n", RP->exitstyle);
690 strcat (buf, small_buf);
691 }
692
693 if (RP->final_map[0])
694 {
695 sprintf (small_buf, "final_map %s\n", RP->final_map);
696 strcat (buf, small_buf);
697 }
698
699 if (RP->exit_on_final_map[0])
700 {
701 sprintf (small_buf, "exit_on_final_map %s\n", RP->exit_on_final_map);
702 strcat (buf, small_buf);
703 }
704
705 if (RP->this_map[0])
706 {
707 sprintf (small_buf, "origin_map %s\n", RP->this_map);
708 strcat (buf, small_buf);
709 }
710 511
711 if (RP->expand2x) 512 if (RP->expand2x)
712 { 513 expand2x (layout);
713 sprintf (small_buf, "expand2x %d\n", RP->expand2x); 514
714 strcat (buf, small_buf); 515 return layout;
516}
517
518bool
519maptile::generate_random_map (random_map_params *RP)
520{
521 int i;
522
523 RP->Xsize = RP->xsize;
524 RP->Ysize = RP->ysize;
525
526 /* pick a random seed, or use the one from the input file */
527 RP->random_seed = RP->random_seed
528 ? RP->random_seed + RP->dungeon_level
529 : time (0);
530
531 // we run "single-threaded"
532 rmg_rndm.seed (RP->random_seed);
533
534 dynbuf_text buf;
535 write_map_parameters_to_string (buf, RP);
536
537 if (RP->difficulty == 0)
715 } 538 {
539 RP->difficulty = RP->dungeon_level; /* use this instead of a map difficulty */
716 540
717 if (RP->layoutoptions1)
718 {
719 sprintf (small_buf, "layoutoptions1 %d\n", RP->layoutoptions1);
720 strcat (buf, small_buf);
721 }
722
723
724 if (RP->layoutoptions2)
725 {
726 sprintf (small_buf, "layoutoptions2 %d\n", RP->layoutoptions2);
727 strcat (buf, small_buf);
728 }
729
730
731 if (RP->layoutoptions3)
732 {
733 sprintf (small_buf, "layoutoptions3 %d\n", RP->layoutoptions3);
734 strcat (buf, small_buf);
735 }
736
737 if (RP->symmetry)
738 {
739 sprintf (small_buf, "symmetry %d\n", RP->symmetry);
740 strcat (buf, small_buf);
741 }
742
743
744 if (RP->difficulty && RP->difficulty_given)
745 {
746 sprintf (small_buf, "difficulty %d\n", RP->difficulty);
747 strcat (buf, small_buf);
748 }
749
750 if (RP->difficulty_increase != 1.0)
751 {
752 sprintf (small_buf, "difficulty_increase %f\n", RP->difficulty_increase);
753 strcat (buf, small_buf);
754 }
755
756 sprintf (small_buf, "dungeon_level %d\n", RP->dungeon_level);
757 strcat (buf, small_buf);
758
759 if (RP->dungeon_depth)
760 {
761 sprintf (small_buf, "dungeon_depth %d\n", RP->dungeon_depth);
762 strcat (buf, small_buf);
763 }
764
765 if (RP->decoroptions)
766 {
767 sprintf (small_buf, "decoroptions %d\n", RP->decoroptions);
768 strcat (buf, small_buf);
769 }
770
771 if (RP->orientation)
772 {
773 sprintf (small_buf, "orientation %d\n", RP->orientation);
774 strcat (buf, small_buf);
775 }
776
777 if (RP->origin_x)
778 {
779 sprintf (small_buf, "origin_x %d\n", RP->origin_x);
780 strcat (buf, small_buf);
781 }
782
783 if (RP->origin_y)
784 {
785 sprintf (small_buf, "origin_y %d\n", RP->origin_y);
786 strcat (buf, small_buf);
787 }
788 if (RP->random_seed)
789 {
790 /* Add one so that the next map is a bit different */
791 sprintf (small_buf, "random_seed %d\n", RP->random_seed + 1);
792 strcat (buf, small_buf);
793 }
794
795 if (RP->treasureoptions)
796 {
797 sprintf (small_buf, "treasureoptions %d\n", RP->treasureoptions);
798 strcat (buf, small_buf);
799 }
800
801
802}
803
804void
805write_parameters_to_string (char *buf,
806 int xsize_n,
807 int ysize_n,
808 char *wallstyle_n,
809 char *floorstyle_n,
810 char *monsterstyle_n,
811 char *treasurestyle_n,
812 char *layoutstyle_n,
813 char *decorstyle_n,
814 char *doorstyle_n,
815 char *exitstyle_n,
816 char *final_map_n,
817 char *exit_on_final_map_n,
818 char *this_map_n,
819 int layoutoptions1_n,
820 int layoutoptions2_n,
821 int layoutoptions3_n,
822 int symmetry_n,
823 int dungeon_depth_n,
824 int dungeon_level_n,
825 int difficulty_n,
826 int difficulty_given_n,
827 int decoroptions_n,
828 int orientation_n,
829 int origin_x_n, int origin_y_n, int random_seed_n, int treasureoptions_n, float difficulty_increase)
830{
831
832 char small_buf[256];
833
834 sprintf (buf, "xsize %d\nysize %d\n", xsize_n, ysize_n);
835
836 if (wallstyle_n && wallstyle_n[0])
837 {
838 sprintf (small_buf, "wallstyle %s\n", wallstyle_n);
839 strcat (buf, small_buf);
840 }
841
842 if (floorstyle_n && floorstyle_n[0])
843 {
844 sprintf (small_buf, "floorstyle %s\n", floorstyle_n);
845 strcat (buf, small_buf);
846 }
847
848 if (monsterstyle_n && monsterstyle_n[0])
849 {
850 sprintf (small_buf, "monsterstyle %s\n", monsterstyle_n);
851 strcat (buf, small_buf);
852 }
853
854 if (treasurestyle_n && treasurestyle_n[0])
855 {
856 sprintf (small_buf, "treasurestyle %s\n", treasurestyle_n);
857 strcat (buf, small_buf);
858 }
859
860 if (layoutstyle_n && layoutstyle_n[0])
861 {
862 sprintf (small_buf, "layoutstyle %s\n", layoutstyle_n);
863 strcat (buf, small_buf);
864 }
865
866 if (decorstyle_n && decorstyle_n[0])
867 {
868 sprintf (small_buf, "decorstyle %s\n", decorstyle_n);
869 strcat (buf, small_buf);
870 }
871
872 if (doorstyle_n && doorstyle_n[0])
873 {
874 sprintf (small_buf, "doorstyle %s\n", doorstyle_n);
875 strcat (buf, small_buf);
876 }
877
878 if (exitstyle_n && exitstyle_n[0])
879 {
880 sprintf (small_buf, "exitstyle %s\n", exitstyle_n);
881 strcat (buf, small_buf);
882 }
883
884 if (final_map_n && final_map_n[0])
885 {
886 sprintf (small_buf, "final_map %s\n", final_map_n);
887 strcat (buf, small_buf);
888 }
889
890 if (exit_on_final_map_n && exit_on_final_map_n[0])
891 {
892 sprintf (small_buf, "exit_on_final_map %s\n", exit_on_final_map_n);
893 strcat (buf, small_buf);
894 }
895
896 if (this_map_n && this_map_n[0])
897 {
898 sprintf (small_buf, "origin_map %s\n", this_map_n);
899 strcat (buf, small_buf);
900 }
901
902 if (layoutoptions1_n)
903 {
904 sprintf (small_buf, "layoutoptions1 %d\n", layoutoptions1_n);
905 strcat (buf, small_buf);
906 }
907
908
909 if (layoutoptions2_n)
910 {
911 sprintf (small_buf, "layoutoptions2 %d\n", layoutoptions2_n);
912 strcat (buf, small_buf);
913 }
914
915
916 if (layoutoptions3_n)
917 {
918 sprintf (small_buf, "layoutoptions3 %d\n", layoutoptions3_n);
919 strcat (buf, small_buf);
920 }
921
922 if (symmetry_n)
923 {
924 sprintf (small_buf, "symmetry %d\n", symmetry_n);
925 strcat (buf, small_buf);
926 }
927
928
929 if (difficulty_n && difficulty_given_n)
930 {
931 sprintf (small_buf, "difficulty %d\n", difficulty_n);
932 strcat (buf, small_buf);
933 }
934
935 if (difficulty_increase > 0.001) 541 if (RP->difficulty_increase > 0.001)
542 RP->difficulty = (int) ((float) RP->dungeon_level * RP->difficulty_increase);
543
544 if (RP->difficulty < 1)
545 RP->difficulty = 1;
936 { 546 }
937 sprintf (small_buf, "difficulty_increase %f\n", difficulty_increase); 547 else
938 strcat (buf, small_buf); 548 RP->difficulty_given = 1;
549
550 if (RP->Xsize < MIN_RANDOM_MAP_SIZE)
551 RP->Xsize = MIN_RANDOM_MAP_SIZE + rmg_rndm (25) + 5;
552
553 if (RP->Ysize < MIN_RANDOM_MAP_SIZE)
554 RP->Ysize = MIN_RANDOM_MAP_SIZE + rmg_rndm (25) + 5;
555
556 if (RP->symmetry == SYMMETRY_RANDOM)
557 RP->symmetry_used = rmg_rndm (SYMMETRY_XY) + 1;
558 else
559 RP->symmetry_used = RP->symmetry;
560
561 if (RP->symmetry_used == SYMMETRY_Y || RP->symmetry_used == SYMMETRY_XY)
562 RP->Ysize = RP->Ysize / 2 + 1;
563
564 if (RP->symmetry_used == SYMMETRY_X || RP->symmetry_used == SYMMETRY_XY)
565 RP->Xsize = RP->Xsize / 2 + 1;
566
567 if (RP->expand2x > 0)
939 } 568 {
940 569 RP->Xsize /= 2;
941 sprintf (small_buf, "dungeon_level %d\n", dungeon_level_n); 570 RP->Ysize /= 2;
942 strcat (buf, small_buf);
943
944 if (dungeon_depth_n)
945 { 571 }
946 sprintf (small_buf, "dungeon_depth %d\n", dungeon_depth_n); 572
947 strcat (buf, small_buf); 573 RP->map_layout_style = LAYOUT_NONE;
574
575 /* Redo this - there was a lot of redundant code of checking for preset
576 * layout style and then random layout style. Instead, figure out
577 * the numeric layoutstyle, so there is only one area that actually
578 * calls the code to make the maps.
579 */
580 if (strstr (RP->layoutstyle, "onion"))
581 RP->map_layout_style = LAYOUT_ONION;
582 else if (strstr (RP->layoutstyle, "maze"))
583 RP->map_layout_style = LAYOUT_MAZE;
584 else if (strstr (RP->layoutstyle, "spiral"))
585 RP->map_layout_style = LAYOUT_SPIRAL;
586 else if (strstr (RP->layoutstyle, "rogue"))
587 RP->map_layout_style = LAYOUT_ROGUELIKE;
588 else if (strstr (RP->layoutstyle, "snake"))
589 RP->map_layout_style = LAYOUT_SNAKE;
590 else if (strstr (RP->layoutstyle, "squarespiral"))
591 RP->map_layout_style = LAYOUT_SQUARE_SPIRAL;
592 else if (RP->map_layout_style == LAYOUT_NONE)
593 RP->map_layout_style = rmg_rndm (NROFLAYOUTS - 1) + 1; /* No style found - choose one randomly */
594 else
595 abort ();
596
597 Layout layout = layoutgen (RP);
598
599#ifdef RMAP_DEBUG
600 dump_layout (layout);
601#endif
602
603 /* increment these for the current map */
604 ++RP->dungeon_level;
605
606 // need to patch RP becasue following code doesn't use the Layout object
607 RP->Xsize = layout->w;
608 RP->Ysize = layout->h;
609
610 /* allocate the map and set the floor */
611 make_map_floor (layout, RP->get_str ("floorstyle", ""), RP);
612
613 /* set region */
614 default_region = RP->region;
615
616 CEDE;
617
618 place_specials_in_map (this, layout, RP);
619
620 CEDE;
621
622 const char *wallstyle = RP->get_str ("wallstyle", 0);
623
624 /* create walls unless the wallstyle is "none" */
625 if (strcmp (wallstyle, "none"))
948 } 626 {
627 make_map_walls (this, layout, wallstyle, RP->get_str ("miningstyle", ""), RP);
949 628
950 if (decoroptions_n) 629 /* place doors unless doorstyle or wallstyle is "none" */
630 if (strcmp (RP->doorstyle, "none"))
631 put_doors (this, layout, RP->doorstyle, RP);
951 { 632 }
952 sprintf (small_buf, "decoroptions %d\n", decoroptions_n);
953 strcat (buf, small_buf);
954 }
955 633
956 if (orientation_n) 634 CEDE;
957 {
958 sprintf (small_buf, "orientation %d\n", orientation_n);
959 strcat (buf, small_buf);
960 }
961 635
962 if (origin_x_n) 636 const char *exitstyle = RP->get_str ("exitstyle", "");
963 {
964 sprintf (small_buf, "origin_x %d\n", origin_x_n);
965 strcat (buf, small_buf);
966 }
967 637
968 if (origin_y_n) 638 /* create exits unless the exitstyle is "none" */
969 { 639 if (strcmp (exitstyle, "none"))
970 sprintf (small_buf, "origin_y %d\n", origin_y_n); 640 place_exits (this, layout, exitstyle, RP->orientation, RP);
971 strcat (buf, small_buf);
972 }
973 if (random_seed_n)
974 {
975 /* Add one so that the next map is a bit different */
976 sprintf (small_buf, "random_seed %d\n", random_seed_n + 1);
977 strcat (buf, small_buf);
978 }
979 641
980 if (treasureoptions_n) 642 CEDE;
981 {
982 sprintf (small_buf, "treasureoptions %d\n", treasureoptions_n);
983 strcat (buf, small_buf);
984 }
985 643
644 /* create monsters unless the monsterstyle is "none" */
645 if (strcmp (RP->monsterstyle, "none"))
646 place_monsters (this, RP->monsterstyle, RP->difficulty, RP);
986 647
987} 648 CEDE;
988 649
989/* copy an object with an inventory... i.e., duplicate the inv too. */ 650 /* treasures needs to have a proper difficulty set for the map. */
990void 651 difficulty = estimate_difficulty ();
991copy_object_with_inv (object *src_ob, object *dest_ob)
992{
993 object *walk, *tmp;
994 652
995 src_ob->copy_to (dest_ob); 653 CEDE;
996 654
997 for (walk = src_ob->inv; walk != NULL; walk = walk->below) 655 /* create treasure unless the treasurestyle is "none" */
998 { 656 place_treasure (this, layout, RP->treasurestyle, RP->treasureoptions, RP);
999 tmp = object::create (); 657
1000 walk->copy_to (tmp); 658 CEDE;
1001 insert_ob_in_ob (tmp, dest_ob); 659
1002 } 660 /* create decor unless the decorstyle is "none" */
661 if (strcmp (RP->decorstyle, "none"))
662 put_decor (this, layout, RP->decorstyle, RP->decoroptions, RP);
663
664 CEDE;
665
666 /* generate treasures, etc. */
667 fix_auto_apply ();
668
669 CEDE;
670
671 unblock_exits (this, layout, RP);
672
673 msg = buf;
674 in_memory = MAP_ACTIVE;
675
676 CEDE;
677
678 return 1;
1003} 679}
680

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines