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

Diff Legend

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