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.12 by root, Sun Dec 31 17:17:23 2006 UTC vs.
Revision 1.29 by root, Tue Apr 17 10:06:34 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_to_tick (); 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
164 free (layout);
165
166 theMap->msg = strdup (buf);
167 theMap->in_memory = MAP_IN_MEMORY;
168
169 return theMap;
170}
171
172/* function selects the layout function and gives it whatever
173 arguments it needs. */
174char **
175layoutgen (random_map_params * RP)
176{
177 char **maze = 0;
178 int oxsize = RP->Xsize, oysize = RP->Ysize;
179
180 if (RP->symmetry == SYMMETRY_RANDOM)
181 RP->symmetry_used = (RANDOM () % (SYMMETRY_XY)) + 1;
182 else
183 RP->symmetry_used = RP->symmetry;
184
185 if (RP->symmetry_used == SYMMETRY_Y || RP->symmetry_used == SYMMETRY_XY)
186 RP->Ysize = RP->Ysize / 2 + 1;
187 if (RP->symmetry_used == SYMMETRY_X || RP->symmetry_used == SYMMETRY_XY)
188 RP->Xsize = RP->Xsize / 2 + 1;
189
190 if (RP->Xsize < MIN_RANDOM_MAP_SIZE)
191 RP->Xsize = MIN_RANDOM_MAP_SIZE + RANDOM () % 5;
192 if (RP->Ysize < MIN_RANDOM_MAP_SIZE)
193 RP->Ysize = MIN_RANDOM_MAP_SIZE + RANDOM () % 5;
194 RP->map_layout_style = 0; 111 RP->map_layout_style = LAYOUT_NONE;
195 112
196 /* 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
197 * layout style and then random layout style. Instead, figure out 114 * layout style and then random layout style. Instead, figure out
198 * the numeric layoutstyle, so there is only one area that actually 115 * the numeric layoutstyle, so there is only one area that actually
199 * calls the code to make the maps. 116 * calls the code to make the maps.
… …
214 RP->map_layout_style = LAYOUT_SNAKE; 131 RP->map_layout_style = LAYOUT_SNAKE;
215 132
216 if (strstr (RP->layoutstyle, "squarespiral")) 133 if (strstr (RP->layoutstyle, "squarespiral"))
217 RP->map_layout_style = LAYOUT_SQUARE_SPIRAL; 134 RP->map_layout_style = LAYOUT_SQUARE_SPIRAL;
218 135
219 /* No style found - choose one ranomdly */ 136 /* No style found - choose one randomly */
220 if (RP->map_layout_style == LAYOUT_NONE) 137 if (RP->map_layout_style == LAYOUT_NONE)
221 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;
222 238
223 switch (RP->map_layout_style) 239 switch (RP->map_layout_style)
224 { 240 {
225 case LAYOUT_ONION: 241 case LAYOUT_ONION:
226 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);
227 if (!(RANDOM () % 3) && !(RP->layoutoptions1 & RMOPT_WALLS_ONLY)) 243 if (!(rndm (3)) && !(RP->layoutoptions1 & RMOPT_WALLS_ONLY))
228 roomify_layout (maze, RP); 244 roomify_layout (maze, RP);
229 break; 245 break;
230 246
231 case LAYOUT_MAZE: 247 case LAYOUT_MAZE:
232 maze = maze_gen (RP->Xsize, RP->Ysize, RANDOM () % 2); 248 maze = maze_gen (RP->Xsize, RP->Ysize, rndm (2));
233 if (!(RANDOM () % 2)) 249 if (!(rndm (2)))
234 doorify_layout (maze, RP); 250 doorify_layout (maze, RP);
235 break; 251 break;
236 252
237 case LAYOUT_SPIRAL: 253 case LAYOUT_SPIRAL:
238 maze = map_gen_spiral (RP->Xsize, RP->Ysize, RP->layoutoptions1); 254 maze = map_gen_spiral (RP->Xsize, RP->Ysize, RP->layoutoptions1);
239 if (!(RANDOM () % 2)) 255 if (!(rndm (2)))
240 doorify_layout (maze, RP); 256 doorify_layout (maze, RP);
241 break; 257 break;
242 258
243 case LAYOUT_ROGUELIKE: 259 case LAYOUT_ROGUELIKE:
244 /* 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
… …
255 /* no doorifying... done already */ 271 /* no doorifying... done already */
256 break; 272 break;
257 273
258 case LAYOUT_SNAKE: 274 case LAYOUT_SNAKE:
259 maze = make_snake_layout (RP->Xsize, RP->Ysize, RP->layoutoptions1); 275 maze = make_snake_layout (RP->Xsize, RP->Ysize, RP->layoutoptions1);
260 if (RANDOM () % 2) 276 if (rndm (2))
261 roomify_layout (maze, RP); 277 roomify_layout (maze, RP);
262 break; 278 break;
263 279
264 case LAYOUT_SQUARE_SPIRAL: 280 case LAYOUT_SQUARE_SPIRAL:
265 maze = make_square_spiral_layout (RP->Xsize, RP->Ysize, RP->layoutoptions1); 281 maze = make_square_spiral_layout (RP->Xsize, RP->Ysize, RP->layoutoptions1);
266 if (RANDOM () % 2) 282 if (rndm (2))
267 roomify_layout (maze, RP); 283 roomify_layout (maze, RP);
268 break; 284 break;
269 } 285 }
270 286
271 maze = symmetrize_layout (maze, RP->symmetry_used, RP); 287 maze = symmetrize_layout (maze, RP->symmetry_used, RP);
… …
285} 301}
286 302
287/* takes a map and makes it symmetric: adjusts Xsize and 303/* takes a map and makes it symmetric: adjusts Xsize and
288Ysize to produce a symmetric map. */ 304Ysize to produce a symmetric map. */
289char ** 305char **
290symmetrize_layout (char **maze, int sym, random_map_params * RP) 306symmetrize_layout (char **maze, int sym, random_map_params *RP)
291{ 307{
292 int i, j; 308 int i, j;
293 char **sym_maze; 309 char **sym_maze;
294 int Xsize_orig, Ysize_orig; 310 int Xsize_orig, Ysize_orig;
295 311
… …
353 onion layouts, making them possibly centered on any wall. 369 onion layouts, making them possibly centered on any wall.
354 It'll modify Xsize and Ysize if they're swapped. 370 It'll modify Xsize and Ysize if they're swapped.
355*/ 371*/
356 372
357char ** 373char **
358rotate_layout (char **maze, int rotation, random_map_params * RP) 374rotate_layout (char **maze, int rotation, random_map_params *RP)
359{ 375{
360 char **new_maze; 376 char **new_maze;
361 int i, j; 377 int i, j;
362 378
363 switch (rotation) 379 switch (rotation)
364 { 380 {
365 case 0: 381 case 0:
366 return maze; 382 return maze;
367 break; 383 break;
368 case 2: /* a reflection */ 384 case 2: /* a reflection */
369 { 385 {
370 char *newmaze = (char *) malloc (sizeof (char) * RP->Xsize * RP->Ysize); 386 char *newmaze = (char *) malloc (sizeof (char) * RP->Xsize * RP->Ysize);
371 387
372 for (i = 0; i < RP->Xsize; i++) 388 for (i = 0; i < RP->Xsize; i++)
373 { /* make a copy */ 389 { /* make a copy */
374 for (j = 0; j < RP->Ysize; j++) 390 for (j = 0; j < RP->Ysize; j++)
375 { 391 {
376 newmaze[i * RP->Ysize + j] = maze[i][j]; 392 newmaze[i * RP->Ysize + j] = maze[i][j];
377 } 393 }
378 } 394 }
379 for (i = 0; i < RP->Xsize; i++) 395 for (i = 0; i < RP->Xsize; i++)
380 { /* copy a reflection back */ 396 { /* copy a reflection back */
381 for (j = 0; j < RP->Ysize; j++) 397 for (j = 0; j < RP->Ysize; j++)
382 { 398 {
383 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];
384 } 400 }
385 } 401 }
… …
394 new_maze = (char **) calloc (sizeof (char *), RP->Ysize); 410 new_maze = (char **) calloc (sizeof (char *), RP->Ysize);
395 for (i = 0; i < RP->Ysize; i++) 411 for (i = 0; i < RP->Ysize; i++)
396 { 412 {
397 new_maze[i] = (char *) calloc (sizeof (char), RP->Xsize); 413 new_maze[i] = (char *) calloc (sizeof (char), RP->Xsize);
398 } 414 }
399 if (rotation == 1) /* swap x and y */ 415 if (rotation == 1) /* swap x and y */
400 for (i = 0; i < RP->Xsize; i++) 416 for (i = 0; i < RP->Xsize; i++)
401 for (j = 0; j < RP->Ysize; j++) 417 for (j = 0; j < RP->Ysize; j++)
402 new_maze[j][i] = maze[i][j]; 418 new_maze[j][i] = maze[i][j];
403 419
404 if (rotation == 3) 420 if (rotation == 3)
405 { /* swap x and y */ 421 { /* swap x and y */
406 for (i = 0; i < RP->Xsize; i++) 422 for (i = 0; i < RP->Xsize; i++)
407 for (j = 0; j < RP->Ysize; j++) 423 for (j = 0; j < RP->Ysize; j++)
408 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];
409 } 425 }
410 426
… …
424} 440}
425 441
426/* take a layout and make some rooms in it. 442/* take a layout and make some rooms in it.
427 --works best on onions.*/ 443 --works best on onions.*/
428void 444void
429roomify_layout (char **maze, random_map_params * RP) 445roomify_layout (char **maze, random_map_params *RP)
430{ 446{
431 int tries = RP->Xsize * RP->Ysize / 30; 447 int tries = RP->Xsize * RP->Ysize / 30;
432 int ti; 448 int ti;
433 449
434 for (ti = 0; ti < tries; ti++) 450 for (ti = 0; ti < tries; ti++)
435 { 451 {
436 int dx, dy; /* starting location for looking at creating a door */ 452 int dx, dy; /* starting location for looking at creating a door */
437 int cx, cy; /* results of checking on creating walls. */ 453 int cx, cy; /* results of checking on creating walls. */
438 454
439 dx = RANDOM () % RP->Xsize; 455 dx = rndm (RP->Xsize);
440 dy = RANDOM () % RP->Ysize; 456 dy = rndm (RP->Ysize);
457
441 cx = can_make_wall (maze, dx, dy, 0, RP); /* horizontal */ 458 cx = can_make_wall (maze, dx, dy, 0, RP); /* horizontal */
442 cy = can_make_wall (maze, dx, dy, 1, RP); /* vertical */ 459 cy = can_make_wall (maze, dx, dy, 1, RP); /* vertical */
443 if (cx == -1) 460 if (cx == -1)
444 { 461 {
445 if (cy != -1) 462 if (cy != -1)
446 make_wall (maze, dx, dy, 1); 463 make_wall (maze, dx, dy, 1);
464
447 continue; 465 continue;
448 } 466 }
467
449 if (cy == -1) 468 if (cy == -1)
450 { 469 {
451 make_wall (maze, dx, dy, 0); 470 make_wall (maze, dx, dy, 0);
452 continue; 471 continue;
453 } 472 }
473
454 if (cx < cy) 474 if (cx < cy)
455 make_wall (maze, dx, dy, 0); 475 make_wall (maze, dx, dy, 0);
456 else 476 else
457 make_wall (maze, dx, dy, 1); 477 make_wall (maze, dx, dy, 1);
458 } 478 }
… …
461/* 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
462 (or vertical, dir == 1) 482 (or vertical, dir == 1)
463 here which ends up on other walls sensibly. */ 483 here which ends up on other walls sensibly. */
464 484
465int 485int
466can_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)
467{ 487{
468 int i1; 488 int i1;
469 int length = 0; 489 int length = 0;
470 490
471 /* dont make walls if we're on the edge. */ 491 /* dont make walls if we're on the edge. */
… …
546make_wall (char **maze, int x, int y, int dir) 566make_wall (char **maze, int x, int y, int dir)
547{ 567{
548 maze[x][y] = 'D'; /* mark a door */ 568 maze[x][y] = 'D'; /* mark a door */
549 switch (dir) 569 switch (dir)
550 { 570 {
551 case 0: /* horizontal */ 571 case 0: /* horizontal */
552 { 572 {
553 int i1; 573 int i1;
554 574
555 for (i1 = x - 1; maze[i1][y] == 0; i1--) 575 for (i1 = x - 1; maze[i1][y] == 0; i1--)
556 maze[i1][y] = '#'; 576 maze[i1][y] = '#';
557 for (i1 = x + 1; maze[i1][y] == 0; i1++) 577 for (i1 = x + 1; maze[i1][y] == 0; i1++)
558 maze[i1][y] = '#'; 578 maze[i1][y] = '#';
559 break; 579 break;
560 } 580 }
561 case 1: /* vertical */ 581 case 1: /* vertical */
562 { 582 {
563 int i1; 583 int i1;
564 584
565 for (i1 = y - 1; maze[x][i1] == 0; i1--) 585 for (i1 = y - 1; maze[x][i1] == 0; i1--)
566 maze[x][i1] = '#'; 586 maze[x][i1] = '#';
567 for (i1 = y + 1; maze[x][i1] == 0; i1++) 587 for (i1 = y + 1; maze[x][i1] == 0; i1++)
568 maze[x][i1] = '#'; 588 maze[x][i1] = '#';
569 break; 589 break;
570 } 590 }
571 } 591 }
572 592
573 return 0; 593 return 0;
574} 594}
575 595
576/* puts doors at appropriate locations in a layout. */ 596/* puts doors at appropriate locations in a layout. */
577void 597void
578doorify_layout (char **maze, random_map_params * RP) 598doorify_layout (char **maze, random_map_params *RP)
579{ 599{
580 int ndoors = RP->Xsize * RP->Ysize / 60; /* reasonable number of doors. */ 600 int ndoors = RP->Xsize * RP->Ysize / 60; /* reasonable number of doors. */
581 char *doorlist_x; 601 char *doorlist_x;
582 char *doorlist_y; 602 char *doorlist_y;
583 int doorlocs = 0; /* # of available doorlocations */ 603 int doorlocs = 0; /* # of available doorlocations */
… …
604 while (ndoors > 0 && doorlocs > 0) 624 while (ndoors > 0 && doorlocs > 0)
605 { 625 {
606 int di; 626 int di;
607 int sindex; 627 int sindex;
608 628
609 di = RANDOM () % doorlocs; 629 di = rndm (doorlocs);
610 i = doorlist_x[di]; 630 i = doorlist_x[di];
611 j = doorlist_y[di]; 631 j = doorlist_y[di];
612 sindex = surround_flag (maze, i, j, RP); 632 sindex = surround_flag (maze, i, j, RP);
633
613 if (sindex == 3 || sindex == 12) /* these are possible door sindex */ 634 if (sindex == 3 || sindex == 12) /* these are possible door sindex */
614 { 635 {
615 maze[i][j] = 'D'; 636 maze[i][j] = 'D';
616 ndoors--; 637 ndoors--;
617 } 638 }
639
618 /* reduce the size of the list */ 640 /* reduce the size of the list */
619 doorlocs--; 641 doorlocs--;
620 doorlist_x[di] = doorlist_x[doorlocs]; 642 doorlist_x[di] = doorlist_x[doorlocs];
621 doorlist_y[di] = doorlist_y[doorlocs]; 643 doorlist_y[di] = doorlist_y[doorlocs];
622 } 644 }
… …
624 free (doorlist_x); 646 free (doorlist_x);
625 free (doorlist_y); 647 free (doorlist_y);
626} 648}
627 649
628void 650void
629write_map_parameters_to_string (char *buf, random_map_params * RP) 651write_map_parameters_to_string (char *buf, random_map_params *RP)
630{ 652{
631 char small_buf[256]; 653 char small_buf[16384];
632 654
633 sprintf (buf, "xsize %d\nysize %d\n", RP->Xsize, RP->Ysize); 655 sprintf (buf, "xsize %d\nysize %d\n", RP->xsize, RP->ysize);
634 656
635 if (RP->wallstyle[0]) 657 if (RP->wallstyle[0])
636 { 658 {
637 sprintf (small_buf, "wallstyle %s\n", RP->wallstyle); 659 sprintf (small_buf, "wallstyle %s\n", RP->wallstyle);
638 strcat (buf, small_buf); 660 strcat (buf, small_buf);
… …
678 { 700 {
679 sprintf (small_buf, "exitstyle %s\n", RP->exitstyle); 701 sprintf (small_buf, "exitstyle %s\n", RP->exitstyle);
680 strcat (buf, small_buf); 702 strcat (buf, small_buf);
681 } 703 }
682 704
683 if (RP->final_map[0]) 705 if (RP->final_map.length ())
684 { 706 {
685 sprintf (small_buf, "final_map %s\n", RP->final_map); 707 sprintf (small_buf, "final_map %s\n", &RP->final_map);
686 strcat (buf, small_buf); 708 strcat (buf, small_buf);
687 } 709 }
688 710
689 if (RP->exit_on_final_map[0]) 711 if (RP->exit_on_final_map[0])
690 { 712 {
691 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);
692 strcat (buf, small_buf); 714 strcat (buf, small_buf);
693 } 715 }
694 716
695 if (RP->this_map[0]) 717 if (RP->this_map.length ())
696 { 718 {
697 sprintf (small_buf, "origin_map %s\n", RP->this_map); 719 sprintf (small_buf, "origin_map %s\n", &RP->this_map);
698 strcat (buf, small_buf); 720 strcat (buf, small_buf);
699 } 721 }
700 722
701 if (RP->expand2x) 723 if (RP->expand2x)
702 { 724 {
… …
708 { 730 {
709 sprintf (small_buf, "layoutoptions1 %d\n", RP->layoutoptions1); 731 sprintf (small_buf, "layoutoptions1 %d\n", RP->layoutoptions1);
710 strcat (buf, small_buf); 732 strcat (buf, small_buf);
711 } 733 }
712 734
713
714 if (RP->layoutoptions2) 735 if (RP->layoutoptions2)
715 { 736 {
716 sprintf (small_buf, "layoutoptions2 %d\n", RP->layoutoptions2); 737 sprintf (small_buf, "layoutoptions2 %d\n", RP->layoutoptions2);
717 strcat (buf, small_buf); 738 strcat (buf, small_buf);
718 } 739 }
719 740
720
721 if (RP->layoutoptions3) 741 if (RP->layoutoptions3)
722 { 742 {
723 sprintf (small_buf, "layoutoptions3 %d\n", RP->layoutoptions3); 743 sprintf (small_buf, "layoutoptions3 %d\n", RP->layoutoptions3);
724 strcat (buf, small_buf); 744 strcat (buf, small_buf);
725 } 745 }
… …
727 if (RP->symmetry) 747 if (RP->symmetry)
728 { 748 {
729 sprintf (small_buf, "symmetry %d\n", RP->symmetry); 749 sprintf (small_buf, "symmetry %d\n", RP->symmetry);
730 strcat (buf, small_buf); 750 strcat (buf, small_buf);
731 } 751 }
732
733 752
734 if (RP->difficulty && RP->difficulty_given) 753 if (RP->difficulty && RP->difficulty_given)
735 { 754 {
736 sprintf (small_buf, "difficulty %d\n", RP->difficulty); 755 sprintf (small_buf, "difficulty %d\n", RP->difficulty);
737 strcat (buf, small_buf); 756 strcat (buf, small_buf);
… …
774 { 793 {
775 sprintf (small_buf, "origin_y %d\n", RP->origin_y); 794 sprintf (small_buf, "origin_y %d\n", RP->origin_y);
776 strcat (buf, small_buf); 795 strcat (buf, small_buf);
777 } 796 }
778 797
798 if (RP->treasureoptions)
799 {
800 sprintf (small_buf, "treasureoptions %d\n", RP->treasureoptions);
801 strcat (buf, small_buf);
802 }
803
779 if (RP->random_seed) 804 if (RP->random_seed)
780 { 805 {
781 /* Add one so that the next map is a bit different */
782 sprintf (small_buf, "random_seed %d\n", RP->random_seed + 1); 806 sprintf (small_buf, "random_seed %u\n", RP->random_seed);
783 strcat (buf, small_buf); 807 strcat (buf, small_buf);
784 }
785
786 if (RP->treasureoptions)
787 { 808 }
788 sprintf (small_buf, "treasureoptions %d\n", RP->treasureoptions); 809
810 if (RP->custom)
811 {
812 sprintf (small_buf, "custom %s\n", RP->custom);
789 strcat (buf, small_buf); 813 strcat (buf, small_buf);
790 } 814 }
791} 815}
792 816
793void 817void
794write_parameters_to_string (char *buf, 818write_parameters_to_string (char *buf,
795 int xsize_n, 819 int xsize_n,
796 int ysize_n, 820 int ysize_n,
797 char *wallstyle_n, 821 const char *wallstyle_n,
798 char *floorstyle_n, 822 const char *floorstyle_n,
799 char *monsterstyle_n, 823 const char *monsterstyle_n,
800 char *treasurestyle_n, 824 const char *treasurestyle_n,
801 char *layoutstyle_n, 825 const char *layoutstyle_n,
802 char *decorstyle_n, 826 const char *decorstyle_n,
803 char *doorstyle_n, 827 const char *doorstyle_n,
804 char *exitstyle_n, 828 const char *exitstyle_n,
805 char *final_map_n, 829 const char *final_map_n,
806 char *exit_on_final_map_n, 830 const char *exit_on_final_map_n,
807 char *this_map_n, 831 const char *this_map_n,
808 int layoutoptions1_n, 832 int layoutoptions1_n,
809 int layoutoptions2_n, 833 int layoutoptions2_n,
810 int layoutoptions3_n, 834 int layoutoptions3_n,
811 int symmetry_n, 835 int symmetry_n,
812 int dungeon_depth_n, 836 int dungeon_depth_n,
813 int dungeon_level_n, 837 int dungeon_level_n,
814 int difficulty_n, 838 int difficulty_n,
815 int difficulty_given_n, 839 int difficulty_given_n,
816 int decoroptions_n, 840 int decoroptions_n,
817 int orientation_n, 841 int orientation_n,
818 int origin_x_n, int origin_y_n, int random_seed_n, int treasureoptions_n, float difficulty_increase) 842 int origin_x_n,
843 int origin_y_n,
844 uint32_t random_seed_n,
845 int treasureoptions_n,
846 float difficulty_increase)
819{ 847{
820
821 char small_buf[256]; 848 char small_buf[16384];
822 849
823 sprintf (buf, "xsize %d\nysize %d\n", xsize_n, ysize_n); 850 sprintf (buf, "xsize %d\nysize %d\n", xsize_n, ysize_n);
824 851
825 if (wallstyle_n && wallstyle_n[0]) 852 if (wallstyle_n && wallstyle_n[0])
826 { 853 {
… …
960 } 987 }
961 988
962 if (random_seed_n) 989 if (random_seed_n)
963 { 990 {
964 /* Add one so that the next map is a bit different */ 991 /* Add one so that the next map is a bit different */
965 sprintf (small_buf, "random_seed %d\n", random_seed_n + 1); 992 sprintf (small_buf, "random_seed %u\n", random_seed_n + 1);
966 strcat (buf, small_buf); 993 strcat (buf, small_buf);
967 } 994 }
968 995
969 if (treasureoptions_n) 996 if (treasureoptions_n)
970 { 997 {
971 sprintf (small_buf, "treasureoptions %d\n", treasureoptions_n); 998 sprintf (small_buf, "treasureoptions %d\n", treasureoptions_n);
972 strcat (buf, small_buf); 999 strcat (buf, small_buf);
973 } 1000 }
974
975
976} 1001}
977 1002
978/* copy an object with an inventory... i.e., duplicate the inv too. */ 1003/* copy an object with an inventory... i.e., duplicate the inv too. */
979void 1004void
980copy_object_with_inv (object *src_ob, object *dest_ob) 1005copy_object_with_inv (object *src_ob, object *dest_ob)
981{ 1006{
982 object *walk, *tmp; 1007 object *walk, *tmp;
983 1008
984 src_ob->copy_to (dest_ob); 1009 src_ob->copy_to (dest_ob);
985 1010
986 for (walk = src_ob->inv; walk != NULL; walk = walk->below) 1011 for (walk = src_ob->inv; walk; walk = walk->below)
987 { 1012 {
988 tmp = object::create (); 1013 tmp = object::create ();
1014
989 walk->copy_to (tmp); 1015 walk->copy_to (tmp);
990 insert_ob_in_ob (tmp, dest_ob); 1016 insert_ob_in_ob (tmp, dest_ob);
991 } 1017 }
992} 1018}

Diff Legend

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