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.20 by pippijn, Mon Jan 15 21:06:19 2007 UTC vs.
Revision 1.49 by root, Tue Apr 13 02:39:53 2010 UTC

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

Diff Legend

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