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.38 by root, Fri May 2 21:22:22 2008 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 Marc Alexander Lehmann / Robin Redeker / the Deliantra team
5 * Copyright (C) 2001 Mark Wedel & Crossfire Development Team 5 * Copyright (©) 2001,2007 Mark Wedel & Crossfire Development Team
6 * Copyright (C) 1992 Frank Tore Johansen 6 * Copyright (©) 1992,2007 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
9 * it under the terms of the GNU General Public License as published by 9 * it under the terms of the GNU General Public License as published by
10 * the Free Software Foundation; either version 2 of the License, or 10 * the Free Software Foundation, either version 3 of the License, or
11 * (at your option) any later version. 11 * (at your 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 GNU General Public License
19 * along with this program; if not, write to the Free Software 19 * along with this program. If not, see <http://www.gnu.org/licenses/>.
20 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
21 * 20 *
22 * The authors can be reached via e-mail at <crossfire@schmorp.de> 21 * The authors can be reached via e-mail to <support@deliantra.net>
23 */ 22 */
24 23
25#include <time.h> 24#include <time.h>
26#include <stdio.h> 25#include <stdio.h>
27#include <global.h> 26#include <global.h>
28#include <maze_gen.h>
29#include <room_gen.h>
30#include <random_map.h> 27#include <random_map.h>
31#include <rproto.h> 28#include <rproto.h>
32#include <sproto.h> 29#include <sproto.h>
33 30
34#define CEDE coroapi::cede (); rndm.seed (RP->random_seed + __LINE__); 31#define CEDE coroapi::cede_to_tick (); rndm.seed (RP->random_seed + __LINE__);
32
33static void symmetrize_layout (Layout maze, random_map_params *RP);
34static void rotate_layout (Layout maze, int rotation);
35 35
36void 36void
37dump_layout (char **layout, random_map_params *RP) 37dump_layout (Layout layout)
38{ 38{
39 { 39 for (int j = 0; j < layout->h; j++)
40 int i, j;
41
42 for (i = 0; i < RP->Xsize; i++)
43 { 40 {
44 for (j = 0; j < RP->Ysize; j++) 41 for (int i = 0; i < layout->w; i++)
45 { 42 putc (layout[i][j] ? layout[i][j] : ' ', stdout);
46 if (layout[i][j] == 0) 43
47 layout[i][j] = ' '; 44 putc ('\n', stdout);
48 printf ("%c", layout[i][j]);
49 if (layout[i][j] == ' ')
50 layout[i][j] = 0;
51 }
52 printf ("\n");
53 } 45 }
54 } 46
55 printf ("\n"); 47 putc ('\n', stdout);
56} 48}
57 49
58bool 50bool
59maptile::generate_random_map (random_map_params *RP) 51maptile::generate_random_map (random_map_params *RP)
60{ 52{
61 char **layout, buf[16384]; 53 char buf[16384];
62 int i; 54 int i;
63 55
64 RP->Xsize = RP->xsize; 56 RP->Xsize = RP->xsize;
65 RP->Ysize = RP->ysize; 57 RP->Ysize = RP->ysize;
66 58
… …
90 82
91 if (RP->Ysize < MIN_RANDOM_MAP_SIZE) 83 if (RP->Ysize < MIN_RANDOM_MAP_SIZE)
92 RP->Ysize = MIN_RANDOM_MAP_SIZE + rndm (25) + 5; 84 RP->Ysize = MIN_RANDOM_MAP_SIZE + rndm (25) + 5;
93 85
94 if (RP->symmetry == SYMMETRY_RANDOM) 86 if (RP->symmetry == SYMMETRY_RANDOM)
95 RP->symmetry_used = (RANDOM () % (SYMMETRY_XY)) + 1; 87 RP->symmetry_used = rndm (SYMMETRY_XY) + 1;
96 else 88 else
97 RP->symmetry_used = RP->symmetry; 89 RP->symmetry_used = RP->symmetry;
98 90
99 if (RP->symmetry_used == SYMMETRY_Y || RP->symmetry_used == SYMMETRY_XY) 91 if (RP->symmetry_used == SYMMETRY_Y || RP->symmetry_used == SYMMETRY_XY)
100 RP->Ysize = RP->Ysize / 2 + 1; 92 RP->Ysize = RP->Ysize / 2 + 1;
… …
115 * the numeric layoutstyle, so there is only one area that actually 107 * the numeric layoutstyle, so there is only one area that actually
116 * calls the code to make the maps. 108 * calls the code to make the maps.
117 */ 109 */
118 if (strstr (RP->layoutstyle, "onion")) 110 if (strstr (RP->layoutstyle, "onion"))
119 RP->map_layout_style = LAYOUT_ONION; 111 RP->map_layout_style = LAYOUT_ONION;
120
121 if (strstr (RP->layoutstyle, "maze")) 112 else if (strstr (RP->layoutstyle, "maze"))
122 RP->map_layout_style = LAYOUT_MAZE; 113 RP->map_layout_style = LAYOUT_MAZE;
123
124 if (strstr (RP->layoutstyle, "spiral")) 114 else if (strstr (RP->layoutstyle, "spiral"))
125 RP->map_layout_style = LAYOUT_SPIRAL; 115 RP->map_layout_style = LAYOUT_SPIRAL;
126
127 if (strstr (RP->layoutstyle, "rogue")) 116 else if (strstr (RP->layoutstyle, "rogue"))
128 RP->map_layout_style = LAYOUT_ROGUELIKE; 117 RP->map_layout_style = LAYOUT_ROGUELIKE;
129
130 if (strstr (RP->layoutstyle, "snake")) 118 else if (strstr (RP->layoutstyle, "snake"))
131 RP->map_layout_style = LAYOUT_SNAKE; 119 RP->map_layout_style = LAYOUT_SNAKE;
132
133 if (strstr (RP->layoutstyle, "squarespiral")) 120 else if (strstr (RP->layoutstyle, "squarespiral"))
134 RP->map_layout_style = LAYOUT_SQUARE_SPIRAL; 121 RP->map_layout_style = LAYOUT_SQUARE_SPIRAL;
135
136 /* No style found - choose one randomly */
137 if (RP->map_layout_style == LAYOUT_NONE) 122 else if (RP->map_layout_style == LAYOUT_NONE)
138 RP->map_layout_style = (RANDOM () % (NROFLAYOUTS - 1)) + 1; 123 RP->map_layout_style = rndm (NROFLAYOUTS - 1) + 1; /* No style found - choose one randomly */
124 else
125 abort ();
139 126
140 layout = layoutgen (RP); 127 Layout layout = layoutgen (RP);
141 128
142#ifdef RMAP_DEBUG 129#ifdef RMAP_DEBUG
143 dump_layout (layout, RP); 130 dump_layout (layout);
144#endif 131#endif
145 132
146 /* increment these for the current map */ 133 /* increment these for the current map */
147 RP->dungeon_level += 1; 134 ++RP->dungeon_level;
148 /* allow constant-difficulty maps. */
149 /* difficulty+=1; */
150 135
151 /* rotate the layout randomly */ 136 // need to patch RP becasue following code doesn't use the Layout object
152 layout = rotate_layout (layout, rndm (4), RP); 137 RP->Xsize = layout->w;
153#ifdef RMAP_DEBUG 138 RP->Ysize = layout->h;
154 dump_layout (layout, RP);
155#endif
156 139
157 /* allocate the map and set the floor */ 140 /* allocate the map and set the floor */
158 make_map_floor (layout, RP->floorstyle, RP); 141 make_map_floor (layout, RP->floorstyle, RP);
159 142
160 /* set region */ 143 /* set region */
… …
212 195
213 CEDE; 196 CEDE;
214 197
215 unblock_exits (this, layout, RP); 198 unblock_exits (this, layout, RP);
216 199
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); 200 msg = strdup (buf);
224 in_memory = MAP_IN_MEMORY; 201 in_memory = MAP_ACTIVE;
225 202
226 CEDE; 203 CEDE;
227 204
228 return 1; 205 return 1;
229} 206}
230 207
231/* function selects the layout function and gives it whatever 208/* function selects the layout function and gives it whatever
232 arguments it needs. */ 209 arguments it needs. */
233char ** 210Layout
234layoutgen (random_map_params *RP) 211layoutgen (random_map_params *RP)
235{ 212{
236 char **maze = 0; 213 Layout layout (RP);
237 int oxsize = RP->Xsize, oysize = RP->Ysize;
238 214
239 switch (RP->map_layout_style) 215 switch (RP->map_layout_style)
240 { 216 {
241 case LAYOUT_ONION: 217 case LAYOUT_ONION:
242 maze = map_gen_onion (RP->Xsize, RP->Ysize, RP->layoutoptions1, RP->layoutoptions2); 218 map_gen_onion (layout, RP->layoutoptions1, RP->layoutoptions2);
219
243 if (!(rndm (3)) && !(RP->layoutoptions1 & RMOPT_WALLS_ONLY)) 220 if (!(rndm (3)) && !(RP->layoutoptions1 & RMOPT_WALLS_ONLY))
244 roomify_layout (maze, RP); 221 roomify_layout (layout, RP);
222
245 break; 223 break;
246 224
247 case LAYOUT_MAZE: 225 case LAYOUT_MAZE:
248 maze = maze_gen (RP->Xsize, RP->Ysize, rndm (2)); 226 maze_gen (layout, rndm (2));
227
249 if (!(rndm (2))) 228 if (!(rndm (2)))
250 doorify_layout (maze, RP); 229 doorify_layout (layout, RP);
230
251 break; 231 break;
252 232
253 case LAYOUT_SPIRAL: 233 case LAYOUT_SPIRAL:
254 maze = map_gen_spiral (RP->Xsize, RP->Ysize, RP->layoutoptions1); 234 map_gen_spiral (layout, RP->layoutoptions1);
235
255 if (!(rndm (2))) 236 if (!(rndm (2)))
256 doorify_layout (maze, RP); 237 doorify_layout (layout, RP);
238
257 break; 239 break;
258 240
259 case LAYOUT_ROGUELIKE: 241 case LAYOUT_ROGUELIKE:
260 /* Don't put symmetry in rogue maps. There isn't much reason to 242 /* 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), 243 * 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 245 * spirals, or maps with lots of passages - making a symmetric rogue
264 * map fails because its likely that the passages the symmetry process 246 * map fails because its likely that the passages the symmetry process
265 * creates may not connect the rooms. 247 * creates may not connect the rooms.
266 */ 248 */
267 RP->symmetry_used = SYMMETRY_NONE; 249 RP->symmetry_used = SYMMETRY_NONE;
268 RP->Ysize = oysize;
269 RP->Xsize = oxsize;
270 maze = roguelike_layout_gen (RP->Xsize, RP->Ysize, RP->layoutoptions1); 250 roguelike_layout_gen (layout, RP->layoutoptions1);
271 /* no doorifying... done already */ 251 /* no doorifying... done already */
272 break; 252 break;
273 253
274 case LAYOUT_SNAKE: 254 case LAYOUT_SNAKE:
275 maze = make_snake_layout (RP->Xsize, RP->Ysize, RP->layoutoptions1); 255 make_snake_layout (layout, RP->layoutoptions1);
256
276 if (rndm (2)) 257 if (rndm (2))
277 roomify_layout (maze, RP); 258 roomify_layout (layout, RP);
259
278 break; 260 break;
279 261
280 case LAYOUT_SQUARE_SPIRAL: 262 case LAYOUT_SQUARE_SPIRAL:
281 maze = make_square_spiral_layout (RP->Xsize, RP->Ysize, RP->layoutoptions1); 263 make_square_spiral_layout (layout, RP->layoutoptions1);
264
282 if (rndm (2)) 265 if (rndm (2))
283 roomify_layout (maze, RP); 266 roomify_layout (layout, RP);
267
284 break; 268 break;
285 }
286 269
287 maze = symmetrize_layout (maze, RP->symmetry_used, RP); 270 default:
271 abort ();
272 }
273
274 /* rotate the layout randomly */
275 rotate_layout (layout, rndm (4));
276
277 symmetrize_layout (layout, RP);
288 278
289#ifdef RMAP_DEBUG 279#ifdef RMAP_DEBUG
290 dump_layout (maze, RP); 280 dump_layout (layout);
291#endif 281#endif
292 282
293 if (RP->expand2x) 283 if (RP->expand2x)
294 { 284 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 285
300 return maze; 286 return layout;
301} 287}
302 288
303/* takes a map and makes it symmetric: adjusts Xsize and 289/* takes a map and makes it symmetric: adjusts Xsize and
304Ysize to produce a symmetric map. */ 290 * Ysize to produce a symmetric map.
305char ** 291 */
292static void
306symmetrize_layout (char **maze, int sym, random_map_params *RP) 293symmetrize_layout (Layout layout, random_map_params *RP)
307{ 294{
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) 295 if (RP->symmetry_used == SYMMETRY_NONE)
316 {
317 RP->Xsize = Xsize_orig;
318 RP->Ysize = Ysize_orig;
319 return maze; 296 return;
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 297
325 sym_maze = (char **) calloc (sizeof (char *), RP->Xsize); 298 Layout sym_layout (
326 for (i = 0; i < RP->Xsize; i++) 299 RP->symmetry_used == SYMMETRY_X || RP->symmetry_used == SYMMETRY_XY ? layout->w * 2 - 3 : layout->w,
327 sym_maze[i] = (char *) calloc (sizeof (char), RP->Ysize); 300 RP->symmetry_used == SYMMETRY_Y || RP->symmetry_used == SYMMETRY_XY ? layout->h * 2 - 3 : layout->h
301 );
328 302
329 if (sym == SYMMETRY_X) 303 if (RP->symmetry_used == SYMMETRY_X)
330 for (i = 0; i < RP->Xsize / 2 + 1; i++) 304 for (int i = 0; i < sym_layout->w / 2 + 1; i++)
331 for (j = 0; j < RP->Ysize; j++) 305 for (int j = 0; j < sym_layout->h; j++)
332 { 306 {
333 sym_maze[i][j] = maze[i][j]; 307 sym_layout[i ][j] =
334 sym_maze[RP->Xsize - i - 1][j] = maze[i][j]; 308 sym_layout[sym_layout->w - i - 1][j] = layout[i][j];
335 }; 309 }
310
336 if (sym == SYMMETRY_Y) 311 if (RP->symmetry_used == SYMMETRY_Y)
337 for (i = 0; i < RP->Xsize; i++) 312 for (int i = 0; i < sym_layout->w; i++)
338 for (j = 0; j < RP->Ysize / 2 + 1; j++) 313 for (int j = 0; j < sym_layout->h / 2 + 1; j++)
339 {
340 sym_maze[i][j] = maze[i][j];
341 sym_maze[i][RP->Ysize - j - 1] = maze[i][j];
342 } 314 {
343 if (sym == SYMMETRY_XY) 315 sym_layout[i][j ] =
344 for (i = 0; i < RP->Xsize / 2 + 1; i++) 316 sym_layout[i][sym_layout->h - j - 1] = layout[i][j];
345 for (j = 0; j < RP->Ysize / 2 + 1; j++)
346 { 317 }
347 sym_maze[i][j] = maze[i][j]; 318
348 sym_maze[i][RP->Ysize - j - 1] = maze[i][j]; 319 if (RP->symmetry_used == SYMMETRY_XY)
349 sym_maze[RP->Xsize - i - 1][j] = maze[i][j]; 320 for (int i = 0; i < sym_layout->w / 2 + 1; i++)
350 sym_maze[RP->Xsize - i - 1][RP->Ysize - j - 1] = maze[i][j]; 321 for (int j = 0; j < sym_layout->h / 2 + 1; j++)
351 } 322 {
352 /* delete the old maze */ 323 sym_layout[i ][j ] =
353 for (i = 0; i < Xsize_orig; i++) 324 sym_layout[i ][sym_layout->h - j - 1] =
354 free (maze[i]); 325 sym_layout[sym_layout->w - i - 1][j ] =
355 free (maze); 326 sym_layout[sym_layout->w - i - 1][sym_layout->h - j - 1] = layout[i][j];
327 }
328
329 layout.swap (sym_layout);
330 sym_layout.free ();
331
356 /* reconnect disjointed spirals */ 332 /* 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 333 /* reconnect disjointed nethacklayouts: the routine for
360 spirals will do the trick? */ 334 spirals will do the trick? */
335 if (RP->map_layout_style == LAYOUT_SPIRAL
361 if (RP->map_layout_style == LAYOUT_ROGUELIKE) 336 || RP->map_layout_style == LAYOUT_ROGUELIKE)
362 connect_spirals (RP->Xsize, RP->Ysize, sym, sym_maze); 337 connect_spirals (layout->w, layout->h, RP->symmetry_used, layout);
363
364 return sym_maze;
365} 338}
366
367 339
368/* takes a map and rotates it. This completes the 340/* takes a map and rotates it. This completes the
369 onion layouts, making them possibly centered on any wall. 341 onion layouts, making them possibly centered on any wall.
370 It'll modify Xsize and Ysize if they're swapped. 342 It'll modify Xsize and Ysize if they're swapped.
371*/ 343*/
372 344static void
373char ** 345rotate_layout (Layout layout, int rotation)
374rotate_layout (char **maze, int rotation, random_map_params *RP)
375{ 346{
376 char **new_maze; 347 int w = layout->w;
377 int i, j; 348 int h = layout->h;
378 349
379 switch (rotation) 350 switch (rotation)
380 { 351 {
381 case 0: 352 case 2: /* a reflection */
382 return maze; 353 {
354 Layout new_layout (w, h);
355
356 for (int i = 0; i < w; i++) /* copy a reflection back */
357 for (int j = 0; j < h; j++)
358 new_layout[i][j] = layout[w - i - 1][h - j - 1];
359
360 layout.swap (new_layout);
361 new_layout.free ();
362 }
383 break; 363 break;
384 case 2: /* a reflection */
385 {
386 char *newmaze = (char *) malloc (sizeof (char) * RP->Xsize * RP->Ysize);
387 364
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: 365 case 1:
407 case 3: 366 case 3:
408 { 367 {
409 int swap; 368 Layout new_layout (h, w);
410 new_maze = (char **) calloc (sizeof (char *), RP->Ysize); 369
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 */ 370 if (rotation == 1) /* swap x and y */
416 for (i = 0; i < RP->Xsize; i++) 371 for (int i = 0; i < w; i++)
417 for (j = 0; j < RP->Ysize; j++) 372 for (int j = 0; j < h; j++)
418 new_maze[j][i] = maze[i][j]; 373 new_layout[j][i] = layout[i][j];
419 374
420 if (rotation == 3) 375 if (rotation == 3) /* swap x and y */
421 { /* swap x and y */
422 for (i = 0; i < RP->Xsize; i++) 376 for (int i = 0; i < w; i++)
423 for (j = 0; j < RP->Ysize; j++) 377 for (int j = 0; j < h; j++)
424 new_maze[j][i] = maze[RP->Xsize - i - 1][RP->Ysize - j - 1]; 378 new_layout[j][i] = layout[w - i - 1][h - j - 1];
379
380 layout.swap (new_layout);
381 new_layout.free ();
425 } 382 }
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; 383 break;
437 }
438 } 384 }
439 return NULL;
440} 385}
441 386
442/* take a layout and make some rooms in it. 387/* take a layout and make some rooms in it.
443 --works best on onions.*/ 388 --works best on onions.*/
444void 389void
… …
450 for (ti = 0; ti < tries; ti++) 395 for (ti = 0; ti < tries; ti++)
451 { 396 {
452 int dx, dy; /* starting location for looking at creating a door */ 397 int dx, dy; /* starting location for looking at creating a door */
453 int cx, cy; /* results of checking on creating walls. */ 398 int cx, cy; /* results of checking on creating walls. */
454 399
455 dx = RANDOM () % RP->Xsize; 400 dx = rndm (RP->Xsize);
456 dy = RANDOM () % RP->Ysize; 401 dy = rndm (RP->Ysize);
402
457 cx = can_make_wall (maze, dx, dy, 0, RP); /* horizontal */ 403 cx = can_make_wall (maze, dx, dy, 0, RP); /* horizontal */
458 cy = can_make_wall (maze, dx, dy, 1, RP); /* vertical */ 404 cy = can_make_wall (maze, dx, dy, 1, RP); /* vertical */
459 if (cx == -1) 405 if (cx == -1)
460 { 406 {
461 if (cy != -1) 407 if (cy != -1)
462 make_wall (maze, dx, dy, 1); 408 make_wall (maze, dx, dy, 1);
409
463 continue; 410 continue;
464 } 411 }
412
465 if (cy == -1) 413 if (cy == -1)
466 { 414 {
467 make_wall (maze, dx, dy, 0); 415 make_wall (maze, dx, dy, 0);
468 continue; 416 continue;
469 } 417 }
418
470 if (cx < cy) 419 if (cx < cy)
471 make_wall (maze, dx, dy, 0); 420 make_wall (maze, dx, dy, 0);
472 else 421 else
473 make_wall (maze, dx, dy, 1); 422 make_wall (maze, dx, dy, 1);
474 } 423 }
… …
592/* puts doors at appropriate locations in a layout. */ 541/* puts doors at appropriate locations in a layout. */
593void 542void
594doorify_layout (char **maze, random_map_params *RP) 543doorify_layout (char **maze, random_map_params *RP)
595{ 544{
596 int ndoors = RP->Xsize * RP->Ysize / 60; /* reasonable number of doors. */ 545 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 */ 546 int doorlocs = 0; /* # of available doorlocations */
600 int i, j; 547 int i, j;
601 548
602 doorlist_x = (char *) malloc (sizeof (int) * RP->Xsize * RP->Ysize); 549 char *doorlist_x = salloc<char> (RP->Xsize * RP->Ysize);
603 doorlist_y = (char *) malloc (sizeof (int) * RP->Xsize * RP->Ysize); 550 char *doorlist_y = salloc<char> (RP->Xsize * RP->Ysize);
604
605 551
606 /* make a list of possible door locations */ 552 /* make a list of possible door locations */
607 for (i = 1; i < RP->Xsize - 1; i++) 553 for (i = 1; i < RP->Xsize - 1; i++)
608 for (j = 1; j < RP->Ysize - 1; j++) 554 for (j = 1; j < RP->Ysize - 1; j++)
609 { 555 {
… …
620 while (ndoors > 0 && doorlocs > 0) 566 while (ndoors > 0 && doorlocs > 0)
621 { 567 {
622 int di; 568 int di;
623 int sindex; 569 int sindex;
624 570
625 di = RANDOM () % doorlocs; 571 di = rndm (doorlocs);
626 i = doorlist_x[di]; 572 i = doorlist_x[di];
627 j = doorlist_y[di]; 573 j = doorlist_y[di];
628 sindex = surround_flag (maze, i, j, RP); 574 sindex = surround_flag (maze, i, j, RP);
575
629 if (sindex == 3 || sindex == 12) /* these are possible door sindex */ 576 if (sindex == 3 || sindex == 12) /* these are possible door sindex */
630 { 577 {
631 maze[i][j] = 'D'; 578 maze[i][j] = 'D';
632 ndoors--; 579 ndoors--;
633 } 580 }
581
634 /* reduce the size of the list */ 582 /* reduce the size of the list */
635 doorlocs--; 583 doorlocs--;
636 doorlist_x[di] = doorlist_x[doorlocs]; 584 doorlist_x[di] = doorlist_x[doorlocs];
637 doorlist_y[di] = doorlist_y[doorlocs]; 585 doorlist_y[di] = doorlist_y[doorlocs];
638 } 586 }
639 587
640 free (doorlist_x); 588 sfree (doorlist_x, RP->Xsize * RP->Ysize);
641 free (doorlist_y); 589 sfree (doorlist_y, RP->Xsize * RP->Ysize);
642} 590}
643 591
644void 592void
645write_map_parameters_to_string (char *buf, random_map_params *RP) 593write_map_parameters_to_string (char *buf, random_map_params *RP)
646{ 594{
… …
810 758
811void 759void
812write_parameters_to_string (char *buf, 760write_parameters_to_string (char *buf,
813 int xsize_n, 761 int xsize_n,
814 int ysize_n, 762 int ysize_n,
815 char *wallstyle_n, 763 const char *wallstyle_n,
816 char *floorstyle_n, 764 const char *floorstyle_n,
817 char *monsterstyle_n, 765 const char *monsterstyle_n,
818 char *treasurestyle_n, 766 const char *treasurestyle_n,
819 char *layoutstyle_n, 767 const char *layoutstyle_n,
820 char *decorstyle_n, 768 const char *decorstyle_n,
821 char *doorstyle_n, 769 const char *doorstyle_n,
822 char *exitstyle_n, 770 const char *exitstyle_n,
823 char *final_map_n, 771 const char *final_map_n,
824 char *exit_on_final_map_n, 772 const char *exit_on_final_map_n,
825 char *this_map_n, 773 const char *this_map_n,
826 int layoutoptions1_n, 774 int layoutoptions1_n,
827 int layoutoptions2_n, 775 int layoutoptions2_n,
828 int layoutoptions3_n, 776 int layoutoptions3_n,
829 int symmetry_n, 777 int symmetry_n,
830 int dungeon_depth_n, 778 int dungeon_depth_n,
831 int dungeon_level_n, 779 int dungeon_level_n,
832 int difficulty_n, 780 int difficulty_n,
833 int difficulty_given_n, 781 int difficulty_given_n,
834 int decoroptions_n, 782 int decoroptions_n,
835 int orientation_n, 783 int orientation_n,
836 int origin_x_n, int origin_y_n, uint32_t random_seed_n, int treasureoptions_n, float difficulty_increase) 784 int origin_x_n,
785 int origin_y_n,
786 uint32_t random_seed_n,
787 int treasureoptions_n,
788 float difficulty_increase)
837{ 789{
838 char small_buf[16384]; 790 char small_buf[16384];
839 791
840 sprintf (buf, "xsize %d\nysize %d\n", xsize_n, ysize_n); 792 sprintf (buf, "xsize %d\nysize %d\n", xsize_n, ysize_n);
841 793
… …
988 sprintf (small_buf, "treasureoptions %d\n", treasureoptions_n); 940 sprintf (small_buf, "treasureoptions %d\n", treasureoptions_n);
989 strcat (buf, small_buf); 941 strcat (buf, small_buf);
990 } 942 }
991} 943}
992 944
993/* copy an object with an inventory... i.e., duplicate the inv too. */ 945/////////////////////////////////////////////////////////////////////////////
994void
995copy_object_with_inv (object *src_ob, object *dest_ob)
996{
997 object *walk, *tmp;
998 946
999 src_ob->copy_to (dest_ob); 947LayoutData::LayoutData (int w, int h)
948: w(w), h(h)
949{
950 int size = (sizeof (char *) + sizeof (char) * h) * w;
1000 951
1001 for (walk = src_ob->inv; walk; walk = walk->below) 952 col = (char **)salloc<char> (size);
1002 {
1003 tmp = object::create ();
1004 953
1005 walk->copy_to (tmp); 954 char *data = (char *)(col + w);
1006 insert_ob_in_ob (tmp, dest_ob); 955
1007 } 956 for (int x = w; x--; )
957 col [x] = data + x * h;
1008} 958}
959
960LayoutData::~LayoutData ()
961{
962 int size = (sizeof (char *) + sizeof (char) * h) * w;
963
964 sfree ((char *)col, size);
965}
966
967void LayoutData::clear (char fill)
968{
969 memset (col [0], fill, w * h);
970}
971
972void LayoutData::border (char fill)
973{
974 for (int i = 0; i < w; i++) col [i][0] = col [i][h - 1] = fill;
975 for (int j = 0; j < h; j++) col [0][j] = col [w - 1][j] = fill;
976}
977

Diff Legend

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