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.5 by root, Sat Sep 16 22:24:13 2006 UTC vs.
Revision 1.49 by root, Tue Apr 13 02:39:53 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
33void 37void
34dump_layout (char **layout, RMParms * RP) 38dump_layout (Layout layout)
35{ 39{
36 { 40 for (int j = 0; j < layout->h; j++)
37 int i, j;
38
39 for (i = 0; i < RP->Xsize; i++)
40 { 41 {
41 for (j = 0; j < RP->Ysize; j++) 42 for (int i = 0; i < layout->w; i++)
42 { 43 putc (layout[i][j] ? layout[i][j] : ' ', stdout);
43 if (layout[i][j] == 0) 44
44 layout[i][j] = ' '; 45 putc ('\n', stdout);
45 printf ("%c", layout[i][j]);
46 if (layout[i][j] == ' ')
47 layout[i][j] = 0;
48 }
49 printf ("\n");
50 } 46 }
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 47
62 /* pick a random seed, or use the one from the input file */ 48 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 if (RP->difficulty_increase > 0.001)
74 {
75 RP->difficulty = (int) ((float) RP->dungeon_level * RP->difficulty_increase);
76 if (RP->difficulty < 1)
77 RP->difficulty = 1;
78 }
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 if (RP->Ysize < MIN_RANDOM_MAP_SIZE)
86 RP->Ysize = MIN_RANDOM_MAP_SIZE + RANDOM () % 25 + 5;
87
88 if (RP->expand2x > 0)
89 {
90 RP->Xsize /= 2;
91 RP->Ysize /= 2;
92 }
93
94 layout = layoutgen (RP);
95
96#ifdef RMAP_DEBUG
97 dump_layout (layout, RP);
98#endif
99
100 /* increment these for the current map */
101 RP->dungeon_level += 1;
102 /* allow constant-difficulty maps. */
103 /* difficulty+=1; */
104
105 /* rotate the layout randomly */
106 layout = rotate_layout (layout, RANDOM () % 4, RP);
107#ifdef RMAP_DEBUG
108 dump_layout (layout, RP);
109#endif
110
111 /* allocate the map and set the floor */
112 theMap = make_map_floor (layout, RP->floorstyle, RP);
113
114 /* set the name of the map. */
115 strcpy (theMap->path, OutFileName);
116
117 /* set region */
118 theMap->region = RP->region;
119
120 /* create walls unless the wallstyle is "none" */
121 if (strcmp (RP->wallstyle, "none"))
122 {
123 make_map_walls (theMap, layout, RP->wallstyle, RP);
124
125 /* place doors unless doorstyle or wallstyle is "none" */
126 if (strcmp (RP->doorstyle, "none"))
127 put_doors (theMap, layout, RP->doorstyle, RP);
128
129 }
130
131 /* create exits unless the exitstyle is "none" */
132 if (strcmp (RP->exitstyle, "none"))
133 place_exits (theMap, layout, RP->exitstyle, RP->orientation, RP);
134
135 place_specials_in_map (theMap, layout, RP);
136
137 /* create monsters unless the monsterstyle is "none" */
138 if (strcmp (RP->monsterstyle, "none"))
139 place_monsters (theMap, RP->monsterstyle, RP->difficulty, RP);
140
141 /* treasures needs to have a proper difficulty set for the map. */
142 theMap->difficulty = calculate_difficulty (theMap);
143
144 /* create treasure unless the treasurestyle is "none" */
145 if (strcmp (RP->treasurestyle, "none"))
146 place_treasure (theMap, layout, RP->treasurestyle, RP->treasureoptions, RP);
147
148 /* create decor unless the decorstyle is "none" */
149 if (strcmp (RP->decorstyle, "none"))
150 put_decor (theMap, layout, RP->decorstyle, RP->decoroptions, RP);
151
152 /* generate treasures, etc. */
153 fix_auto_apply (theMap);
154
155 unblock_exits (theMap, layout, RP);
156
157 /* free the layout */
158 for (i = 0; i < RP->Xsize; i++)
159 free (layout[i]);
160 free (layout);
161
162 theMap->msg = strdup_local (buf);
163
164 return theMap;
165} 49}
166 50
167
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 51/* takes a map and makes it symmetric: adjusts Xsize and
296Ysize to produce a symmetric map. */ 52 * Ysize to produce a symmetric map.
297 53 */
298char ** 54static void
299symmetrize_layout (char **maze, int sym, RMParms * RP) 55symmetrize_layout (Layout layout, random_map_params *RP)
300{ 56{
301 int i, j; 57 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; 58 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 59
318 sym_maze = (char **) calloc (sizeof (char *), RP->Xsize); 60 Layout sym_layout (
319 for (i = 0; i < RP->Xsize; i++) 61 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); 62 RP->symmetry_used == SYMMETRY_Y || RP->symmetry_used == SYMMETRY_XY ? layout->h * 2 - 3 : layout->h
63 );
321 64
322 if (sym == X_SYM) 65 if (RP->symmetry_used == SYMMETRY_X)
323 for (i = 0; i < RP->Xsize / 2 + 1; i++) 66 for (int i = 0; i < sym_layout->w / 2 + 1; i++)
324 for (j = 0; j < RP->Ysize; j++) 67 for (int j = 0; j < sym_layout->h; j++)
325 { 68 {
326 sym_maze[i][j] = maze[i][j]; 69 sym_layout[i ][j] =
327 sym_maze[RP->Xsize - i - 1][j] = maze[i][j]; 70 sym_layout[sym_layout->w - i - 1][j] = layout[i][j];
328 }; 71 }
329 if (sym == Y_SYM) 72
330 for (i = 0; i < RP->Xsize; i++) 73 if (RP->symmetry_used == SYMMETRY_Y)
74 for (int i = 0; i < sym_layout->w; i++)
331 for (j = 0; j < RP->Ysize / 2 + 1; j++) 75 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 } 76 {
336 if (sym == XY_SYM) 77 sym_layout[i][j ] =
337 for (i = 0; i < RP->Xsize / 2 + 1; i++) 78 sym_layout[i][sym_layout->h - j - 1] = layout[i][j];
338 for (j = 0; j < RP->Ysize / 2 + 1; j++)
339 { 79 }
340 sym_maze[i][j] = maze[i][j]; 80
341 sym_maze[i][RP->Ysize - j - 1] = maze[i][j]; 81 if (RP->symmetry_used == SYMMETRY_XY)
342 sym_maze[RP->Xsize - i - 1][j] = maze[i][j]; 82 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]; 83 for (int j = 0; j < sym_layout->h / 2 + 1; j++)
344 } 84 {
345 /* delete the old maze */ 85 sym_layout[i ][j ] =
346 for (i = 0; i < Xsize_orig; i++) 86 sym_layout[i ][sym_layout->h - j - 1] =
347 free (maze[i]); 87 sym_layout[sym_layout->w - i - 1][j ] =
348 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
349 /* reconnect disjointed spirals */ 94 /* 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 95 /* reconnect disjointed nethacklayouts: the routine for
353 spirals will do the trick? */ 96 spirals will do the trick? */
354 if (RP->map_layout_style == ROGUELIKE_LAYOUT) 97 if (RP->map_layout_style == LAYOUT_SPIRAL
355 connect_spirals (RP->Xsize, RP->Ysize, sym, sym_maze); 98 || RP->map_layout_style == LAYOUT_ROGUELIKE)
356 99 connect_spirals (layout->w, layout->h, RP->symmetry_used, layout);
357 return sym_maze;
358} 100}
359
360 101
361/* takes a map and rotates it. This completes the 102/* takes a map and rotates it. This completes the
362 onion layouts, making them possibly centered on any wall. 103 onion layouts, making them possibly centered on any wall.
363 It'll modify Xsize and Ysize if they're swapped. 104 It'll modify Xsize and Ysize if they're swapped.
364*/ 105*/
365 106static void
366char ** 107rotate_layout (Layout layout, int rotation)
367rotate_layout (char **maze, int rotation, RMParms * RP)
368{ 108{
369 char **new_maze; 109 int w = layout->w;
370 int i, j; 110 int h = layout->h;
371 111
372 switch (rotation) 112 switch (rotation)
373 { 113 {
374 case 0:
375 return maze;
376 break;
377 case 2: /* a reflection */ 114 case 2: /* a reflection */
378 { 115 {
379 char *newmaze = (char *) malloc (sizeof (char) * RP->Xsize * RP->Ysize); 116 Layout new_layout (w, h);
380 117
381 for (i = 0; i < RP->Xsize; i++) 118 for (int i = 0; i < w; i++) /* copy a reflection back */
382 { /* make a copy */
383 for (j = 0; j < RP->Ysize; j++) 119 for (int j = 0; j < h; j++)
384 { 120 new_layout[i][j] = layout[w - i - 1][h - j - 1];
385 newmaze[i * RP->Ysize + j] = maze[i][j]; 121
386 } 122 layout.swap (new_layout);
387 } 123 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 } 124 }
125 break;
126
399 case 1: 127 case 1:
400 case 3: 128 case 3:
401 { 129 {
402 int swap; 130 Layout new_layout (h, w);
403 new_maze = (char **) calloc (sizeof (char *), RP->Ysize); 131
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 */ 132 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++) 133 for (int i = 0; i < w; i++)
422 free (maze[i]); 134 for (int j = 0; j < h; j++)
423 free (maze); 135 new_layout[j][i] = layout[i][j];
424 136
425 swap = RP->Ysize; 137 if (rotation == 3) /* swap x and y */
426 RP->Ysize = RP->Xsize; 138 for (int i = 0; i < w; i++)
427 RP->Xsize = swap; 139 for (int j = 0; j < h; j++)
428 return new_maze; 140 new_layout[j][i] = layout[w - i - 1][h - j - 1];
429 break; 141
142 layout.swap (new_layout);
143 new_layout.free ();
430 } 144 }
431 } 145 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 } 146 }
468} 147}
469 148
470/* 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
471 (or vertical, dir == 1) 150 (or vertical, dir == 1)
472 here which ends up on other walls sensibly. */ 151 here which ends up on other walls sensibly. */
473 152static int
474int
475can_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)
476{ 154{
477 int i1; 155 int i1;
478 int length = 0; 156 int length = 0;
479 157
480 /* dont make walls if we're on the edge. */ 158 /* dont make walls if we're on the edge. */
… …
543 return -1; /* can't make verti. wall here */ 221 return -1; /* can't make verti. wall here */
544 if (maze[x][i1] != 0) 222 if (maze[x][i1] != 0)
545 return -1; /* can't make horiz. wall here */ 223 return -1; /* can't make horiz. wall here */
546 length++; 224 length++;
547 } 225 }
226
548 return length; 227 return length;
549 } 228 }
229
550 return -1; 230 return -1;
551} 231}
552 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}
553 271
554int 272int
555make_wall (char **maze, int x, int y, int dir) 273make_wall (char **maze, int x, int y, int dir)
556{ 274{
557 maze[x][y] = 'D'; /* mark a door */ 275 maze[x][y] = 'D'; /* mark a door */
558 switch (dir) 276 switch (dir)
559 { 277 {
560 case 0: /* horizontal */ 278 case 0: /* horizontal */
561 { 279 {
562 int i1; 280 int i1;
563 281
564 for (i1 = x - 1; maze[i1][y] == 0; i1--) 282 for (i1 = x - 1; maze[i1][y] == 0; i1--)
565 maze[i1][y] = '#'; 283 maze[i1][y] = '#';
566 for (i1 = x + 1; maze[i1][y] == 0; i1++) 284 for (i1 = x + 1; maze[i1][y] == 0; i1++)
567 maze[i1][y] = '#'; 285 maze[i1][y] = '#';
568 break; 286 break;
569 } 287 }
570 case 1: /* vertical */ 288 case 1: /* vertical */
571 { 289 {
572 int i1; 290 int i1;
573 291
574 for (i1 = y - 1; maze[x][i1] == 0; i1--) 292 for (i1 = y - 1; maze[x][i1] == 0; i1--)
575 maze[x][i1] = '#'; 293 maze[x][i1] = '#';
576 for (i1 = y + 1; maze[x][i1] == 0; i1++) 294 for (i1 = y + 1; maze[x][i1] == 0; i1++)
577 maze[x][i1] = '#'; 295 maze[x][i1] = '#';
578 break; 296 break;
579 } 297 }
580 } 298 }
581 299
582 return 0; 300 return 0;
583} 301}
584 302
585/* puts doors at appropriate locations in a layout. */ 303/* puts doors at appropriate locations in a layout. */
586 304static void
587void
588doorify_layout (char **maze, RMParms * RP) 305doorify_layout (char **maze, random_map_params *RP)
589{ 306{
590 int ndoors = RP->Xsize * RP->Ysize / 60; /* reasonable number of doors. */ 307 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 */ 308 int doorlocs = 0; /* # of available doorlocations */
594 int i, j;
595 309
596 doorlist_x = (char *) malloc (sizeof (int) * RP->Xsize * RP->Ysize); 310 uint16 *doorlist_x = salloc<uint16> (RP->Xsize * RP->Ysize);
597 doorlist_y = (char *) malloc (sizeof (int) * RP->Xsize * RP->Ysize); 311 uint16 *doorlist_y = salloc<uint16> (RP->Xsize * RP->Ysize);
598
599 312
600 /* make a list of possible door locations */ 313 /* make a list of possible door locations */
601 for (i = 1; i < RP->Xsize - 1; i++) 314 for (int i = 1; i < RP->Xsize - 1; i++)
602 for (j = 1; j < RP->Ysize - 1; j++) 315 for (int j = 1; j < RP->Ysize - 1; j++)
603 { 316 {
604 int sindex = surround_flag (maze, i, j, RP); 317 int sindex = surround_flag (maze, i, j, RP);
605 318
606 if (sindex == 3 || sindex == 12) /* these are possible door sindex */ 319 if (sindex == 3 || sindex == 12) /* these are possible door sindex */
607 { 320 {
608 doorlist_x[doorlocs] = i; 321 doorlist_x[doorlocs] = i;
609 doorlist_y[doorlocs] = j; 322 doorlist_y[doorlocs] = j;
610 doorlocs++; 323 doorlocs++;
611 } 324 }
612 } 325 }
326
613 while (ndoors > 0 && doorlocs > 0) 327 while (ndoors > 0 && doorlocs > 0)
614 { 328 {
615 int di; 329 int di = rmg_rndm (doorlocs);
616 int sindex;
617
618 di = RANDOM () % doorlocs;
619 i = doorlist_x[di]; 330 int i = doorlist_x[di];
620 j = doorlist_y[di]; 331 int j = doorlist_y[di];
621 sindex = surround_flag (maze, i, j, RP); 332 int sindex = surround_flag (maze, i, j, RP);
333
622 if (sindex == 3 || sindex == 12) /* these are possible door sindex */ 334 if (sindex == 3 || sindex == 12) /* these are possible door sindex */
623 { 335 {
624 maze[i][j] = 'D'; 336 maze[i][j] = 'D';
625 ndoors--; 337 ndoors--;
626 } 338 }
339
627 /* reduce the size of the list */ 340 /* reduce the size of the list */
628 doorlocs--; 341 doorlocs--;
629 doorlist_x[di] = doorlist_x[doorlocs]; 342 doorlist_x[di] = doorlist_x[doorlocs];
630 doorlist_y[di] = doorlist_y[doorlocs]; 343 doorlist_y[di] = doorlist_y[doorlocs];
631 } 344 }
632 free (doorlist_x);
633 free (doorlist_y);
634}
635 345
346 sfree (doorlist_x, RP->Xsize * RP->Ysize);
347 sfree (doorlist_y, RP->Xsize * RP->Ysize);
348}
636 349
637void 350void
638write_map_parameters_to_string (char *buf, RMParms * RP) 351write_map_parameters_to_string (char *buf, random_map_params *RP)
639{ 352{
640
641 char small_buf[256]; 353 char small_buf[16384];
642 354
643 sprintf (buf, "xsize %d\nysize %d\n", RP->Xsize, RP->Ysize); 355 sprintf (buf, "xsize %d\nysize %d\n", RP->xsize, RP->ysize);
644 356
645 if (RP->wallstyle[0]) 357 if (RP->wallstyle[0])
646 { 358 {
647 sprintf (small_buf, "wallstyle %s\n", RP->wallstyle); 359 sprintf (small_buf, "wallstyle %s\n", RP->wallstyle);
648 strcat (buf, small_buf); 360 strcat (buf, small_buf);
649 } 361 }
650 362
363 if (RP->miningstyle[0])
364 {
365 sprintf (small_buf, "miningstyle %s\n", RP->miningstyle);
366 strcat (buf, small_buf);
367 }
368
651 if (RP->floorstyle[0]) 369 if (RP->floorstyle[0])
652 { 370 {
653 sprintf (small_buf, "floorstyle %s\n", RP->floorstyle); 371 sprintf (small_buf, "floorstyle %s\n", RP->floorstyle);
654 strcat (buf, small_buf); 372 strcat (buf, small_buf);
655 } 373 }
… …
688 { 406 {
689 sprintf (small_buf, "exitstyle %s\n", RP->exitstyle); 407 sprintf (small_buf, "exitstyle %s\n", RP->exitstyle);
690 strcat (buf, small_buf); 408 strcat (buf, small_buf);
691 } 409 }
692 410
693 if (RP->final_map[0]) 411 if (RP->final_map.length ())
694 { 412 {
695 sprintf (small_buf, "final_map %s\n", RP->final_map); 413 sprintf (small_buf, "final_map %s\n", &RP->final_map);
696 strcat (buf, small_buf); 414 strcat (buf, small_buf);
697 } 415 }
698 416
699 if (RP->exit_on_final_map[0]) 417 if (RP->exit_on_final_map[0])
700 { 418 {
701 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);
702 strcat (buf, small_buf); 420 strcat (buf, small_buf);
703 } 421 }
704 422
705 if (RP->this_map[0]) 423 if (RP->this_map.length ())
706 { 424 {
707 sprintf (small_buf, "origin_map %s\n", RP->this_map); 425 sprintf (small_buf, "origin_map %s\n", &RP->this_map);
708 strcat (buf, small_buf); 426 strcat (buf, small_buf);
709 } 427 }
710 428
711 if (RP->expand2x) 429 if (RP->expand2x)
712 { 430 {
… …
718 { 436 {
719 sprintf (small_buf, "layoutoptions1 %d\n", RP->layoutoptions1); 437 sprintf (small_buf, "layoutoptions1 %d\n", RP->layoutoptions1);
720 strcat (buf, small_buf); 438 strcat (buf, small_buf);
721 } 439 }
722 440
723
724 if (RP->layoutoptions2) 441 if (RP->layoutoptions2)
725 { 442 {
726 sprintf (small_buf, "layoutoptions2 %d\n", RP->layoutoptions2); 443 sprintf (small_buf, "layoutoptions2 %d\n", RP->layoutoptions2);
727 strcat (buf, small_buf); 444 strcat (buf, small_buf);
728 } 445 }
729 446
730
731 if (RP->layoutoptions3) 447 if (RP->layoutoptions3)
732 { 448 {
733 sprintf (small_buf, "layoutoptions3 %d\n", RP->layoutoptions3); 449 sprintf (small_buf, "layoutoptions3 %d\n", RP->layoutoptions3);
734 strcat (buf, small_buf); 450 strcat (buf, small_buf);
735 } 451 }
… …
738 { 454 {
739 sprintf (small_buf, "symmetry %d\n", RP->symmetry); 455 sprintf (small_buf, "symmetry %d\n", RP->symmetry);
740 strcat (buf, small_buf); 456 strcat (buf, small_buf);
741 } 457 }
742 458
743
744 if (RP->difficulty && RP->difficulty_given) 459 if (RP->difficulty && RP->difficulty_given)
745 { 460 {
746 sprintf (small_buf, "difficulty %d\n", RP->difficulty); 461 sprintf (small_buf, "difficulty %d\n", RP->difficulty);
747 strcat (buf, small_buf); 462 strcat (buf, small_buf);
748 } 463 }
749 464
750 if (RP->difficulty_increase != 1.0) 465 if (fabs (RP->difficulty_increase - 1.f) >= (1.f / 1024.f))
751 { 466 {
752 sprintf (small_buf, "difficulty_increase %f\n", RP->difficulty_increase); 467 sprintf (small_buf, "difficulty_increase %f\n", RP->difficulty_increase);
753 strcat (buf, small_buf); 468 strcat (buf, small_buf);
754 } 469 }
755 470
… …
783 if (RP->origin_y) 498 if (RP->origin_y)
784 { 499 {
785 sprintf (small_buf, "origin_y %d\n", RP->origin_y); 500 sprintf (small_buf, "origin_y %d\n", RP->origin_y);
786 strcat (buf, small_buf); 501 strcat (buf, small_buf);
787 } 502 }
503
504 if (RP->treasureoptions)
505 {
506 sprintf (small_buf, "treasureoptions %d\n", RP->treasureoptions);
507 strcat (buf, small_buf);
508 }
509
788 if (RP->random_seed) 510 if (RP->random_seed)
789 { 511 {
790 /* Add one so that the next map is a bit different */
791 sprintf (small_buf, "random_seed %d\n", RP->random_seed + 1); 512 sprintf (small_buf, "random_seed %u\n", RP->random_seed);
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)
936 {
937 sprintf (small_buf, "difficulty_increase %f\n", difficulty_increase);
938 strcat (buf, small_buf);
939 }
940
941 sprintf (small_buf, "dungeon_level %d\n", dungeon_level_n);
942 strcat (buf, small_buf); 513 strcat (buf, small_buf);
943
944 if (dungeon_depth_n)
945 { 514 }
946 sprintf (small_buf, "dungeon_depth %d\n", dungeon_depth_n); 515
947 strcat (buf, small_buf); 516 if (RP->custom)
948 } 517 {
949 518 sprintf (small_buf, "custom %s\n", RP->custom);
950 if (decoroptions_n) 519 strcat (buf, small_buf);
951 { 520 }
952 sprintf (small_buf, "decoroptions %d\n", decoroptions_n); 521}
953 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)
954 } 564 {
565 case LAYOUT_ONION:
566 map_gen_onion (layout, RP->layoutoptions1, RP->layoutoptions2);
955 567
956 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 ();
957 { 620 }
958 sprintf (small_buf, "orientation %d\n", orientation_n); 621
959 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)
960 } 657 {
658 RP->difficulty = RP->dungeon_level; /* use this instead of a map difficulty */
961 659
962 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;
963 { 665 }
964 sprintf (small_buf, "origin_x %d\n", origin_x_n); 666 else
965 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)
966 } 687 {
967 688 RP->Xsize /= 2;
968 if (origin_y_n) 689 RP->Ysize /= 2;
969 { 690 }
970 sprintf (small_buf, "origin_y %d\n", origin_y_n); 691
971 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"))
972 } 743 {
973 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);
974 { 749 }
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 750
980 if (treasureoptions_n) 751 CEDE;
981 {
982 sprintf (small_buf, "treasureoptions %d\n", treasureoptions_n);
983 strcat (buf, small_buf);
984 }
985 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);
986 756
987} 757 CEDE;
988 758
989/* copy an object with an inventory... i.e., duplicate the inv too. */ 759 /* create monsters unless the monsterstyle is "none" */
990void 760 if (strcmp (RP->monsterstyle, "none"))
991copy_object_with_inv (object *src_ob, object *dest_ob) 761 place_monsters (this, RP->monsterstyle, RP->difficulty, RP);
992{
993 object *walk, *tmp;
994 762
995 copy_object (src_ob, dest_ob); 763 CEDE;
996 764
997 for (walk = src_ob->inv; walk != NULL; walk = walk->below) 765 /* treasures needs to have a proper difficulty set for the map. */
998 { 766 difficulty = estimate_difficulty ();
999 tmp = get_object (); 767
1000 copy_object (walk, tmp); 768 CEDE;
1001 insert_ob_in_ob (tmp, dest_ob); 769
1002 } 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;
1003} 794}
795

Diff Legend

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