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.5 by root, Sat Sep 16 22:24:13 2006 UTC vs.
Revision 1.17 by pippijn, Sat Jan 6 14:42:30 2007 UTC

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

Diff Legend

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