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.51 by root, Sat Jun 26 22:10:18 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
37const_utf8_string
38random_map_params::get_str (const_utf8_string option, const_utf8_string fallback) const
39{
40 SV **he = hv_fetch (hv, option, strlen (option), 0);
41
42 return he ? cfSvPVutf8_nolen (*he) : fallback;
43}
44
45IV
46random_map_params::get_iv (const char *option, IV fallback) const
47{
48 SV **he = hv_fetch (hv, option, strlen (option), 0);
49
50 return he ? SvIV (*he) : fallback;
51}
52
53random_map_params::~random_map_params ()
54{
55 SvREFCNT_dec (hv);
56}
57
39void 58void
40dump_layout (char **layout, RMParms * RP) 59dump_layout (Layout layout)
41{ 60{
42 { 61 for (int j = 0; j < layout->h; j++)
43 int i, j;
44
45 for (i = 0; i < RP->Xsize; i++)
46 { 62 {
47 for (j = 0; j < RP->Ysize; j++) 63 for (int i = 0; i < layout->w; i++)
48 { 64 putc (layout[i][j] ? layout[i][j] : ' ', stdout);
49 if (layout[i][j] == 0) 65
50 layout[i][j] = ' '; 66 putc ('\n', stdout);
51 printf ("%c", layout[i][j]);
52 if (layout[i][j] == ' ')
53 layout[i][j] = 0;
54 }
55 printf ("\n");
56 } 67 }
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 68
68 /* pick a random seed, or use the one from the input file */ 69 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} 70}
172 71
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 72/* takes a map and makes it symmetric: adjusts Xsize and
302Ysize to produce a symmetric map. */ 73 * Ysize to produce a symmetric map.
303 74 */
304char ** 75static void
305symmetrize_layout (char **maze, int sym, RMParms * RP) 76symmetrize_layout (Layout layout, random_map_params *RP)
306{ 77{
307 int i, j; 78 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; 79 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 80
324 sym_maze = (char **) calloc (sizeof (char *), RP->Xsize); 81 Layout sym_layout (
325 for (i = 0; i < RP->Xsize; i++) 82 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); 83 RP->symmetry_used == SYMMETRY_Y || RP->symmetry_used == SYMMETRY_XY ? layout->h * 2 - 3 : layout->h
84 );
327 85
328 if (sym == X_SYM) 86 if (RP->symmetry_used == SYMMETRY_X)
329 for (i = 0; i < RP->Xsize / 2 + 1; i++) 87 for (int i = 0; i < sym_layout->w / 2 + 1; i++)
330 for (j = 0; j < RP->Ysize; j++) 88 for (int j = 0; j < sym_layout->h; j++)
331 { 89 {
332 sym_maze[i][j] = maze[i][j]; 90 sym_layout[i ][j] =
333 sym_maze[RP->Xsize - i - 1][j] = maze[i][j]; 91 sym_layout[sym_layout->w - i - 1][j] = layout[i][j];
334 }; 92 }
335 if (sym == Y_SYM) 93
336 for (i = 0; i < RP->Xsize; i++) 94 if (RP->symmetry_used == SYMMETRY_Y)
95 for (int i = 0; i < sym_layout->w; i++)
337 for (j = 0; j < RP->Ysize / 2 + 1; j++) 96 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 } 97 {
342 if (sym == XY_SYM) 98 sym_layout[i][j ] =
343 for (i = 0; i < RP->Xsize / 2 + 1; i++) 99 sym_layout[i][sym_layout->h - j - 1] = layout[i][j];
344 for (j = 0; j < RP->Ysize / 2 + 1; j++)
345 { 100 }
346 sym_maze[i][j] = maze[i][j]; 101
347 sym_maze[i][RP->Ysize - j - 1] = maze[i][j]; 102 if (RP->symmetry_used == SYMMETRY_XY)
348 sym_maze[RP->Xsize - i - 1][j] = maze[i][j]; 103 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]; 104 for (int j = 0; j < sym_layout->h / 2 + 1; j++)
350 } 105 {
351 /* delete the old maze */ 106 sym_layout[i ][j ] =
352 for (i = 0; i < Xsize_orig; i++) 107 sym_layout[i ][sym_layout->h - j - 1] =
353 free (maze[i]); 108 sym_layout[sym_layout->w - i - 1][j ] =
354 free (maze); 109 sym_layout[sym_layout->w - i - 1][sym_layout->h - j - 1] = layout[i][j];
110 }
111
112 layout.swap (sym_layout);
113 sym_layout.free ();
114
355 /* reconnect disjointed spirals */ 115 /* 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 116 /* reconnect disjointed nethacklayouts: the routine for
359 spirals will do the trick? */ 117 spirals will do the trick? */
360 if (RP->map_layout_style == ROGUELIKE_LAYOUT) 118 if (RP->map_layout_style == LAYOUT_SPIRAL
361 connect_spirals (RP->Xsize, RP->Ysize, sym, sym_maze); 119 || RP->map_layout_style == LAYOUT_ROGUELIKE)
362 120 connect_spirals (layout->w, layout->h, RP->symmetry_used, layout);
363 return sym_maze;
364} 121}
365
366 122
367/* takes a map and rotates it. This completes the 123/* takes a map and rotates it. This completes the
368 onion layouts, making them possibly centered on any wall. 124 onion layouts, making them possibly centered on any wall.
369 It'll modify Xsize and Ysize if they're swapped. 125 It'll modify Xsize and Ysize if they're swapped.
370*/ 126*/
371 127static void
372char ** 128rotate_layout (Layout layout, int rotation)
373rotate_layout (char **maze, int rotation, RMParms * RP)
374{ 129{
375 char **new_maze; 130 int w = layout->w;
376 int i, j; 131 int h = layout->h;
377 132
378 switch (rotation) 133 switch (rotation)
379 { 134 {
380 case 0:
381 return maze;
382 break;
383 case 2: /* a reflection */ 135 case 2: /* a reflection */
384 { 136 {
385 char *newmaze = (char *) malloc (sizeof (char) * RP->Xsize * RP->Ysize); 137 Layout new_layout (w, h);
386 138
387 for (i = 0; i < RP->Xsize; i++) 139 for (int i = 0; i < w; i++) /* copy a reflection back */
388 { /* make a copy */
389 for (j = 0; j < RP->Ysize; j++) 140 for (int j = 0; j < h; j++)
390 { 141 new_layout[i][j] = layout[w - i - 1][h - j - 1];
391 newmaze[i * RP->Ysize + j] = maze[i][j]; 142
392 } 143 layout.swap (new_layout);
393 } 144 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 } 145 }
146 break;
147
405 case 1: 148 case 1:
406 case 3: 149 case 3:
407 { 150 {
408 int swap; 151 Layout new_layout (h, w);
409 new_maze = (char **) calloc (sizeof (char *), RP->Ysize); 152
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 */ 153 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++) 154 for (int i = 0; i < w; i++)
428 free (maze[i]); 155 for (int j = 0; j < h; j++)
429 free (maze); 156 new_layout[j][i] = layout[i][j];
430 157
431 swap = RP->Ysize; 158 if (rotation == 3) /* swap x and y */
432 RP->Ysize = RP->Xsize; 159 for (int i = 0; i < w; i++)
433 RP->Xsize = swap; 160 for (int j = 0; j < h; j++)
434 return new_maze; 161 new_layout[j][i] = layout[w - i - 1][h - j - 1];
435 break; 162
163 layout.swap (new_layout);
164 new_layout.free ();
436 } 165 }
437 } 166 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 } 167 }
474} 168}
475 169
476/* checks the layout to see if I can stick a horizontal(dir = 0) wall 170/* checks the layout to see if I can stick a horizontal(dir = 0) wall
477 (or vertical, dir == 1) 171 (or vertical, dir == 1)
478 here which ends up on other walls sensibly. */ 172 here which ends up on other walls sensibly. */
479 173static int
480int
481can_make_wall (char **maze, int dx, int dy, int dir, RMParms * RP) 174can_make_wall (char **maze, int dx, int dy, int dir, random_map_params *RP)
482{ 175{
483 int i1; 176 int i1;
484 int length = 0; 177 int length = 0;
485 178
486 /* dont make walls if we're on the edge. */ 179 /* dont make walls if we're on the edge. */
… …
549 return -1; /* can't make verti. wall here */ 242 return -1; /* can't make verti. wall here */
550 if (maze[x][i1] != 0) 243 if (maze[x][i1] != 0)
551 return -1; /* can't make horiz. wall here */ 244 return -1; /* can't make horiz. wall here */
552 length++; 245 length++;
553 } 246 }
247
554 return length; 248 return length;
555 } 249 }
250
556 return -1; 251 return -1;
557} 252}
558 253
254/* take a layout and make some rooms in it.
255 --works best on onions.*/
256static void
257roomify_layout (char **maze, random_map_params *RP)
258{
259 int tries = RP->Xsize * RP->Ysize / 30;
260
261 for (int ti = 0; ti < tries; ti++)
262 {
263 /* starting location for looking at creating a door */
264 int dx = rmg_rndm (RP->Xsize);
265 int dy = rmg_rndm (RP->Ysize);
266
267 /* results of checking on creating walls. */
268 int cx = can_make_wall (maze, dx, dy, 0, RP); /* horizontal */
269 int cy = can_make_wall (maze, dx, dy, 1, RP); /* vertical */
270
271 if (cx == -1)
272 {
273 if (cy != -1)
274 make_wall (maze, dx, dy, 1);
275
276 continue;
277 }
278
279 if (cy == -1)
280 {
281 make_wall (maze, dx, dy, 0);
282 continue;
283 }
284
285 if (cx < cy)
286 make_wall (maze, dx, dy, 0);
287 else
288 make_wall (maze, dx, dy, 1);
289 }
290}
559 291
560int 292int
561make_wall (char **maze, int x, int y, int dir) 293make_wall (char **maze, int x, int y, int dir)
562{ 294{
563 maze[x][y] = 'D'; /* mark a door */ 295 maze[x][y] = 'D'; /* mark a door */
296
564 switch (dir) 297 switch (dir)
565 { 298 {
566 case 0: /* horizontal */ 299 case 0: /* horizontal */
567 { 300 {
568 int i1;
569
570 for (i1 = x - 1; maze[i1][y] == 0; i1--) 301 for (int i1 = x - 1; maze[i1][y] == 0; --i1) maze[i1][y] = '#';
571 maze[i1][y] = '#';
572 for (i1 = x + 1; maze[i1][y] == 0; i1++) 302 for (int i1 = x + 1; maze[i1][y] == 0; ++i1) maze[i1][y] = '#';
573 maze[i1][y] = '#';
574 break; 303 break;
575 } 304 }
576 case 1: /* vertical */ 305 case 1: /* vertical */
577 { 306 {
578 int i1;
579
580 for (i1 = y - 1; maze[x][i1] == 0; i1--) 307 for (int i1 = y - 1; maze[x][i1] == 0; --i1) maze[x][i1] = '#';
581 maze[x][i1] = '#';
582 for (i1 = y + 1; maze[x][i1] == 0; i1++) 308 for (int i1 = y + 1; maze[x][i1] == 0; ++i1) maze[x][i1] = '#';
583 maze[x][i1] = '#';
584 break; 309 break;
585 } 310 }
586 } 311 }
587 312
588 return 0; 313 return 0;
589} 314}
590 315
591/* puts doors at appropriate locations in a layout. */ 316/* puts doors at appropriate locations in a layout. */
592 317static void
593void
594doorify_layout (char **maze, RMParms * RP) 318doorify_layout (char **maze, random_map_params *RP)
595{ 319{
596 int ndoors = RP->Xsize * RP->Ysize / 60; /* reasonable number of doors. */ 320 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 */ 321 int doorlocs = 0; /* # of available doorlocations */
600 int i, j;
601 322
602 doorlist_x = (char *) malloc (sizeof (int) * RP->Xsize * RP->Ysize); 323 uint16 *doorlist_x = salloc<uint16> (RP->Xsize * RP->Ysize);
603 doorlist_y = (char *) malloc (sizeof (int) * RP->Xsize * RP->Ysize); 324 uint16 *doorlist_y = salloc<uint16> (RP->Xsize * RP->Ysize);
604
605 325
606 /* make a list of possible door locations */ 326 /* make a list of possible door locations */
607 for (i = 1; i < RP->Xsize - 1; i++) 327 for (int i = 1; i < RP->Xsize - 1; i++)
608 for (j = 1; j < RP->Ysize - 1; j++) 328 for (int j = 1; j < RP->Ysize - 1; j++)
609 { 329 {
610 int sindex = surround_flag (maze, i, j, RP); 330 int sindex = surround_flag (maze, i, j, RP);
611 331
612 if (sindex == 3 || sindex == 12) /* these are possible door sindex */ 332 if (sindex == 3 || sindex == 12) /* these are possible door sindex */
613 { 333 {
614 doorlist_x[doorlocs] = i; 334 doorlist_x[doorlocs] = i;
615 doorlist_y[doorlocs] = j; 335 doorlist_y[doorlocs] = j;
616 doorlocs++; 336 doorlocs++;
617 } 337 }
618 } 338 }
339
619 while (ndoors > 0 && doorlocs > 0) 340 while (ndoors > 0 && doorlocs > 0)
620 { 341 {
621 int di; 342 int di = rmg_rndm (doorlocs);
622 int sindex;
623
624 di = RANDOM () % doorlocs;
625 i = doorlist_x[di]; 343 int i = doorlist_x[di];
626 j = doorlist_y[di]; 344 int j = doorlist_y[di];
627 sindex = surround_flag (maze, i, j, RP); 345 int sindex = surround_flag (maze, i, j, RP);
346
628 if (sindex == 3 || sindex == 12) /* these are possible door sindex */ 347 if (sindex == 3 || sindex == 12) /* these are possible door sindex */
629 { 348 {
630 maze[i][j] = 'D'; 349 maze[i][j] = 'D';
631 ndoors--; 350 ndoors--;
632 } 351 }
352
633 /* reduce the size of the list */ 353 /* reduce the size of the list */
634 doorlocs--; 354 doorlocs--;
635 doorlist_x[di] = doorlist_x[doorlocs]; 355 doorlist_x[di] = doorlist_x[doorlocs];
636 doorlist_y[di] = doorlist_y[doorlocs]; 356 doorlist_y[di] = doorlist_y[doorlocs];
637 } 357 }
638 free (doorlist_x);
639 free (doorlist_y);
640}
641 358
359 sfree (doorlist_x, RP->Xsize * RP->Ysize);
360 sfree (doorlist_y, RP->Xsize * RP->Ysize);
361}
642 362
643void 363void
644write_map_parameters_to_string (char *buf, RMParms * RP) 364write_map_parameters_to_string (dynbuf_text &buf, random_map_params *RP)
645{ 365{
366 hv_iterinit (RP->hv);
646 367
647 char small_buf[256]; 368 while (HE *he = hv_iternext (RP->hv))
369 buf << HePV (he, PL_na) << ' ' << cfSvPVutf8_nolen (HeVAL (he)) << '\n';
648 370
649 sprintf (buf, "xsize %d\nysize %d\n", RP->Xsize, RP->Ysize); 371 buf.printf ("xsize %d\nysize %d\n", RP->xsize, RP->ysize);
650 372
651 if (RP->wallstyle[0]) 373 if (RP->monsterstyle[0] ) buf.printf ("monsterstyle %s\n", RP->monsterstyle);
652 { 374 if (RP->treasurestyle[0] ) buf.printf ("treasurestyle %s\n", RP->treasurestyle);
653 sprintf (small_buf, "wallstyle %s\n", RP->wallstyle); 375 if (RP->layoutstyle[0] ) buf.printf ("layoutstyle %s\n", RP->layoutstyle);
654 strcat (buf, small_buf); 376 if (RP->decorstyle[0] ) buf.printf ("decorstyle %s\n", RP->decorstyle);
377 if (RP->doorstyle[0] ) buf.printf ("doorstyle %s\n", RP->doorstyle);
378 if (RP->final_map.length () ) buf.printf ("final_map %s\n", &RP->final_map);
379 if (RP->exit_on_final_map[0]) buf.printf ("exit_on_final_map %s\n", RP->exit_on_final_map);
380 if (RP->this_map.length () ) buf.printf ("origin_map %s\n", &RP->this_map);
381 if (RP->expand2x ) buf.printf ("expand2x %d\n", RP->expand2x);
382 if (RP->layoutoptions1 ) buf.printf ("layoutoptions1 %d\n", RP->layoutoptions1);
383 if (RP->layoutoptions2 ) buf.printf ("layoutoptions2 %d\n", RP->layoutoptions2);
384 if (RP->layoutoptions3 ) buf.printf ("layoutoptions3 %d\n", RP->layoutoptions3);
385 if (RP->symmetry ) buf.printf ("symmetry %d\n", RP->symmetry);
386
387 if (RP->difficulty && RP->difficulty_given)
388 buf.printf ("difficulty %d\n", RP->difficulty);
389
390 if (fabs (RP->difficulty_increase - 1.f) >= (1.f / 1024.f))
391 buf.printf ("difficulty_increase %f\n", RP->difficulty_increase);
392
393 buf.printf ("dungeon_level %d\n", RP->dungeon_level);
394
395 if (RP->dungeon_depth ) buf.printf ("dungeon_depth %d\n", RP->dungeon_depth);
396 if (RP->decoroptions ) buf.printf ("decoroptions %d\n", RP->decoroptions);
397 if (RP->orientation ) buf.printf ("orientation %d\n", RP->orientation);
398 if (RP->origin_x ) buf.printf ("origin_x %d\n", RP->origin_x);
399 if (RP->origin_y ) buf.printf ("origin_y %d\n", RP->origin_y);
400 if (RP->treasureoptions ) buf.printf ("treasureoptions %d\n", RP->treasureoptions);
401 if (RP->random_seed ) buf.printf ("random_seed %u\n", RP->random_seed);
402}
403
404/////////////////////////////////////////////////////////////////////////////
405
406LayoutData::LayoutData (int w, int h)
407: w(w), h(h)
408{
409 int size = (sizeof (char *) + sizeof (char) * h) * w;
410
411 col = (char **)salloc<char> (size);
412
413 char *data = (char *)(col + w);
414
415 for (int x = w; x--; )
416 col [x] = data + x * h;
417}
418
419LayoutData::~LayoutData ()
420{
421 int size = (sizeof (char *) + sizeof (char) * h) * w;
422
423 sfree ((char *)col, size);
424}
425
426void LayoutData::clear (char fill)
427{
428 memset (col [0], fill, w * h);
429}
430
431void LayoutData::border (char fill)
432{
433 for (int i = 0; i < w; i++) col [i][0] = col [i][h - 1] = fill;
434 for (int j = 0; j < h; j++) col [0][j] = col [w - 1][j] = fill;
435}
436
437/* function selects the layout function and gives it whatever
438 arguments it needs. */
439static Layout
440layoutgen (random_map_params *RP)
441{
442 Layout layout (RP);
443
444 switch (RP->map_layout_style)
655 } 445 {
446 case LAYOUT_ONION:
447 map_gen_onion (layout, RP->layoutoptions1, RP->layoutoptions2);
656 448
657 if (RP->floorstyle[0]) 449 if (!(rmg_rndm (3)) && !(RP->layoutoptions1 & (RMOPT_WALLS_ONLY | RMOPT_WALL_OFF)))
450 roomify_layout (layout, RP);
451
452 break;
453
454 case LAYOUT_MAZE:
455 maze_gen (layout, rmg_rndm (2));
456
457 if (!(rmg_rndm (2)))
458 doorify_layout (layout, RP);
459
460 break;
461
462 case LAYOUT_SPIRAL:
463 map_gen_spiral (layout, RP->layoutoptions1);
464
465 if (!(rmg_rndm (2)))
466 doorify_layout (layout, RP);
467
468 break;
469
470 case LAYOUT_ROGUELIKE:
471 /* Don't put symmetry in rogue maps. There isn't much reason to
472 * do so in the first place (doesn't make it any more interesting),
473 * but more importantly, the symmetry code presumes we are symmetrizing
474 * spirals, or maps with lots of passages - making a symmetric rogue
475 * map fails because its likely that the passages the symmetry process
476 * creates may not connect the rooms.
477 */
478 RP->symmetry_used = SYMMETRY_NONE;
479 roguelike_layout_gen (layout, RP->layoutoptions1);
480 /* no doorifying... done already */
481 break;
482
483 case LAYOUT_SNAKE:
484 make_snake_layout (layout, RP->layoutoptions1);
485
486 if (rmg_rndm (2))
487 roomify_layout (layout, RP);
488
489 break;
490
491 case LAYOUT_SQUARE_SPIRAL:
492 make_square_spiral_layout (layout, RP->layoutoptions1);
493
494 if (rmg_rndm (2))
495 roomify_layout (layout, RP);
496
497 break;
498
499 default:
500 abort ();
658 { 501 }
659 sprintf (small_buf, "floorstyle %s\n", RP->floorstyle);
660 strcat (buf, small_buf);
661 }
662 502
663 if (RP->monsterstyle[0]) 503 /* rotate the layout randomly */
664 { 504 rotate_layout (layout, rmg_rndm (4));
665 sprintf (small_buf, "monsterstyle %s\n", RP->monsterstyle);
666 strcat (buf, small_buf);
667 }
668 505
669 if (RP->treasurestyle[0]) 506 symmetrize_layout (layout, RP);
670 {
671 sprintf (small_buf, "treasurestyle %s\n", RP->treasurestyle);
672 strcat (buf, small_buf);
673 }
674 507
675 if (RP->layoutstyle[0]) 508#ifdef RMAP_DEBUG
676 { 509 dump_layout (layout);
677 sprintf (small_buf, "layoutstyle %s\n", RP->layoutstyle); 510#endif
678 strcat (buf, small_buf);
679 }
680
681 if (RP->decorstyle[0])
682 {
683 sprintf (small_buf, "decorstyle %s\n", RP->decorstyle);
684 strcat (buf, small_buf);
685 }
686
687 if (RP->doorstyle[0])
688 {
689 sprintf (small_buf, "doorstyle %s\n", RP->doorstyle);
690 strcat (buf, small_buf);
691 }
692
693 if (RP->exitstyle[0])
694 {
695 sprintf (small_buf, "exitstyle %s\n", RP->exitstyle);
696 strcat (buf, small_buf);
697 }
698
699 if (RP->final_map[0])
700 {
701 sprintf (small_buf, "final_map %s\n", RP->final_map);
702 strcat (buf, small_buf);
703 }
704
705 if (RP->exit_on_final_map[0])
706 {
707 sprintf (small_buf, "exit_on_final_map %s\n", RP->exit_on_final_map);
708 strcat (buf, small_buf);
709 }
710
711 if (RP->this_map[0])
712 {
713 sprintf (small_buf, "origin_map %s\n", RP->this_map);
714 strcat (buf, small_buf);
715 }
716 511
717 if (RP->expand2x) 512 if (RP->expand2x)
718 { 513 expand2x (layout);
719 sprintf (small_buf, "expand2x %d\n", RP->expand2x); 514
720 strcat (buf, small_buf); 515 return layout;
516}
517
518bool
519maptile::generate_random_map (random_map_params *RP)
520{
521 int i;
522
523 RP->Xsize = RP->xsize;
524 RP->Ysize = RP->ysize;
525
526 /* pick a random seed, or use the one from the input file */
527 RP->random_seed = RP->random_seed
528 ? RP->random_seed + RP->dungeon_level
529 : time (0);
530
531 // we run "single-threaded"
532 rmg_rndm.seed (RP->random_seed);
533
534 dynbuf_text buf;
535 write_map_parameters_to_string (buf, RP);
536
537 if (RP->difficulty == 0)
721 } 538 {
539 RP->difficulty = RP->dungeon_level; /* use this instead of a map difficulty */
722 540
723 if (RP->layoutoptions1)
724 {
725 sprintf (small_buf, "layoutoptions1 %d\n", RP->layoutoptions1);
726 strcat (buf, small_buf);
727 }
728
729
730 if (RP->layoutoptions2)
731 {
732 sprintf (small_buf, "layoutoptions2 %d\n", RP->layoutoptions2);
733 strcat (buf, small_buf);
734 }
735
736
737 if (RP->layoutoptions3)
738 {
739 sprintf (small_buf, "layoutoptions3 %d\n", RP->layoutoptions3);
740 strcat (buf, small_buf);
741 }
742
743 if (RP->symmetry)
744 {
745 sprintf (small_buf, "symmetry %d\n", RP->symmetry);
746 strcat (buf, small_buf);
747 }
748
749
750 if (RP->difficulty && RP->difficulty_given)
751 {
752 sprintf (small_buf, "difficulty %d\n", RP->difficulty);
753 strcat (buf, small_buf);
754 }
755
756 if (RP->difficulty_increase != 1.0)
757 {
758 sprintf (small_buf, "difficulty_increase %f\n", RP->difficulty_increase);
759 strcat (buf, small_buf);
760 }
761
762 sprintf (small_buf, "dungeon_level %d\n", RP->dungeon_level);
763 strcat (buf, small_buf);
764
765 if (RP->dungeon_depth)
766 {
767 sprintf (small_buf, "dungeon_depth %d\n", RP->dungeon_depth);
768 strcat (buf, small_buf);
769 }
770
771 if (RP->decoroptions)
772 {
773 sprintf (small_buf, "decoroptions %d\n", RP->decoroptions);
774 strcat (buf, small_buf);
775 }
776
777 if (RP->orientation)
778 {
779 sprintf (small_buf, "orientation %d\n", RP->orientation);
780 strcat (buf, small_buf);
781 }
782
783 if (RP->origin_x)
784 {
785 sprintf (small_buf, "origin_x %d\n", RP->origin_x);
786 strcat (buf, small_buf);
787 }
788
789 if (RP->origin_y)
790 {
791 sprintf (small_buf, "origin_y %d\n", RP->origin_y);
792 strcat (buf, small_buf);
793 }
794 if (RP->random_seed)
795 {
796 /* Add one so that the next map is a bit different */
797 sprintf (small_buf, "random_seed %d\n", RP->random_seed + 1);
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) 541 if (RP->difficulty_increase > 0.001)
542 RP->difficulty = (int) ((float) RP->dungeon_level * RP->difficulty_increase);
543
544 if (RP->difficulty < 1)
545 RP->difficulty = 1;
942 { 546 }
943 sprintf (small_buf, "difficulty_increase %f\n", difficulty_increase); 547 else
944 strcat (buf, small_buf); 548 RP->difficulty_given = 1;
549
550 if (RP->Xsize < MIN_RANDOM_MAP_SIZE)
551 RP->Xsize = MIN_RANDOM_MAP_SIZE + rmg_rndm (25) + 5;
552
553 if (RP->Ysize < MIN_RANDOM_MAP_SIZE)
554 RP->Ysize = MIN_RANDOM_MAP_SIZE + rmg_rndm (25) + 5;
555
556 if (RP->symmetry == SYMMETRY_RANDOM)
557 RP->symmetry_used = rmg_rndm (SYMMETRY_XY) + 1;
558 else
559 RP->symmetry_used = RP->symmetry;
560
561 if (RP->symmetry_used == SYMMETRY_Y || RP->symmetry_used == SYMMETRY_XY)
562 RP->Ysize = RP->Ysize / 2 + 1;
563
564 if (RP->symmetry_used == SYMMETRY_X || RP->symmetry_used == SYMMETRY_XY)
565 RP->Xsize = RP->Xsize / 2 + 1;
566
567 if (RP->expand2x > 0)
945 } 568 {
946 569 RP->Xsize /= 2;
947 sprintf (small_buf, "dungeon_level %d\n", dungeon_level_n); 570 RP->Ysize /= 2;
948 strcat (buf, small_buf);
949
950 if (dungeon_depth_n)
951 { 571 }
952 sprintf (small_buf, "dungeon_depth %d\n", dungeon_depth_n); 572
953 strcat (buf, small_buf); 573 RP->map_layout_style = LAYOUT_NONE;
574
575 /* Redo this - there was a lot of redundant code of checking for preset
576 * layout style and then random layout style. Instead, figure out
577 * the numeric layoutstyle, so there is only one area that actually
578 * calls the code to make the maps.
579 */
580 if (strstr (RP->layoutstyle, "onion"))
581 RP->map_layout_style = LAYOUT_ONION;
582 else if (strstr (RP->layoutstyle, "maze"))
583 RP->map_layout_style = LAYOUT_MAZE;
584 else if (strstr (RP->layoutstyle, "spiral"))
585 RP->map_layout_style = LAYOUT_SPIRAL;
586 else if (strstr (RP->layoutstyle, "rogue"))
587 RP->map_layout_style = LAYOUT_ROGUELIKE;
588 else if (strstr (RP->layoutstyle, "snake"))
589 RP->map_layout_style = LAYOUT_SNAKE;
590 else if (strstr (RP->layoutstyle, "squarespiral"))
591 RP->map_layout_style = LAYOUT_SQUARE_SPIRAL;
592 else if (RP->map_layout_style == LAYOUT_NONE)
593 RP->map_layout_style = rmg_rndm (NROFLAYOUTS - 1) + 1; /* No style found - choose one randomly */
594 else
595 abort ();
596
597 Layout layout = layoutgen (RP);
598
599#ifdef RMAP_DEBUG
600 dump_layout (layout);
601#endif
602
603 /* increment these for the current map */
604 ++RP->dungeon_level;
605
606 // need to patch RP becasue following code doesn't use the Layout object
607 RP->Xsize = layout->w;
608 RP->Ysize = layout->h;
609
610 /* allocate the map and set the floor */
611 make_map_floor (layout, RP->get_str ("floorstyle", ""), RP);
612
613 /* set region */
614 default_region = RP->region;
615
616 CEDE;
617
618 place_specials_in_map (this, layout, RP);
619
620 CEDE;
621
622 const char *wallstyle = RP->get_str ("wallstyle", 0);
623
624 /* create walls unless the wallstyle is "none" */
625 if (strcmp (wallstyle, "none"))
954 } 626 {
627 make_map_walls (this, layout, wallstyle, RP->get_str ("miningstyle", ""), RP);
955 628
956 if (decoroptions_n) 629 /* place doors unless doorstyle or wallstyle is "none" */
630 if (strcmp (RP->doorstyle, "none"))
631 put_doors (this, layout, RP->doorstyle, RP);
957 { 632 }
958 sprintf (small_buf, "decoroptions %d\n", decoroptions_n);
959 strcat (buf, small_buf);
960 }
961 633
962 if (orientation_n) 634 CEDE;
963 {
964 sprintf (small_buf, "orientation %d\n", orientation_n);
965 strcat (buf, small_buf);
966 }
967 635
968 if (origin_x_n) 636 const char *exitstyle = RP->get_str ("exitstyle", "");
969 {
970 sprintf (small_buf, "origin_x %d\n", origin_x_n);
971 strcat (buf, small_buf);
972 }
973 637
974 if (origin_y_n) 638 /* create exits unless the exitstyle is "none" */
975 { 639 if (strcmp (exitstyle, "none"))
976 sprintf (small_buf, "origin_y %d\n", origin_y_n); 640 place_exits (this, layout, exitstyle, RP->orientation, RP);
977 strcat (buf, small_buf);
978 }
979 if (random_seed_n)
980 {
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 641
986 if (treasureoptions_n) 642 CEDE;
987 {
988 sprintf (small_buf, "treasureoptions %d\n", treasureoptions_n);
989 strcat (buf, small_buf);
990 }
991 643
644 /* create monsters unless the monsterstyle is "none" */
645 if (strcmp (RP->monsterstyle, "none"))
646 place_monsters (this, RP->monsterstyle, RP->difficulty, RP);
992 647
993} 648 CEDE;
994 649
995/* copy an object with an inventory... i.e., duplicate the inv too. */ 650 /* treasures needs to have a proper difficulty set for the map. */
996void 651 difficulty = estimate_difficulty ();
997copy_object_with_inv (object *src_ob, object *dest_ob)
998{
999 object *walk, *tmp;
1000 652
1001 copy_object (src_ob, dest_ob); 653 CEDE;
1002 654
1003 for (walk = src_ob->inv; walk != NULL; walk = walk->below) 655 /* create treasure unless the treasurestyle is "none" */
1004 { 656 place_treasure (this, layout, RP->treasurestyle, RP->treasureoptions, RP);
1005 tmp = get_object (); 657
1006 copy_object (walk, tmp); 658 CEDE;
1007 insert_ob_in_ob (tmp, dest_ob); 659
1008 } 660 /* create decor unless the decorstyle is "none" */
661 if (strcmp (RP->decorstyle, "none"))
662 put_decor (this, layout, RP->decorstyle, RP->decoroptions, RP);
663
664 CEDE;
665
666 /* generate treasures, etc. */
667 fix_auto_apply ();
668
669 CEDE;
670
671 unblock_exits (this, layout, RP);
672
673 msg = buf;
674 in_memory = MAP_ACTIVE;
675
676 CEDE;
677
678 return 1;
1009} 679}
680

Diff Legend

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