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

Diff Legend

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