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.30 by root, Sun Jul 1 05:00:19 2007 UTC

1/* 1/*
2 CrossFire, A Multiplayer game for X-windows 2 * This file is part of Crossfire TRT, the Roguelike Realtime MORPG.
3 3 *
4 * Copyright (©) 2005,2006,2007 Marc Alexander Lehmann / Robin Redeker / the Crossfire TRT team
4 Copyright (C) 2001 Mark Wedel & Crossfire Development Team 5 * Copyright (©) 2001,2007 Mark Wedel & Crossfire Development Team
5 Copyright (C) 1992 Frank Tore Johansen 6 * Copyright (©) 1992,2007 Frank Tore Johansen
6 7 *
7 This program is free software; you can redistribute it and/or modify 8 * Crossfire TRT 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 3 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, see <http://www.gnu.org/licenses/>.
19 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 20 *
20
21 The authors can be reached via e-mail at <crossfire@schmorp.de> 21 * The authors can be reached via e-mail to <crossfire@schmorp.de>
22*/ 22 */
23 23
24#include <time.h> 24#include <time.h>
25#include <stdio.h> 25#include <stdio.h>
26#include <global.h> 26#include <global.h>
27#include <maze_gen.h> 27#include <maze_gen.h>
28#include <room_gen.h> 28#include <room_gen.h>
29#include <random_map.h> 29#include <random_map.h>
30#include <rproto.h> 30#include <rproto.h>
31#include <sproto.h> 31#include <sproto.h>
32 32
33#define CEDE coroapi::cede_to_tick (); rndm.seed (RP->random_seed + __LINE__);
34
33void 35void
34dump_layout (char **layout, random_map_params * RP) 36dump_layout (char **layout, random_map_params *RP)
35{ 37{
36 { 38 {
37 int i, j; 39 int i, j;
38 40
39 for (i = 0; i < RP->Xsize; i++) 41 for (i = 0; i < RP->Xsize; i++)
… …
50 } 52 }
51 } 53 }
52 printf ("\n"); 54 printf ("\n");
53} 55}
54 56
55extern FILE *logfile; 57bool
56 58maptile::generate_random_map (random_map_params *RP)
57maptile *
58generate_random_map (const char *OutFileName, random_map_params * RP)
59{ 59{
60 char **layout, buf[HUGE_BUF]; 60 char **layout, buf[16384];
61 maptile *theMap;
62 int i; 61 int i;
63 62
63 RP->Xsize = RP->xsize;
64 RP->Ysize = RP->ysize;
65
64 /* pick a random seed, or use the one from the input file */ 66 /* pick a random seed, or use the one from the input file */
65 if (RP->random_seed == 0) 67 RP->random_seed = RP->random_seed
66 RP->random_seed = time (0); 68 ? RP->random_seed + RP->dungeon_level
67 69 : time (0);
68 SRANDOM (RP->random_seed); 70 CEDE;
69 71
70 write_map_parameters_to_string (buf, RP); 72 write_map_parameters_to_string (buf, RP);
71 73
72 if (RP->difficulty == 0) 74 if (RP->difficulty == 0)
73 { 75 {
… …
81 } 83 }
82 else 84 else
83 RP->difficulty_given = 1; 85 RP->difficulty_given = 1;
84 86
85 if (RP->Xsize < MIN_RANDOM_MAP_SIZE) 87 if (RP->Xsize < MIN_RANDOM_MAP_SIZE)
86 RP->Xsize = MIN_RANDOM_MAP_SIZE + RANDOM () % 25 + 5; 88 RP->Xsize = MIN_RANDOM_MAP_SIZE + rndm (25) + 5;
87 89
88 if (RP->Ysize < MIN_RANDOM_MAP_SIZE) 90 if (RP->Ysize < MIN_RANDOM_MAP_SIZE)
89 RP->Ysize = MIN_RANDOM_MAP_SIZE + RANDOM () % 25 + 5; 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;
90 103
91 if (RP->expand2x > 0) 104 if (RP->expand2x > 0)
92 { 105 {
93 RP->Xsize /= 2; 106 RP->Xsize /= 2;
94 RP->Ysize /= 2; 107 RP->Ysize /= 2;
95 } 108 }
96 109
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; 110 RP->map_layout_style = LAYOUT_NONE;
193 111
194 /* Redo this - there was a lot of redundant code of checking for preset 112 /* Redo this - there was a lot of redundant code of checking for preset
195 * layout style and then random layout style. Instead, figure out 113 * layout style and then random layout style. Instead, figure out
196 * the numeric layoutstyle, so there is only one area that actually 114 * the numeric layoutstyle, so there is only one area that actually
197 * calls the code to make the maps. 115 * calls the code to make the maps.
… …
212 RP->map_layout_style = LAYOUT_SNAKE; 130 RP->map_layout_style = LAYOUT_SNAKE;
213 131
214 if (strstr (RP->layoutstyle, "squarespiral")) 132 if (strstr (RP->layoutstyle, "squarespiral"))
215 RP->map_layout_style = LAYOUT_SQUARE_SPIRAL; 133 RP->map_layout_style = LAYOUT_SQUARE_SPIRAL;
216 134
217 /* No style found - choose one ranomdly */ 135 /* No style found - choose one randomly */
218 if (RP->map_layout_style == LAYOUT_NONE) 136 if (RP->map_layout_style == LAYOUT_NONE)
219 RP->map_layout_style = (RANDOM () % (NROFLAYOUTS - 1)) + 1; 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}
229
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;
220 237
221 switch (RP->map_layout_style) 238 switch (RP->map_layout_style)
222 { 239 {
223 case LAYOUT_ONION: 240 case LAYOUT_ONION:
224 maze = map_gen_onion (RP->Xsize, RP->Ysize, RP->layoutoptions1, RP->layoutoptions2); 241 maze = map_gen_onion (RP->Xsize, RP->Ysize, RP->layoutoptions1, RP->layoutoptions2);
225 if (!(RANDOM () % 3) && !(RP->layoutoptions1 & RMOPT_WALLS_ONLY)) 242 if (!(rndm (3)) && !(RP->layoutoptions1 & RMOPT_WALLS_ONLY))
226 roomify_layout (maze, RP); 243 roomify_layout (maze, RP);
227 break; 244 break;
228 245
229 case LAYOUT_MAZE: 246 case LAYOUT_MAZE:
230 maze = maze_gen (RP->Xsize, RP->Ysize, RANDOM () % 2); 247 maze = maze_gen (RP->Xsize, RP->Ysize, rndm (2));
231 if (!(RANDOM () % 2)) 248 if (!(rndm (2)))
232 doorify_layout (maze, RP); 249 doorify_layout (maze, RP);
233 break; 250 break;
234 251
235 case LAYOUT_SPIRAL: 252 case LAYOUT_SPIRAL:
236 maze = map_gen_spiral (RP->Xsize, RP->Ysize, RP->layoutoptions1); 253 maze = map_gen_spiral (RP->Xsize, RP->Ysize, RP->layoutoptions1);
237 if (!(RANDOM () % 2)) 254 if (!(rndm (2)))
238 doorify_layout (maze, RP); 255 doorify_layout (maze, RP);
239 break; 256 break;
240 257
241 case LAYOUT_ROGUELIKE: 258 case LAYOUT_ROGUELIKE:
242 /* Don't put symmetry in rogue maps. There isn't much reason to 259 /* Don't put symmetry in rogue maps. There isn't much reason to
… …
253 /* no doorifying... done already */ 270 /* no doorifying... done already */
254 break; 271 break;
255 272
256 case LAYOUT_SNAKE: 273 case LAYOUT_SNAKE:
257 maze = make_snake_layout (RP->Xsize, RP->Ysize, RP->layoutoptions1); 274 maze = make_snake_layout (RP->Xsize, RP->Ysize, RP->layoutoptions1);
258 if (RANDOM () % 2) 275 if (rndm (2))
259 roomify_layout (maze, RP); 276 roomify_layout (maze, RP);
260 break; 277 break;
261 278
262 case LAYOUT_SQUARE_SPIRAL: 279 case LAYOUT_SQUARE_SPIRAL:
263 maze = make_square_spiral_layout (RP->Xsize, RP->Ysize, RP->layoutoptions1); 280 maze = make_square_spiral_layout (RP->Xsize, RP->Ysize, RP->layoutoptions1);
264 if (RANDOM () % 2) 281 if (rndm (2))
265 roomify_layout (maze, RP); 282 roomify_layout (maze, RP);
266 break; 283 break;
267 } 284 }
268 285
269 maze = symmetrize_layout (maze, RP->symmetry_used, RP); 286 maze = symmetrize_layout (maze, RP->symmetry_used, RP);
… …
283} 300}
284 301
285/* takes a map and makes it symmetric: adjusts Xsize and 302/* takes a map and makes it symmetric: adjusts Xsize and
286Ysize to produce a symmetric map. */ 303Ysize to produce a symmetric map. */
287char ** 304char **
288symmetrize_layout (char **maze, int sym, random_map_params * RP) 305symmetrize_layout (char **maze, int sym, random_map_params *RP)
289{ 306{
290 int i, j; 307 int i, j;
291 char **sym_maze; 308 char **sym_maze;
292 int Xsize_orig, Ysize_orig; 309 int Xsize_orig, Ysize_orig;
293 310
… …
351 onion layouts, making them possibly centered on any wall. 368 onion layouts, making them possibly centered on any wall.
352 It'll modify Xsize and Ysize if they're swapped. 369 It'll modify Xsize and Ysize if they're swapped.
353*/ 370*/
354 371
355char ** 372char **
356rotate_layout (char **maze, int rotation, random_map_params * RP) 373rotate_layout (char **maze, int rotation, random_map_params *RP)
357{ 374{
358 char **new_maze; 375 char **new_maze;
359 int i, j; 376 int i, j;
360 377
361 switch (rotation) 378 switch (rotation)
362 { 379 {
363 case 0: 380 case 0:
364 return maze; 381 return maze;
365 break; 382 break;
366 case 2: /* a reflection */ 383 case 2: /* a reflection */
367 { 384 {
368 char *newmaze = (char *) malloc (sizeof (char) * RP->Xsize * RP->Ysize); 385 char *newmaze = (char *) malloc (sizeof (char) * RP->Xsize * RP->Ysize);
369 386
370 for (i = 0; i < RP->Xsize; i++) 387 for (i = 0; i < RP->Xsize; i++)
371 { /* make a copy */ 388 { /* make a copy */
372 for (j = 0; j < RP->Ysize; j++) 389 for (j = 0; j < RP->Ysize; j++)
373 { 390 {
374 newmaze[i * RP->Ysize + j] = maze[i][j]; 391 newmaze[i * RP->Ysize + j] = maze[i][j];
375 } 392 }
376 } 393 }
377 for (i = 0; i < RP->Xsize; i++) 394 for (i = 0; i < RP->Xsize; i++)
378 { /* copy a reflection back */ 395 { /* copy a reflection back */
379 for (j = 0; j < RP->Ysize; j++) 396 for (j = 0; j < RP->Ysize; j++)
380 { 397 {
381 maze[i][j] = newmaze[(RP->Xsize - i - 1) * RP->Ysize + RP->Ysize - j - 1]; 398 maze[i][j] = newmaze[(RP->Xsize - i - 1) * RP->Ysize + RP->Ysize - j - 1];
382 } 399 }
383 } 400 }
… …
392 new_maze = (char **) calloc (sizeof (char *), RP->Ysize); 409 new_maze = (char **) calloc (sizeof (char *), RP->Ysize);
393 for (i = 0; i < RP->Ysize; i++) 410 for (i = 0; i < RP->Ysize; i++)
394 { 411 {
395 new_maze[i] = (char *) calloc (sizeof (char), RP->Xsize); 412 new_maze[i] = (char *) calloc (sizeof (char), RP->Xsize);
396 } 413 }
397 if (rotation == 1) /* swap x and y */ 414 if (rotation == 1) /* swap x and y */
398 for (i = 0; i < RP->Xsize; i++) 415 for (i = 0; i < RP->Xsize; i++)
399 for (j = 0; j < RP->Ysize; j++) 416 for (j = 0; j < RP->Ysize; j++)
400 new_maze[j][i] = maze[i][j]; 417 new_maze[j][i] = maze[i][j];
401 418
402 if (rotation == 3) 419 if (rotation == 3)
403 { /* swap x and y */ 420 { /* swap x and y */
404 for (i = 0; i < RP->Xsize; i++) 421 for (i = 0; i < RP->Xsize; i++)
405 for (j = 0; j < RP->Ysize; j++) 422 for (j = 0; j < RP->Ysize; j++)
406 new_maze[j][i] = maze[RP->Xsize - i - 1][RP->Ysize - j - 1]; 423 new_maze[j][i] = maze[RP->Xsize - i - 1][RP->Ysize - j - 1];
407 } 424 }
408 425
… …
422} 439}
423 440
424/* take a layout and make some rooms in it. 441/* take a layout and make some rooms in it.
425 --works best on onions.*/ 442 --works best on onions.*/
426void 443void
427roomify_layout (char **maze, random_map_params * RP) 444roomify_layout (char **maze, random_map_params *RP)
428{ 445{
429 int tries = RP->Xsize * RP->Ysize / 30; 446 int tries = RP->Xsize * RP->Ysize / 30;
430 int ti; 447 int ti;
431 448
432 for (ti = 0; ti < tries; ti++) 449 for (ti = 0; ti < tries; ti++)
433 { 450 {
434 int dx, dy; /* starting location for looking at creating a door */ 451 int dx, dy; /* starting location for looking at creating a door */
435 int cx, cy; /* results of checking on creating walls. */ 452 int cx, cy; /* results of checking on creating walls. */
436 453
437 dx = RANDOM () % RP->Xsize; 454 dx = rndm (RP->Xsize);
438 dy = RANDOM () % RP->Ysize; 455 dy = rndm (RP->Ysize);
456
439 cx = can_make_wall (maze, dx, dy, 0, RP); /* horizontal */ 457 cx = can_make_wall (maze, dx, dy, 0, RP); /* horizontal */
440 cy = can_make_wall (maze, dx, dy, 1, RP); /* vertical */ 458 cy = can_make_wall (maze, dx, dy, 1, RP); /* vertical */
441 if (cx == -1) 459 if (cx == -1)
442 { 460 {
443 if (cy != -1) 461 if (cy != -1)
444 make_wall (maze, dx, dy, 1); 462 make_wall (maze, dx, dy, 1);
463
445 continue; 464 continue;
446 } 465 }
466
447 if (cy == -1) 467 if (cy == -1)
448 { 468 {
449 make_wall (maze, dx, dy, 0); 469 make_wall (maze, dx, dy, 0);
450 continue; 470 continue;
451 } 471 }
472
452 if (cx < cy) 473 if (cx < cy)
453 make_wall (maze, dx, dy, 0); 474 make_wall (maze, dx, dy, 0);
454 else 475 else
455 make_wall (maze, dx, dy, 1); 476 make_wall (maze, dx, dy, 1);
456 } 477 }
… …
459/* checks the layout to see if I can stick a horizontal(dir = 0) wall 480/* checks the layout to see if I can stick a horizontal(dir = 0) wall
460 (or vertical, dir == 1) 481 (or vertical, dir == 1)
461 here which ends up on other walls sensibly. */ 482 here which ends up on other walls sensibly. */
462 483
463int 484int
464can_make_wall (char **maze, int dx, int dy, int dir, random_map_params * RP) 485can_make_wall (char **maze, int dx, int dy, int dir, random_map_params *RP)
465{ 486{
466 int i1; 487 int i1;
467 int length = 0; 488 int length = 0;
468 489
469 /* dont make walls if we're on the edge. */ 490 /* dont make walls if we're on the edge. */
… …
544make_wall (char **maze, int x, int y, int dir) 565make_wall (char **maze, int x, int y, int dir)
545{ 566{
546 maze[x][y] = 'D'; /* mark a door */ 567 maze[x][y] = 'D'; /* mark a door */
547 switch (dir) 568 switch (dir)
548 { 569 {
549 case 0: /* horizontal */ 570 case 0: /* horizontal */
550 { 571 {
551 int i1; 572 int i1;
552 573
553 for (i1 = x - 1; maze[i1][y] == 0; i1--) 574 for (i1 = x - 1; maze[i1][y] == 0; i1--)
554 maze[i1][y] = '#'; 575 maze[i1][y] = '#';
555 for (i1 = x + 1; maze[i1][y] == 0; i1++) 576 for (i1 = x + 1; maze[i1][y] == 0; i1++)
556 maze[i1][y] = '#'; 577 maze[i1][y] = '#';
557 break; 578 break;
558 } 579 }
559 case 1: /* vertical */ 580 case 1: /* vertical */
560 { 581 {
561 int i1; 582 int i1;
562 583
563 for (i1 = y - 1; maze[x][i1] == 0; i1--) 584 for (i1 = y - 1; maze[x][i1] == 0; i1--)
564 maze[x][i1] = '#'; 585 maze[x][i1] = '#';
565 for (i1 = y + 1; maze[x][i1] == 0; i1++) 586 for (i1 = y + 1; maze[x][i1] == 0; i1++)
566 maze[x][i1] = '#'; 587 maze[x][i1] = '#';
567 break; 588 break;
568 } 589 }
569 } 590 }
570 591
571 return 0; 592 return 0;
572} 593}
573 594
574/* puts doors at appropriate locations in a layout. */ 595/* puts doors at appropriate locations in a layout. */
575
576void 596void
577doorify_layout (char **maze, random_map_params * RP) 597doorify_layout (char **maze, random_map_params *RP)
578{ 598{
579 int ndoors = RP->Xsize * RP->Ysize / 60; /* reasonable number of doors. */ 599 int ndoors = RP->Xsize * RP->Ysize / 60; /* reasonable number of doors. */
580 char *doorlist_x; 600 char *doorlist_x;
581 char *doorlist_y; 601 char *doorlist_y;
582 int doorlocs = 0; /* # of available doorlocations */ 602 int doorlocs = 0; /* # of available doorlocations */
… …
597 doorlist_x[doorlocs] = i; 617 doorlist_x[doorlocs] = i;
598 doorlist_y[doorlocs] = j; 618 doorlist_y[doorlocs] = j;
599 doorlocs++; 619 doorlocs++;
600 } 620 }
601 } 621 }
622
602 while (ndoors > 0 && doorlocs > 0) 623 while (ndoors > 0 && doorlocs > 0)
603 { 624 {
604 int di; 625 int di;
605 int sindex; 626 int sindex;
606 627
607 di = RANDOM () % doorlocs; 628 di = rndm (doorlocs);
608 i = doorlist_x[di]; 629 i = doorlist_x[di];
609 j = doorlist_y[di]; 630 j = doorlist_y[di];
610 sindex = surround_flag (maze, i, j, RP); 631 sindex = surround_flag (maze, i, j, RP);
632
611 if (sindex == 3 || sindex == 12) /* these are possible door sindex */ 633 if (sindex == 3 || sindex == 12) /* these are possible door sindex */
612 { 634 {
613 maze[i][j] = 'D'; 635 maze[i][j] = 'D';
614 ndoors--; 636 ndoors--;
615 } 637 }
638
616 /* reduce the size of the list */ 639 /* reduce the size of the list */
617 doorlocs--; 640 doorlocs--;
618 doorlist_x[di] = doorlist_x[doorlocs]; 641 doorlist_x[di] = doorlist_x[doorlocs];
619 doorlist_y[di] = doorlist_y[doorlocs]; 642 doorlist_y[di] = doorlist_y[doorlocs];
620 } 643 }
644
621 free (doorlist_x); 645 free (doorlist_x);
622 free (doorlist_y); 646 free (doorlist_y);
623} 647}
624 648
625
626void 649void
627write_map_parameters_to_string (char *buf, random_map_params * RP) 650write_map_parameters_to_string (char *buf, random_map_params *RP)
628{ 651{
629 char small_buf[256]; 652 char small_buf[16384];
630 653
631 sprintf (buf, "xsize %d\nysize %d\n", RP->Xsize, RP->Ysize); 654 sprintf (buf, "xsize %d\nysize %d\n", RP->xsize, RP->ysize);
632 655
633 if (RP->wallstyle[0]) 656 if (RP->wallstyle[0])
634 { 657 {
635 sprintf (small_buf, "wallstyle %s\n", RP->wallstyle); 658 sprintf (small_buf, "wallstyle %s\n", RP->wallstyle);
636 strcat (buf, small_buf); 659 strcat (buf, small_buf);
… …
676 { 699 {
677 sprintf (small_buf, "exitstyle %s\n", RP->exitstyle); 700 sprintf (small_buf, "exitstyle %s\n", RP->exitstyle);
678 strcat (buf, small_buf); 701 strcat (buf, small_buf);
679 } 702 }
680 703
681 if (RP->final_map[0]) 704 if (RP->final_map.length ())
682 { 705 {
683 sprintf (small_buf, "final_map %s\n", RP->final_map); 706 sprintf (small_buf, "final_map %s\n", &RP->final_map);
684 strcat (buf, small_buf); 707 strcat (buf, small_buf);
685 } 708 }
686 709
687 if (RP->exit_on_final_map[0]) 710 if (RP->exit_on_final_map[0])
688 { 711 {
689 sprintf (small_buf, "exit_on_final_map %s\n", RP->exit_on_final_map); 712 sprintf (small_buf, "exit_on_final_map %s\n", RP->exit_on_final_map);
690 strcat (buf, small_buf); 713 strcat (buf, small_buf);
691 } 714 }
692 715
693 if (RP->this_map[0]) 716 if (RP->this_map.length ())
694 { 717 {
695 sprintf (small_buf, "origin_map %s\n", RP->this_map); 718 sprintf (small_buf, "origin_map %s\n", &RP->this_map);
696 strcat (buf, small_buf); 719 strcat (buf, small_buf);
697 } 720 }
698 721
699 if (RP->expand2x) 722 if (RP->expand2x)
700 { 723 {
… …
706 { 729 {
707 sprintf (small_buf, "layoutoptions1 %d\n", RP->layoutoptions1); 730 sprintf (small_buf, "layoutoptions1 %d\n", RP->layoutoptions1);
708 strcat (buf, small_buf); 731 strcat (buf, small_buf);
709 } 732 }
710 733
711
712 if (RP->layoutoptions2) 734 if (RP->layoutoptions2)
713 { 735 {
714 sprintf (small_buf, "layoutoptions2 %d\n", RP->layoutoptions2); 736 sprintf (small_buf, "layoutoptions2 %d\n", RP->layoutoptions2);
715 strcat (buf, small_buf); 737 strcat (buf, small_buf);
716 } 738 }
717 739
718
719 if (RP->layoutoptions3) 740 if (RP->layoutoptions3)
720 { 741 {
721 sprintf (small_buf, "layoutoptions3 %d\n", RP->layoutoptions3); 742 sprintf (small_buf, "layoutoptions3 %d\n", RP->layoutoptions3);
722 strcat (buf, small_buf); 743 strcat (buf, small_buf);
723 } 744 }
… …
725 if (RP->symmetry) 746 if (RP->symmetry)
726 { 747 {
727 sprintf (small_buf, "symmetry %d\n", RP->symmetry); 748 sprintf (small_buf, "symmetry %d\n", RP->symmetry);
728 strcat (buf, small_buf); 749 strcat (buf, small_buf);
729 } 750 }
730
731 751
732 if (RP->difficulty && RP->difficulty_given) 752 if (RP->difficulty && RP->difficulty_given)
733 { 753 {
734 sprintf (small_buf, "difficulty %d\n", RP->difficulty); 754 sprintf (small_buf, "difficulty %d\n", RP->difficulty);
735 strcat (buf, small_buf); 755 strcat (buf, small_buf);
… …
772 { 792 {
773 sprintf (small_buf, "origin_y %d\n", RP->origin_y); 793 sprintf (small_buf, "origin_y %d\n", RP->origin_y);
774 strcat (buf, small_buf); 794 strcat (buf, small_buf);
775 } 795 }
776 796
797 if (RP->treasureoptions)
798 {
799 sprintf (small_buf, "treasureoptions %d\n", RP->treasureoptions);
800 strcat (buf, small_buf);
801 }
802
777 if (RP->random_seed) 803 if (RP->random_seed)
778 { 804 {
779 /* Add one so that the next map is a bit different */
780 sprintf (small_buf, "random_seed %d\n", RP->random_seed + 1); 805 sprintf (small_buf, "random_seed %u\n", RP->random_seed);
781 strcat (buf, small_buf); 806 strcat (buf, small_buf);
782 }
783
784 if (RP->treasureoptions)
785 { 807 }
786 sprintf (small_buf, "treasureoptions %d\n", RP->treasureoptions); 808
809 if (RP->custom)
810 {
811 sprintf (small_buf, "custom %s\n", RP->custom);
787 strcat (buf, small_buf); 812 strcat (buf, small_buf);
788 } 813 }
789} 814}
790 815
791void 816void
792write_parameters_to_string (char *buf, 817write_parameters_to_string (char *buf,
793 int xsize_n, 818 int xsize_n,
794 int ysize_n, 819 int ysize_n,
795 char *wallstyle_n, 820 const char *wallstyle_n,
796 char *floorstyle_n, 821 const char *floorstyle_n,
797 char *monsterstyle_n, 822 const char *monsterstyle_n,
798 char *treasurestyle_n, 823 const char *treasurestyle_n,
799 char *layoutstyle_n, 824 const char *layoutstyle_n,
800 char *decorstyle_n, 825 const char *decorstyle_n,
801 char *doorstyle_n, 826 const char *doorstyle_n,
802 char *exitstyle_n, 827 const char *exitstyle_n,
803 char *final_map_n, 828 const char *final_map_n,
804 char *exit_on_final_map_n, 829 const char *exit_on_final_map_n,
805 char *this_map_n, 830 const char *this_map_n,
806 int layoutoptions1_n, 831 int layoutoptions1_n,
807 int layoutoptions2_n, 832 int layoutoptions2_n,
808 int layoutoptions3_n, 833 int layoutoptions3_n,
809 int symmetry_n, 834 int symmetry_n,
810 int dungeon_depth_n, 835 int dungeon_depth_n,
811 int dungeon_level_n, 836 int dungeon_level_n,
812 int difficulty_n, 837 int difficulty_n,
813 int difficulty_given_n, 838 int difficulty_given_n,
814 int decoroptions_n, 839 int decoroptions_n,
815 int orientation_n, 840 int orientation_n,
816 int origin_x_n, int origin_y_n, int random_seed_n, int treasureoptions_n, float difficulty_increase) 841 int origin_x_n,
842 int origin_y_n,
843 uint32_t random_seed_n,
844 int treasureoptions_n,
845 float difficulty_increase)
817{ 846{
818
819 char small_buf[256]; 847 char small_buf[16384];
820 848
821 sprintf (buf, "xsize %d\nysize %d\n", xsize_n, ysize_n); 849 sprintf (buf, "xsize %d\nysize %d\n", xsize_n, ysize_n);
822 850
823 if (wallstyle_n && wallstyle_n[0]) 851 if (wallstyle_n && wallstyle_n[0])
824 { 852 {
… …
889 if (layoutoptions1_n) 917 if (layoutoptions1_n)
890 { 918 {
891 sprintf (small_buf, "layoutoptions1 %d\n", layoutoptions1_n); 919 sprintf (small_buf, "layoutoptions1 %d\n", layoutoptions1_n);
892 strcat (buf, small_buf); 920 strcat (buf, small_buf);
893 } 921 }
894
895 922
896 if (layoutoptions2_n) 923 if (layoutoptions2_n)
897 { 924 {
898 sprintf (small_buf, "layoutoptions2 %d\n", layoutoptions2_n); 925 sprintf (small_buf, "layoutoptions2 %d\n", layoutoptions2_n);
899 strcat (buf, small_buf); 926 strcat (buf, small_buf);
… …
959 } 986 }
960 987
961 if (random_seed_n) 988 if (random_seed_n)
962 { 989 {
963 /* Add one so that the next map is a bit different */ 990 /* Add one so that the next map is a bit different */
964 sprintf (small_buf, "random_seed %d\n", random_seed_n + 1); 991 sprintf (small_buf, "random_seed %u\n", random_seed_n + 1);
965 strcat (buf, small_buf); 992 strcat (buf, small_buf);
966 } 993 }
967 994
968 if (treasureoptions_n) 995 if (treasureoptions_n)
969 { 996 {
970 sprintf (small_buf, "treasureoptions %d\n", treasureoptions_n); 997 sprintf (small_buf, "treasureoptions %d\n", treasureoptions_n);
971 strcat (buf, small_buf); 998 strcat (buf, small_buf);
972 } 999 }
973
974
975} 1000}
976 1001
977/* copy an object with an inventory... i.e., duplicate the inv too. */ 1002/* copy an object with an inventory... i.e., duplicate the inv too. */
978void 1003void
979copy_object_with_inv (object *src_ob, object *dest_ob) 1004copy_object_with_inv (object *src_ob, object *dest_ob)
980{ 1005{
981 object *walk, *tmp; 1006 object *walk, *tmp;
982 1007
983 src_ob->copy_to (dest_ob); 1008 src_ob->copy_to (dest_ob);
984 1009
985 for (walk = src_ob->inv; walk != NULL; walk = walk->below) 1010 for (walk = src_ob->inv; walk; walk = walk->below)
986 { 1011 {
987 tmp = object::create (); 1012 tmp = object::create ();
1013
988 walk->copy_to (tmp); 1014 walk->copy_to (tmp);
989 insert_ob_in_ob (tmp, dest_ob); 1015 insert_ob_in_ob (tmp, dest_ob);
990 } 1016 }
991} 1017}

Diff Legend

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