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.3 by root, Sun Sep 10 16:06:37 2006 UTC vs.
Revision 1.13 by root, Sun Dec 31 19:02:24 2006 UTC

1
2/*
3 * static char *rcsid_random_map_c =
4 * "$Id: random_map.C,v 1.3 2006/09/10 16:06:37 root Exp $";
5 */
6 1
7/* 2/*
8 CrossFire, A Multiplayer game for X-windows 3 CrossFire, A Multiplayer game for X-windows
9 4
10 Copyright (C) 2001 Mark Wedel & Crossfire Development Team 5 Copyright (C) 2001 Mark Wedel & Crossfire Development Team
… …
22 17
23 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
24 along with this program; if not, write to the Free Software 19 along with this program; if not, write to the Free Software
25 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 20 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
26 21
27 The authors can be reached via e-mail at crossfire-devel@real-time.com 22 The authors can be reached via e-mail at <crossfire@schmorp.de>
28*/ 23*/
29 24
30#include <time.h> 25#include <time.h>
31#include <stdio.h> 26#include <stdio.h>
32#include <global.h> 27#include <global.h>
… …
35#include <random_map.h> 30#include <random_map.h>
36#include <rproto.h> 31#include <rproto.h>
37#include <sproto.h> 32#include <sproto.h>
38 33
39void 34void
40dump_layout (char **layout, RMParms * RP) 35dump_layout (char **layout, random_map_params *RP)
41{ 36{
42 { 37 {
43 int i, j; 38 int i, j;
44 39
45 for (i = 0; i < RP->Xsize; i++) 40 for (i = 0; i < RP->Xsize; i++)
… …
55 printf ("\n"); 50 printf ("\n");
56 } 51 }
57 } 52 }
58 printf ("\n"); 53 printf ("\n");
59} 54}
60EXTERN FILE *logfile; 55
61mapstruct * 56extern FILE *logfile;
57
58maptile *
62generate_random_map (const char *OutFileName, RMParms * RP) 59generate_random_map (const char *OutFileName, random_map_params *RP)
63{ 60{
64 char **layout, buf[HUGE_BUF]; 61 char **layout, buf[HUGE_BUF];
65 mapstruct *theMap; 62 maptile *theMap;
66 int i; 63 int i;
67 64
68 /* pick a random seed, or use the one from the input file */ 65 /* pick a random seed, or use the one from the input file */
69 if (RP->random_seed == 0) 66 if (RP->random_seed == 0)
70 RP->random_seed = time (0); 67 RP->random_seed = time (0);
… …
74 write_map_parameters_to_string (buf, RP); 71 write_map_parameters_to_string (buf, RP);
75 72
76 if (RP->difficulty == 0) 73 if (RP->difficulty == 0)
77 { 74 {
78 RP->difficulty = RP->dungeon_level; /* use this instead of a map difficulty */ 75 RP->difficulty = RP->dungeon_level; /* use this instead of a map difficulty */
76
79 if (RP->difficulty_increase > 0.001) 77 if (RP->difficulty_increase > 0.001)
80 {
81 RP->difficulty = (int) ((float) RP->dungeon_level * RP->difficulty_increase); 78 RP->difficulty = (int) ((float) RP->dungeon_level * RP->difficulty_increase);
79
82 if (RP->difficulty < 1) 80 if (RP->difficulty < 1)
83 RP->difficulty = 1; 81 RP->difficulty = 1;
84 }
85 } 82 }
86 else 83 else
87 RP->difficulty_given = 1; 84 RP->difficulty_given = 1;
88 85
89 if (RP->Xsize < MIN_RANDOM_MAP_SIZE) 86 if (RP->Xsize < MIN_RANDOM_MAP_SIZE)
90 RP->Xsize = MIN_RANDOM_MAP_SIZE + RANDOM () % 25 + 5; 87 RP->Xsize = MIN_RANDOM_MAP_SIZE + RANDOM () % 25 + 5;
88
91 if (RP->Ysize < MIN_RANDOM_MAP_SIZE) 89 if (RP->Ysize < MIN_RANDOM_MAP_SIZE)
92 RP->Ysize = MIN_RANDOM_MAP_SIZE + RANDOM () % 25 + 5; 90 RP->Ysize = MIN_RANDOM_MAP_SIZE + RANDOM () % 25 + 5;
93 91
94 if (RP->expand2x > 0) 92 if (RP->expand2x > 0)
95 { 93 {
… …
116 114
117 /* allocate the map and set the floor */ 115 /* allocate the map and set the floor */
118 theMap = make_map_floor (layout, RP->floorstyle, RP); 116 theMap = make_map_floor (layout, RP->floorstyle, RP);
119 117
120 /* set the name of the map. */ 118 /* set the name of the map. */
121 strcpy (theMap->path, OutFileName); 119 theMap->path = OutFileName;
122 120
123 /* set region */ 121 /* set region */
124 theMap->region = RP->region; 122 theMap->region = RP->region;
125 123
126 /* create walls unless the wallstyle is "none" */ 124 /* create walls unless the wallstyle is "none" */
… …
143 /* create monsters unless the monsterstyle is "none" */ 141 /* create monsters unless the monsterstyle is "none" */
144 if (strcmp (RP->monsterstyle, "none")) 142 if (strcmp (RP->monsterstyle, "none"))
145 place_monsters (theMap, RP->monsterstyle, RP->difficulty, RP); 143 place_monsters (theMap, RP->monsterstyle, RP->difficulty, RP);
146 144
147 /* treasures needs to have a proper difficulty set for the map. */ 145 /* treasures needs to have a proper difficulty set for the map. */
148 theMap->difficulty = calculate_difficulty (theMap); 146 theMap->difficulty = theMap->estimate_difficulty ();
149 147
150 /* create treasure unless the treasurestyle is "none" */ 148 /* create treasure unless the treasurestyle is "none" */
151 if (strcmp (RP->treasurestyle, "none")) 149 if (strcmp (RP->treasurestyle, "none"))
152 place_treasure (theMap, layout, RP->treasurestyle, RP->treasureoptions, RP); 150 place_treasure (theMap, layout, RP->treasurestyle, RP->treasureoptions, RP);
153 151
154 /* create decor unless the decorstyle is "none" */ 152 /* create decor unless the decorstyle is "none" */
155 if (strcmp (RP->decorstyle, "none")) 153 if (strcmp (RP->decorstyle, "none"))
156 put_decor (theMap, layout, RP->decorstyle, RP->decoroptions, RP); 154 put_decor (theMap, layout, RP->decorstyle, RP->decoroptions, RP);
157 155
158 /* generate treasures, etc. */ 156 /* generate treasures, etc. */
159 fix_auto_apply (theMap); 157 theMap->fix_auto_apply ();
160 158
161 unblock_exits (theMap, layout, RP); 159 unblock_exits (theMap, layout, RP);
162 160
163 /* free the layout */ 161 /* free the layout */
164 for (i = 0; i < RP->Xsize; i++) 162 for (i = 0; i < RP->Xsize; i++)
165 free (layout[i]); 163 free (layout[i]);
164
166 free (layout); 165 free (layout);
167 166
168 theMap->msg = strdup_local (buf); 167 theMap->msg = strdup (buf);
168 theMap->in_memory = MAP_IN_MEMORY;
169 169
170 return theMap; 170 return theMap;
171} 171}
172
173 172
174/* function selects the layout function and gives it whatever 173/* function selects the layout function and gives it whatever
175 arguments it needs. */ 174 arguments it needs. */
176char ** 175char **
177layoutgen (RMParms * RP) 176layoutgen (random_map_params *RP)
178{ 177{
179 char **maze = 0; 178 char **maze = 0;
180 int oxsize = RP->Xsize, oysize = RP->Ysize; 179 int oxsize = RP->Xsize, oysize = RP->Ysize;
181 180
182 if (RP->symmetry == RANDOM_SYM) 181 if (RP->symmetry == SYMMETRY_RANDOM)
183 RP->symmetry_used = (RANDOM () % (XY_SYM)) + 1; 182 RP->symmetry_used = (RANDOM () % (SYMMETRY_XY)) + 1;
184 else 183 else
185 RP->symmetry_used = RP->symmetry; 184 RP->symmetry_used = RP->symmetry;
186 185
187 if (RP->symmetry_used == Y_SYM || RP->symmetry_used == XY_SYM) 186 if (RP->symmetry_used == SYMMETRY_Y || RP->symmetry_used == SYMMETRY_XY)
188 RP->Ysize = RP->Ysize / 2 + 1; 187 RP->Ysize = RP->Ysize / 2 + 1;
189 if (RP->symmetry_used == X_SYM || RP->symmetry_used == XY_SYM) 188 if (RP->symmetry_used == SYMMETRY_X || RP->symmetry_used == SYMMETRY_XY)
190 RP->Xsize = RP->Xsize / 2 + 1; 189 RP->Xsize = RP->Xsize / 2 + 1;
191 190
192 if (RP->Xsize < MIN_RANDOM_MAP_SIZE) 191 if (RP->Xsize < MIN_RANDOM_MAP_SIZE)
193 RP->Xsize = MIN_RANDOM_MAP_SIZE + RANDOM () % 5; 192 RP->Xsize = MIN_RANDOM_MAP_SIZE + RANDOM () % 5;
194 if (RP->Ysize < MIN_RANDOM_MAP_SIZE) 193 if (RP->Ysize < MIN_RANDOM_MAP_SIZE)
… …
199 * layout style and then random layout style. Instead, figure out 198 * layout style and then random layout style. Instead, figure out
200 * the numeric layoutstyle, so there is only one area that actually 199 * the numeric layoutstyle, so there is only one area that actually
201 * calls the code to make the maps. 200 * calls the code to make the maps.
202 */ 201 */
203 if (strstr (RP->layoutstyle, "onion")) 202 if (strstr (RP->layoutstyle, "onion"))
204 {
205 RP->map_layout_style = ONION_LAYOUT; 203 RP->map_layout_style = LAYOUT_ONION;
206 }
207 204
208 if (strstr (RP->layoutstyle, "maze")) 205 if (strstr (RP->layoutstyle, "maze"))
209 {
210 RP->map_layout_style = MAZE_LAYOUT; 206 RP->map_layout_style = LAYOUT_MAZE;
211 }
212 207
213 if (strstr (RP->layoutstyle, "spiral")) 208 if (strstr (RP->layoutstyle, "spiral"))
214 {
215 RP->map_layout_style = SPIRAL_LAYOUT; 209 RP->map_layout_style = LAYOUT_SPIRAL;
216 }
217 210
218 if (strstr (RP->layoutstyle, "rogue")) 211 if (strstr (RP->layoutstyle, "rogue"))
219 {
220 RP->map_layout_style = ROGUELIKE_LAYOUT; 212 RP->map_layout_style = LAYOUT_ROGUELIKE;
221 }
222 213
223 if (strstr (RP->layoutstyle, "snake")) 214 if (strstr (RP->layoutstyle, "snake"))
224 {
225 RP->map_layout_style = SNAKE_LAYOUT; 215 RP->map_layout_style = LAYOUT_SNAKE;
226 }
227 216
228 if (strstr (RP->layoutstyle, "squarespiral")) 217 if (strstr (RP->layoutstyle, "squarespiral"))
229 {
230 RP->map_layout_style = SQUARE_SPIRAL_LAYOUT; 218 RP->map_layout_style = LAYOUT_SQUARE_SPIRAL;
231 } 219
232 /* No style found - choose one ranomdly */ 220 /* No style found - choose one ranomdly */
233 if (RP->map_layout_style == 0) 221 if (RP->map_layout_style == LAYOUT_NONE)
234 {
235 RP->map_layout_style = (RANDOM () % NROFLAYOUTS) + 1; 222 RP->map_layout_style = (RANDOM () % (NROFLAYOUTS - 1)) + 1;
236 }
237 223
238 switch (RP->map_layout_style) 224 switch (RP->map_layout_style)
239 { 225 {
240 226 case LAYOUT_ONION:
241 case ONION_LAYOUT:
242 maze = map_gen_onion (RP->Xsize, RP->Ysize, RP->layoutoptions1, RP->layoutoptions2); 227 maze = map_gen_onion (RP->Xsize, RP->Ysize, RP->layoutoptions1, RP->layoutoptions2);
243 if (!(RANDOM () % 3) && !(RP->layoutoptions1 & OPT_WALLS_ONLY)) 228 if (!(RANDOM () % 3) && !(RP->layoutoptions1 & RMOPT_WALLS_ONLY))
244 roomify_layout (maze, RP); 229 roomify_layout (maze, RP);
245 break; 230 break;
246 231
247 case MAZE_LAYOUT: 232 case LAYOUT_MAZE:
248 maze = maze_gen (RP->Xsize, RP->Ysize, RANDOM () % 2); 233 maze = maze_gen (RP->Xsize, RP->Ysize, RANDOM () % 2);
249 if (!(RANDOM () % 2)) 234 if (!(RANDOM () % 2))
250 doorify_layout (maze, RP); 235 doorify_layout (maze, RP);
251 break; 236 break;
252 237
253 case SPIRAL_LAYOUT: 238 case LAYOUT_SPIRAL:
254 maze = map_gen_spiral (RP->Xsize, RP->Ysize, RP->layoutoptions1); 239 maze = map_gen_spiral (RP->Xsize, RP->Ysize, RP->layoutoptions1);
255 if (!(RANDOM () % 2)) 240 if (!(RANDOM () % 2))
256 doorify_layout (maze, RP); 241 doorify_layout (maze, RP);
257 break; 242 break;
258 243
259 case ROGUELIKE_LAYOUT: 244 case LAYOUT_ROGUELIKE:
260 /* Don't put symmetry in rogue maps. There isn't much reason to 245 /* 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), 246 * do so in the first place (doesn't make it any more interesting),
262 * but more importantly, the symmetry code presumes we are symmetrizing 247 * but more importantly, the symmetry code presumes we are symmetrizing
263 * spirals, or maps with lots of passages - making a symmetric rogue 248 * spirals, or maps with lots of passages - making a symmetric rogue
264 * map fails because its likely that the passages the symmetry process 249 * map fails because its likely that the passages the symmetry process
265 * creates may not connect the rooms. 250 * creates may not connect the rooms.
266 */ 251 */
267 RP->symmetry_used = NO_SYM; 252 RP->symmetry_used = SYMMETRY_NONE;
268 RP->Ysize = oysize; 253 RP->Ysize = oysize;
269 RP->Xsize = oxsize; 254 RP->Xsize = oxsize;
270 maze = roguelike_layout_gen (RP->Xsize, RP->Ysize, RP->layoutoptions1); 255 maze = roguelike_layout_gen (RP->Xsize, RP->Ysize, RP->layoutoptions1);
271 /* no doorifying... done already */ 256 /* no doorifying... done already */
272 break; 257 break;
273 258
274 case SNAKE_LAYOUT: 259 case LAYOUT_SNAKE:
275 maze = make_snake_layout (RP->Xsize, RP->Ysize, RP->layoutoptions1); 260 maze = make_snake_layout (RP->Xsize, RP->Ysize, RP->layoutoptions1);
276 if (RANDOM () % 2) 261 if (RANDOM () % 2)
277 roomify_layout (maze, RP); 262 roomify_layout (maze, RP);
278 break; 263 break;
279 264
280 case SQUARE_SPIRAL_LAYOUT: 265 case LAYOUT_SQUARE_SPIRAL:
281 maze = make_square_spiral_layout (RP->Xsize, RP->Ysize, RP->layoutoptions1); 266 maze = make_square_spiral_layout (RP->Xsize, RP->Ysize, RP->layoutoptions1);
282 if (RANDOM () % 2) 267 if (RANDOM () % 2)
283 roomify_layout (maze, RP); 268 roomify_layout (maze, RP);
284 break; 269 break;
285 } 270 }
286 271
287 maze = symmetrize_layout (maze, RP->symmetry_used, RP); 272 maze = symmetrize_layout (maze, RP->symmetry_used, RP);
273
288#ifdef RMAP_DEBUG 274#ifdef RMAP_DEBUG
289 dump_layout (maze, RP); 275 dump_layout (maze, RP);
290#endif 276#endif
277
291 if (RP->expand2x) 278 if (RP->expand2x)
292 { 279 {
293 maze = expand2x (maze, RP->Xsize, RP->Ysize); 280 maze = expand2x (maze, RP->Xsize, RP->Ysize);
294 RP->Xsize = RP->Xsize * 2 - 1; 281 RP->Xsize = RP->Xsize * 2 - 1;
295 RP->Ysize = RP->Ysize * 2 - 1; 282 RP->Ysize = RP->Ysize * 2 - 1;
296 } 283 }
284
297 return maze; 285 return maze;
298} 286}
299
300 287
301/* takes a map and makes it symmetric: adjusts Xsize and 288/* takes a map and makes it symmetric: adjusts Xsize and
302Ysize to produce a symmetric map. */ 289Ysize to produce a symmetric map. */
303
304char ** 290char **
305symmetrize_layout (char **maze, int sym, RMParms * RP) 291symmetrize_layout (char **maze, int sym, random_map_params *RP)
306{ 292{
307 int i, j; 293 int i, j;
308 char **sym_maze; 294 char **sym_maze;
309 int Xsize_orig, Ysize_orig; 295 int Xsize_orig, Ysize_orig;
310 296
311 Xsize_orig = RP->Xsize; 297 Xsize_orig = RP->Xsize;
312 Ysize_orig = RP->Ysize; 298 Ysize_orig = RP->Ysize;
313 RP->symmetry_used = sym; /* tell everyone else what sort of symmetry is used. */ 299 RP->symmetry_used = sym; /* tell everyone else what sort of symmetry is used. */
314 if (sym == NO_SYM) 300 if (sym == SYMMETRY_NONE)
315 { 301 {
316 RP->Xsize = Xsize_orig; 302 RP->Xsize = Xsize_orig;
317 RP->Ysize = Ysize_orig; 303 RP->Ysize = Ysize_orig;
318 return maze; 304 return maze;
319 } 305 }
320 /* pick new sizes */ 306 /* pick new sizes */
321 RP->Xsize = ((sym == X_SYM || sym == XY_SYM) ? RP->Xsize * 2 - 3 : RP->Xsize); 307 RP->Xsize = ((sym == SYMMETRY_X || sym == SYMMETRY_XY) ? RP->Xsize * 2 - 3 : RP->Xsize);
322 RP->Ysize = ((sym == Y_SYM || sym == XY_SYM) ? RP->Ysize * 2 - 3 : RP->Ysize); 308 RP->Ysize = ((sym == SYMMETRY_Y || sym == SYMMETRY_XY) ? RP->Ysize * 2 - 3 : RP->Ysize);
323 309
324 sym_maze = (char **) calloc (sizeof (char *), RP->Xsize); 310 sym_maze = (char **) calloc (sizeof (char *), RP->Xsize);
325 for (i = 0; i < RP->Xsize; i++) 311 for (i = 0; i < RP->Xsize; i++)
326 sym_maze[i] = (char *) calloc (sizeof (char), RP->Ysize); 312 sym_maze[i] = (char *) calloc (sizeof (char), RP->Ysize);
327 313
328 if (sym == X_SYM) 314 if (sym == SYMMETRY_X)
329 for (i = 0; i < RP->Xsize / 2 + 1; i++) 315 for (i = 0; i < RP->Xsize / 2 + 1; i++)
330 for (j = 0; j < RP->Ysize; j++) 316 for (j = 0; j < RP->Ysize; j++)
331 { 317 {
332 sym_maze[i][j] = maze[i][j]; 318 sym_maze[i][j] = maze[i][j];
333 sym_maze[RP->Xsize - i - 1][j] = maze[i][j]; 319 sym_maze[RP->Xsize - i - 1][j] = maze[i][j];
334 }; 320 };
335 if (sym == Y_SYM) 321 if (sym == SYMMETRY_Y)
336 for (i = 0; i < RP->Xsize; i++) 322 for (i = 0; i < RP->Xsize; i++)
337 for (j = 0; j < RP->Ysize / 2 + 1; j++) 323 for (j = 0; j < RP->Ysize / 2 + 1; j++)
338 { 324 {
339 sym_maze[i][j] = maze[i][j]; 325 sym_maze[i][j] = maze[i][j];
340 sym_maze[i][RP->Ysize - j - 1] = maze[i][j]; 326 sym_maze[i][RP->Ysize - j - 1] = maze[i][j];
341 } 327 }
342 if (sym == XY_SYM) 328 if (sym == SYMMETRY_XY)
343 for (i = 0; i < RP->Xsize / 2 + 1; i++) 329 for (i = 0; i < RP->Xsize / 2 + 1; i++)
344 for (j = 0; j < RP->Ysize / 2 + 1; j++) 330 for (j = 0; j < RP->Ysize / 2 + 1; j++)
345 { 331 {
346 sym_maze[i][j] = maze[i][j]; 332 sym_maze[i][j] = maze[i][j];
347 sym_maze[i][RP->Ysize - j - 1] = maze[i][j]; 333 sym_maze[i][RP->Ysize - j - 1] = maze[i][j];
… …
351 /* delete the old maze */ 337 /* delete the old maze */
352 for (i = 0; i < Xsize_orig; i++) 338 for (i = 0; i < Xsize_orig; i++)
353 free (maze[i]); 339 free (maze[i]);
354 free (maze); 340 free (maze);
355 /* reconnect disjointed spirals */ 341 /* reconnect disjointed spirals */
356 if (RP->map_layout_style == SPIRAL_LAYOUT) 342 if (RP->map_layout_style == LAYOUT_SPIRAL)
357 connect_spirals (RP->Xsize, RP->Ysize, sym, sym_maze); 343 connect_spirals (RP->Xsize, RP->Ysize, sym, sym_maze);
358 /* reconnect disjointed nethackmazes: the routine for 344 /* reconnect disjointed nethackmazes: the routine for
359 spirals will do the trick? */ 345 spirals will do the trick? */
360 if (RP->map_layout_style == ROGUELIKE_LAYOUT) 346 if (RP->map_layout_style == LAYOUT_ROGUELIKE)
361 connect_spirals (RP->Xsize, RP->Ysize, sym, sym_maze); 347 connect_spirals (RP->Xsize, RP->Ysize, sym, sym_maze);
362 348
363 return sym_maze; 349 return sym_maze;
364} 350}
365 351
… …
368 onion layouts, making them possibly centered on any wall. 354 onion layouts, making them possibly centered on any wall.
369 It'll modify Xsize and Ysize if they're swapped. 355 It'll modify Xsize and Ysize if they're swapped.
370*/ 356*/
371 357
372char ** 358char **
373rotate_layout (char **maze, int rotation, RMParms * RP) 359rotate_layout (char **maze, int rotation, random_map_params *RP)
374{ 360{
375 char **new_maze; 361 char **new_maze;
376 int i, j; 362 int i, j;
377 363
378 switch (rotation) 364 switch (rotation)
379 { 365 {
380 case 0: 366 case 0:
367 return maze;
368 break;
369 case 2: /* a reflection */
370 {
371 char *newmaze = (char *) malloc (sizeof (char) * RP->Xsize * RP->Ysize);
372
373 for (i = 0; i < RP->Xsize; i++)
374 { /* make a copy */
375 for (j = 0; j < RP->Ysize; j++)
376 {
377 newmaze[i * RP->Ysize + j] = maze[i][j];
378 }
379 }
380 for (i = 0; i < RP->Xsize; i++)
381 { /* copy a reflection back */
382 for (j = 0; j < RP->Ysize; j++)
383 {
384 maze[i][j] = newmaze[(RP->Xsize - i - 1) * RP->Ysize + RP->Ysize - j - 1];
385 }
386 }
387 free (newmaze);
381 return maze; 388 return maze;
382 break; 389 break;
383 case 2: /* a reflection */ 390 }
391 case 1:
392 case 3:
393 {
394 int swap;
395 new_maze = (char **) calloc (sizeof (char *), RP->Ysize);
396 for (i = 0; i < RP->Ysize; i++)
384 { 397 {
385 char *newmaze = (char *) malloc (sizeof (char) * RP->Xsize * RP->Ysize); 398 new_maze[i] = (char *) calloc (sizeof (char), RP->Xsize);
386 399 }
400 if (rotation == 1) /* swap x and y */
387 for (i = 0; i < RP->Xsize; i++) 401 for (i = 0; i < RP->Xsize; i++)
388 { /* make a copy */
389 for (j = 0; j < RP->Ysize; j++) 402 for (j = 0; j < RP->Ysize; j++)
390 {
391 newmaze[i * RP->Ysize + j] = maze[i][j]; 403 new_maze[j][i] = maze[i][j];
392 } 404
393 } 405 if (rotation == 3)
394 for (i = 0; i < RP->Xsize; i++) 406 { /* swap x and y */
395 { /* copy a reflection back */
396 for (j = 0; j < RP->Ysize; j++)
397 {
398 maze[i][j] = newmaze[(RP->Xsize - i - 1) * RP->Ysize + RP->Ysize - j - 1];
399 }
400 }
401 free (newmaze);
402 return maze;
403 break;
404 }
405 case 1:
406 case 3:
407 {
408 int swap;
409 new_maze = (char **) calloc (sizeof (char *), RP->Ysize);
410 for (i = 0; i < RP->Ysize; i++)
411 {
412 new_maze[i] = (char *) calloc (sizeof (char), RP->Xsize);
413 }
414 if (rotation == 1) /* swap x and y */
415 for (i = 0; i < RP->Xsize; i++) 407 for (i = 0; i < RP->Xsize; i++)
416 for (j = 0; j < RP->Ysize; j++) 408 for (j = 0; j < RP->Ysize; j++)
417 new_maze[j][i] = maze[i][j];
418
419 if (rotation == 3)
420 { /* swap x and y */
421 for (i = 0; i < RP->Xsize; i++)
422 for (j = 0; j < RP->Ysize; j++)
423 new_maze[j][i] = maze[RP->Xsize - i - 1][RP->Ysize - j - 1]; 409 new_maze[j][i] = maze[RP->Xsize - i - 1][RP->Ysize - j - 1];
424 } 410 }
425 411
426 /* delete the old layout */ 412 /* delete the old layout */
427 for (i = 0; i < RP->Xsize; i++) 413 for (i = 0; i < RP->Xsize; i++)
428 free (maze[i]); 414 free (maze[i]);
429 free (maze); 415 free (maze);
430 416
431 swap = RP->Ysize; 417 swap = RP->Ysize;
432 RP->Ysize = RP->Xsize; 418 RP->Ysize = RP->Xsize;
433 RP->Xsize = swap; 419 RP->Xsize = swap;
434 return new_maze; 420 return new_maze;
435 break; 421 break;
436 } 422 }
437 } 423 }
438 return NULL; 424 return NULL;
439} 425}
440 426
441/* take a layout and make some rooms in it. 427/* take a layout and make some rooms in it.
442 --works best on onions.*/ 428 --works best on onions.*/
443void 429void
444roomify_layout (char **maze, RMParms * RP) 430roomify_layout (char **maze, random_map_params *RP)
445{ 431{
446 int tries = RP->Xsize * RP->Ysize / 30; 432 int tries = RP->Xsize * RP->Ysize / 30;
447 int ti; 433 int ti;
448 434
449 for (ti = 0; ti < tries; ti++) 435 for (ti = 0; ti < tries; ti++)
… …
476/* checks the layout to see if I can stick a horizontal(dir = 0) wall 462/* checks the layout to see if I can stick a horizontal(dir = 0) wall
477 (or vertical, dir == 1) 463 (or vertical, dir == 1)
478 here which ends up on other walls sensibly. */ 464 here which ends up on other walls sensibly. */
479 465
480int 466int
481can_make_wall (char **maze, int dx, int dy, int dir, RMParms * RP) 467can_make_wall (char **maze, int dx, int dy, int dir, random_map_params *RP)
482{ 468{
483 int i1; 469 int i1;
484 int length = 0; 470 int length = 0;
485 471
486 /* dont make walls if we're on the edge. */ 472 /* dont make walls if we're on the edge. */
… …
561make_wall (char **maze, int x, int y, int dir) 547make_wall (char **maze, int x, int y, int dir)
562{ 548{
563 maze[x][y] = 'D'; /* mark a door */ 549 maze[x][y] = 'D'; /* mark a door */
564 switch (dir) 550 switch (dir)
565 { 551 {
566 case 0: /* horizontal */ 552 case 0: /* horizontal */
567 { 553 {
568 int i1; 554 int i1;
569 555
570 for (i1 = x - 1; maze[i1][y] == 0; i1--) 556 for (i1 = x - 1; maze[i1][y] == 0; i1--)
571 maze[i1][y] = '#'; 557 maze[i1][y] = '#';
572 for (i1 = x + 1; maze[i1][y] == 0; i1++) 558 for (i1 = x + 1; maze[i1][y] == 0; i1++)
573 maze[i1][y] = '#'; 559 maze[i1][y] = '#';
574 break; 560 break;
575 } 561 }
576 case 1: /* vertical */ 562 case 1: /* vertical */
577 { 563 {
578 int i1; 564 int i1;
579 565
580 for (i1 = y - 1; maze[x][i1] == 0; i1--) 566 for (i1 = y - 1; maze[x][i1] == 0; i1--)
581 maze[x][i1] = '#'; 567 maze[x][i1] = '#';
582 for (i1 = y + 1; maze[x][i1] == 0; i1++) 568 for (i1 = y + 1; maze[x][i1] == 0; i1++)
583 maze[x][i1] = '#'; 569 maze[x][i1] = '#';
584 break; 570 break;
585 } 571 }
586 } 572 }
587 573
588 return 0; 574 return 0;
589} 575}
590 576
591/* puts doors at appropriate locations in a layout. */ 577/* puts doors at appropriate locations in a layout. */
592
593void 578void
594doorify_layout (char **maze, RMParms * RP) 579doorify_layout (char **maze, random_map_params *RP)
595{ 580{
596 int ndoors = RP->Xsize * RP->Ysize / 60; /* reasonable number of doors. */ 581 int ndoors = RP->Xsize * RP->Ysize / 60; /* reasonable number of doors. */
597 char *doorlist_x; 582 char *doorlist_x;
598 char *doorlist_y; 583 char *doorlist_y;
599 int doorlocs = 0; /* # of available doorlocations */ 584 int doorlocs = 0; /* # of available doorlocations */
… …
614 doorlist_x[doorlocs] = i; 599 doorlist_x[doorlocs] = i;
615 doorlist_y[doorlocs] = j; 600 doorlist_y[doorlocs] = j;
616 doorlocs++; 601 doorlocs++;
617 } 602 }
618 } 603 }
604
619 while (ndoors > 0 && doorlocs > 0) 605 while (ndoors > 0 && doorlocs > 0)
620 { 606 {
621 int di; 607 int di;
622 int sindex; 608 int sindex;
623 609
… …
633 /* reduce the size of the list */ 619 /* reduce the size of the list */
634 doorlocs--; 620 doorlocs--;
635 doorlist_x[di] = doorlist_x[doorlocs]; 621 doorlist_x[di] = doorlist_x[doorlocs];
636 doorlist_y[di] = doorlist_y[doorlocs]; 622 doorlist_y[di] = doorlist_y[doorlocs];
637 } 623 }
624
638 free (doorlist_x); 625 free (doorlist_x);
639 free (doorlist_y); 626 free (doorlist_y);
640} 627}
641 628
642
643void 629void
644write_map_parameters_to_string (char *buf, RMParms * RP) 630write_map_parameters_to_string (char *buf, random_map_params *RP)
645{ 631{
646
647 char small_buf[256]; 632 char small_buf[256];
648 633
649 sprintf (buf, "xsize %d\nysize %d\n", RP->Xsize, RP->Ysize); 634 sprintf (buf, "xsize %d\nysize %d\n", RP->Xsize, RP->Ysize);
650 635
651 if (RP->wallstyle[0]) 636 if (RP->wallstyle[0])
… …
789 if (RP->origin_y) 774 if (RP->origin_y)
790 { 775 {
791 sprintf (small_buf, "origin_y %d\n", RP->origin_y); 776 sprintf (small_buf, "origin_y %d\n", RP->origin_y);
792 strcat (buf, small_buf); 777 strcat (buf, small_buf);
793 } 778 }
779
794 if (RP->random_seed) 780 if (RP->random_seed)
795 { 781 {
796 /* Add one so that the next map is a bit different */ 782 /* Add one so that the next map is a bit different */
797 sprintf (small_buf, "random_seed %d\n", RP->random_seed + 1); 783 sprintf (small_buf, "random_seed %d\n", RP->random_seed + 1);
798 strcat (buf, small_buf); 784 strcat (buf, small_buf);
… …
801 if (RP->treasureoptions) 787 if (RP->treasureoptions)
802 { 788 {
803 sprintf (small_buf, "treasureoptions %d\n", RP->treasureoptions); 789 sprintf (small_buf, "treasureoptions %d\n", RP->treasureoptions);
804 strcat (buf, small_buf); 790 strcat (buf, small_buf);
805 } 791 }
806
807
808} 792}
809 793
810void 794void
811write_parameters_to_string (char *buf, 795write_parameters_to_string (char *buf,
812 int xsize_n, 796 int xsize_n,
… …
909 { 893 {
910 sprintf (small_buf, "layoutoptions1 %d\n", layoutoptions1_n); 894 sprintf (small_buf, "layoutoptions1 %d\n", layoutoptions1_n);
911 strcat (buf, small_buf); 895 strcat (buf, small_buf);
912 } 896 }
913 897
914
915 if (layoutoptions2_n) 898 if (layoutoptions2_n)
916 { 899 {
917 sprintf (small_buf, "layoutoptions2 %d\n", layoutoptions2_n); 900 sprintf (small_buf, "layoutoptions2 %d\n", layoutoptions2_n);
918 strcat (buf, small_buf); 901 strcat (buf, small_buf);
919 } 902 }
… …
974 if (origin_y_n) 957 if (origin_y_n)
975 { 958 {
976 sprintf (small_buf, "origin_y %d\n", origin_y_n); 959 sprintf (small_buf, "origin_y %d\n", origin_y_n);
977 strcat (buf, small_buf); 960 strcat (buf, small_buf);
978 } 961 }
962
979 if (random_seed_n) 963 if (random_seed_n)
980 { 964 {
981 /* Add one so that the next map is a bit different */ 965 /* Add one so that the next map is a bit different */
982 sprintf (small_buf, "random_seed %d\n", random_seed_n + 1); 966 sprintf (small_buf, "random_seed %d\n", random_seed_n + 1);
983 strcat (buf, small_buf); 967 strcat (buf, small_buf);
… …
996void 980void
997copy_object_with_inv (object *src_ob, object *dest_ob) 981copy_object_with_inv (object *src_ob, object *dest_ob)
998{ 982{
999 object *walk, *tmp; 983 object *walk, *tmp;
1000 984
1001 copy_object (src_ob, dest_ob); 985 src_ob->copy_to (dest_ob);
1002 986
1003 for (walk = src_ob->inv; walk != NULL; walk = walk->below) 987 for (walk = src_ob->inv; walk != NULL; walk = walk->below)
1004 { 988 {
1005 tmp = get_object (); 989 tmp = object::create ();
1006 copy_object (walk, tmp); 990
991 walk->copy_to (tmp);
1007 insert_ob_in_ob (tmp, dest_ob); 992 insert_ob_in_ob (tmp, dest_ob);
1008 } 993 }
1009} 994}

Diff Legend

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