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.11 by root, Sat Dec 30 18:45:28 2006 UTC vs.
Revision 1.27 by root, Sat Jan 27 02:19:37 2007 UTC

1/* 1/*
2 CrossFire, A Multiplayer game for X-windows 2 * CrossFire, A Multiplayer game for X-windows
3 3 *
4 * Copyright (C) 2005, 2006, 2007 Marc Lehmann & Crossfire+ Development Team
4 Copyright (C) 2001 Mark Wedel & Crossfire Development Team 5 * Copyright (C) 2001 Mark Wedel & Crossfire Development Team
5 Copyright (C) 1992 Frank Tore Johansen 6 * Copyright (C) 1992 Frank Tore Johansen
6 7 *
7 This program is free software; you can redistribute it and/or modify 8 * This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by 9 * it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or 10 * the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version. 11 * (at your option) any later version.
11 12 *
12 This program is distributed in the hope that it will be useful, 13 * This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of 14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details. 16 * GNU General Public License for more details.
16 17 *
17 You should have received a copy of the GNU General Public License 18 * You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software 19 * along with this program; if not, write to the Free Software
19 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 20 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
20 21 *
21 The authors can be reached via e-mail at <crossfire@schmorp.de> 22 * The authors can be reached via e-mail at <crossfire@schmorp.de>
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 <maze_gen.h>
28#include <room_gen.h> 29#include <room_gen.h>
29#include <random_map.h> 30#include <random_map.h>
30#include <rproto.h> 31#include <rproto.h>
31#include <sproto.h> 32#include <sproto.h>
32 33
34#define CEDE coroapi::cede (); rndm.seed (RP->random_seed + __LINE__);
35
33void 36void
34dump_layout (char **layout, random_map_params * RP) 37dump_layout (char **layout, random_map_params *RP)
35{ 38{
36 { 39 {
37 int i, j; 40 int i, j;
38 41
39 for (i = 0; i < RP->Xsize; i++) 42 for (i = 0; i < RP->Xsize; i++)
… …
50 } 53 }
51 } 54 }
52 printf ("\n"); 55 printf ("\n");
53} 56}
54 57
55extern FILE *logfile; 58bool
56 59maptile::generate_random_map (random_map_params *RP)
57maptile *
58generate_random_map (const char *OutFileName, random_map_params * RP)
59{ 60{
60 char **layout, buf[HUGE_BUF]; 61 char **layout, buf[16384];
61 maptile *theMap;
62 int i; 62 int i;
63 63
64 RP->Xsize = RP->xsize;
65 RP->Ysize = RP->ysize;
66
64 /* pick a random seed, or use the one from the input file */ 67 /* pick a random seed, or use the one from the input file */
65 if (RP->random_seed == 0) 68 RP->random_seed = RP->random_seed
66 RP->random_seed = time (0); 69 ? RP->random_seed + RP->dungeon_level
67 70 : time (0);
68 SRANDOM (RP->random_seed); 71 CEDE;
69 72
70 write_map_parameters_to_string (buf, RP); 73 write_map_parameters_to_string (buf, RP);
71 74
72 if (RP->difficulty == 0) 75 if (RP->difficulty == 0)
73 { 76 {
… …
81 } 84 }
82 else 85 else
83 RP->difficulty_given = 1; 86 RP->difficulty_given = 1;
84 87
85 if (RP->Xsize < MIN_RANDOM_MAP_SIZE) 88 if (RP->Xsize < MIN_RANDOM_MAP_SIZE)
86 RP->Xsize = MIN_RANDOM_MAP_SIZE + RANDOM () % 25 + 5; 89 RP->Xsize = MIN_RANDOM_MAP_SIZE + rndm (25) + 5;
87 90
88 if (RP->Ysize < MIN_RANDOM_MAP_SIZE) 91 if (RP->Ysize < MIN_RANDOM_MAP_SIZE)
89 RP->Ysize = MIN_RANDOM_MAP_SIZE + RANDOM () % 25 + 5; 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;
90 104
91 if (RP->expand2x > 0) 105 if (RP->expand2x > 0)
92 { 106 {
93 RP->Xsize /= 2; 107 RP->Xsize /= 2;
94 RP->Ysize /= 2; 108 RP->Ysize /= 2;
95 } 109 }
96 110
97 layout = layoutgen (RP);
98
99#ifdef RMAP_DEBUG
100 dump_layout (layout, RP);
101#endif
102
103 /* increment these for the current map */
104 RP->dungeon_level += 1;
105 /* allow constant-difficulty maps. */
106 /* difficulty+=1; */
107
108 /* rotate the layout randomly */
109 layout = rotate_layout (layout, RANDOM () % 4, RP);
110#ifdef RMAP_DEBUG
111 dump_layout (layout, RP);
112#endif
113
114 /* allocate the map and set the floor */
115 theMap = make_map_floor (layout, RP->floorstyle, RP);
116
117 /* set the name of the map. */
118 theMap->path = OutFileName;
119
120 /* set region */
121 theMap->region = RP->region;
122
123 /* create walls unless the wallstyle is "none" */
124 if (strcmp (RP->wallstyle, "none"))
125 {
126 make_map_walls (theMap, layout, RP->wallstyle, RP);
127
128 /* place doors unless doorstyle or wallstyle is "none" */
129 if (strcmp (RP->doorstyle, "none"))
130 put_doors (theMap, layout, RP->doorstyle, RP);
131
132 }
133
134 /* create exits unless the exitstyle is "none" */
135 if (strcmp (RP->exitstyle, "none"))
136 place_exits (theMap, layout, RP->exitstyle, RP->orientation, RP);
137
138 place_specials_in_map (theMap, layout, RP);
139
140 /* create monsters unless the monsterstyle is "none" */
141 if (strcmp (RP->monsterstyle, "none"))
142 place_monsters (theMap, RP->monsterstyle, RP->difficulty, RP);
143
144 /* treasures needs to have a proper difficulty set for the map. */
145 theMap->difficulty = theMap->estimate_difficulty ();
146
147 /* create treasure unless the treasurestyle is "none" */
148 if (strcmp (RP->treasurestyle, "none"))
149 place_treasure (theMap, layout, RP->treasurestyle, RP->treasureoptions, RP);
150
151 /* create decor unless the decorstyle is "none" */
152 if (strcmp (RP->decorstyle, "none"))
153 put_decor (theMap, layout, RP->decorstyle, RP->decoroptions, RP);
154
155 /* generate treasures, etc. */
156 theMap->fix_auto_apply ();
157
158 unblock_exits (theMap, layout, RP);
159
160 /* free the layout */
161 for (i = 0; i < RP->Xsize; i++)
162 free (layout[i]);
163 free (layout);
164
165 theMap->msg = strdup (buf);
166
167 return theMap;
168}
169
170/* function selects the layout function and gives it whatever
171 arguments it needs. */
172char **
173layoutgen (random_map_params * RP)
174{
175 char **maze = 0;
176 int oxsize = RP->Xsize, oysize = RP->Ysize;
177
178 if (RP->symmetry == SYMMETRY_RANDOM)
179 RP->symmetry_used = (RANDOM () % (SYMMETRY_XY)) + 1;
180 else
181 RP->symmetry_used = RP->symmetry;
182
183 if (RP->symmetry_used == SYMMETRY_Y || RP->symmetry_used == SYMMETRY_XY)
184 RP->Ysize = RP->Ysize / 2 + 1;
185 if (RP->symmetry_used == SYMMETRY_X || RP->symmetry_used == SYMMETRY_XY)
186 RP->Xsize = RP->Xsize / 2 + 1;
187
188 if (RP->Xsize < MIN_RANDOM_MAP_SIZE)
189 RP->Xsize = MIN_RANDOM_MAP_SIZE + RANDOM () % 5;
190 if (RP->Ysize < MIN_RANDOM_MAP_SIZE)
191 RP->Ysize = MIN_RANDOM_MAP_SIZE + RANDOM () % 5;
192 RP->map_layout_style = 0; 111 RP->map_layout_style = LAYOUT_NONE;
193 112
194 /* Redo this - there was a lot of redundant code of checking for preset 113 /* Redo this - there was a lot of redundant code of checking for preset
195 * layout style and then random layout style. Instead, figure out 114 * layout style and then random layout style. Instead, figure out
196 * the numeric layoutstyle, so there is only one area that actually 115 * the numeric layoutstyle, so there is only one area that actually
197 * calls the code to make the maps. 116 * calls the code to make the maps.
… …
212 RP->map_layout_style = LAYOUT_SNAKE; 131 RP->map_layout_style = LAYOUT_SNAKE;
213 132
214 if (strstr (RP->layoutstyle, "squarespiral")) 133 if (strstr (RP->layoutstyle, "squarespiral"))
215 RP->map_layout_style = LAYOUT_SQUARE_SPIRAL; 134 RP->map_layout_style = LAYOUT_SQUARE_SPIRAL;
216 135
217 /* No style found - choose one ranomdly */ 136 /* No style found - choose one randomly */
218 if (RP->map_layout_style == LAYOUT_NONE) 137 if (RP->map_layout_style == LAYOUT_NONE)
219 RP->map_layout_style = (RANDOM () % (NROFLAYOUTS - 1)) + 1; 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}
230
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;
220 238
221 switch (RP->map_layout_style) 239 switch (RP->map_layout_style)
222 { 240 {
223 case LAYOUT_ONION: 241 case LAYOUT_ONION:
224 maze = map_gen_onion (RP->Xsize, RP->Ysize, RP->layoutoptions1, RP->layoutoptions2); 242 maze = map_gen_onion (RP->Xsize, RP->Ysize, RP->layoutoptions1, RP->layoutoptions2);
225 if (!(RANDOM () % 3) && !(RP->layoutoptions1 & RMOPT_WALLS_ONLY)) 243 if (!(rndm (3)) && !(RP->layoutoptions1 & RMOPT_WALLS_ONLY))
226 roomify_layout (maze, RP); 244 roomify_layout (maze, RP);
227 break; 245 break;
228 246
229 case LAYOUT_MAZE: 247 case LAYOUT_MAZE:
230 maze = maze_gen (RP->Xsize, RP->Ysize, RANDOM () % 2); 248 maze = maze_gen (RP->Xsize, RP->Ysize, rndm (2));
231 if (!(RANDOM () % 2)) 249 if (!(rndm (2)))
232 doorify_layout (maze, RP); 250 doorify_layout (maze, RP);
233 break; 251 break;
234 252
235 case LAYOUT_SPIRAL: 253 case LAYOUT_SPIRAL:
236 maze = map_gen_spiral (RP->Xsize, RP->Ysize, RP->layoutoptions1); 254 maze = map_gen_spiral (RP->Xsize, RP->Ysize, RP->layoutoptions1);
237 if (!(RANDOM () % 2)) 255 if (!(rndm (2)))
238 doorify_layout (maze, RP); 256 doorify_layout (maze, RP);
239 break; 257 break;
240 258
241 case LAYOUT_ROGUELIKE: 259 case LAYOUT_ROGUELIKE:
242 /* Don't put symmetry in rogue maps. There isn't much reason to 260 /* Don't put symmetry in rogue maps. There isn't much reason to
… …
253 /* no doorifying... done already */ 271 /* no doorifying... done already */
254 break; 272 break;
255 273
256 case LAYOUT_SNAKE: 274 case LAYOUT_SNAKE:
257 maze = make_snake_layout (RP->Xsize, RP->Ysize, RP->layoutoptions1); 275 maze = make_snake_layout (RP->Xsize, RP->Ysize, RP->layoutoptions1);
258 if (RANDOM () % 2) 276 if (rndm (2))
259 roomify_layout (maze, RP); 277 roomify_layout (maze, RP);
260 break; 278 break;
261 279
262 case LAYOUT_SQUARE_SPIRAL: 280 case LAYOUT_SQUARE_SPIRAL:
263 maze = make_square_spiral_layout (RP->Xsize, RP->Ysize, RP->layoutoptions1); 281 maze = make_square_spiral_layout (RP->Xsize, RP->Ysize, RP->layoutoptions1);
264 if (RANDOM () % 2) 282 if (rndm (2))
265 roomify_layout (maze, RP); 283 roomify_layout (maze, RP);
266 break; 284 break;
267 } 285 }
268 286
269 maze = symmetrize_layout (maze, RP->symmetry_used, RP); 287 maze = symmetrize_layout (maze, RP->symmetry_used, RP);
… …
283} 301}
284 302
285/* takes a map and makes it symmetric: adjusts Xsize and 303/* takes a map and makes it symmetric: adjusts Xsize and
286Ysize to produce a symmetric map. */ 304Ysize to produce a symmetric map. */
287char ** 305char **
288symmetrize_layout (char **maze, int sym, random_map_params * RP) 306symmetrize_layout (char **maze, int sym, random_map_params *RP)
289{ 307{
290 int i, j; 308 int i, j;
291 char **sym_maze; 309 char **sym_maze;
292 int Xsize_orig, Ysize_orig; 310 int Xsize_orig, Ysize_orig;
293 311
… …
351 onion layouts, making them possibly centered on any wall. 369 onion layouts, making them possibly centered on any wall.
352 It'll modify Xsize and Ysize if they're swapped. 370 It'll modify Xsize and Ysize if they're swapped.
353*/ 371*/
354 372
355char ** 373char **
356rotate_layout (char **maze, int rotation, random_map_params * RP) 374rotate_layout (char **maze, int rotation, random_map_params *RP)
357{ 375{
358 char **new_maze; 376 char **new_maze;
359 int i, j; 377 int i, j;
360 378
361 switch (rotation) 379 switch (rotation)
362 { 380 {
363 case 0: 381 case 0:
364 return maze; 382 return maze;
365 break; 383 break;
366 case 2: /* a reflection */ 384 case 2: /* a reflection */
367 { 385 {
368 char *newmaze = (char *) malloc (sizeof (char) * RP->Xsize * RP->Ysize); 386 char *newmaze = (char *) malloc (sizeof (char) * RP->Xsize * RP->Ysize);
369 387
370 for (i = 0; i < RP->Xsize; i++) 388 for (i = 0; i < RP->Xsize; i++)
371 { /* make a copy */ 389 { /* make a copy */
372 for (j = 0; j < RP->Ysize; j++) 390 for (j = 0; j < RP->Ysize; j++)
373 { 391 {
374 newmaze[i * RP->Ysize + j] = maze[i][j]; 392 newmaze[i * RP->Ysize + j] = maze[i][j];
375 } 393 }
376 } 394 }
377 for (i = 0; i < RP->Xsize; i++) 395 for (i = 0; i < RP->Xsize; i++)
378 { /* copy a reflection back */ 396 { /* copy a reflection back */
379 for (j = 0; j < RP->Ysize; j++) 397 for (j = 0; j < RP->Ysize; j++)
380 { 398 {
381 maze[i][j] = newmaze[(RP->Xsize - i - 1) * RP->Ysize + RP->Ysize - j - 1]; 399 maze[i][j] = newmaze[(RP->Xsize - i - 1) * RP->Ysize + RP->Ysize - j - 1];
382 } 400 }
383 } 401 }
… …
392 new_maze = (char **) calloc (sizeof (char *), RP->Ysize); 410 new_maze = (char **) calloc (sizeof (char *), RP->Ysize);
393 for (i = 0; i < RP->Ysize; i++) 411 for (i = 0; i < RP->Ysize; i++)
394 { 412 {
395 new_maze[i] = (char *) calloc (sizeof (char), RP->Xsize); 413 new_maze[i] = (char *) calloc (sizeof (char), RP->Xsize);
396 } 414 }
397 if (rotation == 1) /* swap x and y */ 415 if (rotation == 1) /* swap x and y */
398 for (i = 0; i < RP->Xsize; i++) 416 for (i = 0; i < RP->Xsize; i++)
399 for (j = 0; j < RP->Ysize; j++) 417 for (j = 0; j < RP->Ysize; j++)
400 new_maze[j][i] = maze[i][j]; 418 new_maze[j][i] = maze[i][j];
401 419
402 if (rotation == 3) 420 if (rotation == 3)
403 { /* swap x and y */ 421 { /* swap x and y */
404 for (i = 0; i < RP->Xsize; i++) 422 for (i = 0; i < RP->Xsize; i++)
405 for (j = 0; j < RP->Ysize; j++) 423 for (j = 0; j < RP->Ysize; j++)
406 new_maze[j][i] = maze[RP->Xsize - i - 1][RP->Ysize - j - 1]; 424 new_maze[j][i] = maze[RP->Xsize - i - 1][RP->Ysize - j - 1];
407 } 425 }
408 426
… …
422} 440}
423 441
424/* take a layout and make some rooms in it. 442/* take a layout and make some rooms in it.
425 --works best on onions.*/ 443 --works best on onions.*/
426void 444void
427roomify_layout (char **maze, random_map_params * RP) 445roomify_layout (char **maze, random_map_params *RP)
428{ 446{
429 int tries = RP->Xsize * RP->Ysize / 30; 447 int tries = RP->Xsize * RP->Ysize / 30;
430 int ti; 448 int ti;
431 449
432 for (ti = 0; ti < tries; ti++) 450 for (ti = 0; ti < tries; ti++)
433 { 451 {
434 int dx, dy; /* starting location for looking at creating a door */ 452 int dx, dy; /* starting location for looking at creating a door */
435 int cx, cy; /* results of checking on creating walls. */ 453 int cx, cy; /* results of checking on creating walls. */
436 454
437 dx = RANDOM () % RP->Xsize; 455 dx = rndm (RP->Xsize);
438 dy = RANDOM () % RP->Ysize; 456 dy = rndm (RP->Ysize);
457
439 cx = can_make_wall (maze, dx, dy, 0, RP); /* horizontal */ 458 cx = can_make_wall (maze, dx, dy, 0, RP); /* horizontal */
440 cy = can_make_wall (maze, dx, dy, 1, RP); /* vertical */ 459 cy = can_make_wall (maze, dx, dy, 1, RP); /* vertical */
441 if (cx == -1) 460 if (cx == -1)
442 { 461 {
443 if (cy != -1) 462 if (cy != -1)
444 make_wall (maze, dx, dy, 1); 463 make_wall (maze, dx, dy, 1);
464
445 continue; 465 continue;
446 } 466 }
467
447 if (cy == -1) 468 if (cy == -1)
448 { 469 {
449 make_wall (maze, dx, dy, 0); 470 make_wall (maze, dx, dy, 0);
450 continue; 471 continue;
451 } 472 }
473
452 if (cx < cy) 474 if (cx < cy)
453 make_wall (maze, dx, dy, 0); 475 make_wall (maze, dx, dy, 0);
454 else 476 else
455 make_wall (maze, dx, dy, 1); 477 make_wall (maze, dx, dy, 1);
456 } 478 }
… …
459/* checks the layout to see if I can stick a horizontal(dir = 0) wall 481/* checks the layout to see if I can stick a horizontal(dir = 0) wall
460 (or vertical, dir == 1) 482 (or vertical, dir == 1)
461 here which ends up on other walls sensibly. */ 483 here which ends up on other walls sensibly. */
462 484
463int 485int
464can_make_wall (char **maze, int dx, int dy, int dir, random_map_params * RP) 486can_make_wall (char **maze, int dx, int dy, int dir, random_map_params *RP)
465{ 487{
466 int i1; 488 int i1;
467 int length = 0; 489 int length = 0;
468 490
469 /* dont make walls if we're on the edge. */ 491 /* dont make walls if we're on the edge. */
… …
544make_wall (char **maze, int x, int y, int dir) 566make_wall (char **maze, int x, int y, int dir)
545{ 567{
546 maze[x][y] = 'D'; /* mark a door */ 568 maze[x][y] = 'D'; /* mark a door */
547 switch (dir) 569 switch (dir)
548 { 570 {
549 case 0: /* horizontal */ 571 case 0: /* horizontal */
550 { 572 {
551 int i1; 573 int i1;
552 574
553 for (i1 = x - 1; maze[i1][y] == 0; i1--) 575 for (i1 = x - 1; maze[i1][y] == 0; i1--)
554 maze[i1][y] = '#'; 576 maze[i1][y] = '#';
555 for (i1 = x + 1; maze[i1][y] == 0; i1++) 577 for (i1 = x + 1; maze[i1][y] == 0; i1++)
556 maze[i1][y] = '#'; 578 maze[i1][y] = '#';
557 break; 579 break;
558 } 580 }
559 case 1: /* vertical */ 581 case 1: /* vertical */
560 { 582 {
561 int i1; 583 int i1;
562 584
563 for (i1 = y - 1; maze[x][i1] == 0; i1--) 585 for (i1 = y - 1; maze[x][i1] == 0; i1--)
564 maze[x][i1] = '#'; 586 maze[x][i1] = '#';
565 for (i1 = y + 1; maze[x][i1] == 0; i1++) 587 for (i1 = y + 1; maze[x][i1] == 0; i1++)
566 maze[x][i1] = '#'; 588 maze[x][i1] = '#';
567 break; 589 break;
568 } 590 }
569 } 591 }
570 592
571 return 0; 593 return 0;
572} 594}
573 595
574/* puts doors at appropriate locations in a layout. */ 596/* puts doors at appropriate locations in a layout. */
575
576void 597void
577doorify_layout (char **maze, random_map_params * RP) 598doorify_layout (char **maze, random_map_params *RP)
578{ 599{
579 int ndoors = RP->Xsize * RP->Ysize / 60; /* reasonable number of doors. */ 600 int ndoors = RP->Xsize * RP->Ysize / 60; /* reasonable number of doors. */
580 char *doorlist_x; 601 char *doorlist_x;
581 char *doorlist_y; 602 char *doorlist_y;
582 int doorlocs = 0; /* # of available doorlocations */ 603 int doorlocs = 0; /* # of available doorlocations */
… …
597 doorlist_x[doorlocs] = i; 618 doorlist_x[doorlocs] = i;
598 doorlist_y[doorlocs] = j; 619 doorlist_y[doorlocs] = j;
599 doorlocs++; 620 doorlocs++;
600 } 621 }
601 } 622 }
623
602 while (ndoors > 0 && doorlocs > 0) 624 while (ndoors > 0 && doorlocs > 0)
603 { 625 {
604 int di; 626 int di;
605 int sindex; 627 int sindex;
606 628
607 di = RANDOM () % doorlocs; 629 di = rndm (doorlocs);
608 i = doorlist_x[di]; 630 i = doorlist_x[di];
609 j = doorlist_y[di]; 631 j = doorlist_y[di];
610 sindex = surround_flag (maze, i, j, RP); 632 sindex = surround_flag (maze, i, j, RP);
633
611 if (sindex == 3 || sindex == 12) /* these are possible door sindex */ 634 if (sindex == 3 || sindex == 12) /* these are possible door sindex */
612 { 635 {
613 maze[i][j] = 'D'; 636 maze[i][j] = 'D';
614 ndoors--; 637 ndoors--;
615 } 638 }
639
616 /* reduce the size of the list */ 640 /* reduce the size of the list */
617 doorlocs--; 641 doorlocs--;
618 doorlist_x[di] = doorlist_x[doorlocs]; 642 doorlist_x[di] = doorlist_x[doorlocs];
619 doorlist_y[di] = doorlist_y[doorlocs]; 643 doorlist_y[di] = doorlist_y[doorlocs];
620 } 644 }
645
621 free (doorlist_x); 646 free (doorlist_x);
622 free (doorlist_y); 647 free (doorlist_y);
623} 648}
624 649
625
626void 650void
627write_map_parameters_to_string (char *buf, random_map_params * RP) 651write_map_parameters_to_string (char *buf, random_map_params *RP)
628{ 652{
629 char small_buf[256]; 653 char small_buf[16384];
630 654
631 sprintf (buf, "xsize %d\nysize %d\n", RP->Xsize, RP->Ysize); 655 sprintf (buf, "xsize %d\nysize %d\n", RP->xsize, RP->ysize);
632 656
633 if (RP->wallstyle[0]) 657 if (RP->wallstyle[0])
634 { 658 {
635 sprintf (small_buf, "wallstyle %s\n", RP->wallstyle); 659 sprintf (small_buf, "wallstyle %s\n", RP->wallstyle);
636 strcat (buf, small_buf); 660 strcat (buf, small_buf);
… …
676 { 700 {
677 sprintf (small_buf, "exitstyle %s\n", RP->exitstyle); 701 sprintf (small_buf, "exitstyle %s\n", RP->exitstyle);
678 strcat (buf, small_buf); 702 strcat (buf, small_buf);
679 } 703 }
680 704
681 if (RP->final_map[0]) 705 if (RP->final_map.length ())
682 { 706 {
683 sprintf (small_buf, "final_map %s\n", RP->final_map); 707 sprintf (small_buf, "final_map %s\n", &RP->final_map);
684 strcat (buf, small_buf); 708 strcat (buf, small_buf);
685 } 709 }
686 710
687 if (RP->exit_on_final_map[0]) 711 if (RP->exit_on_final_map[0])
688 { 712 {
689 sprintf (small_buf, "exit_on_final_map %s\n", RP->exit_on_final_map); 713 sprintf (small_buf, "exit_on_final_map %s\n", RP->exit_on_final_map);
690 strcat (buf, small_buf); 714 strcat (buf, small_buf);
691 } 715 }
692 716
693 if (RP->this_map[0]) 717 if (RP->this_map.length ())
694 { 718 {
695 sprintf (small_buf, "origin_map %s\n", RP->this_map); 719 sprintf (small_buf, "origin_map %s\n", &RP->this_map);
696 strcat (buf, small_buf); 720 strcat (buf, small_buf);
697 } 721 }
698 722
699 if (RP->expand2x) 723 if (RP->expand2x)
700 { 724 {
… …
706 { 730 {
707 sprintf (small_buf, "layoutoptions1 %d\n", RP->layoutoptions1); 731 sprintf (small_buf, "layoutoptions1 %d\n", RP->layoutoptions1);
708 strcat (buf, small_buf); 732 strcat (buf, small_buf);
709 } 733 }
710 734
711
712 if (RP->layoutoptions2) 735 if (RP->layoutoptions2)
713 { 736 {
714 sprintf (small_buf, "layoutoptions2 %d\n", RP->layoutoptions2); 737 sprintf (small_buf, "layoutoptions2 %d\n", RP->layoutoptions2);
715 strcat (buf, small_buf); 738 strcat (buf, small_buf);
716 } 739 }
717 740
718
719 if (RP->layoutoptions3) 741 if (RP->layoutoptions3)
720 { 742 {
721 sprintf (small_buf, "layoutoptions3 %d\n", RP->layoutoptions3); 743 sprintf (small_buf, "layoutoptions3 %d\n", RP->layoutoptions3);
722 strcat (buf, small_buf); 744 strcat (buf, small_buf);
723 } 745 }
… …
725 if (RP->symmetry) 747 if (RP->symmetry)
726 { 748 {
727 sprintf (small_buf, "symmetry %d\n", RP->symmetry); 749 sprintf (small_buf, "symmetry %d\n", RP->symmetry);
728 strcat (buf, small_buf); 750 strcat (buf, small_buf);
729 } 751 }
730
731 752
732 if (RP->difficulty && RP->difficulty_given) 753 if (RP->difficulty && RP->difficulty_given)
733 { 754 {
734 sprintf (small_buf, "difficulty %d\n", RP->difficulty); 755 sprintf (small_buf, "difficulty %d\n", RP->difficulty);
735 strcat (buf, small_buf); 756 strcat (buf, small_buf);
… …
772 { 793 {
773 sprintf (small_buf, "origin_y %d\n", RP->origin_y); 794 sprintf (small_buf, "origin_y %d\n", RP->origin_y);
774 strcat (buf, small_buf); 795 strcat (buf, small_buf);
775 } 796 }
776 797
798 if (RP->treasureoptions)
799 {
800 sprintf (small_buf, "treasureoptions %d\n", RP->treasureoptions);
801 strcat (buf, small_buf);
802 }
803
777 if (RP->random_seed) 804 if (RP->random_seed)
778 { 805 {
779 /* Add one so that the next map is a bit different */
780 sprintf (small_buf, "random_seed %d\n", RP->random_seed + 1); 806 sprintf (small_buf, "random_seed %u\n", RP->random_seed);
781 strcat (buf, small_buf); 807 strcat (buf, small_buf);
782 }
783
784 if (RP->treasureoptions)
785 { 808 }
786 sprintf (small_buf, "treasureoptions %d\n", RP->treasureoptions); 809
810 if (RP->custom)
811 {
812 sprintf (small_buf, "custom %s\n", RP->custom);
787 strcat (buf, small_buf); 813 strcat (buf, small_buf);
788 } 814 }
789} 815}
790 816
791void 817void
… …
811 int dungeon_level_n, 837 int dungeon_level_n,
812 int difficulty_n, 838 int difficulty_n,
813 int difficulty_given_n, 839 int difficulty_given_n,
814 int decoroptions_n, 840 int decoroptions_n,
815 int orientation_n, 841 int orientation_n,
816 int origin_x_n, int origin_y_n, int random_seed_n, int treasureoptions_n, float difficulty_increase) 842 int origin_x_n, int origin_y_n, uint32_t random_seed_n, int treasureoptions_n, float difficulty_increase)
817{ 843{
818
819 char small_buf[256]; 844 char small_buf[16384];
820 845
821 sprintf (buf, "xsize %d\nysize %d\n", xsize_n, ysize_n); 846 sprintf (buf, "xsize %d\nysize %d\n", xsize_n, ysize_n);
822 847
823 if (wallstyle_n && wallstyle_n[0]) 848 if (wallstyle_n && wallstyle_n[0])
824 { 849 {
… …
889 if (layoutoptions1_n) 914 if (layoutoptions1_n)
890 { 915 {
891 sprintf (small_buf, "layoutoptions1 %d\n", layoutoptions1_n); 916 sprintf (small_buf, "layoutoptions1 %d\n", layoutoptions1_n);
892 strcat (buf, small_buf); 917 strcat (buf, small_buf);
893 } 918 }
894
895 919
896 if (layoutoptions2_n) 920 if (layoutoptions2_n)
897 { 921 {
898 sprintf (small_buf, "layoutoptions2 %d\n", layoutoptions2_n); 922 sprintf (small_buf, "layoutoptions2 %d\n", layoutoptions2_n);
899 strcat (buf, small_buf); 923 strcat (buf, small_buf);
… …
959 } 983 }
960 984
961 if (random_seed_n) 985 if (random_seed_n)
962 { 986 {
963 /* Add one so that the next map is a bit different */ 987 /* Add one so that the next map is a bit different */
964 sprintf (small_buf, "random_seed %d\n", random_seed_n + 1); 988 sprintf (small_buf, "random_seed %u\n", random_seed_n + 1);
965 strcat (buf, small_buf); 989 strcat (buf, small_buf);
966 } 990 }
967 991
968 if (treasureoptions_n) 992 if (treasureoptions_n)
969 { 993 {
970 sprintf (small_buf, "treasureoptions %d\n", treasureoptions_n); 994 sprintf (small_buf, "treasureoptions %d\n", treasureoptions_n);
971 strcat (buf, small_buf); 995 strcat (buf, small_buf);
972 } 996 }
973
974
975} 997}
976 998
977/* copy an object with an inventory... i.e., duplicate the inv too. */ 999/* copy an object with an inventory... i.e., duplicate the inv too. */
978void 1000void
979copy_object_with_inv (object *src_ob, object *dest_ob) 1001copy_object_with_inv (object *src_ob, object *dest_ob)
980{ 1002{
981 object *walk, *tmp; 1003 object *walk, *tmp;
982 1004
983 src_ob->copy_to (dest_ob); 1005 src_ob->copy_to (dest_ob);
984 1006
985 for (walk = src_ob->inv; walk != NULL; walk = walk->below) 1007 for (walk = src_ob->inv; walk; walk = walk->below)
986 { 1008 {
987 tmp = object::create (); 1009 tmp = object::create ();
1010
988 walk->copy_to (tmp); 1011 walk->copy_to (tmp);
989 insert_ob_in_ob (tmp, dest_ob); 1012 insert_ob_in_ob (tmp, dest_ob);
990 } 1013 }
991} 1014}

Diff Legend

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