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.49 by root, Tue Apr 13 02:39:53 2010 UTC vs.
Revision 1.81 by root, Tue Jan 3 11:25:34 2012 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,2009,2010 Marc Alexander Lehmann / Robin Redeker / the Deliantra team 4 * Copyright (©) 2005,2006,2007,2008,2009,2010,2011,2012 Marc Alexander Lehmann / Robin Redeker / the Deliantra team
5 * Copyright (©) 2001 Mark Wedel & Crossfire Development Team 5 * Copyright (©) 2001 Mark Wedel & Crossfire Development Team
6 * Copyright (©) 1992 Frank Tore Johansen 6 * Copyright (©) 1992 Frank Tore Johansen
7 * 7 *
8 * Deliantra is free software: you can redistribute it and/or modify it under 8 * Deliantra is free software: you can redistribute it and/or modify it under
9 * the terms of the Affero GNU General Public License as published by the 9 * the terms of the Affero GNU General Public License as published by the
… …
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}
38
39random_map_params::random_map_params (random_map_params *RP)
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::opt_sv (const char *option) const
115{
116 SV **he = hv_fetch (hv, option, strlen (option), 0);
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 = opt_sv (option);
125 return sv ? cfSvPVutf8_nolen (sv) : fallback;
126}
127
128noinline IV
129random_map_params::get_iv (const char *option, IV fallback) const
130{
131 SV *sv = opt_sv (option);
132 return sv ? SvIV (sv) : fallback;
133}
134
135noinline UV
136random_map_params::get_uv (const char *option, UV fallback) const
137{
138 SV *sv = opt_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 = opt_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);
164}
36 165
37void 166void
38dump_layout (Layout layout) 167random_map_params::set (const char *option, IV value) const
39{ 168{
40 for (int j = 0; j < layout->h; j++) 169 set (option, newSViv (value));
41 {
42 for (int i = 0; i < layout->w; i++)
43 putc (layout[i][j] ? layout[i][j] : ' ', stdout);
44
45 putc ('\n', stdout);
46 }
47
48 putc ('\n', stdout);
49}
50
51/* takes a map and makes it symmetric: adjusts Xsize and
52 * Ysize to produce a symmetric map.
53 */
54static void
55symmetrize_layout (Layout layout, random_map_params *RP)
56{
57 if (RP->symmetry_used == SYMMETRY_NONE)
58 return;
59
60 Layout sym_layout (
61 RP->symmetry_used == SYMMETRY_X || RP->symmetry_used == SYMMETRY_XY ? layout->w * 2 - 3 : layout->w,
62 RP->symmetry_used == SYMMETRY_Y || RP->symmetry_used == SYMMETRY_XY ? layout->h * 2 - 3 : layout->h
63 );
64
65 if (RP->symmetry_used == SYMMETRY_X)
66 for (int i = 0; i < sym_layout->w / 2 + 1; i++)
67 for (int j = 0; j < sym_layout->h; j++)
68 {
69 sym_layout[i ][j] =
70 sym_layout[sym_layout->w - i - 1][j] = layout[i][j];
71 }
72
73 if (RP->symmetry_used == SYMMETRY_Y)
74 for (int i = 0; i < sym_layout->w; i++)
75 for (int j = 0; j < sym_layout->h / 2 + 1; j++)
76 {
77 sym_layout[i][j ] =
78 sym_layout[i][sym_layout->h - j - 1] = layout[i][j];
79 }
80
81 if (RP->symmetry_used == SYMMETRY_XY)
82 for (int i = 0; i < sym_layout->w / 2 + 1; i++)
83 for (int j = 0; j < sym_layout->h / 2 + 1; j++)
84 {
85 sym_layout[i ][j ] =
86 sym_layout[i ][sym_layout->h - j - 1] =
87 sym_layout[sym_layout->w - i - 1][j ] =
88 sym_layout[sym_layout->w - i - 1][sym_layout->h - j - 1] = layout[i][j];
89 }
90
91 layout.swap (sym_layout);
92 sym_layout.free ();
93
94 /* reconnect disjointed spirals */
95 /* reconnect disjointed nethacklayouts: the routine for
96 spirals will do the trick? */
97 if (RP->map_layout_style == LAYOUT_SPIRAL
98 || RP->map_layout_style == LAYOUT_ROGUELIKE)
99 connect_spirals (layout->w, layout->h, RP->symmetry_used, layout);
100}
101
102/* takes a map and rotates it. This completes the
103 onion layouts, making them possibly centered on any wall.
104 It'll modify Xsize and Ysize if they're swapped.
105*/
106static void
107rotate_layout (Layout layout, int rotation)
108{
109 int w = layout->w;
110 int h = layout->h;
111
112 switch (rotation)
113 {
114 case 2: /* a reflection */
115 {
116 Layout new_layout (w, h);
117
118 for (int i = 0; i < w; i++) /* copy a reflection back */
119 for (int j = 0; j < h; j++)
120 new_layout[i][j] = layout[w - i - 1][h - j - 1];
121
122 layout.swap (new_layout);
123 new_layout.free ();
124 }
125 break;
126
127 case 1:
128 case 3:
129 {
130 Layout new_layout (h, w);
131
132 if (rotation == 1) /* swap x and y */
133 for (int i = 0; i < w; i++)
134 for (int j = 0; j < h; j++)
135 new_layout[j][i] = layout[i][j];
136
137 if (rotation == 3) /* swap x and y */
138 for (int i = 0; i < w; i++)
139 for (int j = 0; j < h; j++)
140 new_layout[j][i] = layout[w - i - 1][h - j - 1];
141
142 layout.swap (new_layout);
143 new_layout.free ();
144 }
145 break;
146 }
147}
148
149/* checks the layout to see if I can stick a horizontal(dir = 0) wall
150 (or vertical, dir == 1)
151 here which ends up on other walls sensibly. */
152static int
153can_make_wall (char **maze, int dx, int dy, int dir, random_map_params *RP)
154{
155 int i1;
156 int length = 0;
157
158 /* dont make walls if we're on the edge. */
159 if (dx == 0 || dx == (RP->Xsize - 1) || dy == 0 || dy == (RP->Ysize - 1))
160 return -1;
161
162 /* don't make walls if we're ON a wall. */
163 if (maze[dx][dy] != 0)
164 return -1;
165
166 if (dir == 0) /* horizontal */
167 {
168 int y = dy;
169
170 for (i1 = dx - 1; i1 > 0; i1--)
171 {
172 int sindex = surround_flag2 (maze, i1, y, RP);
173
174 if (sindex == 1)
175 break;
176 if (sindex != 0)
177 return -1; /* can't make horiz. wall here */
178 if (maze[i1][y] != 0)
179 return -1; /* can't make horiz. wall here */
180 length++;
181 }
182
183 for (i1 = dx + 1; i1 < RP->Xsize - 1; i1++)
184 {
185 int sindex = surround_flag2 (maze, i1, y, RP);
186
187 if (sindex == 2)
188 break;
189 if (sindex != 0)
190 return -1; /* can't make horiz. wall here */
191 if (maze[i1][y] != 0)
192 return -1; /* can't make horiz. wall here */
193 length++;
194 }
195 return length;
196 }
197 else
198 { /* vertical */
199 int x = dx;
200
201 for (i1 = dy - 1; i1 > 0; i1--)
202 {
203 int sindex = surround_flag2 (maze, x, i1, RP);
204
205 if (sindex == 4)
206 break;
207 if (sindex != 0)
208 return -1; /* can't make vert. wall here */
209 if (maze[x][i1] != 0)
210 return -1; /* can't make horiz. wall here */
211 length++;
212 }
213
214 for (i1 = dy + 1; i1 < RP->Ysize - 1; i1++)
215 {
216 int sindex = surround_flag2 (maze, x, i1, RP);
217
218 if (sindex == 8)
219 break;
220 if (sindex != 0)
221 return -1; /* can't make verti. wall here */
222 if (maze[x][i1] != 0)
223 return -1; /* can't make horiz. wall here */
224 length++;
225 }
226
227 return length;
228 }
229
230 return -1;
231}
232
233/* take a layout and make some rooms in it.
234 --works best on onions.*/
235static void
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} 170}
349 171
350void 172void
351write_map_parameters_to_string (char *buf, random_map_params *RP) 173random_map_params::set (const char *option, UV value) const
352{ 174{
353 char small_buf[16384]; 175 set (option, newSVuv (value));
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} 176}
522 177
523///////////////////////////////////////////////////////////////////////////// 178void
524 179random_map_params::set (const char *option, NV value) const
525LayoutData::LayoutData (int w, int h)
526: w(w), h(h)
527{ 180{
528 int size = (sizeof (char *) + sizeof (char) * h) * w; 181 set (option, newSVnv (value));
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;
635} 182}
636 183
637bool 184bool
638maptile::generate_random_map (random_map_params *RP) 185maptile::generate_random_map (random_map_params *RP)
639{ 186{
640 char buf[16384];
641 int i;
642
643 RP->Xsize = RP->xsize; 187 RP->Xsize = RP->xsize;
644 RP->Ysize = RP->ysize; 188 RP->Ysize = RP->ysize;
645 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
646 /* 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 */
647 RP->random_seed = RP->random_seed 196 random_seed = random_seed
648 ? RP->random_seed + RP->dungeon_level 197 ? random_seed + RP->dungeon_level
649 : time (0); 198 : server_tick;
650 199
651 // we run "single-threaded" 200 // we run "single-threaded"
652 rmg_rndm.seed (RP->random_seed); 201 rmg_rndm.seed (random_seed);
653 202
654 write_map_parameters_to_string (buf, RP); 203 shstr buf = RP->as_shstr ();
655 204
656 if (RP->difficulty == 0) 205 if (RP->difficulty == 0)
657 { 206 {
658 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 */
659 208
660 if (RP->difficulty_increase > 0.001) 209 if (RP->difficulty_increase > 0.001f)
661 RP->difficulty = (int) ((float) RP->dungeon_level * RP->difficulty_increase); 210 RP->difficulty = RP->dungeon_level * RP->difficulty_increase;
662 211
663 if (RP->difficulty < 1) 212 if (RP->difficulty < 1)
664 RP->difficulty = 1; 213 RP->difficulty = 1;
665 } 214 }
666 else 215 else
… …
670 RP->Xsize = MIN_RANDOM_MAP_SIZE + rmg_rndm (25) + 5; 219 RP->Xsize = MIN_RANDOM_MAP_SIZE + rmg_rndm (25) + 5;
671 220
672 if (RP->Ysize < MIN_RANDOM_MAP_SIZE) 221 if (RP->Ysize < MIN_RANDOM_MAP_SIZE)
673 RP->Ysize = MIN_RANDOM_MAP_SIZE + rmg_rndm (25) + 5; 222 RP->Ysize = MIN_RANDOM_MAP_SIZE + rmg_rndm (25) + 5;
674 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
675 if (RP->symmetry == SYMMETRY_RANDOM) 229 if (symmetry == SYMMETRY_RANDOM)
676 RP->symmetry_used = rmg_rndm (SYMMETRY_XY) + 1; 230 RP->symmetry_used = rmg_rndm (SYMMETRY_XY) + 1;
677 else 231 else
678 RP->symmetry_used = RP->symmetry; 232 RP->symmetry_used = symmetry;
679 233
680 if (RP->symmetry_used == SYMMETRY_Y || RP->symmetry_used == SYMMETRY_XY) 234 if (RP->symmetry_used == SYMMETRY_Y || RP->symmetry_used == SYMMETRY_XY)
681 RP->Ysize = RP->Ysize / 2 + 1; 235 RP->Ysize = RP->Ysize / 2 + 1;
682 236
683 if (RP->symmetry_used == SYMMETRY_X || RP->symmetry_used == SYMMETRY_XY) 237 if (RP->symmetry_used == SYMMETRY_X || RP->symmetry_used == SYMMETRY_XY)
684 RP->Xsize = RP->Xsize / 2 + 1; 238 RP->Xsize = RP->Xsize / 2 + 1;
685 239
686 if (RP->expand2x > 0) 240 if (expand2x)
687 { 241 {
688 RP->Xsize /= 2; 242 RP->Xsize /= 2;
689 RP->Ysize /= 2; 243 RP->Ysize /= 2;
690 } 244 }
691 245
692 RP->map_layout_style = LAYOUT_NONE; 246 const char *layoutstyle = RP->get_str ("layoutstyle", "");
693 247
694 /* Redo this - there was a lot of redundant code of checking for preset
695 * layout style and then random layout style. Instead, figure out
696 * the numeric layoutstyle, so there is only one area that actually
697 * calls the code to make the maps.
698 */
699 if (strstr (RP->layoutstyle, "onion")) 248 if (strstr (layoutstyle, "onion"))
700 RP->map_layout_style = LAYOUT_ONION; 249 RP->map_layout_style = LAYOUT_ONION;
701 else if (strstr (RP->layoutstyle, "maze")) 250 else if (strstr (layoutstyle, "maze"))
702 RP->map_layout_style = LAYOUT_MAZE; 251 RP->map_layout_style = LAYOUT_MAZE;
703 else if (strstr (RP->layoutstyle, "spiral")) 252 else if (strstr (layoutstyle, "spiral"))
704 RP->map_layout_style = LAYOUT_SPIRAL; 253 RP->map_layout_style = LAYOUT_SPIRAL;
705 else if (strstr (RP->layoutstyle, "rogue")) 254 else if (strstr (layoutstyle, "rogue"))
706 RP->map_layout_style = LAYOUT_ROGUELIKE; 255 RP->map_layout_style = LAYOUT_ROGUELIKE;
707 else if (strstr (RP->layoutstyle, "snake")) 256 else if (strstr (layoutstyle, "snake"))
708 RP->map_layout_style = LAYOUT_SNAKE; 257 RP->map_layout_style = LAYOUT_SNAKE;
709 else if (strstr (RP->layoutstyle, "squarespiral")) 258 else if (strstr (layoutstyle, "squarespiral"))
710 RP->map_layout_style = LAYOUT_SQUARE_SPIRAL; 259 RP->map_layout_style = LAYOUT_SQUARE_SPIRAL;
260 else if (strstr (layoutstyle, "cave"))
711 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
712 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 */
713 else
714 abort ();
715 268
716 Layout layout = layoutgen (RP); 269 layout maze (RP->Xsize, RP->Ysize);
270 maze.generate (RP);
717 271
718#ifdef RMAP_DEBUG 272 if (RP->get_iv ("rotate", 1))
719 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
720#endif 282#endif
721 283
722 /* increment these for the current map */ 284 /* increment these for the current map */
723 ++RP->dungeon_level; 285 ++RP->dungeon_level;
724 286
725 // 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
726 RP->Xsize = layout->w; 288 RP->Xsize = maze.w;
727 RP->Ysize = layout->h; 289 RP->Ysize = maze.h;
728 290
729 /* allocate the map and set the floor */ 291 /* allocate the map and set the floor */
730 make_map_floor (layout, RP->floorstyle, RP); 292 make_map_floor (maze, RP->get_str ("floorstyle", ""), RP);
731 293
732 /* set region */ 294 /* set region */
733 default_region = RP->region; 295 default_region = region::find (RP->get_str ("region", 0));
734 296
735 CEDE; 297 CEDE;
736 298
737 place_specials_in_map (this, layout, RP); 299 place_specials_in_map (this, maze, RP);
738 300
739 CEDE; 301 CEDE;
302
303 const char *wallstyle = RP->get_str ("wallstyle", "");
740 304
741 /* create walls unless the wallstyle is "none" */ 305 /* create walls unless the wallstyle is "none" */
742 if (strcmp (RP->wallstyle, "none")) 306 if (strcmp (wallstyle, "none"))
743 { 307 {
744 make_map_walls (this, layout, RP->wallstyle, RP->miningstyle, RP); 308 make_map_walls (this, maze, wallstyle, RP->get_str ("miningstyle", ""), RP);
309
310 const char *doorstyle = RP->get_str ("doorstyle", "");
745 311
746 /* place doors unless doorstyle or wallstyle is "none" */ 312 /* place doors unless doorstyle or wallstyle is "none" */
747 if (strcmp (RP->doorstyle, "none")) 313 if (strcmp (doorstyle, "none"))
748 put_doors (this, layout, RP->doorstyle, RP); 314 put_doors (this, maze, doorstyle, RP);
749 } 315 }
750 316
751 CEDE; 317 CEDE;
318
319 const char *exitstyle = RP->get_str ("exitstyle", "");
752 320
753 /* create exits unless the exitstyle is "none" */ 321 /* create exits unless the exitstyle is "none" */
754 if (strcmp (RP->exitstyle, "none")) 322 if (strcmp (exitstyle, "none"))
755 place_exits (this, layout, RP->exitstyle, RP->orientation, RP); 323 place_exits (this, maze, exitstyle, RP->get_iv ("orientation", 0), RP);
756 324
757 CEDE; 325 CEDE;
326
327 const char *monsterstyle = RP->get_str ("monsterstyle", "");
758 328
759 /* create monsters unless the monsterstyle is "none" */ 329 /* create monsters unless the monsterstyle is "none" */
760 if (strcmp (RP->monsterstyle, "none")) 330 if (strcmp (monsterstyle, "none"))
761 place_monsters (this, RP->monsterstyle, RP->difficulty, RP); 331 place_monsters (this, monsterstyle, RP->difficulty, RP);
762 332
763 CEDE; 333 CEDE;
764 334
765 /* treasures needs to have a proper difficulty set for the map. */ 335 /* treasures needs to have a proper difficulty set for the map. */
766 difficulty = estimate_difficulty (); 336 difficulty = estimate_difficulty ();
767 337
768 CEDE; 338 CEDE;
769 339
340 const char *treasurestyle = RP->get_str ("treasurestyle", "");
341
770 /* create treasure unless the treasurestyle is "none" */ 342 /* create treasure unless the treasurestyle is "none" */
771 place_treasure (this, layout, RP->treasurestyle, RP->treasureoptions, RP); 343 place_treasure (this, maze, treasurestyle, RP->get_iv ("treasureoptions"), RP);
772 344
773 CEDE; 345 CEDE;
346
347 const char *decorstyle = RP->get_str ("decorstyle", "");
774 348
775 /* create decor unless the decorstyle is "none" */ 349 /* create decor unless the decorstyle is "none" */
776 if (strcmp (RP->decorstyle, "none")) 350 if (strcmp (decorstyle, "none"))
777 put_decor (this, layout, RP->decorstyle, RP->decoroptions, RP); 351 put_decor (this, maze, decorstyle, RP->get_iv ("decoroptions"), RP);
778 352
779 CEDE; 353 CEDE;
780 354
781 /* generate treasures, etc. */ 355 /* generate treasures, etc. */
782 fix_auto_apply (); 356 fix_auto_apply ();
783 357
784 CEDE; 358 CEDE;
785 359
786 unblock_exits (this, layout, RP); 360 unblock_exits (this, maze);
787 361
788 msg = strdup (buf); 362 msg = buf;
789 in_memory = MAP_ACTIVE; 363 state = MAP_INACTIVE; // this is probably a lie, but currently works with ext/map-random.ext
790 364
791 CEDE; 365 CEDE;
792 366
793 return 1; 367 return 1;
794} 368}

Diff Legend

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