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.9 by root, Thu Dec 14 22:45:40 2006 UTC vs.
Revision 1.16 by root, Sun Dec 31 21:02:05 2006 UTC

1
1/* 2/*
2 CrossFire, A Multiplayer game for X-windows 3 CrossFire, A Multiplayer game for X-windows
3 4
4 Copyright (C) 2001 Mark Wedel & Crossfire Development Team 5 Copyright (C) 2001 Mark Wedel & Crossfire Development Team
5 Copyright (C) 1992 Frank Tore Johansen 6 Copyright (C) 1992 Frank Tore Johansen
… …
29#include <random_map.h> 30#include <random_map.h>
30#include <rproto.h> 31#include <rproto.h>
31#include <sproto.h> 32#include <sproto.h>
32 33
33void 34void
34dump_layout (char **layout, RMParms * RP) 35dump_layout (char **layout, random_map_params *RP)
35{ 36{
36 { 37 {
37 int i, j; 38 int i, j;
38 39
39 for (i = 0; i < RP->Xsize; i++) 40 for (i = 0; i < RP->Xsize; i++)
… …
50 } 51 }
51 } 52 }
52 printf ("\n"); 53 printf ("\n");
53} 54}
54 55
55extern FILE *logfile;
56
57maptile * 56maptile *
58generate_random_map (const char *OutFileName, RMParms * RP) 57generate_random_map (const char *OutFileName, random_map_params *RP)
59{ 58{
60 char **layout, buf[HUGE_BUF]; 59 char **layout, buf[HUGE_BUF];
61 maptile *theMap; 60 maptile *theMap;
62 int i; 61 int i;
63 62
64 /* pick a random seed, or use the one from the input file */ 63 /* pick a random seed, or use the one from the input file */
65 if (RP->random_seed == 0) 64 SRANDOM (RP->random_seed ? RP->random_seed + RP->dungeon_level : time (0));
66 RP->random_seed = time (0);
67
68 SRANDOM (RP->random_seed);
69 65
70 write_map_parameters_to_string (buf, RP); 66 write_map_parameters_to_string (buf, RP);
71 67
72 if (RP->difficulty == 0) 68 if (RP->difficulty == 0)
73 { 69 {
… …
113 109
114 /* allocate the map and set the floor */ 110 /* allocate the map and set the floor */
115 theMap = make_map_floor (layout, RP->floorstyle, RP); 111 theMap = make_map_floor (layout, RP->floorstyle, RP);
116 112
117 /* set the name of the map. */ 113 /* set the name of the map. */
118 strcpy (theMap->path, OutFileName); 114 theMap->path = OutFileName;
119 115
120 /* set region */ 116 /* set region */
121 theMap->region = RP->region; 117 theMap->region = RP->region;
122 118
119 coroapi::cede ();
123 /* create walls unless the wallstyle is "none" */ 120 /* create walls unless the wallstyle is "none" */
124 if (strcmp (RP->wallstyle, "none")) 121 if (strcmp (RP->wallstyle, "none"))
125 { 122 {
126 make_map_walls (theMap, layout, RP->wallstyle, RP); 123 make_map_walls (theMap, layout, RP->wallstyle, RP);
127 124
… …
129 if (strcmp (RP->doorstyle, "none")) 126 if (strcmp (RP->doorstyle, "none"))
130 put_doors (theMap, layout, RP->doorstyle, RP); 127 put_doors (theMap, layout, RP->doorstyle, RP);
131 128
132 } 129 }
133 130
131 coroapi::cede ();
134 /* create exits unless the exitstyle is "none" */ 132 /* create exits unless the exitstyle is "none" */
135 if (strcmp (RP->exitstyle, "none")) 133 if (strcmp (RP->exitstyle, "none"))
136 place_exits (theMap, layout, RP->exitstyle, RP->orientation, RP); 134 place_exits (theMap, layout, RP->exitstyle, RP->orientation, RP);
137 135
136 coroapi::cede ();
138 place_specials_in_map (theMap, layout, RP); 137 place_specials_in_map (theMap, layout, RP);
139 138
139 coroapi::cede ();
140 /* create monsters unless the monsterstyle is "none" */ 140 /* create monsters unless the monsterstyle is "none" */
141 if (strcmp (RP->monsterstyle, "none")) 141 if (strcmp (RP->monsterstyle, "none"))
142 place_monsters (theMap, RP->monsterstyle, RP->difficulty, RP); 142 place_monsters (theMap, RP->monsterstyle, RP->difficulty, RP);
143 143
144 coroapi::cede ();
144 /* treasures needs to have a proper difficulty set for the map. */ 145 /* treasures needs to have a proper difficulty set for the map. */
145 theMap->difficulty = calculate_difficulty (theMap); 146 theMap->difficulty = theMap->estimate_difficulty ();
146 147
148 coroapi::cede ();
147 /* create treasure unless the treasurestyle is "none" */ 149 /* create treasure unless the treasurestyle is "none" */
148 if (strcmp (RP->treasurestyle, "none")) 150 if (strcmp (RP->treasurestyle, "none"))
149 place_treasure (theMap, layout, RP->treasurestyle, RP->treasureoptions, RP); 151 place_treasure (theMap, layout, RP->treasurestyle, RP->treasureoptions, RP);
150 152
153 coroapi::cede ();
151 /* create decor unless the decorstyle is "none" */ 154 /* create decor unless the decorstyle is "none" */
152 if (strcmp (RP->decorstyle, "none")) 155 if (strcmp (RP->decorstyle, "none"))
153 put_decor (theMap, layout, RP->decorstyle, RP->decoroptions, RP); 156 put_decor (theMap, layout, RP->decorstyle, RP->decoroptions, RP);
154 157
158 coroapi::cede ();
155 /* generate treasures, etc. */ 159 /* generate treasures, etc. */
156 fix_auto_apply (theMap); 160 theMap->fix_auto_apply ();
157 161
162 coroapi::cede ();
158 unblock_exits (theMap, layout, RP); 163 unblock_exits (theMap, layout, RP);
159 164
160 /* free the layout */ 165 /* free the layout */
161 for (i = 0; i < RP->Xsize; i++) 166 for (i = 0; i < RP->Xsize; i++)
162 free (layout[i]); 167 free (layout[i]);
168
163 free (layout); 169 free (layout);
164 170
165 theMap->msg = strdup (buf); 171 theMap->msg = strdup (buf);
172 theMap->in_memory = MAP_IN_MEMORY;
166 173
167 return theMap; 174 return theMap;
168} 175}
169 176
170/* function selects the layout function and gives it whatever 177/* function selects the layout function and gives it whatever
171 arguments it needs. */ 178 arguments it needs. */
172char ** 179char **
173layoutgen (RMParms * RP) 180layoutgen (random_map_params *RP)
174{ 181{
175 char **maze = 0; 182 char **maze = 0;
176 int oxsize = RP->Xsize, oysize = RP->Ysize; 183 int oxsize = RP->Xsize, oysize = RP->Ysize;
177 184
178 if (RP->symmetry == RANDOM_SYM) 185 if (RP->symmetry == SYMMETRY_RANDOM)
179 RP->symmetry_used = (RANDOM () % (XY_SYM)) + 1; 186 RP->symmetry_used = (RANDOM () % (SYMMETRY_XY)) + 1;
180 else 187 else
181 RP->symmetry_used = RP->symmetry; 188 RP->symmetry_used = RP->symmetry;
182 189
183 if (RP->symmetry_used == Y_SYM || RP->symmetry_used == XY_SYM) 190 if (RP->symmetry_used == SYMMETRY_Y || RP->symmetry_used == SYMMETRY_XY)
184 RP->Ysize = RP->Ysize / 2 + 1; 191 RP->Ysize = RP->Ysize / 2 + 1;
185 if (RP->symmetry_used == X_SYM || RP->symmetry_used == XY_SYM) 192 if (RP->symmetry_used == SYMMETRY_X || RP->symmetry_used == SYMMETRY_XY)
186 RP->Xsize = RP->Xsize / 2 + 1; 193 RP->Xsize = RP->Xsize / 2 + 1;
187 194
188 if (RP->Xsize < MIN_RANDOM_MAP_SIZE) 195 if (RP->Xsize < MIN_RANDOM_MAP_SIZE)
189 RP->Xsize = MIN_RANDOM_MAP_SIZE + RANDOM () % 5; 196 RP->Xsize = MIN_RANDOM_MAP_SIZE + RANDOM () % 5;
190 if (RP->Ysize < MIN_RANDOM_MAP_SIZE) 197 if (RP->Ysize < MIN_RANDOM_MAP_SIZE)
… …
195 * layout style and then random layout style. Instead, figure out 202 * layout style and then random layout style. Instead, figure out
196 * the numeric layoutstyle, so there is only one area that actually 203 * the numeric layoutstyle, so there is only one area that actually
197 * calls the code to make the maps. 204 * calls the code to make the maps.
198 */ 205 */
199 if (strstr (RP->layoutstyle, "onion")) 206 if (strstr (RP->layoutstyle, "onion"))
200 {
201 RP->map_layout_style = ONION_LAYOUT; 207 RP->map_layout_style = LAYOUT_ONION;
202 }
203 208
204 if (strstr (RP->layoutstyle, "maze")) 209 if (strstr (RP->layoutstyle, "maze"))
205 {
206 RP->map_layout_style = MAZE_LAYOUT; 210 RP->map_layout_style = LAYOUT_MAZE;
207 }
208 211
209 if (strstr (RP->layoutstyle, "spiral")) 212 if (strstr (RP->layoutstyle, "spiral"))
210 {
211 RP->map_layout_style = SPIRAL_LAYOUT; 213 RP->map_layout_style = LAYOUT_SPIRAL;
212 }
213 214
214 if (strstr (RP->layoutstyle, "rogue")) 215 if (strstr (RP->layoutstyle, "rogue"))
215 {
216 RP->map_layout_style = ROGUELIKE_LAYOUT; 216 RP->map_layout_style = LAYOUT_ROGUELIKE;
217 }
218 217
219 if (strstr (RP->layoutstyle, "snake")) 218 if (strstr (RP->layoutstyle, "snake"))
220 {
221 RP->map_layout_style = SNAKE_LAYOUT; 219 RP->map_layout_style = LAYOUT_SNAKE;
222 }
223 220
224 if (strstr (RP->layoutstyle, "squarespiral")) 221 if (strstr (RP->layoutstyle, "squarespiral"))
225 {
226 RP->map_layout_style = SQUARE_SPIRAL_LAYOUT; 222 RP->map_layout_style = LAYOUT_SQUARE_SPIRAL;
227 } 223
228 /* No style found - choose one ranomdly */ 224 /* No style found - choose one ranomdly */
229 if (RP->map_layout_style == 0) 225 if (RP->map_layout_style == LAYOUT_NONE)
230 {
231 RP->map_layout_style = (RANDOM () % NROFLAYOUTS) + 1; 226 RP->map_layout_style = (RANDOM () % (NROFLAYOUTS - 1)) + 1;
232 }
233 227
234 switch (RP->map_layout_style) 228 switch (RP->map_layout_style)
235 { 229 {
236 230 case LAYOUT_ONION:
237 case ONION_LAYOUT:
238 maze = map_gen_onion (RP->Xsize, RP->Ysize, RP->layoutoptions1, RP->layoutoptions2); 231 maze = map_gen_onion (RP->Xsize, RP->Ysize, RP->layoutoptions1, RP->layoutoptions2);
239 if (!(RANDOM () % 3) && !(RP->layoutoptions1 & OPT_WALLS_ONLY)) 232 if (!(RANDOM () % 3) && !(RP->layoutoptions1 & RMOPT_WALLS_ONLY))
240 roomify_layout (maze, RP); 233 roomify_layout (maze, RP);
241 break; 234 break;
242 235
243 case MAZE_LAYOUT: 236 case LAYOUT_MAZE:
244 maze = maze_gen (RP->Xsize, RP->Ysize, RANDOM () % 2); 237 maze = maze_gen (RP->Xsize, RP->Ysize, RANDOM () % 2);
245 if (!(RANDOM () % 2)) 238 if (!(RANDOM () % 2))
246 doorify_layout (maze, RP); 239 doorify_layout (maze, RP);
247 break; 240 break;
248 241
249 case SPIRAL_LAYOUT: 242 case LAYOUT_SPIRAL:
250 maze = map_gen_spiral (RP->Xsize, RP->Ysize, RP->layoutoptions1); 243 maze = map_gen_spiral (RP->Xsize, RP->Ysize, RP->layoutoptions1);
251 if (!(RANDOM () % 2)) 244 if (!(RANDOM () % 2))
252 doorify_layout (maze, RP); 245 doorify_layout (maze, RP);
253 break; 246 break;
254 247
255 case ROGUELIKE_LAYOUT: 248 case LAYOUT_ROGUELIKE:
256 /* Don't put symmetry in rogue maps. There isn't much reason to 249 /* Don't put symmetry in rogue maps. There isn't much reason to
257 * do so in the first place (doesn't make it any more interesting), 250 * do so in the first place (doesn't make it any more interesting),
258 * but more importantly, the symmetry code presumes we are symmetrizing 251 * but more importantly, the symmetry code presumes we are symmetrizing
259 * spirals, or maps with lots of passages - making a symmetric rogue 252 * spirals, or maps with lots of passages - making a symmetric rogue
260 * map fails because its likely that the passages the symmetry process 253 * map fails because its likely that the passages the symmetry process
261 * creates may not connect the rooms. 254 * creates may not connect the rooms.
262 */ 255 */
263 RP->symmetry_used = NO_SYM; 256 RP->symmetry_used = SYMMETRY_NONE;
264 RP->Ysize = oysize; 257 RP->Ysize = oysize;
265 RP->Xsize = oxsize; 258 RP->Xsize = oxsize;
266 maze = roguelike_layout_gen (RP->Xsize, RP->Ysize, RP->layoutoptions1); 259 maze = roguelike_layout_gen (RP->Xsize, RP->Ysize, RP->layoutoptions1);
267 /* no doorifying... done already */ 260 /* no doorifying... done already */
268 break; 261 break;
269 262
270 case SNAKE_LAYOUT: 263 case LAYOUT_SNAKE:
271 maze = make_snake_layout (RP->Xsize, RP->Ysize, RP->layoutoptions1); 264 maze = make_snake_layout (RP->Xsize, RP->Ysize, RP->layoutoptions1);
272 if (RANDOM () % 2) 265 if (RANDOM () % 2)
273 roomify_layout (maze, RP); 266 roomify_layout (maze, RP);
274 break; 267 break;
275 268
276 case SQUARE_SPIRAL_LAYOUT: 269 case LAYOUT_SQUARE_SPIRAL:
277 maze = make_square_spiral_layout (RP->Xsize, RP->Ysize, RP->layoutoptions1); 270 maze = make_square_spiral_layout (RP->Xsize, RP->Ysize, RP->layoutoptions1);
278 if (RANDOM () % 2) 271 if (RANDOM () % 2)
279 roomify_layout (maze, RP); 272 roomify_layout (maze, RP);
280 break; 273 break;
281 } 274 }
282 275
283 maze = symmetrize_layout (maze, RP->symmetry_used, RP); 276 maze = symmetrize_layout (maze, RP->symmetry_used, RP);
277
284#ifdef RMAP_DEBUG 278#ifdef RMAP_DEBUG
285 dump_layout (maze, RP); 279 dump_layout (maze, RP);
286#endif 280#endif
281
287 if (RP->expand2x) 282 if (RP->expand2x)
288 { 283 {
289 maze = expand2x (maze, RP->Xsize, RP->Ysize); 284 maze = expand2x (maze, RP->Xsize, RP->Ysize);
290 RP->Xsize = RP->Xsize * 2 - 1; 285 RP->Xsize = RP->Xsize * 2 - 1;
291 RP->Ysize = RP->Ysize * 2 - 1; 286 RP->Ysize = RP->Ysize * 2 - 1;
292 } 287 }
288
293 return maze; 289 return maze;
294} 290}
295
296 291
297/* takes a map and makes it symmetric: adjusts Xsize and 292/* takes a map and makes it symmetric: adjusts Xsize and
298Ysize to produce a symmetric map. */ 293Ysize to produce a symmetric map. */
299
300char ** 294char **
301symmetrize_layout (char **maze, int sym, RMParms * RP) 295symmetrize_layout (char **maze, int sym, random_map_params *RP)
302{ 296{
303 int i, j; 297 int i, j;
304 char **sym_maze; 298 char **sym_maze;
305 int Xsize_orig, Ysize_orig; 299 int Xsize_orig, Ysize_orig;
306 300
307 Xsize_orig = RP->Xsize; 301 Xsize_orig = RP->Xsize;
308 Ysize_orig = RP->Ysize; 302 Ysize_orig = RP->Ysize;
309 RP->symmetry_used = sym; /* tell everyone else what sort of symmetry is used. */ 303 RP->symmetry_used = sym; /* tell everyone else what sort of symmetry is used. */
310 if (sym == NO_SYM) 304 if (sym == SYMMETRY_NONE)
311 { 305 {
312 RP->Xsize = Xsize_orig; 306 RP->Xsize = Xsize_orig;
313 RP->Ysize = Ysize_orig; 307 RP->Ysize = Ysize_orig;
314 return maze; 308 return maze;
315 } 309 }
316 /* pick new sizes */ 310 /* pick new sizes */
317 RP->Xsize = ((sym == X_SYM || sym == XY_SYM) ? RP->Xsize * 2 - 3 : RP->Xsize); 311 RP->Xsize = ((sym == SYMMETRY_X || sym == SYMMETRY_XY) ? RP->Xsize * 2 - 3 : RP->Xsize);
318 RP->Ysize = ((sym == Y_SYM || sym == XY_SYM) ? RP->Ysize * 2 - 3 : RP->Ysize); 312 RP->Ysize = ((sym == SYMMETRY_Y || sym == SYMMETRY_XY) ? RP->Ysize * 2 - 3 : RP->Ysize);
319 313
320 sym_maze = (char **) calloc (sizeof (char *), RP->Xsize); 314 sym_maze = (char **) calloc (sizeof (char *), RP->Xsize);
321 for (i = 0; i < RP->Xsize; i++) 315 for (i = 0; i < RP->Xsize; i++)
322 sym_maze[i] = (char *) calloc (sizeof (char), RP->Ysize); 316 sym_maze[i] = (char *) calloc (sizeof (char), RP->Ysize);
323 317
324 if (sym == X_SYM) 318 if (sym == SYMMETRY_X)
325 for (i = 0; i < RP->Xsize / 2 + 1; i++) 319 for (i = 0; i < RP->Xsize / 2 + 1; i++)
326 for (j = 0; j < RP->Ysize; j++) 320 for (j = 0; j < RP->Ysize; j++)
327 { 321 {
328 sym_maze[i][j] = maze[i][j]; 322 sym_maze[i][j] = maze[i][j];
329 sym_maze[RP->Xsize - i - 1][j] = maze[i][j]; 323 sym_maze[RP->Xsize - i - 1][j] = maze[i][j];
330 }; 324 };
331 if (sym == Y_SYM) 325 if (sym == SYMMETRY_Y)
332 for (i = 0; i < RP->Xsize; i++) 326 for (i = 0; i < RP->Xsize; i++)
333 for (j = 0; j < RP->Ysize / 2 + 1; j++) 327 for (j = 0; j < RP->Ysize / 2 + 1; j++)
334 { 328 {
335 sym_maze[i][j] = maze[i][j]; 329 sym_maze[i][j] = maze[i][j];
336 sym_maze[i][RP->Ysize - j - 1] = maze[i][j]; 330 sym_maze[i][RP->Ysize - j - 1] = maze[i][j];
337 } 331 }
338 if (sym == XY_SYM) 332 if (sym == SYMMETRY_XY)
339 for (i = 0; i < RP->Xsize / 2 + 1; i++) 333 for (i = 0; i < RP->Xsize / 2 + 1; i++)
340 for (j = 0; j < RP->Ysize / 2 + 1; j++) 334 for (j = 0; j < RP->Ysize / 2 + 1; j++)
341 { 335 {
342 sym_maze[i][j] = maze[i][j]; 336 sym_maze[i][j] = maze[i][j];
343 sym_maze[i][RP->Ysize - j - 1] = maze[i][j]; 337 sym_maze[i][RP->Ysize - j - 1] = maze[i][j];
… …
347 /* delete the old maze */ 341 /* delete the old maze */
348 for (i = 0; i < Xsize_orig; i++) 342 for (i = 0; i < Xsize_orig; i++)
349 free (maze[i]); 343 free (maze[i]);
350 free (maze); 344 free (maze);
351 /* reconnect disjointed spirals */ 345 /* reconnect disjointed spirals */
352 if (RP->map_layout_style == SPIRAL_LAYOUT) 346 if (RP->map_layout_style == LAYOUT_SPIRAL)
353 connect_spirals (RP->Xsize, RP->Ysize, sym, sym_maze); 347 connect_spirals (RP->Xsize, RP->Ysize, sym, sym_maze);
354 /* reconnect disjointed nethackmazes: the routine for 348 /* reconnect disjointed nethackmazes: the routine for
355 spirals will do the trick? */ 349 spirals will do the trick? */
356 if (RP->map_layout_style == ROGUELIKE_LAYOUT) 350 if (RP->map_layout_style == LAYOUT_ROGUELIKE)
357 connect_spirals (RP->Xsize, RP->Ysize, sym, sym_maze); 351 connect_spirals (RP->Xsize, RP->Ysize, sym, sym_maze);
358 352
359 return sym_maze; 353 return sym_maze;
360} 354}
361 355
… …
364 onion layouts, making them possibly centered on any wall. 358 onion layouts, making them possibly centered on any wall.
365 It'll modify Xsize and Ysize if they're swapped. 359 It'll modify Xsize and Ysize if they're swapped.
366*/ 360*/
367 361
368char ** 362char **
369rotate_layout (char **maze, int rotation, RMParms * RP) 363rotate_layout (char **maze, int rotation, random_map_params *RP)
370{ 364{
371 char **new_maze; 365 char **new_maze;
372 int i, j; 366 int i, j;
373 367
374 switch (rotation) 368 switch (rotation)
375 { 369 {
376 case 0: 370 case 0:
371 return maze;
372 break;
373 case 2: /* a reflection */
374 {
375 char *newmaze = (char *) malloc (sizeof (char) * RP->Xsize * RP->Ysize);
376
377 for (i = 0; i < RP->Xsize; i++)
378 { /* make a copy */
379 for (j = 0; j < RP->Ysize; j++)
380 {
381 newmaze[i * RP->Ysize + j] = maze[i][j];
382 }
383 }
384 for (i = 0; i < RP->Xsize; i++)
385 { /* copy a reflection back */
386 for (j = 0; j < RP->Ysize; j++)
387 {
388 maze[i][j] = newmaze[(RP->Xsize - i - 1) * RP->Ysize + RP->Ysize - j - 1];
389 }
390 }
391 free (newmaze);
377 return maze; 392 return maze;
378 break; 393 break;
379 case 2: /* a reflection */ 394 }
395 case 1:
396 case 3:
397 {
398 int swap;
399 new_maze = (char **) calloc (sizeof (char *), RP->Ysize);
400 for (i = 0; i < RP->Ysize; i++)
380 { 401 {
381 char *newmaze = (char *) malloc (sizeof (char) * RP->Xsize * RP->Ysize); 402 new_maze[i] = (char *) calloc (sizeof (char), RP->Xsize);
382 403 }
404 if (rotation == 1) /* swap x and y */
383 for (i = 0; i < RP->Xsize; i++) 405 for (i = 0; i < RP->Xsize; i++)
384 { /* make a copy */
385 for (j = 0; j < RP->Ysize; j++) 406 for (j = 0; j < RP->Ysize; j++)
386 {
387 newmaze[i * RP->Ysize + j] = maze[i][j]; 407 new_maze[j][i] = maze[i][j];
388 } 408
389 } 409 if (rotation == 3)
390 for (i = 0; i < RP->Xsize; i++) 410 { /* swap x and y */
391 { /* copy a reflection back */
392 for (j = 0; j < RP->Ysize; j++)
393 {
394 maze[i][j] = newmaze[(RP->Xsize - i - 1) * RP->Ysize + RP->Ysize - j - 1];
395 }
396 }
397 free (newmaze);
398 return maze;
399 break;
400 }
401 case 1:
402 case 3:
403 {
404 int swap;
405 new_maze = (char **) calloc (sizeof (char *), RP->Ysize);
406 for (i = 0; i < RP->Ysize; i++)
407 {
408 new_maze[i] = (char *) calloc (sizeof (char), RP->Xsize);
409 }
410 if (rotation == 1) /* swap x and y */
411 for (i = 0; i < RP->Xsize; i++) 411 for (i = 0; i < RP->Xsize; i++)
412 for (j = 0; j < RP->Ysize; j++) 412 for (j = 0; j < RP->Ysize; j++)
413 new_maze[j][i] = maze[i][j];
414
415 if (rotation == 3)
416 { /* swap x and y */
417 for (i = 0; i < RP->Xsize; i++)
418 for (j = 0; j < RP->Ysize; j++)
419 new_maze[j][i] = maze[RP->Xsize - i - 1][RP->Ysize - j - 1]; 413 new_maze[j][i] = maze[RP->Xsize - i - 1][RP->Ysize - j - 1];
420 } 414 }
421 415
422 /* delete the old layout */ 416 /* delete the old layout */
423 for (i = 0; i < RP->Xsize; i++) 417 for (i = 0; i < RP->Xsize; i++)
424 free (maze[i]); 418 free (maze[i]);
425 free (maze); 419 free (maze);
426 420
427 swap = RP->Ysize; 421 swap = RP->Ysize;
428 RP->Ysize = RP->Xsize; 422 RP->Ysize = RP->Xsize;
429 RP->Xsize = swap; 423 RP->Xsize = swap;
430 return new_maze; 424 return new_maze;
431 break; 425 break;
432 } 426 }
433 } 427 }
434 return NULL; 428 return NULL;
435} 429}
436 430
437/* take a layout and make some rooms in it. 431/* take a layout and make some rooms in it.
438 --works best on onions.*/ 432 --works best on onions.*/
439void 433void
440roomify_layout (char **maze, RMParms * RP) 434roomify_layout (char **maze, random_map_params *RP)
441{ 435{
442 int tries = RP->Xsize * RP->Ysize / 30; 436 int tries = RP->Xsize * RP->Ysize / 30;
443 int ti; 437 int ti;
444 438
445 for (ti = 0; ti < tries; ti++) 439 for (ti = 0; ti < tries; ti++)
… …
472/* checks the layout to see if I can stick a horizontal(dir = 0) wall 466/* checks the layout to see if I can stick a horizontal(dir = 0) wall
473 (or vertical, dir == 1) 467 (or vertical, dir == 1)
474 here which ends up on other walls sensibly. */ 468 here which ends up on other walls sensibly. */
475 469
476int 470int
477can_make_wall (char **maze, int dx, int dy, int dir, RMParms * RP) 471can_make_wall (char **maze, int dx, int dy, int dir, random_map_params *RP)
478{ 472{
479 int i1; 473 int i1;
480 int length = 0; 474 int length = 0;
481 475
482 /* dont make walls if we're on the edge. */ 476 /* dont make walls if we're on the edge. */
… …
557make_wall (char **maze, int x, int y, int dir) 551make_wall (char **maze, int x, int y, int dir)
558{ 552{
559 maze[x][y] = 'D'; /* mark a door */ 553 maze[x][y] = 'D'; /* mark a door */
560 switch (dir) 554 switch (dir)
561 { 555 {
562 case 0: /* horizontal */ 556 case 0: /* horizontal */
563 { 557 {
564 int i1; 558 int i1;
565 559
566 for (i1 = x - 1; maze[i1][y] == 0; i1--) 560 for (i1 = x - 1; maze[i1][y] == 0; i1--)
567 maze[i1][y] = '#'; 561 maze[i1][y] = '#';
568 for (i1 = x + 1; maze[i1][y] == 0; i1++) 562 for (i1 = x + 1; maze[i1][y] == 0; i1++)
569 maze[i1][y] = '#'; 563 maze[i1][y] = '#';
570 break; 564 break;
571 } 565 }
572 case 1: /* vertical */ 566 case 1: /* vertical */
573 { 567 {
574 int i1; 568 int i1;
575 569
576 for (i1 = y - 1; maze[x][i1] == 0; i1--) 570 for (i1 = y - 1; maze[x][i1] == 0; i1--)
577 maze[x][i1] = '#'; 571 maze[x][i1] = '#';
578 for (i1 = y + 1; maze[x][i1] == 0; i1++) 572 for (i1 = y + 1; maze[x][i1] == 0; i1++)
579 maze[x][i1] = '#'; 573 maze[x][i1] = '#';
580 break; 574 break;
581 } 575 }
582 } 576 }
583 577
584 return 0; 578 return 0;
585} 579}
586 580
587/* puts doors at appropriate locations in a layout. */ 581/* puts doors at appropriate locations in a layout. */
588
589void 582void
590doorify_layout (char **maze, RMParms * RP) 583doorify_layout (char **maze, random_map_params *RP)
591{ 584{
592 int ndoors = RP->Xsize * RP->Ysize / 60; /* reasonable number of doors. */ 585 int ndoors = RP->Xsize * RP->Ysize / 60; /* reasonable number of doors. */
593 char *doorlist_x; 586 char *doorlist_x;
594 char *doorlist_y; 587 char *doorlist_y;
595 int doorlocs = 0; /* # of available doorlocations */ 588 int doorlocs = 0; /* # of available doorlocations */
… …
610 doorlist_x[doorlocs] = i; 603 doorlist_x[doorlocs] = i;
611 doorlist_y[doorlocs] = j; 604 doorlist_y[doorlocs] = j;
612 doorlocs++; 605 doorlocs++;
613 } 606 }
614 } 607 }
608
615 while (ndoors > 0 && doorlocs > 0) 609 while (ndoors > 0 && doorlocs > 0)
616 { 610 {
617 int di; 611 int di;
618 int sindex; 612 int sindex;
619 613
… …
629 /* reduce the size of the list */ 623 /* reduce the size of the list */
630 doorlocs--; 624 doorlocs--;
631 doorlist_x[di] = doorlist_x[doorlocs]; 625 doorlist_x[di] = doorlist_x[doorlocs];
632 doorlist_y[di] = doorlist_y[doorlocs]; 626 doorlist_y[di] = doorlist_y[doorlocs];
633 } 627 }
628
634 free (doorlist_x); 629 free (doorlist_x);
635 free (doorlist_y); 630 free (doorlist_y);
636} 631}
637 632
638
639void 633void
640write_map_parameters_to_string (char *buf, RMParms * RP) 634write_map_parameters_to_string (char *buf, random_map_params *RP)
641{ 635{
642
643 char small_buf[256]; 636 char small_buf[2048];
644 637
645 sprintf (buf, "xsize %d\nysize %d\n", RP->Xsize, RP->Ysize); 638 sprintf (buf, "xsize %d\nysize %d\n", RP->Xsize, RP->Ysize);
646 639
647 if (RP->wallstyle[0]) 640 if (RP->wallstyle[0])
648 { 641 {
… …
690 { 683 {
691 sprintf (small_buf, "exitstyle %s\n", RP->exitstyle); 684 sprintf (small_buf, "exitstyle %s\n", RP->exitstyle);
692 strcat (buf, small_buf); 685 strcat (buf, small_buf);
693 } 686 }
694 687
695 if (RP->final_map[0]) 688 if (RP->final_map.length ())
696 { 689 {
697 sprintf (small_buf, "final_map %s\n", RP->final_map); 690 sprintf (small_buf, "final_map %s\n", &RP->final_map);
698 strcat (buf, small_buf); 691 strcat (buf, small_buf);
699 } 692 }
700 693
701 if (RP->exit_on_final_map[0]) 694 if (RP->exit_on_final_map[0])
702 { 695 {
703 sprintf (small_buf, "exit_on_final_map %s\n", RP->exit_on_final_map); 696 sprintf (small_buf, "exit_on_final_map %s\n", RP->exit_on_final_map);
704 strcat (buf, small_buf); 697 strcat (buf, small_buf);
705 } 698 }
706 699
707 if (RP->this_map[0]) 700 if (RP->this_map.length ())
708 { 701 {
709 sprintf (small_buf, "origin_map %s\n", RP->this_map); 702 sprintf (small_buf, "origin_map %s\n", &RP->this_map);
710 strcat (buf, small_buf); 703 strcat (buf, small_buf);
711 } 704 }
712 705
713 if (RP->expand2x) 706 if (RP->expand2x)
714 { 707 {
… …
720 { 713 {
721 sprintf (small_buf, "layoutoptions1 %d\n", RP->layoutoptions1); 714 sprintf (small_buf, "layoutoptions1 %d\n", RP->layoutoptions1);
722 strcat (buf, small_buf); 715 strcat (buf, small_buf);
723 } 716 }
724 717
725
726 if (RP->layoutoptions2) 718 if (RP->layoutoptions2)
727 { 719 {
728 sprintf (small_buf, "layoutoptions2 %d\n", RP->layoutoptions2); 720 sprintf (small_buf, "layoutoptions2 %d\n", RP->layoutoptions2);
729 strcat (buf, small_buf); 721 strcat (buf, small_buf);
730 } 722 }
731 723
732
733 if (RP->layoutoptions3) 724 if (RP->layoutoptions3)
734 { 725 {
735 sprintf (small_buf, "layoutoptions3 %d\n", RP->layoutoptions3); 726 sprintf (small_buf, "layoutoptions3 %d\n", RP->layoutoptions3);
736 strcat (buf, small_buf); 727 strcat (buf, small_buf);
737 } 728 }
… …
739 if (RP->symmetry) 730 if (RP->symmetry)
740 { 731 {
741 sprintf (small_buf, "symmetry %d\n", RP->symmetry); 732 sprintf (small_buf, "symmetry %d\n", RP->symmetry);
742 strcat (buf, small_buf); 733 strcat (buf, small_buf);
743 } 734 }
744
745 735
746 if (RP->difficulty && RP->difficulty_given) 736 if (RP->difficulty && RP->difficulty_given)
747 { 737 {
748 sprintf (small_buf, "difficulty %d\n", RP->difficulty); 738 sprintf (small_buf, "difficulty %d\n", RP->difficulty);
749 strcat (buf, small_buf); 739 strcat (buf, small_buf);
… …
785 if (RP->origin_y) 775 if (RP->origin_y)
786 { 776 {
787 sprintf (small_buf, "origin_y %d\n", RP->origin_y); 777 sprintf (small_buf, "origin_y %d\n", RP->origin_y);
788 strcat (buf, small_buf); 778 strcat (buf, small_buf);
789 } 779 }
780
781 if (RP->treasureoptions)
782 {
783 sprintf (small_buf, "treasureoptions %d\n", RP->treasureoptions);
784 strcat (buf, small_buf);
785 }
786
790 if (RP->random_seed) 787 if (RP->random_seed)
791 { 788 {
792 /* Add one so that the next map is a bit different */
793 sprintf (small_buf, "random_seed %d\n", RP->random_seed + 1); 789 sprintf (small_buf, "random_seed %d\n", RP->random_seed);
794 strcat (buf, small_buf); 790 strcat (buf, small_buf);
795 }
796
797 if (RP->treasureoptions)
798 { 791 }
799 sprintf (small_buf, "treasureoptions %d\n", RP->treasureoptions);
800 strcat (buf, small_buf);
801 }
802
803
804} 792}
805 793
806void 794void
807write_parameters_to_string (char *buf, 795write_parameters_to_string (char *buf,
808 int xsize_n, 796 int xsize_n,
… …
828 int difficulty_given_n, 816 int difficulty_given_n,
829 int decoroptions_n, 817 int decoroptions_n,
830 int orientation_n, 818 int orientation_n,
831 int origin_x_n, int origin_y_n, int random_seed_n, int treasureoptions_n, float difficulty_increase) 819 int origin_x_n, int origin_y_n, int random_seed_n, int treasureoptions_n, float difficulty_increase)
832{ 820{
833
834 char small_buf[256]; 821 char small_buf[2048];
835 822
836 sprintf (buf, "xsize %d\nysize %d\n", xsize_n, ysize_n); 823 sprintf (buf, "xsize %d\nysize %d\n", xsize_n, ysize_n);
837 824
838 if (wallstyle_n && wallstyle_n[0]) 825 if (wallstyle_n && wallstyle_n[0])
839 { 826 {
… …
904 if (layoutoptions1_n) 891 if (layoutoptions1_n)
905 { 892 {
906 sprintf (small_buf, "layoutoptions1 %d\n", layoutoptions1_n); 893 sprintf (small_buf, "layoutoptions1 %d\n", layoutoptions1_n);
907 strcat (buf, small_buf); 894 strcat (buf, small_buf);
908 } 895 }
909
910 896
911 if (layoutoptions2_n) 897 if (layoutoptions2_n)
912 { 898 {
913 sprintf (small_buf, "layoutoptions2 %d\n", layoutoptions2_n); 899 sprintf (small_buf, "layoutoptions2 %d\n", layoutoptions2_n);
914 strcat (buf, small_buf); 900 strcat (buf, small_buf);
… …
970 if (origin_y_n) 956 if (origin_y_n)
971 { 957 {
972 sprintf (small_buf, "origin_y %d\n", origin_y_n); 958 sprintf (small_buf, "origin_y %d\n", origin_y_n);
973 strcat (buf, small_buf); 959 strcat (buf, small_buf);
974 } 960 }
961
975 if (random_seed_n) 962 if (random_seed_n)
976 { 963 {
977 /* Add one so that the next map is a bit different */ 964 /* Add one so that the next map is a bit different */
978 sprintf (small_buf, "random_seed %d\n", random_seed_n + 1); 965 sprintf (small_buf, "random_seed %d\n", random_seed_n + 1);
979 strcat (buf, small_buf); 966 strcat (buf, small_buf);
… …
982 if (treasureoptions_n) 969 if (treasureoptions_n)
983 { 970 {
984 sprintf (small_buf, "treasureoptions %d\n", treasureoptions_n); 971 sprintf (small_buf, "treasureoptions %d\n", treasureoptions_n);
985 strcat (buf, small_buf); 972 strcat (buf, small_buf);
986 } 973 }
987
988
989} 974}
990 975
991/* copy an object with an inventory... i.e., duplicate the inv too. */ 976/* copy an object with an inventory... i.e., duplicate the inv too. */
992void 977void
993copy_object_with_inv (object *src_ob, object *dest_ob) 978copy_object_with_inv (object *src_ob, object *dest_ob)
994{ 979{
995 object *walk, *tmp; 980 object *walk, *tmp;
996 981
997 src_ob->copy_to (dest_ob); 982 src_ob->copy_to (dest_ob);
998 983
999 for (walk = src_ob->inv; walk != NULL; walk = walk->below) 984 for (walk = src_ob->inv; walk; walk = walk->below)
1000 { 985 {
1001 tmp = object::create (); 986 tmp = object::create ();
987
1002 walk->copy_to (tmp); 988 walk->copy_to (tmp);
1003 insert_ob_in_ob (tmp, dest_ob); 989 insert_ob_in_ob (tmp, dest_ob);
1004 } 990 }
1005} 991}

Diff Legend

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