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.51 by root, Sat Jun 26 22:10:18 2010 UTC vs.
Revision 1.75 by root, Sun Aug 22 20:36:37 2010 UTC

… …
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 <random_map.h> 28#include <rmg.h>
29#include <rproto.h> 29#include <rproto.h>
30#include <sproto.h> 30#include <sproto.h>
31 31
32#define CEDE coroapi::cede_to_tick () 32#define CEDE coroapi::cede_to_tick ()
33 33
34static void symmetrize_layout (Layout maze, random_map_params *RP); 34random_map_params::random_map_params ()
35static void rotate_layout (Layout maze, int rotation); 35{
36 hv = newHV ();
37}
36 38
37const_utf8_string 39random_map_params::random_map_params (random_map_params *RP)
38random_map_params::get_str (const_utf8_string option, const_utf8_string fallback) const 40{
41 *this = *RP;
42
43 HV *copy = newHV ();
44
45 hv_iterinit (hv);
46
47 // does not work for utf-8 keys
48 while (HE *he = hv_iternext (hv))
49 {
50 STRLEN klen; const char *key = HePV (he, klen);
51 hv_store (copy, key, klen, newSVsv (HeVAL (he)), HeHASH (he));
52 }
53
54 hv = copy;
55}
56
57random_map_params::random_map_params (HV *hv)
58{
59 this->hv = (HV *)SvREFCNT_inc_NN ((SV *)hv);
60
61 assign (wall_name, get_str ("wall_name"));
62
63 xsize = get_iv ("xsize");
64 ysize = get_iv ("ysize");
65 layoutoptions1 = get_iv ("layoutoptions1");
66 layoutoptions2 = get_iv ("layoutoptions2");
67 layoutoptions3 = get_iv ("layoutoptions3");
68 difficulty = get_iv ("difficulty");
69 difficulty_given = get_iv ("difficulty_given");
70 difficulty_increase = get_nv ("difficulty_increase");
71 dungeon_level = get_iv ("dungeon_level");
72 dungeon_depth = get_iv ("dungeon_depth");
73 total_map_hp = get_nv ("total_map_hp"); // actually val64, but I am too lazy
74 symmetry_used = get_iv ("symmetry_used");
75}
76
77random_map_params::~random_map_params ()
78{
79 SvREFCNT_dec (hv);
80}
81
82shstr_tmp
83random_map_params::as_shstr () const
84{
85 set ("xsize" , xsize);
86 set ("ysize" , ysize);
87 set ("layoutoptions1" , layoutoptions1);
88 set ("layoutoptions2" , layoutoptions2);
89 set ("layoutoptions3" , layoutoptions3);
90 set ("dungeon_depth" , dungeon_depth);
91 set ("difficulty" , difficulty && difficulty_given ? difficulty : 0);
92 set ("difficulty_increase", difficulty_increase);
93 set ("dungeon_level" , dungeon_level);
94
95 dynbuf_text buf;
96 hv_iterinit (hv);
97
98 // does not work for utf-8 keys
99 while (HE *he = hv_iternext (hv))
100 {
101 STRLEN klen; const char *key = HePV (he, klen);
102 STRLEN vlen; const char *value = SvPVutf8 (HeVAL (he), vlen);
103
104 buf.fadd (key, klen);
105 buf << ' ';
106 buf.fadd (value, vlen);
107 buf << '\n';
108 }
109
110 return shstr (buf);
111}
112
113noinline SV *
114random_map_params::get_sv (const char *option) const
39{ 115{
40 SV **he = hv_fetch (hv, option, strlen (option), 0); 116 SV **he = hv_fetch (hv, option, strlen (option), 0);
41 117
118 return he ? *he : 0;
119}
120
121noinline const_utf8_string
122random_map_params::get_str (const char *option, const_utf8_string fallback) const
123{
124 SV *sv = get_sv (option);
42 return he ? cfSvPVutf8_nolen (*he) : fallback; 125 return sv ? cfSvPVutf8_nolen (sv) : fallback;
43} 126}
44 127
45IV 128noinline IV
46random_map_params::get_iv (const char *option, IV fallback) const 129random_map_params::get_iv (const char *option, IV fallback) const
47{ 130{
48 SV **he = hv_fetch (hv, option, strlen (option), 0); 131 SV *sv = get_sv (option);
49
50 return he ? SvIV (*he) : fallback; 132 return sv ? SvIV (sv) : fallback;
51} 133}
52 134
53random_map_params::~random_map_params () 135noinline UV
136random_map_params::get_uv (const char *option, UV fallback) const
54{ 137{
55 SvREFCNT_dec (hv); 138 SV *sv = get_sv (option);
139 return sv ? SvUV (sv) : fallback;
140}
141
142noinline NV
143random_map_params::get_nv (const char *option, NV fallback) const
144{
145 SV *sv = get_sv (option);
146 return sv ? SvNV (sv) : fallback;
147}
148
149noinline void
150random_map_params::set (const char *option, SV *value) const
151{
152 int len = strlen (option);
153
154 if (value)
155 hv_store (hv, option, len, value, 0);
156 else
157 hv_delete (hv, option, len, G_DISCARD);
158}
159
160noinline void
161random_map_params::set (const char *option, const_utf8_string value) const
162{
163 set (option, value && *value ? newSVpvn_utf8 (value, strlen (value), 1) : 0);
56} 164}
57 165
58void 166void
59dump_layout (Layout layout) 167random_map_params::set (const char *option, IV value) const
60{ 168{
61 for (int j = 0; j < layout->h; j++) 169 set (option, newSViv (value));
62 {
63 for (int i = 0; i < layout->w; i++)
64 putc (layout[i][j] ? layout[i][j] : ' ', stdout);
65
66 putc ('\n', stdout);
67 }
68
69 putc ('\n', stdout);
70}
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} 170}
362 171
363void 172void
364write_map_parameters_to_string (dynbuf_text &buf, random_map_params *RP) 173random_map_params::set (const char *option, UV value) const
365{ 174{
366 hv_iterinit (RP->hv); 175 set (option, newSVuv (value));
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} 176}
403 177
404///////////////////////////////////////////////////////////////////////////// 178void
405 179random_map_params::set (const char *option, NV value) const
406LayoutData::LayoutData (int w, int h)
407: w(w), h(h)
408{ 180{
409 int size = (sizeof (char *) + sizeof (char) * h) * w; 181 set (option, newSVnv (value));
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} 182}
517 183
518bool 184bool
519maptile::generate_random_map (random_map_params *RP) 185maptile::generate_random_map (random_map_params *RP)
520{ 186{
521 int i;
522
523 RP->Xsize = RP->xsize; 187 RP->Xsize = RP->xsize;
524 RP->Ysize = RP->ysize; 188 RP->Ysize = RP->ysize;
525 189
190 max_it (RP->dungeon_level, 1);
191
192 IV expand2x = RP->get_iv ("expand2x");
193 UV random_seed = RP->get_uv ("random_seed");
194
526 /* pick a random seed, or use the one from the input file */ 195 /* pick a random seed, or use the one from the input file */
527 RP->random_seed = RP->random_seed 196 random_seed = random_seed
528 ? RP->random_seed + RP->dungeon_level 197 ? random_seed + RP->dungeon_level
529 : time (0); 198 : pticks;
530 199
531 // we run "single-threaded" 200 // we run "single-threaded"
532 rmg_rndm.seed (RP->random_seed); 201 rmg_rndm.seed (random_seed);
533 202
534 dynbuf_text buf; 203 shstr buf = RP->as_shstr ();
535 write_map_parameters_to_string (buf, RP);
536 204
537 if (RP->difficulty == 0) 205 if (RP->difficulty == 0)
538 { 206 {
539 RP->difficulty = RP->dungeon_level; /* use this instead of a map difficulty */ 207 RP->difficulty = RP->dungeon_level; /* use this instead of a map difficulty */
540 208
541 if (RP->difficulty_increase > 0.001) 209 if (RP->difficulty_increase > 0.001f)
542 RP->difficulty = (int) ((float) RP->dungeon_level * RP->difficulty_increase); 210 RP->difficulty = RP->dungeon_level * RP->difficulty_increase;
543 211
544 if (RP->difficulty < 1) 212 if (RP->difficulty < 1)
545 RP->difficulty = 1; 213 RP->difficulty = 1;
546 } 214 }
547 else 215 else
… …
551 RP->Xsize = MIN_RANDOM_MAP_SIZE + rmg_rndm (25) + 5; 219 RP->Xsize = MIN_RANDOM_MAP_SIZE + rmg_rndm (25) + 5;
552 220
553 if (RP->Ysize < MIN_RANDOM_MAP_SIZE) 221 if (RP->Ysize < MIN_RANDOM_MAP_SIZE)
554 RP->Ysize = MIN_RANDOM_MAP_SIZE + rmg_rndm (25) + 5; 222 RP->Ysize = MIN_RANDOM_MAP_SIZE + rmg_rndm (25) + 5;
555 223
224 min_it (RP->Xsize, MAX_RANDOM_MAP_SIZE);
225 min_it (RP->Ysize, MAX_RANDOM_MAP_SIZE);
226
227 int symmetry = RP->get_iv ("symmetry", SYMMETRY_NONE);
228
556 if (RP->symmetry == SYMMETRY_RANDOM) 229 if (symmetry == SYMMETRY_RANDOM)
557 RP->symmetry_used = rmg_rndm (SYMMETRY_XY) + 1; 230 RP->symmetry_used = rmg_rndm (SYMMETRY_XY) + 1;
558 else 231 else
559 RP->symmetry_used = RP->symmetry; 232 RP->symmetry_used = symmetry;
560 233
561 if (RP->symmetry_used == SYMMETRY_Y || RP->symmetry_used == SYMMETRY_XY) 234 if (RP->symmetry_used == SYMMETRY_Y || RP->symmetry_used == SYMMETRY_XY)
562 RP->Ysize = RP->Ysize / 2 + 1; 235 RP->Ysize = RP->Ysize / 2 + 1;
563 236
564 if (RP->symmetry_used == SYMMETRY_X || RP->symmetry_used == SYMMETRY_XY) 237 if (RP->symmetry_used == SYMMETRY_X || RP->symmetry_used == SYMMETRY_XY)
565 RP->Xsize = RP->Xsize / 2 + 1; 238 RP->Xsize = RP->Xsize / 2 + 1;
566 239
567 if (RP->expand2x > 0) 240 if (expand2x)
568 { 241 {
569 RP->Xsize /= 2; 242 RP->Xsize /= 2;
570 RP->Ysize /= 2; 243 RP->Ysize /= 2;
571 } 244 }
572 245
573 RP->map_layout_style = LAYOUT_NONE; 246 const char *layoutstyle = RP->get_str ("layoutstyle", "");
574 247
575 /* Redo this - there was a lot of redundant code of checking for preset
576 * layout style and then random layout style. Instead, figure out
577 * the numeric layoutstyle, so there is only one area that actually
578 * calls the code to make the maps.
579 */
580 if (strstr (RP->layoutstyle, "onion")) 248 if (strstr (layoutstyle, "onion"))
581 RP->map_layout_style = LAYOUT_ONION; 249 RP->map_layout_style = LAYOUT_ONION;
582 else if (strstr (RP->layoutstyle, "maze")) 250 else if (strstr (layoutstyle, "maze"))
583 RP->map_layout_style = LAYOUT_MAZE; 251 RP->map_layout_style = LAYOUT_MAZE;
584 else if (strstr (RP->layoutstyle, "spiral")) 252 else if (strstr (layoutstyle, "spiral"))
585 RP->map_layout_style = LAYOUT_SPIRAL; 253 RP->map_layout_style = LAYOUT_SPIRAL;
586 else if (strstr (RP->layoutstyle, "rogue")) 254 else if (strstr (layoutstyle, "rogue"))
587 RP->map_layout_style = LAYOUT_ROGUELIKE; 255 RP->map_layout_style = LAYOUT_ROGUELIKE;
588 else if (strstr (RP->layoutstyle, "snake")) 256 else if (strstr (layoutstyle, "snake"))
589 RP->map_layout_style = LAYOUT_SNAKE; 257 RP->map_layout_style = LAYOUT_SNAKE;
590 else if (strstr (RP->layoutstyle, "squarespiral")) 258 else if (strstr (layoutstyle, "squarespiral"))
591 RP->map_layout_style = LAYOUT_SQUARE_SPIRAL; 259 RP->map_layout_style = LAYOUT_SQUARE_SPIRAL;
260 else if (strstr (layoutstyle, "cave"))
592 else if (RP->map_layout_style == LAYOUT_NONE) 261 RP->map_layout_style = LAYOUT_CAVE;
262 else if (strstr (layoutstyle, "castle"))
263 RP->map_layout_style = LAYOUT_CASTLE;
264 else if (strstr (layoutstyle, "multiple"))
265 RP->map_layout_style = LAYOUT_MULTIPLE;
266 else
593 RP->map_layout_style = rmg_rndm (NROFLAYOUTS - 1) + 1; /* No style found - choose one randomly */ 267 RP->map_layout_style = rmg_rndm (NROFLAYOUTS - 1) + 1; /* No style found - choose one randomly */
594 else
595 abort ();
596 268
597 Layout layout = layoutgen (RP); 269 layout maze (RP->Xsize, RP->Ysize);
270 maze.generate (RP);
598 271
599#ifdef RMAP_DEBUG 272 if (RP->get_iv ("rotate", 1))
600 dump_layout (layout); 273 maze.rotate (rmg_rndm (4));
274
275 maze.symmetrize (RP->symmetry_used);
276
277 if (expand2x)
278 maze.expand2x ();
279
280#if 0
281 maze.print ();//D
601#endif 282#endif
602 283
603 /* increment these for the current map */ 284 /* increment these for the current map */
604 ++RP->dungeon_level; 285 ++RP->dungeon_level;
605 286
606 // need to patch RP becasue following code doesn't use the Layout object 287 // need to patch RP becasue following code doesn't use the layout object
607 RP->Xsize = layout->w; 288 RP->Xsize = maze.w;
608 RP->Ysize = layout->h; 289 RP->Ysize = maze.h;
609 290
610 /* allocate the map and set the floor */ 291 /* allocate the map and set the floor */
611 make_map_floor (layout, RP->get_str ("floorstyle", ""), RP); 292 make_map_floor (maze, RP->get_str ("floorstyle", ""), RP);
612 293
613 /* set region */ 294 /* set region */
614 default_region = RP->region; 295 default_region = region::find (RP->get_str ("region", 0));
615 296
616 CEDE; 297 CEDE;
617 298
618 place_specials_in_map (this, layout, RP); 299 place_specials_in_map (this, maze, RP);
619 300
620 CEDE; 301 CEDE;
621 302
622 const char *wallstyle = RP->get_str ("wallstyle", 0); 303 const char *wallstyle = RP->get_str ("wallstyle", "");
623 304
624 /* create walls unless the wallstyle is "none" */ 305 /* create walls unless the wallstyle is "none" */
625 if (strcmp (wallstyle, "none")) 306 if (strcmp (wallstyle, "none"))
626 { 307 {
627 make_map_walls (this, layout, wallstyle, RP->get_str ("miningstyle", ""), RP); 308 make_map_walls (this, maze, wallstyle, RP->get_str ("miningstyle", ""), RP);
309
310 const char *doorstyle = RP->get_str ("doorstyle", "");
628 311
629 /* place doors unless doorstyle or wallstyle is "none" */ 312 /* place doors unless doorstyle or wallstyle is "none" */
630 if (strcmp (RP->doorstyle, "none")) 313 if (strcmp (doorstyle, "none"))
631 put_doors (this, layout, RP->doorstyle, RP); 314 put_doors (this, maze, doorstyle, RP);
632 } 315 }
633 316
634 CEDE; 317 CEDE;
635 318
636 const char *exitstyle = RP->get_str ("exitstyle", ""); 319 const char *exitstyle = RP->get_str ("exitstyle", "");
637 320
638 /* create exits unless the exitstyle is "none" */ 321 /* create exits unless the exitstyle is "none" */
639 if (strcmp (exitstyle, "none")) 322 if (strcmp (exitstyle, "none"))
640 place_exits (this, layout, exitstyle, RP->orientation, RP); 323 place_exits (this, maze, exitstyle, RP->get_iv ("orientation", 0), RP);
641 324
642 CEDE; 325 CEDE;
326
327 const char *monsterstyle = RP->get_str ("monsterstyle", "");
643 328
644 /* create monsters unless the monsterstyle is "none" */ 329 /* create monsters unless the monsterstyle is "none" */
645 if (strcmp (RP->monsterstyle, "none")) 330 if (strcmp (monsterstyle, "none"))
646 place_monsters (this, RP->monsterstyle, RP->difficulty, RP); 331 place_monsters (this, monsterstyle, RP->difficulty, RP);
647 332
648 CEDE; 333 CEDE;
649 334
650 /* treasures needs to have a proper difficulty set for the map. */ 335 /* treasures needs to have a proper difficulty set for the map. */
651 difficulty = estimate_difficulty (); 336 difficulty = estimate_difficulty ();
652 337
653 CEDE; 338 CEDE;
654 339
340 const char *treasurestyle = RP->get_str ("treasurestyle", "");
341
655 /* create treasure unless the treasurestyle is "none" */ 342 /* create treasure unless the treasurestyle is "none" */
656 place_treasure (this, layout, RP->treasurestyle, RP->treasureoptions, RP); 343 place_treasure (this, maze, treasurestyle, RP->get_iv ("treasureoptions"), RP);
657 344
658 CEDE; 345 CEDE;
346
347 const char *decorstyle = RP->get_str ("decorstyle", "");
659 348
660 /* create decor unless the decorstyle is "none" */ 349 /* create decor unless the decorstyle is "none" */
661 if (strcmp (RP->decorstyle, "none")) 350 if (strcmp (decorstyle, "none"))
662 put_decor (this, layout, RP->decorstyle, RP->decoroptions, RP); 351 put_decor (this, maze, decorstyle, RP->get_iv ("decoroptions"), RP);
663 352
664 CEDE; 353 CEDE;
665 354
666 /* generate treasures, etc. */ 355 /* generate treasures, etc. */
667 fix_auto_apply (); 356 fix_auto_apply ();
668 357
669 CEDE; 358 CEDE;
670 359
671 unblock_exits (this, layout, RP); 360 unblock_exits (this, maze);
672 361
673 msg = buf; 362 msg = buf;
674 in_memory = MAP_ACTIVE; 363 in_memory = MAP_ACTIVE;
675 364
676 CEDE; 365 CEDE;

Diff Legend

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