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

Diff Legend

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