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.11 by root, Sat Dec 30 18:45:28 2006 UTC vs.
Revision 1.55 by root, Wed Jun 30 01:32:57 2010 UTC

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

Diff Legend

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