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.22 by root, Fri Jan 19 15:29:52 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 /* pick a random seed, or use the one from the input file */ 64 /* pick a random seed, or use the one from the input file */
65 if (RP->random_seed == 0) 65 RP->random_seed = RP->random_seed
66 RP->random_seed = time (0); 66 ? RP->random_seed + RP->dungeon_level
67 67 : time (0);
68 SRANDOM (RP->random_seed); 68 CEDE;
69 69
70 write_map_parameters_to_string (buf, RP); 70 write_map_parameters_to_string (buf, RP);
71 71
72 if (RP->difficulty == 0) 72 if (RP->difficulty == 0)
73 { 73 {
… …
81 } 81 }
82 else 82 else
83 RP->difficulty_given = 1; 83 RP->difficulty_given = 1;
84 84
85 if (RP->Xsize < MIN_RANDOM_MAP_SIZE) 85 if (RP->Xsize < MIN_RANDOM_MAP_SIZE)
86 RP->Xsize = MIN_RANDOM_MAP_SIZE + RANDOM () % 25 + 5; 86 RP->Xsize = MIN_RANDOM_MAP_SIZE + rndm (25) + 5;
87 87
88 if (RP->Ysize < MIN_RANDOM_MAP_SIZE) 88 if (RP->Ysize < MIN_RANDOM_MAP_SIZE)
89 RP->Ysize = MIN_RANDOM_MAP_SIZE + RANDOM () % 25 + 5; 89 RP->Ysize = MIN_RANDOM_MAP_SIZE + rndm (25) + 5;
90
91 if (RP->expand2x > 0)
92 {
93 RP->Xsize /= 2;
94 RP->Ysize /= 2;
95 }
96
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 90
180 if (RP->symmetry == SYMMETRY_RANDOM) 91 if (RP->symmetry == SYMMETRY_RANDOM)
181 RP->symmetry_used = (RANDOM () % (SYMMETRY_XY)) + 1; 92 RP->symmetry_used = (RANDOM () % (SYMMETRY_XY)) + 1;
182 else 93 else
183 RP->symmetry_used = RP->symmetry; 94 RP->symmetry_used = RP->symmetry;
… …
185 if (RP->symmetry_used == SYMMETRY_Y || RP->symmetry_used == SYMMETRY_XY) 96 if (RP->symmetry_used == SYMMETRY_Y || RP->symmetry_used == SYMMETRY_XY)
186 RP->Ysize = RP->Ysize / 2 + 1; 97 RP->Ysize = RP->Ysize / 2 + 1;
187 if (RP->symmetry_used == SYMMETRY_X || RP->symmetry_used == SYMMETRY_XY) 98 if (RP->symmetry_used == SYMMETRY_X || RP->symmetry_used == SYMMETRY_XY)
188 RP->Xsize = RP->Xsize / 2 + 1; 99 RP->Xsize = RP->Xsize / 2 + 1;
189 100
190 if (RP->Xsize < MIN_RANDOM_MAP_SIZE) 101 if (RP->expand2x > 0)
191 RP->Xsize = MIN_RANDOM_MAP_SIZE + RANDOM () % 5; 102 {
192 if (RP->Ysize < MIN_RANDOM_MAP_SIZE) 103 RP->Xsize /= 2;
193 RP->Ysize = MIN_RANDOM_MAP_SIZE + RANDOM () % 5; 104 RP->Ysize /= 2;
105 }
106
194 RP->map_layout_style = 0; 107 RP->map_layout_style = LAYOUT_NONE;
195 108
196 /* Redo this - there was a lot of redundant code of checking for preset 109 /* Redo this - there was a lot of redundant code of checking for preset
197 * layout style and then random layout style. Instead, figure out 110 * layout style and then random layout style. Instead, figure out
198 * the numeric layoutstyle, so there is only one area that actually 111 * the numeric layoutstyle, so there is only one area that actually
199 * calls the code to make the maps. 112 * calls the code to make the maps.
… …
214 RP->map_layout_style = LAYOUT_SNAKE; 127 RP->map_layout_style = LAYOUT_SNAKE;
215 128
216 if (strstr (RP->layoutstyle, "squarespiral")) 129 if (strstr (RP->layoutstyle, "squarespiral"))
217 RP->map_layout_style = LAYOUT_SQUARE_SPIRAL; 130 RP->map_layout_style = LAYOUT_SQUARE_SPIRAL;
218 131
219 /* No style found - choose one ranomdly */ 132 /* No style found - choose one randomly */
220 if (RP->map_layout_style == LAYOUT_NONE) 133 if (RP->map_layout_style == LAYOUT_NONE)
221 RP->map_layout_style = (RANDOM () % (NROFLAYOUTS - 1)) + 1; 134 RP->map_layout_style = (RANDOM () % (NROFLAYOUTS - 1)) + 1;
222 135
136 layout = layoutgen (RP);
137
138#ifdef RMAP_DEBUG
139 dump_layout (layout, RP);
140#endif
141
142 /* increment these for the current map */
143 RP->dungeon_level += 1;
144 /* allow constant-difficulty maps. */
145 /* difficulty+=1; */
146
147 /* rotate the layout randomly */
148 layout = rotate_layout (layout, rndm (4), RP);
149#ifdef RMAP_DEBUG
150 dump_layout (layout, RP);
151#endif
152
153 /* allocate the map and set the floor */
154 make_map_floor (layout, RP->floorstyle, RP);
155
156 /* set region */
157 region = RP->region;
158
159 CEDE;
160
161 /* create walls unless the wallstyle is "none" */
162 if (strcmp (RP->wallstyle, "none"))
163 {
164 make_map_walls (this, layout, RP->wallstyle, RP);
165
166 /* place doors unless doorstyle or wallstyle is "none" */
167 if (strcmp (RP->doorstyle, "none"))
168 put_doors (this, layout, RP->doorstyle, RP);
169
170 }
171
172 CEDE;
173
174 /* create exits unless the exitstyle is "none" */
175 if (strcmp (RP->exitstyle, "none"))
176 place_exits (this, layout, RP->exitstyle, RP->orientation, RP);
177
178 CEDE;
179
180 place_specials_in_map (this, layout, RP);
181
182 CEDE;
183
184 /* create monsters unless the monsterstyle is "none" */
185 if (strcmp (RP->monsterstyle, "none"))
186 place_monsters (this, RP->monsterstyle, RP->difficulty, RP);
187
188 CEDE;
189
190 /* treasures needs to have a proper difficulty set for the map. */
191 difficulty = estimate_difficulty ();
192
193 CEDE;
194
195 /* create treasure unless the treasurestyle is "none" */
196 if (strcmp (RP->treasurestyle, "none"))
197 place_treasure (this, layout, RP->treasurestyle, RP->treasureoptions, RP);
198
199 CEDE;
200
201 /* create decor unless the decorstyle is "none" */
202 if (strcmp (RP->decorstyle, "none"))
203 put_decor (this, layout, RP->decorstyle, RP->decoroptions, RP);
204
205 CEDE;
206
207 /* generate treasures, etc. */
208 fix_auto_apply ();
209
210 CEDE;
211
212 unblock_exits (this, layout, RP);
213
214 /* free the layout */
215 for (i = 0; i < RP->Xsize; i++)
216 free (layout[i]);
217
218 free (layout);
219
220 msg = strdup (buf);
221 in_memory = MAP_IN_MEMORY;
222
223 CEDE;
224
225 return 1;
226}
227
228/* function selects the layout function and gives it whatever
229 arguments it needs. */
230char **
231layoutgen (random_map_params *RP)
232{
233 char **maze = 0;
234 int oxsize = RP->Xsize, oysize = RP->Ysize;
235
223 switch (RP->map_layout_style) 236 switch (RP->map_layout_style)
224 { 237 {
225 case LAYOUT_ONION: 238 case LAYOUT_ONION:
226 maze = map_gen_onion (RP->Xsize, RP->Ysize, RP->layoutoptions1, RP->layoutoptions2); 239 maze = map_gen_onion (RP->Xsize, RP->Ysize, RP->layoutoptions1, RP->layoutoptions2);
227 if (!(RANDOM () % 3) && !(RP->layoutoptions1 & RMOPT_WALLS_ONLY)) 240 if (!(rndm (3)) && !(RP->layoutoptions1 & RMOPT_WALLS_ONLY))
228 roomify_layout (maze, RP); 241 roomify_layout (maze, RP);
229 break; 242 break;
230 243
231 case LAYOUT_MAZE: 244 case LAYOUT_MAZE:
232 maze = maze_gen (RP->Xsize, RP->Ysize, RANDOM () % 2); 245 maze = maze_gen (RP->Xsize, RP->Ysize, rndm (2));
233 if (!(RANDOM () % 2)) 246 if (!(rndm (2)))
234 doorify_layout (maze, RP); 247 doorify_layout (maze, RP);
235 break; 248 break;
236 249
237 case LAYOUT_SPIRAL: 250 case LAYOUT_SPIRAL:
238 maze = map_gen_spiral (RP->Xsize, RP->Ysize, RP->layoutoptions1); 251 maze = map_gen_spiral (RP->Xsize, RP->Ysize, RP->layoutoptions1);
239 if (!(RANDOM () % 2)) 252 if (!(rndm (2)))
240 doorify_layout (maze, RP); 253 doorify_layout (maze, RP);
241 break; 254 break;
242 255
243 case LAYOUT_ROGUELIKE: 256 case LAYOUT_ROGUELIKE:
244 /* Don't put symmetry in rogue maps. There isn't much reason to 257 /* Don't put symmetry in rogue maps. There isn't much reason to
… …
255 /* no doorifying... done already */ 268 /* no doorifying... done already */
256 break; 269 break;
257 270
258 case LAYOUT_SNAKE: 271 case LAYOUT_SNAKE:
259 maze = make_snake_layout (RP->Xsize, RP->Ysize, RP->layoutoptions1); 272 maze = make_snake_layout (RP->Xsize, RP->Ysize, RP->layoutoptions1);
260 if (RANDOM () % 2) 273 if (rndm (2))
261 roomify_layout (maze, RP); 274 roomify_layout (maze, RP);
262 break; 275 break;
263 276
264 case LAYOUT_SQUARE_SPIRAL: 277 case LAYOUT_SQUARE_SPIRAL:
265 maze = make_square_spiral_layout (RP->Xsize, RP->Ysize, RP->layoutoptions1); 278 maze = make_square_spiral_layout (RP->Xsize, RP->Ysize, RP->layoutoptions1);
266 if (RANDOM () % 2) 279 if (rndm (2))
267 roomify_layout (maze, RP); 280 roomify_layout (maze, RP);
268 break; 281 break;
269 } 282 }
270 283
271 maze = symmetrize_layout (maze, RP->symmetry_used, RP); 284 maze = symmetrize_layout (maze, RP->symmetry_used, RP);
… …
285} 298}
286 299
287/* takes a map and makes it symmetric: adjusts Xsize and 300/* takes a map and makes it symmetric: adjusts Xsize and
288Ysize to produce a symmetric map. */ 301Ysize to produce a symmetric map. */
289char ** 302char **
290symmetrize_layout (char **maze, int sym, random_map_params * RP) 303symmetrize_layout (char **maze, int sym, random_map_params *RP)
291{ 304{
292 int i, j; 305 int i, j;
293 char **sym_maze; 306 char **sym_maze;
294 int Xsize_orig, Ysize_orig; 307 int Xsize_orig, Ysize_orig;
295 308
… …
353 onion layouts, making them possibly centered on any wall. 366 onion layouts, making them possibly centered on any wall.
354 It'll modify Xsize and Ysize if they're swapped. 367 It'll modify Xsize and Ysize if they're swapped.
355*/ 368*/
356 369
357char ** 370char **
358rotate_layout (char **maze, int rotation, random_map_params * RP) 371rotate_layout (char **maze, int rotation, random_map_params *RP)
359{ 372{
360 char **new_maze; 373 char **new_maze;
361 int i, j; 374 int i, j;
362 375
363 switch (rotation) 376 switch (rotation)
364 { 377 {
365 case 0: 378 case 0:
366 return maze; 379 return maze;
367 break; 380 break;
368 case 2: /* a reflection */ 381 case 2: /* a reflection */
369 { 382 {
370 char *newmaze = (char *) malloc (sizeof (char) * RP->Xsize * RP->Ysize); 383 char *newmaze = (char *) malloc (sizeof (char) * RP->Xsize * RP->Ysize);
371 384
372 for (i = 0; i < RP->Xsize; i++) 385 for (i = 0; i < RP->Xsize; i++)
373 { /* make a copy */ 386 { /* make a copy */
374 for (j = 0; j < RP->Ysize; j++) 387 for (j = 0; j < RP->Ysize; j++)
375 { 388 {
376 newmaze[i * RP->Ysize + j] = maze[i][j]; 389 newmaze[i * RP->Ysize + j] = maze[i][j];
377 } 390 }
378 } 391 }
379 for (i = 0; i < RP->Xsize; i++) 392 for (i = 0; i < RP->Xsize; i++)
380 { /* copy a reflection back */ 393 { /* copy a reflection back */
381 for (j = 0; j < RP->Ysize; j++) 394 for (j = 0; j < RP->Ysize; j++)
382 { 395 {
383 maze[i][j] = newmaze[(RP->Xsize - i - 1) * RP->Ysize + RP->Ysize - j - 1]; 396 maze[i][j] = newmaze[(RP->Xsize - i - 1) * RP->Ysize + RP->Ysize - j - 1];
384 } 397 }
385 } 398 }
… …
394 new_maze = (char **) calloc (sizeof (char *), RP->Ysize); 407 new_maze = (char **) calloc (sizeof (char *), RP->Ysize);
395 for (i = 0; i < RP->Ysize; i++) 408 for (i = 0; i < RP->Ysize; i++)
396 { 409 {
397 new_maze[i] = (char *) calloc (sizeof (char), RP->Xsize); 410 new_maze[i] = (char *) calloc (sizeof (char), RP->Xsize);
398 } 411 }
399 if (rotation == 1) /* swap x and y */ 412 if (rotation == 1) /* swap x and y */
400 for (i = 0; i < RP->Xsize; i++) 413 for (i = 0; i < RP->Xsize; i++)
401 for (j = 0; j < RP->Ysize; j++) 414 for (j = 0; j < RP->Ysize; j++)
402 new_maze[j][i] = maze[i][j]; 415 new_maze[j][i] = maze[i][j];
403 416
404 if (rotation == 3) 417 if (rotation == 3)
405 { /* swap x and y */ 418 { /* swap x and y */
406 for (i = 0; i < RP->Xsize; i++) 419 for (i = 0; i < RP->Xsize; i++)
407 for (j = 0; j < RP->Ysize; j++) 420 for (j = 0; j < RP->Ysize; j++)
408 new_maze[j][i] = maze[RP->Xsize - i - 1][RP->Ysize - j - 1]; 421 new_maze[j][i] = maze[RP->Xsize - i - 1][RP->Ysize - j - 1];
409 } 422 }
410 423
… …
424} 437}
425 438
426/* take a layout and make some rooms in it. 439/* take a layout and make some rooms in it.
427 --works best on onions.*/ 440 --works best on onions.*/
428void 441void
429roomify_layout (char **maze, random_map_params * RP) 442roomify_layout (char **maze, random_map_params *RP)
430{ 443{
431 int tries = RP->Xsize * RP->Ysize / 30; 444 int tries = RP->Xsize * RP->Ysize / 30;
432 int ti; 445 int ti;
433 446
434 for (ti = 0; ti < tries; ti++) 447 for (ti = 0; ti < tries; ti++)
… …
461/* checks the layout to see if I can stick a horizontal(dir = 0) wall 474/* checks the layout to see if I can stick a horizontal(dir = 0) wall
462 (or vertical, dir == 1) 475 (or vertical, dir == 1)
463 here which ends up on other walls sensibly. */ 476 here which ends up on other walls sensibly. */
464 477
465int 478int
466can_make_wall (char **maze, int dx, int dy, int dir, random_map_params * RP) 479can_make_wall (char **maze, int dx, int dy, int dir, random_map_params *RP)
467{ 480{
468 int i1; 481 int i1;
469 int length = 0; 482 int length = 0;
470 483
471 /* dont make walls if we're on the edge. */ 484 /* dont make walls if we're on the edge. */
… …
546make_wall (char **maze, int x, int y, int dir) 559make_wall (char **maze, int x, int y, int dir)
547{ 560{
548 maze[x][y] = 'D'; /* mark a door */ 561 maze[x][y] = 'D'; /* mark a door */
549 switch (dir) 562 switch (dir)
550 { 563 {
551 case 0: /* horizontal */ 564 case 0: /* horizontal */
552 { 565 {
553 int i1; 566 int i1;
554 567
555 for (i1 = x - 1; maze[i1][y] == 0; i1--) 568 for (i1 = x - 1; maze[i1][y] == 0; i1--)
556 maze[i1][y] = '#'; 569 maze[i1][y] = '#';
557 for (i1 = x + 1; maze[i1][y] == 0; i1++) 570 for (i1 = x + 1; maze[i1][y] == 0; i1++)
558 maze[i1][y] = '#'; 571 maze[i1][y] = '#';
559 break; 572 break;
560 } 573 }
561 case 1: /* vertical */ 574 case 1: /* vertical */
562 { 575 {
563 int i1; 576 int i1;
564 577
565 for (i1 = y - 1; maze[x][i1] == 0; i1--) 578 for (i1 = y - 1; maze[x][i1] == 0; i1--)
566 maze[x][i1] = '#'; 579 maze[x][i1] = '#';
567 for (i1 = y + 1; maze[x][i1] == 0; i1++) 580 for (i1 = y + 1; maze[x][i1] == 0; i1++)
568 maze[x][i1] = '#'; 581 maze[x][i1] = '#';
569 break; 582 break;
570 } 583 }
571 } 584 }
572 585
573 return 0; 586 return 0;
574} 587}
575 588
576/* puts doors at appropriate locations in a layout. */ 589/* puts doors at appropriate locations in a layout. */
577void 590void
578doorify_layout (char **maze, random_map_params * RP) 591doorify_layout (char **maze, random_map_params *RP)
579{ 592{
580 int ndoors = RP->Xsize * RP->Ysize / 60; /* reasonable number of doors. */ 593 int ndoors = RP->Xsize * RP->Ysize / 60; /* reasonable number of doors. */
581 char *doorlist_x; 594 char *doorlist_x;
582 char *doorlist_y; 595 char *doorlist_y;
583 int doorlocs = 0; /* # of available doorlocations */ 596 int doorlocs = 0; /* # of available doorlocations */
… …
624 free (doorlist_x); 637 free (doorlist_x);
625 free (doorlist_y); 638 free (doorlist_y);
626} 639}
627 640
628void 641void
629write_map_parameters_to_string (char *buf, random_map_params * RP) 642write_map_parameters_to_string (char *buf, random_map_params *RP)
630{ 643{
631 char small_buf[256]; 644 char small_buf[16384];
632 645
633 sprintf (buf, "xsize %d\nysize %d\n", RP->Xsize, RP->Ysize); 646 sprintf (buf, "xsize %d\nysize %d\n", RP->Xsize, RP->Ysize);
634 647
635 if (RP->wallstyle[0]) 648 if (RP->wallstyle[0])
636 { 649 {
… …
678 { 691 {
679 sprintf (small_buf, "exitstyle %s\n", RP->exitstyle); 692 sprintf (small_buf, "exitstyle %s\n", RP->exitstyle);
680 strcat (buf, small_buf); 693 strcat (buf, small_buf);
681 } 694 }
682 695
683 if (RP->final_map[0]) 696 if (RP->final_map.length ())
684 { 697 {
685 sprintf (small_buf, "final_map %s\n", RP->final_map); 698 sprintf (small_buf, "final_map %s\n", &RP->final_map);
686 strcat (buf, small_buf); 699 strcat (buf, small_buf);
687 } 700 }
688 701
689 if (RP->exit_on_final_map[0]) 702 if (RP->exit_on_final_map[0])
690 { 703 {
691 sprintf (small_buf, "exit_on_final_map %s\n", RP->exit_on_final_map); 704 sprintf (small_buf, "exit_on_final_map %s\n", RP->exit_on_final_map);
692 strcat (buf, small_buf); 705 strcat (buf, small_buf);
693 } 706 }
694 707
695 if (RP->this_map[0]) 708 if (RP->this_map.length ())
696 { 709 {
697 sprintf (small_buf, "origin_map %s\n", RP->this_map); 710 sprintf (small_buf, "origin_map %s\n", &RP->this_map);
698 strcat (buf, small_buf); 711 strcat (buf, small_buf);
699 } 712 }
700 713
701 if (RP->expand2x) 714 if (RP->expand2x)
702 { 715 {
… …
708 { 721 {
709 sprintf (small_buf, "layoutoptions1 %d\n", RP->layoutoptions1); 722 sprintf (small_buf, "layoutoptions1 %d\n", RP->layoutoptions1);
710 strcat (buf, small_buf); 723 strcat (buf, small_buf);
711 } 724 }
712 725
713
714 if (RP->layoutoptions2) 726 if (RP->layoutoptions2)
715 { 727 {
716 sprintf (small_buf, "layoutoptions2 %d\n", RP->layoutoptions2); 728 sprintf (small_buf, "layoutoptions2 %d\n", RP->layoutoptions2);
717 strcat (buf, small_buf); 729 strcat (buf, small_buf);
718 } 730 }
719 731
720
721 if (RP->layoutoptions3) 732 if (RP->layoutoptions3)
722 { 733 {
723 sprintf (small_buf, "layoutoptions3 %d\n", RP->layoutoptions3); 734 sprintf (small_buf, "layoutoptions3 %d\n", RP->layoutoptions3);
724 strcat (buf, small_buf); 735 strcat (buf, small_buf);
725 } 736 }
… …
727 if (RP->symmetry) 738 if (RP->symmetry)
728 { 739 {
729 sprintf (small_buf, "symmetry %d\n", RP->symmetry); 740 sprintf (small_buf, "symmetry %d\n", RP->symmetry);
730 strcat (buf, small_buf); 741 strcat (buf, small_buf);
731 } 742 }
732
733 743
734 if (RP->difficulty && RP->difficulty_given) 744 if (RP->difficulty && RP->difficulty_given)
735 { 745 {
736 sprintf (small_buf, "difficulty %d\n", RP->difficulty); 746 sprintf (small_buf, "difficulty %d\n", RP->difficulty);
737 strcat (buf, small_buf); 747 strcat (buf, small_buf);
… …
774 { 784 {
775 sprintf (small_buf, "origin_y %d\n", RP->origin_y); 785 sprintf (small_buf, "origin_y %d\n", RP->origin_y);
776 strcat (buf, small_buf); 786 strcat (buf, small_buf);
777 } 787 }
778 788
789 if (RP->treasureoptions)
790 {
791 sprintf (small_buf, "treasureoptions %d\n", RP->treasureoptions);
792 strcat (buf, small_buf);
793 }
794
779 if (RP->random_seed) 795 if (RP->random_seed)
780 { 796 {
781 /* Add one so that the next map is a bit different */
782 sprintf (small_buf, "random_seed %d\n", RP->random_seed + 1); 797 sprintf (small_buf, "random_seed %d\n", RP->random_seed);
783 strcat (buf, small_buf); 798 strcat (buf, small_buf);
784 }
785
786 if (RP->treasureoptions)
787 { 799 }
788 sprintf (small_buf, "treasureoptions %d\n", RP->treasureoptions); 800
801 if (RP->custom)
802 {
803 sprintf (small_buf, "custom %s\n", RP->custom);
789 strcat (buf, small_buf); 804 strcat (buf, small_buf);
790 } 805 }
791} 806}
792 807
793void 808void
… …
815 int difficulty_given_n, 830 int difficulty_given_n,
816 int decoroptions_n, 831 int decoroptions_n,
817 int orientation_n, 832 int orientation_n,
818 int origin_x_n, int origin_y_n, int random_seed_n, int treasureoptions_n, float difficulty_increase) 833 int origin_x_n, int origin_y_n, int random_seed_n, int treasureoptions_n, float difficulty_increase)
819{ 834{
820
821 char small_buf[256]; 835 char small_buf[16384];
822 836
823 sprintf (buf, "xsize %d\nysize %d\n", xsize_n, ysize_n); 837 sprintf (buf, "xsize %d\nysize %d\n", xsize_n, ysize_n);
824 838
825 if (wallstyle_n && wallstyle_n[0]) 839 if (wallstyle_n && wallstyle_n[0])
826 { 840 {
… …
969 if (treasureoptions_n) 983 if (treasureoptions_n)
970 { 984 {
971 sprintf (small_buf, "treasureoptions %d\n", treasureoptions_n); 985 sprintf (small_buf, "treasureoptions %d\n", treasureoptions_n);
972 strcat (buf, small_buf); 986 strcat (buf, small_buf);
973 } 987 }
974
975
976} 988}
977 989
978/* copy an object with an inventory... i.e., duplicate the inv too. */ 990/* copy an object with an inventory... i.e., duplicate the inv too. */
979void 991void
980copy_object_with_inv (object *src_ob, object *dest_ob) 992copy_object_with_inv (object *src_ob, object *dest_ob)
981{ 993{
982 object *walk, *tmp; 994 object *walk, *tmp;
983 995
984 src_ob->copy_to (dest_ob); 996 src_ob->copy_to (dest_ob);
985 997
986 for (walk = src_ob->inv; walk != NULL; walk = walk->below) 998 for (walk = src_ob->inv; walk; walk = walk->below)
987 { 999 {
988 tmp = object::create (); 1000 tmp = object::create ();
1001
989 walk->copy_to (tmp); 1002 walk->copy_to (tmp);
990 insert_ob_in_ob (tmp, dest_ob); 1003 insert_ob_in_ob (tmp, dest_ob);
991 } 1004 }
992} 1005}

Diff Legend

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