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

Diff Legend

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