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.30 by root, Sun Jul 1 05:00:19 2007 UTC vs.
Revision 1.47 by root, Fri Mar 26 01:04:44 2010 UTC

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

Diff Legend

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