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.3 by root, Sun Sep 10 16:06:37 2006 UTC vs.
Revision 1.49 by root, Tue Apr 13 02:39:53 2010 UTC

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

Diff Legend

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