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

Diff Legend

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