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

Diff Legend

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