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

Diff Legend

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