ViewVC Help
View File | Revision Log | Show Annotations | Download File
/cvs/deliantra/server/random_maps/random_map.C
(Generate patch)

Comparing deliantra/server/random_maps/random_map.C (file contents):
Revision 1.30 by root, Sun Jul 1 05:00:19 2007 UTC vs.
Revision 1.50 by root, Sun May 16 13:48:08 2010 UTC

1/* 1/*
2 * This file is part of Crossfire TRT, the Roguelike Realtime MORPG. 2 * This file is part of Deliantra, the Roguelike Realtime MMORPG.
3 * 3 *
4 * Copyright (©) 2005,2006,2007 Marc Alexander Lehmann / Robin Redeker / the Crossfire TRT team 4 * Copyright (©) 2005,2006,2007,2008,2009,2010 Marc Alexander Lehmann / Robin Redeker / the Deliantra team
5 * Copyright (©) 2001,2007 Mark Wedel & Crossfire Development Team 5 * Copyright (©) 2001 Mark Wedel & Crossfire Development Team
6 * Copyright (©) 1992,2007 Frank Tore Johansen 6 * Copyright (©) 1992 Frank Tore Johansen
7 * 7 *
8 * Crossfire TRT is free software: you can redistribute it and/or modify 8 * Deliantra is free software: you can redistribute it and/or modify it under
9 * it under the terms of the GNU General Public License as published by 9 * the terms of the Affero GNU General Public License as published by the
10 * the Free Software Foundation, either version 3 of the License, or 10 * Free Software Foundation, either version 3 of the License, or (at your
11 * (at your option) any later version. 11 * option) any later version.
12 * 12 *
13 * This program is distributed in the hope that it will be useful, 13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of 14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details. 16 * GNU General Public License for more details.
17 * 17 *
18 * You should have received a copy of the GNU General Public License 18 * You should have received a copy of the Affero GNU General Public License
19 * along with this program. If not, see <http://www.gnu.org/licenses/>. 19 * and the GNU General Public License along with this program. If not, see
20 * <http://www.gnu.org/licenses/>.
20 * 21 *
21 * The authors can be reached via e-mail to <crossfire@schmorp.de> 22 * The authors can be reached via e-mail to <support@deliantra.net>
22 */ 23 */
23 24
24#include <time.h> 25#include <time.h>
25#include <stdio.h> 26#include <stdio.h>
26#include <global.h> 27#include <global.h>
27#include <maze_gen.h>
28#include <room_gen.h>
29#include <random_map.h> 28#include <random_map.h>
30#include <rproto.h> 29#include <rproto.h>
31#include <sproto.h> 30#include <sproto.h>
32 31
33#define CEDE coroapi::cede_to_tick (); rndm.seed (RP->random_seed + __LINE__); 32#define CEDE coroapi::cede_to_tick ()
33
34static void symmetrize_layout (Layout maze, random_map_params *RP);
35static void rotate_layout (Layout maze, int rotation);
34 36
35void 37void
38dump_layout (Layout layout)
39{
40 for (int j = 0; j < layout->h; j++)
41 {
42 for (int i = 0; i < layout->w; i++)
43 putc (layout[i][j] ? layout[i][j] : ' ', stdout);
44
45 putc ('\n', stdout);
46 }
47
48 putc ('\n', stdout);
49}
50
51/* takes a map and makes it symmetric: adjusts Xsize and
52 * Ysize to produce a symmetric map.
53 */
54static void
55symmetrize_layout (Layout layout, random_map_params *RP)
56{
57 if (RP->symmetry_used == SYMMETRY_NONE)
58 return;
59
60 Layout sym_layout (
61 RP->symmetry_used == SYMMETRY_X || RP->symmetry_used == SYMMETRY_XY ? layout->w * 2 - 3 : layout->w,
62 RP->symmetry_used == SYMMETRY_Y || RP->symmetry_used == SYMMETRY_XY ? layout->h * 2 - 3 : layout->h
63 );
64
65 if (RP->symmetry_used == SYMMETRY_X)
66 for (int i = 0; i < sym_layout->w / 2 + 1; i++)
67 for (int j = 0; j < sym_layout->h; j++)
68 {
69 sym_layout[i ][j] =
70 sym_layout[sym_layout->w - i - 1][j] = layout[i][j];
71 }
72
73 if (RP->symmetry_used == SYMMETRY_Y)
74 for (int i = 0; i < sym_layout->w; i++)
75 for (int j = 0; j < sym_layout->h / 2 + 1; j++)
76 {
77 sym_layout[i][j ] =
78 sym_layout[i][sym_layout->h - j - 1] = layout[i][j];
79 }
80
81 if (RP->symmetry_used == SYMMETRY_XY)
82 for (int i = 0; i < sym_layout->w / 2 + 1; i++)
83 for (int j = 0; j < sym_layout->h / 2 + 1; j++)
84 {
85 sym_layout[i ][j ] =
86 sym_layout[i ][sym_layout->h - j - 1] =
87 sym_layout[sym_layout->w - i - 1][j ] =
88 sym_layout[sym_layout->w - i - 1][sym_layout->h - j - 1] = layout[i][j];
89 }
90
91 layout.swap (sym_layout);
92 sym_layout.free ();
93
94 /* reconnect disjointed spirals */
95 /* reconnect disjointed nethacklayouts: the routine for
96 spirals will do the trick? */
97 if (RP->map_layout_style == LAYOUT_SPIRAL
98 || RP->map_layout_style == LAYOUT_ROGUELIKE)
99 connect_spirals (layout->w, layout->h, RP->symmetry_used, layout);
100}
101
102/* takes a map and rotates it. This completes the
103 onion layouts, making them possibly centered on any wall.
104 It'll modify Xsize and Ysize if they're swapped.
105*/
106static void
107rotate_layout (Layout layout, int rotation)
108{
109 int w = layout->w;
110 int h = layout->h;
111
112 switch (rotation)
113 {
114 case 2: /* a reflection */
115 {
116 Layout new_layout (w, h);
117
118 for (int i = 0; i < w; i++) /* copy a reflection back */
119 for (int j = 0; j < h; j++)
120 new_layout[i][j] = layout[w - i - 1][h - j - 1];
121
122 layout.swap (new_layout);
123 new_layout.free ();
124 }
125 break;
126
127 case 1:
128 case 3:
129 {
130 Layout new_layout (h, w);
131
132 if (rotation == 1) /* swap x and y */
133 for (int i = 0; i < w; i++)
134 for (int j = 0; j < h; j++)
135 new_layout[j][i] = layout[i][j];
136
137 if (rotation == 3) /* swap x and y */
138 for (int i = 0; i < w; i++)
139 for (int j = 0; j < h; j++)
140 new_layout[j][i] = layout[w - i - 1][h - j - 1];
141
142 layout.swap (new_layout);
143 new_layout.free ();
144 }
145 break;
146 }
147}
148
149/* checks the layout to see if I can stick a horizontal(dir = 0) wall
150 (or vertical, dir == 1)
151 here which ends up on other walls sensibly. */
152static int
153can_make_wall (char **maze, int dx, int dy, int dir, random_map_params *RP)
154{
155 int i1;
156 int length = 0;
157
158 /* dont make walls if we're on the edge. */
159 if (dx == 0 || dx == (RP->Xsize - 1) || dy == 0 || dy == (RP->Ysize - 1))
160 return -1;
161
162 /* don't make walls if we're ON a wall. */
163 if (maze[dx][dy] != 0)
164 return -1;
165
166 if (dir == 0) /* horizontal */
167 {
168 int y = dy;
169
170 for (i1 = dx - 1; i1 > 0; i1--)
171 {
172 int sindex = surround_flag2 (maze, i1, y, RP);
173
174 if (sindex == 1)
175 break;
176 if (sindex != 0)
177 return -1; /* can't make horiz. wall here */
178 if (maze[i1][y] != 0)
179 return -1; /* can't make horiz. wall here */
180 length++;
181 }
182
183 for (i1 = dx + 1; i1 < RP->Xsize - 1; i1++)
184 {
185 int sindex = surround_flag2 (maze, i1, y, RP);
186
187 if (sindex == 2)
188 break;
189 if (sindex != 0)
190 return -1; /* can't make horiz. wall here */
191 if (maze[i1][y] != 0)
192 return -1; /* can't make horiz. wall here */
193 length++;
194 }
195 return length;
196 }
197 else
198 { /* vertical */
199 int x = dx;
200
201 for (i1 = dy - 1; i1 > 0; i1--)
202 {
203 int sindex = surround_flag2 (maze, x, i1, RP);
204
205 if (sindex == 4)
206 break;
207 if (sindex != 0)
208 return -1; /* can't make vert. wall here */
209 if (maze[x][i1] != 0)
210 return -1; /* can't make horiz. wall here */
211 length++;
212 }
213
214 for (i1 = dy + 1; i1 < RP->Ysize - 1; i1++)
215 {
216 int sindex = surround_flag2 (maze, x, i1, RP);
217
218 if (sindex == 8)
219 break;
220 if (sindex != 0)
221 return -1; /* can't make verti. wall here */
222 if (maze[x][i1] != 0)
223 return -1; /* can't make horiz. wall here */
224 length++;
225 }
226
227 return length;
228 }
229
230 return -1;
231}
232
233/* take a layout and make some rooms in it.
234 --works best on onions.*/
235static void
36dump_layout (char **layout, random_map_params *RP) 236roomify_layout (char **maze, random_map_params *RP)
37{ 237{
238 int tries = RP->Xsize * RP->Ysize / 30;
239
240 for (int ti = 0; ti < tries; ti++)
38 { 241 {
39 int i, j; 242 /* starting location for looking at creating a door */
243 int dx = rmg_rndm (RP->Xsize);
244 int dy = rmg_rndm (RP->Ysize);
40 245
246 /* results of checking on creating walls. */
247 int cx = can_make_wall (maze, dx, dy, 0, RP); /* horizontal */
248 int cy = can_make_wall (maze, dx, dy, 1, RP); /* vertical */
249
250 if (cx == -1)
251 {
252 if (cy != -1)
253 make_wall (maze, dx, dy, 1);
254
255 continue;
256 }
257
258 if (cy == -1)
259 {
260 make_wall (maze, dx, dy, 0);
261 continue;
262 }
263
264 if (cx < cy)
265 make_wall (maze, dx, dy, 0);
266 else
267 make_wall (maze, dx, dy, 1);
268 }
269}
270
271int
272make_wall (char **maze, int x, int y, int dir)
273{
274 maze[x][y] = 'D'; /* mark a door */
275
276 switch (dir)
277 {
278 case 0: /* horizontal */
279 {
280 for (int i1 = x - 1; maze[i1][y] == 0; --i1) maze[i1][y] = '#';
281 for (int i1 = x + 1; maze[i1][y] == 0; ++i1) maze[i1][y] = '#';
282 break;
283 }
284 case 1: /* vertical */
285 {
286 for (int i1 = y - 1; maze[x][i1] == 0; --i1) maze[x][i1] = '#';
287 for (int i1 = y + 1; maze[x][i1] == 0; ++i1) maze[x][i1] = '#';
288 break;
289 }
290 }
291
292 return 0;
293}
294
295/* puts doors at appropriate locations in a layout. */
296static void
297doorify_layout (char **maze, random_map_params *RP)
298{
299 int ndoors = RP->Xsize * RP->Ysize / 60; /* reasonable number of doors. */
300 int doorlocs = 0; /* # of available doorlocations */
301
302 uint16 *doorlist_x = salloc<uint16> (RP->Xsize * RP->Ysize);
303 uint16 *doorlist_y = salloc<uint16> (RP->Xsize * RP->Ysize);
304
305 /* make a list of possible door locations */
41 for (i = 0; i < RP->Xsize; i++) 306 for (int i = 1; i < RP->Xsize - 1; i++)
307 for (int j = 1; j < RP->Ysize - 1; j++)
42 { 308 {
43 for (j = 0; j < RP->Ysize; j++) 309 int sindex = surround_flag (maze, i, j, RP);
310
311 if (sindex == 3 || sindex == 12) /* these are possible door sindex */
44 { 312 {
45 if (layout[i][j] == 0) 313 doorlist_x[doorlocs] = i;
46 layout[i][j] = ' '; 314 doorlist_y[doorlocs] = j;
47 printf ("%c", layout[i][j]); 315 doorlocs++;
48 if (layout[i][j] == ' ')
49 layout[i][j] = 0;
50 } 316 }
51 printf ("\n");
52 } 317 }
53 }
54 printf ("\n");
55}
56 318
57bool 319 while (ndoors > 0 && doorlocs > 0)
58maptile::generate_random_map (random_map_params *RP)
59{
60 char **layout, buf[16384];
61 int i;
62
63 RP->Xsize = RP->xsize;
64 RP->Ysize = RP->ysize;
65
66 /* pick a random seed, or use the one from the input file */
67 RP->random_seed = RP->random_seed
68 ? RP->random_seed + RP->dungeon_level
69 : time (0);
70 CEDE;
71
72 write_map_parameters_to_string (buf, RP);
73
74 if (RP->difficulty == 0)
75 {
76 RP->difficulty = RP->dungeon_level; /* use this instead of a map difficulty */
77
78 if (RP->difficulty_increase > 0.001)
79 RP->difficulty = (int) ((float) RP->dungeon_level * RP->difficulty_increase);
80
81 if (RP->difficulty < 1)
82 RP->difficulty = 1;
83 } 320 {
84 else 321 int di = rmg_rndm (doorlocs);
85 RP->difficulty_given = 1; 322 int i = doorlist_x[di];
323 int j = doorlist_y[di];
324 int sindex = surround_flag (maze, i, j, RP);
86 325
87 if (RP->Xsize < MIN_RANDOM_MAP_SIZE) 326 if (sindex == 3 || sindex == 12) /* these are possible door sindex */
88 RP->Xsize = MIN_RANDOM_MAP_SIZE + rndm (25) + 5; 327 {
328 maze[i][j] = 'D';
329 ndoors--;
330 }
89 331
90 if (RP->Ysize < MIN_RANDOM_MAP_SIZE) 332 /* reduce the size of the list */
91 RP->Ysize = MIN_RANDOM_MAP_SIZE + rndm (25) + 5; 333 doorlocs--;
334 doorlist_x[di] = doorlist_x[doorlocs];
335 doorlist_y[di] = doorlist_y[doorlocs];
336 }
92 337
93 if (RP->symmetry == SYMMETRY_RANDOM) 338 sfree (doorlist_x, RP->Xsize * RP->Ysize);
94 RP->symmetry_used = rndm (SYMMETRY_XY) + 1; 339 sfree (doorlist_y, RP->Xsize * RP->Ysize);
95 else 340}
96 RP->symmetry_used = RP->symmetry;
97 341
98 if (RP->symmetry_used == SYMMETRY_Y || RP->symmetry_used == SYMMETRY_XY) 342void
99 RP->Ysize = RP->Ysize / 2 + 1; 343write_map_parameters_to_string (char *buf, random_map_params *RP)
344{
345 char small_buf[16384];
100 346
101 if (RP->symmetry_used == SYMMETRY_X || RP->symmetry_used == SYMMETRY_XY) 347 sprintf (buf, "xsize %d\nysize %d\n", RP->xsize, RP->ysize);
102 RP->Xsize = RP->Xsize / 2 + 1;
103 348
349 if (RP->wallstyle[0])
350 {
351 sprintf (small_buf, "wallstyle %s\n", RP->wallstyle);
352 strcat (buf, small_buf);
353 }
354
355 if (RP->miningstyle[0])
356 {
357 sprintf (small_buf, "miningstyle %s\n", RP->miningstyle);
358 strcat (buf, small_buf);
359 }
360
361 if (RP->floorstyle[0])
362 {
363 sprintf (small_buf, "floorstyle %s\n", RP->floorstyle);
364 strcat (buf, small_buf);
365 }
366
367 if (RP->monsterstyle[0])
368 {
369 sprintf (small_buf, "monsterstyle %s\n", RP->monsterstyle);
370 strcat (buf, small_buf);
371 }
372
373 if (RP->treasurestyle[0])
374 {
375 sprintf (small_buf, "treasurestyle %s\n", RP->treasurestyle);
376 strcat (buf, small_buf);
377 }
378
379 if (RP->layoutstyle[0])
380 {
381 sprintf (small_buf, "layoutstyle %s\n", RP->layoutstyle);
382 strcat (buf, small_buf);
383 }
384
385 if (RP->decorstyle[0])
386 {
387 sprintf (small_buf, "decorstyle %s\n", RP->decorstyle);
388 strcat (buf, small_buf);
389 }
390
391 if (RP->doorstyle[0])
392 {
393 sprintf (small_buf, "doorstyle %s\n", RP->doorstyle);
394 strcat (buf, small_buf);
395 }
396
397 if (RP->exitstyle[0])
398 {
399 sprintf (small_buf, "exitstyle %s\n", RP->exitstyle);
400 strcat (buf, small_buf);
401 }
402
403 if (RP->final_map.length ())
404 {
405 sprintf (small_buf, "final_map %s\n", &RP->final_map);
406 strcat (buf, small_buf);
407 }
408
409 if (RP->exit_on_final_map[0])
410 {
411 sprintf (small_buf, "exit_on_final_map %s\n", RP->exit_on_final_map);
412 strcat (buf, small_buf);
413 }
414
415 if (RP->this_map.length ())
416 {
417 sprintf (small_buf, "origin_map %s\n", &RP->this_map);
418 strcat (buf, small_buf);
419 }
420
104 if (RP->expand2x > 0) 421 if (RP->expand2x)
105 {
106 RP->Xsize /= 2;
107 RP->Ysize /= 2;
108 } 422 {
109 423 sprintf (small_buf, "expand2x %d\n", RP->expand2x);
110 RP->map_layout_style = LAYOUT_NONE; 424 strcat (buf, small_buf);
111
112 /* Redo this - there was a lot of redundant code of checking for preset
113 * layout style and then random layout style. Instead, figure out
114 * the numeric layoutstyle, so there is only one area that actually
115 * calls the code to make the maps.
116 */
117 if (strstr (RP->layoutstyle, "onion"))
118 RP->map_layout_style = LAYOUT_ONION;
119
120 if (strstr (RP->layoutstyle, "maze"))
121 RP->map_layout_style = LAYOUT_MAZE;
122
123 if (strstr (RP->layoutstyle, "spiral"))
124 RP->map_layout_style = LAYOUT_SPIRAL;
125
126 if (strstr (RP->layoutstyle, "rogue"))
127 RP->map_layout_style = LAYOUT_ROGUELIKE;
128
129 if (strstr (RP->layoutstyle, "snake"))
130 RP->map_layout_style = LAYOUT_SNAKE;
131
132 if (strstr (RP->layoutstyle, "squarespiral"))
133 RP->map_layout_style = LAYOUT_SQUARE_SPIRAL;
134
135 /* No style found - choose one randomly */
136 if (RP->map_layout_style == LAYOUT_NONE)
137 RP->map_layout_style = rndm (NROFLAYOUTS - 1) + 1;
138
139 layout = layoutgen (RP);
140
141#ifdef RMAP_DEBUG
142 dump_layout (layout, RP);
143#endif
144
145 /* increment these for the current map */
146 RP->dungeon_level += 1;
147 /* allow constant-difficulty maps. */
148 /* difficulty+=1; */
149
150 /* rotate the layout randomly */
151 layout = rotate_layout (layout, rndm (4), RP);
152#ifdef RMAP_DEBUG
153 dump_layout (layout, RP);
154#endif
155
156 /* allocate the map and set the floor */
157 make_map_floor (layout, RP->floorstyle, RP);
158
159 /* set region */
160 default_region = RP->region;
161
162 CEDE;
163
164 /* create walls unless the wallstyle is "none" */
165 if (strcmp (RP->wallstyle, "none"))
166 { 425 }
167 make_map_walls (this, layout, RP->wallstyle, RP);
168 426
169 /* place doors unless doorstyle or wallstyle is "none" */ 427 if (RP->layoutoptions1)
170 if (strcmp (RP->doorstyle, "none"))
171 put_doors (this, layout, RP->doorstyle, RP);
172 } 428 {
429 sprintf (small_buf, "layoutoptions1 %d\n", RP->layoutoptions1);
430 strcat (buf, small_buf);
431 }
173 432
174 CEDE; 433 if (RP->layoutoptions2)
434 {
435 sprintf (small_buf, "layoutoptions2 %d\n", RP->layoutoptions2);
436 strcat (buf, small_buf);
437 }
175 438
176 /* create exits unless the exitstyle is "none" */ 439 if (RP->layoutoptions3)
177 if (strcmp (RP->exitstyle, "none")) 440 {
178 place_exits (this, layout, RP->exitstyle, RP->orientation, RP); 441 sprintf (small_buf, "layoutoptions3 %d\n", RP->layoutoptions3);
442 strcat (buf, small_buf);
443 }
179 444
180 CEDE; 445 if (RP->symmetry)
446 {
447 sprintf (small_buf, "symmetry %d\n", RP->symmetry);
448 strcat (buf, small_buf);
449 }
181 450
182 place_specials_in_map (this, layout, RP); 451 if (RP->difficulty && RP->difficulty_given)
452 {
453 sprintf (small_buf, "difficulty %d\n", RP->difficulty);
454 strcat (buf, small_buf);
455 }
183 456
184 CEDE; 457 if (fabs (RP->difficulty_increase - 1.f) >= (1.f / 1024.f))
458 {
459 sprintf (small_buf, "difficulty_increase %f\n", RP->difficulty_increase);
460 strcat (buf, small_buf);
461 }
185 462
186 /* create monsters unless the monsterstyle is "none" */ 463 sprintf (small_buf, "dungeon_level %d\n", RP->dungeon_level);
187 if (strcmp (RP->monsterstyle, "none")) 464 strcat (buf, small_buf);
188 place_monsters (this, RP->monsterstyle, RP->difficulty, RP);
189 465
190 CEDE; 466 if (RP->dungeon_depth)
467 {
468 sprintf (small_buf, "dungeon_depth %d\n", RP->dungeon_depth);
469 strcat (buf, small_buf);
470 }
191 471
192 /* treasures needs to have a proper difficulty set for the map. */ 472 if (RP->decoroptions)
193 difficulty = estimate_difficulty (); 473 {
474 sprintf (small_buf, "decoroptions %d\n", RP->decoroptions);
475 strcat (buf, small_buf);
476 }
194 477
195 CEDE; 478 if (RP->orientation)
479 {
480 sprintf (small_buf, "orientation %d\n", RP->orientation);
481 strcat (buf, small_buf);
482 }
196 483
197 /* create treasure unless the treasurestyle is "none" */ 484 if (RP->origin_x)
198 if (strcmp (RP->treasurestyle, "none")) 485 {
199 place_treasure (this, layout, RP->treasurestyle, RP->treasureoptions, RP); 486 sprintf (small_buf, "origin_x %d\n", RP->origin_x);
487 strcat (buf, small_buf);
488 }
200 489
201 CEDE; 490 if (RP->origin_y)
491 {
492 sprintf (small_buf, "origin_y %d\n", RP->origin_y);
493 strcat (buf, small_buf);
494 }
202 495
203 /* create decor unless the decorstyle is "none" */ 496 if (RP->treasureoptions)
204 if (strcmp (RP->decorstyle, "none")) 497 {
205 put_decor (this, layout, RP->decorstyle, RP->decoroptions, RP); 498 sprintf (small_buf, "treasureoptions %d\n", RP->treasureoptions);
499 strcat (buf, small_buf);
500 }
206 501
207 CEDE; 502 if (RP->random_seed)
503 {
504 sprintf (small_buf, "random_seed %u\n", RP->random_seed);
505 strcat (buf, small_buf);
506 }
208 507
209 /* generate treasures, etc. */ 508 if (RP->custom)
210 fix_auto_apply (); 509 {
510 sprintf (small_buf, "custom %s\n", RP->custom);
511 strcat (buf, small_buf);
512 }
513}
211 514
212 CEDE; 515/////////////////////////////////////////////////////////////////////////////
213 516
214 unblock_exits (this, layout, RP); 517LayoutData::LayoutData (int w, int h)
518: w(w), h(h)
519{
520 int size = (sizeof (char *) + sizeof (char) * h) * w;
215 521
216 /* free the layout */ 522 col = (char **)salloc<char> (size);
217 for (i = 0; i < RP->Xsize; i++)
218 free (layout[i]);
219 523
220 free (layout); 524 char *data = (char *)(col + w);
221 525
222 msg = strdup (buf); 526 for (int x = w; x--; )
223 in_memory = MAP_IN_MEMORY; 527 col [x] = data + x * h;
528}
224 529
225 CEDE; 530LayoutData::~LayoutData ()
531{
532 int size = (sizeof (char *) + sizeof (char) * h) * w;
226 533
227 return 1; 534 sfree ((char *)col, size);
535}
536
537void LayoutData::clear (char fill)
538{
539 memset (col [0], fill, w * h);
540}
541
542void LayoutData::border (char fill)
543{
544 for (int i = 0; i < w; i++) col [i][0] = col [i][h - 1] = fill;
545 for (int j = 0; j < h; j++) col [0][j] = col [w - 1][j] = fill;
228} 546}
229 547
230/* function selects the layout function and gives it whatever 548/* function selects the layout function and gives it whatever
231 arguments it needs. */ 549 arguments it needs. */
232char ** 550static Layout
233layoutgen (random_map_params *RP) 551layoutgen (random_map_params *RP)
234{ 552{
235 char **maze = 0; 553 Layout layout (RP);
236 int oxsize = RP->Xsize, oysize = RP->Ysize;
237 554
238 switch (RP->map_layout_style) 555 switch (RP->map_layout_style)
239 { 556 {
240 case LAYOUT_ONION: 557 case LAYOUT_ONION:
241 maze = map_gen_onion (RP->Xsize, RP->Ysize, RP->layoutoptions1, RP->layoutoptions2); 558 map_gen_onion (layout, RP->layoutoptions1, RP->layoutoptions2);
559
242 if (!(rndm (3)) && !(RP->layoutoptions1 & RMOPT_WALLS_ONLY)) 560 if (!(rmg_rndm (3)) && !(RP->layoutoptions1 & (RMOPT_WALLS_ONLY | RMOPT_WALL_OFF)))
243 roomify_layout (maze, RP); 561 roomify_layout (layout, RP);
562
244 break; 563 break;
245 564
246 case LAYOUT_MAZE: 565 case LAYOUT_MAZE:
247 maze = maze_gen (RP->Xsize, RP->Ysize, rndm (2)); 566 maze_gen (layout, rmg_rndm (2));
567
248 if (!(rndm (2))) 568 if (!(rmg_rndm (2)))
249 doorify_layout (maze, RP); 569 doorify_layout (layout, RP);
570
250 break; 571 break;
251 572
252 case LAYOUT_SPIRAL: 573 case LAYOUT_SPIRAL:
253 maze = map_gen_spiral (RP->Xsize, RP->Ysize, RP->layoutoptions1); 574 map_gen_spiral (layout, RP->layoutoptions1);
575
254 if (!(rndm (2))) 576 if (!(rmg_rndm (2)))
255 doorify_layout (maze, RP); 577 doorify_layout (layout, RP);
578
256 break; 579 break;
257 580
258 case LAYOUT_ROGUELIKE: 581 case LAYOUT_ROGUELIKE:
259 /* Don't put symmetry in rogue maps. There isn't much reason to 582 /* Don't put symmetry in rogue maps. There isn't much reason to
260 * do so in the first place (doesn't make it any more interesting), 583 * do so in the first place (doesn't make it any more interesting),
… …
262 * spirals, or maps with lots of passages - making a symmetric rogue 585 * spirals, or maps with lots of passages - making a symmetric rogue
263 * map fails because its likely that the passages the symmetry process 586 * map fails because its likely that the passages the symmetry process
264 * creates may not connect the rooms. 587 * creates may not connect the rooms.
265 */ 588 */
266 RP->symmetry_used = SYMMETRY_NONE; 589 RP->symmetry_used = SYMMETRY_NONE;
267 RP->Ysize = oysize;
268 RP->Xsize = oxsize;
269 maze = roguelike_layout_gen (RP->Xsize, RP->Ysize, RP->layoutoptions1); 590 roguelike_layout_gen (layout, RP->layoutoptions1);
270 /* no doorifying... done already */ 591 /* no doorifying... done already */
271 break; 592 break;
272 593
273 case LAYOUT_SNAKE: 594 case LAYOUT_SNAKE:
274 maze = make_snake_layout (RP->Xsize, RP->Ysize, RP->layoutoptions1); 595 make_snake_layout (layout, RP->layoutoptions1);
596
275 if (rndm (2)) 597 if (rmg_rndm (2))
276 roomify_layout (maze, RP); 598 roomify_layout (layout, RP);
599
277 break; 600 break;
278 601
279 case LAYOUT_SQUARE_SPIRAL: 602 case LAYOUT_SQUARE_SPIRAL:
280 maze = make_square_spiral_layout (RP->Xsize, RP->Ysize, RP->layoutoptions1); 603 make_square_spiral_layout (layout, RP->layoutoptions1);
604
281 if (rndm (2)) 605 if (rmg_rndm (2))
282 roomify_layout (maze, RP); 606 roomify_layout (layout, RP);
607
283 break; 608 break;
284 }
285 609
286 maze = symmetrize_layout (maze, RP->symmetry_used, RP); 610 default:
611 abort ();
612 }
613
614 /* rotate the layout randomly */
615 rotate_layout (layout, rmg_rndm (4));
616
617 symmetrize_layout (layout, RP);
287 618
288#ifdef RMAP_DEBUG 619#ifdef RMAP_DEBUG
289 dump_layout (maze, RP); 620 dump_layout (layout);
290#endif 621#endif
291 622
292 if (RP->expand2x) 623 if (RP->expand2x)
293 { 624 expand2x (layout);
294 maze = expand2x (maze, RP->Xsize, RP->Ysize);
295 RP->Xsize = RP->Xsize * 2 - 1;
296 RP->Ysize = RP->Ysize * 2 - 1;
297 }
298 625
299 return maze; 626 return layout;
300} 627}
301 628
302/* takes a map and makes it symmetric: adjusts Xsize and 629bool
303Ysize to produce a symmetric map. */ 630maptile::generate_random_map (random_map_params *RP)
304char **
305symmetrize_layout (char **maze, int sym, random_map_params *RP)
306{ 631{
307 int i, j; 632 char buf[16384];
308 char **sym_maze;
309 int Xsize_orig, Ysize_orig;
310
311 Xsize_orig = RP->Xsize;
312 Ysize_orig = RP->Ysize;
313 RP->symmetry_used = sym; /* tell everyone else what sort of symmetry is used. */
314 if (sym == SYMMETRY_NONE)
315 {
316 RP->Xsize = Xsize_orig;
317 RP->Ysize = Ysize_orig;
318 return maze;
319 }
320 /* pick new sizes */
321 RP->Xsize = ((sym == SYMMETRY_X || sym == SYMMETRY_XY) ? RP->Xsize * 2 - 3 : RP->Xsize);
322 RP->Ysize = ((sym == SYMMETRY_Y || sym == SYMMETRY_XY) ? RP->Ysize * 2 - 3 : RP->Ysize);
323
324 sym_maze = (char **) calloc (sizeof (char *), RP->Xsize);
325 for (i = 0; i < RP->Xsize; i++)
326 sym_maze[i] = (char *) calloc (sizeof (char), RP->Ysize);
327
328 if (sym == SYMMETRY_X)
329 for (i = 0; i < RP->Xsize / 2 + 1; i++)
330 for (j = 0; j < RP->Ysize; j++)
331 {
332 sym_maze[i][j] = maze[i][j];
333 sym_maze[RP->Xsize - i - 1][j] = maze[i][j];
334 };
335 if (sym == SYMMETRY_Y)
336 for (i = 0; i < RP->Xsize; i++)
337 for (j = 0; j < RP->Ysize / 2 + 1; j++)
338 {
339 sym_maze[i][j] = maze[i][j];
340 sym_maze[i][RP->Ysize - j - 1] = maze[i][j];
341 }
342 if (sym == SYMMETRY_XY)
343 for (i = 0; i < RP->Xsize / 2 + 1; i++)
344 for (j = 0; j < RP->Ysize / 2 + 1; j++)
345 {
346 sym_maze[i][j] = maze[i][j];
347 sym_maze[i][RP->Ysize - j - 1] = maze[i][j];
348 sym_maze[RP->Xsize - i - 1][j] = maze[i][j];
349 sym_maze[RP->Xsize - i - 1][RP->Ysize - j - 1] = maze[i][j];
350 }
351 /* delete the old maze */
352 for (i = 0; i < Xsize_orig; i++)
353 free (maze[i]);
354 free (maze);
355 /* reconnect disjointed spirals */
356 if (RP->map_layout_style == LAYOUT_SPIRAL)
357 connect_spirals (RP->Xsize, RP->Ysize, sym, sym_maze);
358 /* reconnect disjointed nethackmazes: the routine for
359 spirals will do the trick? */
360 if (RP->map_layout_style == LAYOUT_ROGUELIKE)
361 connect_spirals (RP->Xsize, RP->Ysize, sym, sym_maze);
362
363 return sym_maze;
364}
365
366
367/* takes a map and rotates it. This completes the
368 onion layouts, making them possibly centered on any wall.
369 It'll modify Xsize and Ysize if they're swapped.
370*/
371
372char **
373rotate_layout (char **maze, int rotation, random_map_params *RP)
374{
375 char **new_maze;
376 int i, j;
377
378 switch (rotation)
379 {
380 case 0:
381 return maze;
382 break;
383 case 2: /* a reflection */
384 {
385 char *newmaze = (char *) malloc (sizeof (char) * RP->Xsize * RP->Ysize);
386
387 for (i = 0; i < RP->Xsize; i++)
388 { /* make a copy */
389 for (j = 0; j < RP->Ysize; j++)
390 {
391 newmaze[i * RP->Ysize + j] = maze[i][j];
392 }
393 }
394 for (i = 0; i < RP->Xsize; i++)
395 { /* copy a reflection back */
396 for (j = 0; j < RP->Ysize; j++)
397 {
398 maze[i][j] = newmaze[(RP->Xsize - i - 1) * RP->Ysize + RP->Ysize - j - 1];
399 }
400 }
401 free (newmaze);
402 return maze;
403 break;
404 }
405 case 1:
406 case 3:
407 {
408 int swap;
409 new_maze = (char **) calloc (sizeof (char *), RP->Ysize);
410 for (i = 0; i < RP->Ysize; i++)
411 {
412 new_maze[i] = (char *) calloc (sizeof (char), RP->Xsize);
413 }
414 if (rotation == 1) /* swap x and y */
415 for (i = 0; i < RP->Xsize; i++)
416 for (j = 0; j < RP->Ysize; j++)
417 new_maze[j][i] = maze[i][j];
418
419 if (rotation == 3)
420 { /* swap x and y */
421 for (i = 0; i < RP->Xsize; i++)
422 for (j = 0; j < RP->Ysize; j++)
423 new_maze[j][i] = maze[RP->Xsize - i - 1][RP->Ysize - j - 1];
424 }
425
426 /* delete the old layout */
427 for (i = 0; i < RP->Xsize; i++)
428 free (maze[i]);
429 free (maze);
430
431 swap = RP->Ysize;
432 RP->Ysize = RP->Xsize;
433 RP->Xsize = swap;
434 return new_maze;
435 break;
436 }
437 }
438 return NULL;
439}
440
441/* take a layout and make some rooms in it.
442 --works best on onions.*/
443void
444roomify_layout (char **maze, random_map_params *RP)
445{
446 int tries = RP->Xsize * RP->Ysize / 30;
447 int ti; 633 int i;
448 634
449 for (ti = 0; ti < tries; ti++) 635 RP->Xsize = RP->xsize;
450 { 636 RP->Ysize = RP->ysize;
451 int dx, dy; /* starting location for looking at creating a door */
452 int cx, cy; /* results of checking on creating walls. */
453 637
454 dx = rndm (RP->Xsize); 638 /* pick a random seed, or use the one from the input file */
455 dy = rndm (RP->Ysize); 639 RP->random_seed = RP->random_seed
640 ? RP->random_seed + RP->dungeon_level
641 : time (0);
456 642
457 cx = can_make_wall (maze, dx, dy, 0, RP); /* horizontal */ 643 // we run "single-threaded"
458 cy = can_make_wall (maze, dx, dy, 1, RP); /* vertical */ 644 rmg_rndm.seed (RP->random_seed);
459 if (cx == -1)
460 {
461 if (cy != -1)
462 make_wall (maze, dx, dy, 1);
463 645
464 continue; 646 write_map_parameters_to_string (buf, RP);
465 }
466 647
467 if (cy == -1) 648 if (RP->difficulty == 0)
468 {
469 make_wall (maze, dx, dy, 0);
470 continue;
471 }
472
473 if (cx < cy)
474 make_wall (maze, dx, dy, 0);
475 else
476 make_wall (maze, dx, dy, 1);
477 } 649 {
478} 650 RP->difficulty = RP->dungeon_level; /* use this instead of a map difficulty */
479 651
480/* checks the layout to see if I can stick a horizontal(dir = 0) wall 652 if (RP->difficulty_increase > 0.001)
481 (or vertical, dir == 1) 653 RP->difficulty = (int) ((float) RP->dungeon_level * RP->difficulty_increase);
482 here which ends up on other walls sensibly. */
483 654
484int 655 if (RP->difficulty < 1)
485can_make_wall (char **maze, int dx, int dy, int dir, random_map_params *RP) 656 RP->difficulty = 1;
486{
487 int i1;
488 int length = 0;
489
490 /* dont make walls if we're on the edge. */
491 if (dx == 0 || dx == (RP->Xsize - 1) || dy == 0 || dy == (RP->Ysize - 1))
492 return -1;
493
494 /* don't make walls if we're ON a wall. */
495 if (maze[dx][dy] != 0)
496 return -1;
497
498 if (dir == 0) /* horizontal */
499 {
500 int y = dy;
501
502 for (i1 = dx - 1; i1 > 0; i1--)
503 {
504 int sindex = surround_flag2 (maze, i1, y, RP);
505
506 if (sindex == 1)
507 break;
508 if (sindex != 0)
509 return -1; /* can't make horiz. wall here */
510 if (maze[i1][y] != 0)
511 return -1; /* can't make horiz. wall here */
512 length++;
513 }
514
515 for (i1 = dx + 1; i1 < RP->Xsize - 1; i1++)
516 {
517 int sindex = surround_flag2 (maze, i1, y, RP);
518
519 if (sindex == 2)
520 break;
521 if (sindex != 0)
522 return -1; /* can't make horiz. wall here */
523 if (maze[i1][y] != 0)
524 return -1; /* can't make horiz. wall here */
525 length++;
526 }
527 return length;
528 } 657 }
529 else 658 else
530 { /* vertical */ 659 RP->difficulty_given = 1;
531 int x = dx;
532 660
533 for (i1 = dy - 1; i1 > 0; i1--) 661 if (RP->Xsize < MIN_RANDOM_MAP_SIZE)
534 { 662 RP->Xsize = MIN_RANDOM_MAP_SIZE + rmg_rndm (25) + 5;
535 int sindex = surround_flag2 (maze, x, i1, RP);
536 663
537 if (sindex == 4) 664 if (RP->Ysize < MIN_RANDOM_MAP_SIZE)
538 break; 665 RP->Ysize = MIN_RANDOM_MAP_SIZE + rmg_rndm (25) + 5;
539 if (sindex != 0)
540 return -1; /* can't make vert. wall here */
541 if (maze[x][i1] != 0)
542 return -1; /* can't make horiz. wall here */
543 length++;
544 }
545 666
546 for (i1 = dy + 1; i1 < RP->Ysize - 1; i1++) 667 if (RP->symmetry == SYMMETRY_RANDOM)
547 { 668 RP->symmetry_used = rmg_rndm (SYMMETRY_XY) + 1;
548 int sindex = surround_flag2 (maze, x, i1, RP); 669 else
670 RP->symmetry_used = RP->symmetry;
549 671
550 if (sindex == 8) 672 if (RP->symmetry_used == SYMMETRY_Y || RP->symmetry_used == SYMMETRY_XY)
551 break; 673 RP->Ysize = RP->Ysize / 2 + 1;
552 if (sindex != 0) 674
553 return -1; /* can't make verti. wall here */ 675 if (RP->symmetry_used == SYMMETRY_X || RP->symmetry_used == SYMMETRY_XY)
554 if (maze[x][i1] != 0) 676 RP->Xsize = RP->Xsize / 2 + 1;
555 return -1; /* can't make horiz. wall here */ 677
556 length++; 678 if (RP->expand2x > 0)
557 }
558 return length;
559 } 679 {
680 RP->Xsize /= 2;
681 RP->Ysize /= 2;
682 }
683
684 RP->map_layout_style = LAYOUT_NONE;
685
686 /* Redo this - there was a lot of redundant code of checking for preset
687 * layout style and then random layout style. Instead, figure out
688 * the numeric layoutstyle, so there is only one area that actually
689 * calls the code to make the maps.
690 */
691 if (strstr (RP->layoutstyle, "onion"))
692 RP->map_layout_style = LAYOUT_ONION;
693 else if (strstr (RP->layoutstyle, "maze"))
694 RP->map_layout_style = LAYOUT_MAZE;
695 else if (strstr (RP->layoutstyle, "spiral"))
696 RP->map_layout_style = LAYOUT_SPIRAL;
697 else if (strstr (RP->layoutstyle, "rogue"))
698 RP->map_layout_style = LAYOUT_ROGUELIKE;
699 else if (strstr (RP->layoutstyle, "snake"))
700 RP->map_layout_style = LAYOUT_SNAKE;
701 else if (strstr (RP->layoutstyle, "squarespiral"))
702 RP->map_layout_style = LAYOUT_SQUARE_SPIRAL;
703 else if (RP->map_layout_style == LAYOUT_NONE)
704 RP->map_layout_style = rmg_rndm (NROFLAYOUTS - 1) + 1; /* No style found - choose one randomly */
705 else
706 abort ();
707
708 Layout layout = layoutgen (RP);
709
710#ifdef RMAP_DEBUG
711 dump_layout (layout);
712#endif
713
714 /* increment these for the current map */
715 ++RP->dungeon_level;
716
717 // need to patch RP becasue following code doesn't use the Layout object
718 RP->Xsize = layout->w;
719 RP->Ysize = layout->h;
720
721 /* allocate the map and set the floor */
722 make_map_floor (layout, RP->floorstyle, RP);
723
724 /* set region */
725 default_region = RP->region;
726
727 CEDE;
728
729 place_specials_in_map (this, layout, RP);
730
731 CEDE;
732
733 /* create walls unless the wallstyle is "none" */
734 if (strcmp (RP->wallstyle, "none"))
735 {
736 make_map_walls (this, layout, RP->wallstyle, RP->miningstyle, RP);
737
738 /* place doors unless doorstyle or wallstyle is "none" */
739 if (strcmp (RP->doorstyle, "none"))
740 put_doors (this, layout, RP->doorstyle, RP);
741 }
742
743 CEDE;
744
745 /* create exits unless the exitstyle is "none" */
746 if (strcmp (RP->exitstyle, "none"))
747 place_exits (this, layout, RP->exitstyle, RP->orientation, RP);
748
749 CEDE;
750
751 /* create monsters unless the monsterstyle is "none" */
752 if (strcmp (RP->monsterstyle, "none"))
753 place_monsters (this, RP->monsterstyle, RP->difficulty, RP);
754
755 CEDE;
756
757 /* treasures needs to have a proper difficulty set for the map. */
758 difficulty = estimate_difficulty ();
759
760 CEDE;
761
762 /* create treasure unless the treasurestyle is "none" */
763 place_treasure (this, layout, RP->treasurestyle, RP->treasureoptions, RP);
764
765 CEDE;
766
767 /* create decor unless the decorstyle is "none" */
768 if (strcmp (RP->decorstyle, "none"))
769 put_decor (this, layout, RP->decorstyle, RP->decoroptions, RP);
770
771 CEDE;
772
773 /* generate treasures, etc. */
774 fix_auto_apply ();
775
776 CEDE;
777
778 unblock_exits (this, layout, RP);
779
780 msg = strdup (buf);
781 in_memory = MAP_ACTIVE;
782
783 CEDE;
784
560 return -1; 785 return 1;
561} 786}
562 787
563
564int
565make_wall (char **maze, int x, int y, int dir)
566{
567 maze[x][y] = 'D'; /* mark a door */
568 switch (dir)
569 {
570 case 0: /* horizontal */
571 {
572 int i1;
573
574 for (i1 = x - 1; maze[i1][y] == 0; i1--)
575 maze[i1][y] = '#';
576 for (i1 = x + 1; maze[i1][y] == 0; i1++)
577 maze[i1][y] = '#';
578 break;
579 }
580 case 1: /* vertical */
581 {
582 int i1;
583
584 for (i1 = y - 1; maze[x][i1] == 0; i1--)
585 maze[x][i1] = '#';
586 for (i1 = y + 1; maze[x][i1] == 0; i1++)
587 maze[x][i1] = '#';
588 break;
589 }
590 }
591
592 return 0;
593}
594
595/* puts doors at appropriate locations in a layout. */
596void
597doorify_layout (char **maze, random_map_params *RP)
598{
599 int ndoors = RP->Xsize * RP->Ysize / 60; /* reasonable number of doors. */
600 char *doorlist_x;
601 char *doorlist_y;
602 int doorlocs = 0; /* # of available doorlocations */
603 int i, j;
604
605 doorlist_x = (char *) malloc (sizeof (int) * RP->Xsize * RP->Ysize);
606 doorlist_y = (char *) malloc (sizeof (int) * RP->Xsize * RP->Ysize);
607
608
609 /* make a list of possible door locations */
610 for (i = 1; i < RP->Xsize - 1; i++)
611 for (j = 1; j < RP->Ysize - 1; j++)
612 {
613 int sindex = surround_flag (maze, i, j, RP);
614
615 if (sindex == 3 || sindex == 12) /* these are possible door sindex */
616 {
617 doorlist_x[doorlocs] = i;
618 doorlist_y[doorlocs] = j;
619 doorlocs++;
620 }
621 }
622
623 while (ndoors > 0 && doorlocs > 0)
624 {
625 int di;
626 int sindex;
627
628 di = rndm (doorlocs);
629 i = doorlist_x[di];
630 j = doorlist_y[di];
631 sindex = surround_flag (maze, i, j, RP);
632
633 if (sindex == 3 || sindex == 12) /* these are possible door sindex */
634 {
635 maze[i][j] = 'D';
636 ndoors--;
637 }
638
639 /* reduce the size of the list */
640 doorlocs--;
641 doorlist_x[di] = doorlist_x[doorlocs];
642 doorlist_y[di] = doorlist_y[doorlocs];
643 }
644
645 free (doorlist_x);
646 free (doorlist_y);
647}
648
649void
650write_map_parameters_to_string (char *buf, random_map_params *RP)
651{
652 char small_buf[16384];
653
654 sprintf (buf, "xsize %d\nysize %d\n", RP->xsize, RP->ysize);
655
656 if (RP->wallstyle[0])
657 {
658 sprintf (small_buf, "wallstyle %s\n", RP->wallstyle);
659 strcat (buf, small_buf);
660 }
661
662 if (RP->floorstyle[0])
663 {
664 sprintf (small_buf, "floorstyle %s\n", RP->floorstyle);
665 strcat (buf, small_buf);
666 }
667
668 if (RP->monsterstyle[0])
669 {
670 sprintf (small_buf, "monsterstyle %s\n", RP->monsterstyle);
671 strcat (buf, small_buf);
672 }
673
674 if (RP->treasurestyle[0])
675 {
676 sprintf (small_buf, "treasurestyle %s\n", RP->treasurestyle);
677 strcat (buf, small_buf);
678 }
679
680 if (RP->layoutstyle[0])
681 {
682 sprintf (small_buf, "layoutstyle %s\n", RP->layoutstyle);
683 strcat (buf, small_buf);
684 }
685
686 if (RP->decorstyle[0])
687 {
688 sprintf (small_buf, "decorstyle %s\n", RP->decorstyle);
689 strcat (buf, small_buf);
690 }
691
692 if (RP->doorstyle[0])
693 {
694 sprintf (small_buf, "doorstyle %s\n", RP->doorstyle);
695 strcat (buf, small_buf);
696 }
697
698 if (RP->exitstyle[0])
699 {
700 sprintf (small_buf, "exitstyle %s\n", RP->exitstyle);
701 strcat (buf, small_buf);
702 }
703
704 if (RP->final_map.length ())
705 {
706 sprintf (small_buf, "final_map %s\n", &RP->final_map);
707 strcat (buf, small_buf);
708 }
709
710 if (RP->exit_on_final_map[0])
711 {
712 sprintf (small_buf, "exit_on_final_map %s\n", RP->exit_on_final_map);
713 strcat (buf, small_buf);
714 }
715
716 if (RP->this_map.length ())
717 {
718 sprintf (small_buf, "origin_map %s\n", &RP->this_map);
719 strcat (buf, small_buf);
720 }
721
722 if (RP->expand2x)
723 {
724 sprintf (small_buf, "expand2x %d\n", RP->expand2x);
725 strcat (buf, small_buf);
726 }
727
728 if (RP->layoutoptions1)
729 {
730 sprintf (small_buf, "layoutoptions1 %d\n", RP->layoutoptions1);
731 strcat (buf, small_buf);
732 }
733
734 if (RP->layoutoptions2)
735 {
736 sprintf (small_buf, "layoutoptions2 %d\n", RP->layoutoptions2);
737 strcat (buf, small_buf);
738 }
739
740 if (RP->layoutoptions3)
741 {
742 sprintf (small_buf, "layoutoptions3 %d\n", RP->layoutoptions3);
743 strcat (buf, small_buf);
744 }
745
746 if (RP->symmetry)
747 {
748 sprintf (small_buf, "symmetry %d\n", RP->symmetry);
749 strcat (buf, small_buf);
750 }
751
752 if (RP->difficulty && RP->difficulty_given)
753 {
754 sprintf (small_buf, "difficulty %d\n", RP->difficulty);
755 strcat (buf, small_buf);
756 }
757
758 if (RP->difficulty_increase != 1.0)
759 {
760 sprintf (small_buf, "difficulty_increase %f\n", RP->difficulty_increase);
761 strcat (buf, small_buf);
762 }
763
764 sprintf (small_buf, "dungeon_level %d\n", RP->dungeon_level);
765 strcat (buf, small_buf);
766
767 if (RP->dungeon_depth)
768 {
769 sprintf (small_buf, "dungeon_depth %d\n", RP->dungeon_depth);
770 strcat (buf, small_buf);
771 }
772
773 if (RP->decoroptions)
774 {
775 sprintf (small_buf, "decoroptions %d\n", RP->decoroptions);
776 strcat (buf, small_buf);
777 }
778
779 if (RP->orientation)
780 {
781 sprintf (small_buf, "orientation %d\n", RP->orientation);
782 strcat (buf, small_buf);
783 }
784
785 if (RP->origin_x)
786 {
787 sprintf (small_buf, "origin_x %d\n", RP->origin_x);
788 strcat (buf, small_buf);
789 }
790
791 if (RP->origin_y)
792 {
793 sprintf (small_buf, "origin_y %d\n", RP->origin_y);
794 strcat (buf, small_buf);
795 }
796
797 if (RP->treasureoptions)
798 {
799 sprintf (small_buf, "treasureoptions %d\n", RP->treasureoptions);
800 strcat (buf, small_buf);
801 }
802
803 if (RP->random_seed)
804 {
805 sprintf (small_buf, "random_seed %u\n", RP->random_seed);
806 strcat (buf, small_buf);
807 }
808
809 if (RP->custom)
810 {
811 sprintf (small_buf, "custom %s\n", RP->custom);
812 strcat (buf, small_buf);
813 }
814}
815
816void
817write_parameters_to_string (char *buf,
818 int xsize_n,
819 int ysize_n,
820 const char *wallstyle_n,
821 const char *floorstyle_n,
822 const char *monsterstyle_n,
823 const char *treasurestyle_n,
824 const char *layoutstyle_n,
825 const char *decorstyle_n,
826 const char *doorstyle_n,
827 const char *exitstyle_n,
828 const char *final_map_n,
829 const char *exit_on_final_map_n,
830 const char *this_map_n,
831 int layoutoptions1_n,
832 int layoutoptions2_n,
833 int layoutoptions3_n,
834 int symmetry_n,
835 int dungeon_depth_n,
836 int dungeon_level_n,
837 int difficulty_n,
838 int difficulty_given_n,
839 int decoroptions_n,
840 int orientation_n,
841 int origin_x_n,
842 int origin_y_n,
843 uint32_t random_seed_n,
844 int treasureoptions_n,
845 float difficulty_increase)
846{
847 char small_buf[16384];
848
849 sprintf (buf, "xsize %d\nysize %d\n", xsize_n, ysize_n);
850
851 if (wallstyle_n && wallstyle_n[0])
852 {
853 sprintf (small_buf, "wallstyle %s\n", wallstyle_n);
854 strcat (buf, small_buf);
855 }
856
857 if (floorstyle_n && floorstyle_n[0])
858 {
859 sprintf (small_buf, "floorstyle %s\n", floorstyle_n);
860 strcat (buf, small_buf);
861 }
862
863 if (monsterstyle_n && monsterstyle_n[0])
864 {
865 sprintf (small_buf, "monsterstyle %s\n", monsterstyle_n);
866 strcat (buf, small_buf);
867 }
868
869 if (treasurestyle_n && treasurestyle_n[0])
870 {
871 sprintf (small_buf, "treasurestyle %s\n", treasurestyle_n);
872 strcat (buf, small_buf);
873 }
874
875 if (layoutstyle_n && layoutstyle_n[0])
876 {
877 sprintf (small_buf, "layoutstyle %s\n", layoutstyle_n);
878 strcat (buf, small_buf);
879 }
880
881 if (decorstyle_n && decorstyle_n[0])
882 {
883 sprintf (small_buf, "decorstyle %s\n", decorstyle_n);
884 strcat (buf, small_buf);
885 }
886
887 if (doorstyle_n && doorstyle_n[0])
888 {
889 sprintf (small_buf, "doorstyle %s\n", doorstyle_n);
890 strcat (buf, small_buf);
891 }
892
893 if (exitstyle_n && exitstyle_n[0])
894 {
895 sprintf (small_buf, "exitstyle %s\n", exitstyle_n);
896 strcat (buf, small_buf);
897 }
898
899 if (final_map_n && final_map_n[0])
900 {
901 sprintf (small_buf, "final_map %s\n", final_map_n);
902 strcat (buf, small_buf);
903 }
904
905 if (exit_on_final_map_n && exit_on_final_map_n[0])
906 {
907 sprintf (small_buf, "exit_on_final_map %s\n", exit_on_final_map_n);
908 strcat (buf, small_buf);
909 }
910
911 if (this_map_n && this_map_n[0])
912 {
913 sprintf (small_buf, "origin_map %s\n", this_map_n);
914 strcat (buf, small_buf);
915 }
916
917 if (layoutoptions1_n)
918 {
919 sprintf (small_buf, "layoutoptions1 %d\n", layoutoptions1_n);
920 strcat (buf, small_buf);
921 }
922
923 if (layoutoptions2_n)
924 {
925 sprintf (small_buf, "layoutoptions2 %d\n", layoutoptions2_n);
926 strcat (buf, small_buf);
927 }
928
929
930 if (layoutoptions3_n)
931 {
932 sprintf (small_buf, "layoutoptions3 %d\n", layoutoptions3_n);
933 strcat (buf, small_buf);
934 }
935
936 if (symmetry_n)
937 {
938 sprintf (small_buf, "symmetry %d\n", symmetry_n);
939 strcat (buf, small_buf);
940 }
941
942
943 if (difficulty_n && difficulty_given_n)
944 {
945 sprintf (small_buf, "difficulty %d\n", difficulty_n);
946 strcat (buf, small_buf);
947 }
948
949 if (difficulty_increase > 0.001)
950 {
951 sprintf (small_buf, "difficulty_increase %f\n", difficulty_increase);
952 strcat (buf, small_buf);
953 }
954
955 sprintf (small_buf, "dungeon_level %d\n", dungeon_level_n);
956 strcat (buf, small_buf);
957
958 if (dungeon_depth_n)
959 {
960 sprintf (small_buf, "dungeon_depth %d\n", dungeon_depth_n);
961 strcat (buf, small_buf);
962 }
963
964 if (decoroptions_n)
965 {
966 sprintf (small_buf, "decoroptions %d\n", decoroptions_n);
967 strcat (buf, small_buf);
968 }
969
970 if (orientation_n)
971 {
972 sprintf (small_buf, "orientation %d\n", orientation_n);
973 strcat (buf, small_buf);
974 }
975
976 if (origin_x_n)
977 {
978 sprintf (small_buf, "origin_x %d\n", origin_x_n);
979 strcat (buf, small_buf);
980 }
981
982 if (origin_y_n)
983 {
984 sprintf (small_buf, "origin_y %d\n", origin_y_n);
985 strcat (buf, small_buf);
986 }
987
988 if (random_seed_n)
989 {
990 /* Add one so that the next map is a bit different */
991 sprintf (small_buf, "random_seed %u\n", random_seed_n + 1);
992 strcat (buf, small_buf);
993 }
994
995 if (treasureoptions_n)
996 {
997 sprintf (small_buf, "treasureoptions %d\n", treasureoptions_n);
998 strcat (buf, small_buf);
999 }
1000}
1001
1002/* copy an object with an inventory... i.e., duplicate the inv too. */
1003void
1004copy_object_with_inv (object *src_ob, object *dest_ob)
1005{
1006 object *walk, *tmp;
1007
1008 src_ob->copy_to (dest_ob);
1009
1010 for (walk = src_ob->inv; walk; walk = walk->below)
1011 {
1012 tmp = object::create ();
1013
1014 walk->copy_to (tmp);
1015 insert_ob_in_ob (tmp, dest_ob);
1016 }
1017}

Diff Legend

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