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.36 by root, Tue Apr 15 18:43:11 2008 UTC vs.
Revision 1.49 by root, Tue Apr 13 02:39:53 2010 UTC

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

Diff Legend

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