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.1 by elmex, Sun Aug 13 17:16:03 2006 UTC vs.
Revision 1.12 by root, Sun Dec 31 17:17:23 2006 UTC

1/*
2 * static char *rcsid_random_map_c =
3 * "$Id: random_map.C,v 1.1 2006/08/13 17:16:03 elmex Exp $";
4 */
5
6/* 1/*
7 CrossFire, A Multiplayer game for X-windows 2 CrossFire, A Multiplayer game for X-windows
8 3
9 Copyright (C) 2001 Mark Wedel & Crossfire Development Team 4 Copyright (C) 2001 Mark Wedel & Crossfire Development Team
10 Copyright (C) 1992 Frank Tore Johansen 5 Copyright (C) 1992 Frank Tore Johansen
… …
21 16
22 You should have received a copy of the GNU General Public License 17 You should have received a copy of the GNU General Public License
23 along with this program; if not, write to the Free Software 18 along with this program; if not, write to the Free Software
24 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 19 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
25 20
26 The authors can be reached via e-mail at crossfire-devel@real-time.com 21 The authors can be reached via e-mail at <crossfire@schmorp.de>
27*/ 22*/
28 23
29#include <time.h> 24#include <time.h>
30#include <stdio.h> 25#include <stdio.h>
31#include <global.h> 26#include <global.h>
… …
33#include <room_gen.h> 28#include <room_gen.h>
34#include <random_map.h> 29#include <random_map.h>
35#include <rproto.h> 30#include <rproto.h>
36#include <sproto.h> 31#include <sproto.h>
37 32
38void dump_layout(char **layout,RMParms *RP) { 33void
34dump_layout (char **layout, random_map_params * RP)
35{
36 {
39 { int i,j; 37 int i, j;
38
40 for(i=0;i<RP->Xsize;i++) { 39 for (i = 0; i < RP->Xsize; i++)
40 {
41 for(j=0;j<RP->Ysize;j++) { 41 for (j = 0; j < RP->Ysize; j++)
42 if(layout[i][j]==0) layout[i][j]=' '; 42 {
43 if (layout[i][j] == 0)
44 layout[i][j] = ' ';
43 printf("%c",layout[i][j]); 45 printf ("%c", layout[i][j]);
44 if(layout[i][j]==' ') layout[i][j]=0; 46 if (layout[i][j] == ' ')
47 layout[i][j] = 0;
48 }
49 printf ("\n");
45 } 50 }
51 }
46 printf("\n"); 52 printf ("\n");
47 }}
48 printf("\n");
49} 53}
50EXTERN FILE *logfile; 54
55extern FILE *logfile;
56
57maptile *
51mapstruct *generate_random_map(const char *OutFileName, RMParms *RP) { 58generate_random_map (const char *OutFileName, random_map_params * RP)
59{
52 char **layout, buf[HUGE_BUF]; 60 char **layout, buf[HUGE_BUF];
53 mapstruct *theMap; 61 maptile *theMap;
54 int i; 62 int i;
55 63
56 /* pick a random seed, or use the one from the input file */ 64 /* pick a random seed, or use the one from the input file */
57 if(RP->random_seed == 0) 65 if (RP->random_seed == 0)
58 RP->random_seed=time(0); 66 RP->random_seed = time (0);
59 67
60 SRANDOM(RP->random_seed); 68 SRANDOM (RP->random_seed);
61 69
62 write_map_parameters_to_string(buf, RP); 70 write_map_parameters_to_string (buf, RP);
63 71
64 if(RP->difficulty==0) { 72 if (RP->difficulty == 0)
73 {
65 RP->difficulty = RP->dungeon_level; /* use this instead of a map difficulty */ 74 RP->difficulty = RP->dungeon_level; /* use this instead of a map difficulty */
75
66 if (RP->difficulty_increase > 0.001) { 76 if (RP->difficulty_increase > 0.001)
67 RP->difficulty = (int)((float)RP->dungeon_level * RP->difficulty_increase); 77 RP->difficulty = (int) ((float) RP->dungeon_level * RP->difficulty_increase);
68 if (RP->difficulty < 1) RP->difficulty=1; 78
69 } 79 if (RP->difficulty < 1)
80 RP->difficulty = 1;
70 } 81 }
71 else 82 else
72 RP->difficulty_given=1; 83 RP->difficulty_given = 1;
73 84
74 if(RP->Xsize<MIN_RANDOM_MAP_SIZE) RP->Xsize = MIN_RANDOM_MAP_SIZE + RANDOM()%25 + 5; 85 if (RP->Xsize < MIN_RANDOM_MAP_SIZE)
75 if(RP->Ysize<MIN_RANDOM_MAP_SIZE) RP->Ysize = MIN_RANDOM_MAP_SIZE + RANDOM()%25 + 5; 86 RP->Xsize = MIN_RANDOM_MAP_SIZE + RANDOM () % 25 + 5;
76 87
88 if (RP->Ysize < MIN_RANDOM_MAP_SIZE)
89 RP->Ysize = MIN_RANDOM_MAP_SIZE + RANDOM () % 25 + 5;
90
77 if(RP->expand2x > 0) { 91 if (RP->expand2x > 0)
78 RP->Xsize /=2;
79 RP->Ysize /=2;
80 } 92 {
93 RP->Xsize /= 2;
94 RP->Ysize /= 2;
95 }
81 96
82 layout = layoutgen(RP); 97 layout = layoutgen (RP);
83 98
84#ifdef RMAP_DEBUG 99#ifdef RMAP_DEBUG
85 dump_layout(layout,RP); 100 dump_layout (layout, RP);
86#endif 101#endif
87 102
88 /* increment these for the current map */ 103 /* increment these for the current map */
89 RP->dungeon_level+=1; 104 RP->dungeon_level += 1;
90 /* allow constant-difficulty maps. */ 105 /* allow constant-difficulty maps. */
91 /* difficulty+=1; */ 106 /* difficulty+=1; */
92 107
93 /* rotate the layout randomly */ 108 /* rotate the layout randomly */
94 layout=rotate_layout(layout,RANDOM()%4,RP); 109 layout = rotate_layout (layout, RANDOM () % 4, RP);
95#ifdef RMAP_DEBUG 110#ifdef RMAP_DEBUG
96 dump_layout(layout,RP); 111 dump_layout (layout, RP);
97#endif 112#endif
98 113
99 /* allocate the map and set the floor */ 114 /* allocate the map and set the floor */
100 theMap = make_map_floor(layout,RP->floorstyle,RP); 115 theMap = make_map_floor (layout, RP->floorstyle, RP);
101 116
102 /* set the name of the map. */ 117 /* set the name of the map. */
103 strcpy(theMap->path,OutFileName); 118 theMap->path = OutFileName;
104 119
105 /* set region */ 120 /* set region */
106 theMap->region=RP->region; 121 theMap->region = RP->region;
107 122
108 /* create walls unless the wallstyle is "none" */ 123 /* create walls unless the wallstyle is "none" */
109 if (strcmp (RP->wallstyle, "none")) { 124 if (strcmp (RP->wallstyle, "none"))
125 {
110 make_map_walls(theMap,layout,RP->wallstyle,RP); 126 make_map_walls (theMap, layout, RP->wallstyle, RP);
111 127
112 /* place doors unless doorstyle or wallstyle is "none"*/ 128 /* place doors unless doorstyle or wallstyle is "none" */
113 if (strcmp (RP->doorstyle, "none")) 129 if (strcmp (RP->doorstyle, "none"))
114 put_doors(theMap,layout,RP->doorstyle,RP); 130 put_doors (theMap, layout, RP->doorstyle, RP);
115
116 }
117 131
132 }
133
118 /* create exits unless the exitstyle is "none" */ 134 /* create exits unless the exitstyle is "none" */
119 if (strcmp (RP->exitstyle, "none")) 135 if (strcmp (RP->exitstyle, "none"))
120 place_exits(theMap,layout,RP->exitstyle,RP->orientation,RP); 136 place_exits (theMap, layout, RP->exitstyle, RP->orientation, RP);
121 137
122 place_specials_in_map(theMap,layout,RP); 138 place_specials_in_map (theMap, layout, RP);
123 139
124 /* create monsters unless the monsterstyle is "none" */ 140 /* create monsters unless the monsterstyle is "none" */
125 if (strcmp (RP->monsterstyle, "none")) 141 if (strcmp (RP->monsterstyle, "none"))
126 place_monsters(theMap,RP->monsterstyle,RP->difficulty,RP); 142 place_monsters (theMap, RP->monsterstyle, RP->difficulty, RP);
127 143
128 /* treasures needs to have a proper difficulty set for the map. */ 144 /* treasures needs to have a proper difficulty set for the map. */
129 theMap->difficulty=calculate_difficulty(theMap); 145 theMap->difficulty = theMap->estimate_difficulty ();
130 146
131 /* create treasure unless the treasurestyle is "none" */ 147 /* create treasure unless the treasurestyle is "none" */
132 if (strcmp (RP->treasurestyle, "none")) 148 if (strcmp (RP->treasurestyle, "none"))
133 place_treasure(theMap,layout,RP->treasurestyle,RP->treasureoptions,RP); 149 place_treasure (theMap, layout, RP->treasurestyle, RP->treasureoptions, RP);
134 150
135 /* create decor unless the decorstyle is "none" */ 151 /* create decor unless the decorstyle is "none" */
136 if (strcmp (RP->decorstyle, "none")) 152 if (strcmp (RP->decorstyle, "none"))
137 put_decor(theMap,layout,RP->decorstyle,RP->decoroptions,RP); 153 put_decor (theMap, layout, RP->decorstyle, RP->decoroptions, RP);
138 154
139 /* generate treasures, etc. */ 155 /* generate treasures, etc. */
140 fix_auto_apply(theMap); 156 theMap->fix_auto_apply ();
141 157
142 unblock_exits(theMap,layout,RP); 158 unblock_exits (theMap, layout, RP);
143 159
144 /* free the layout */ 160 /* free the layout */
145 for(i=0;i<RP->Xsize;i++) 161 for (i = 0; i < RP->Xsize; i++)
146 free(layout[i]); 162 free (layout[i]);
163
147 free(layout); 164 free (layout);
148 165
149 theMap->msg = strdup_local(buf); 166 theMap->msg = strdup (buf);
150 167 theMap->in_memory = MAP_IN_MEMORY;
168
151 return theMap; 169 return theMap;
152} 170}
153
154 171
155/* function selects the layout function and gives it whatever 172/* function selects the layout function and gives it whatever
156 arguments it needs. */ 173 arguments it needs. */
157char **layoutgen(RMParms *RP) { 174char **
175layoutgen (random_map_params * RP)
176{
158 char **maze=0; 177 char **maze = 0;
159 int oxsize= RP->Xsize, oysize=RP->Ysize; 178 int oxsize = RP->Xsize, oysize = RP->Ysize;
160 179
161 if(RP->symmetry == RANDOM_SYM) 180 if (RP->symmetry == SYMMETRY_RANDOM)
162 RP->symmetry_used = (RANDOM() % ( XY_SYM))+1; 181 RP->symmetry_used = (RANDOM () % (SYMMETRY_XY)) + 1;
182 else
163 else RP->symmetry_used = RP->symmetry; 183 RP->symmetry_used = RP->symmetry;
164 184
165 if(RP->symmetry_used==Y_SYM||RP->symmetry_used==XY_SYM) RP->Ysize = RP->Ysize/2+1; 185 if (RP->symmetry_used == SYMMETRY_Y || RP->symmetry_used == SYMMETRY_XY)
166 if(RP->symmetry_used==X_SYM||RP->symmetry_used==XY_SYM) RP->Xsize = RP->Xsize/2+1; 186 RP->Ysize = RP->Ysize / 2 + 1;
187 if (RP->symmetry_used == SYMMETRY_X || RP->symmetry_used == SYMMETRY_XY)
188 RP->Xsize = RP->Xsize / 2 + 1;
167 189
168 if(RP->Xsize<MIN_RANDOM_MAP_SIZE) RP->Xsize = MIN_RANDOM_MAP_SIZE + RANDOM()%5; 190 if (RP->Xsize < MIN_RANDOM_MAP_SIZE)
169 if(RP->Ysize<MIN_RANDOM_MAP_SIZE) RP->Ysize = MIN_RANDOM_MAP_SIZE + RANDOM()%5; 191 RP->Xsize = MIN_RANDOM_MAP_SIZE + RANDOM () % 5;
192 if (RP->Ysize < MIN_RANDOM_MAP_SIZE)
193 RP->Ysize = MIN_RANDOM_MAP_SIZE + RANDOM () % 5;
170 RP->map_layout_style = 0; 194 RP->map_layout_style = 0;
171 195
172 /* Redo this - there was a lot of redundant code of checking for preset 196 /* Redo this - there was a lot of redundant code of checking for preset
173 * layout style and then random layout style. Instead, figure out 197 * layout style and then random layout style. Instead, figure out
174 * the numeric layoutstyle, so there is only one area that actually 198 * the numeric layoutstyle, so there is only one area that actually
175 * calls the code to make the maps. 199 * calls the code to make the maps.
176 */ 200 */
177 if(strstr(RP->layoutstyle,"onion")) { 201 if (strstr (RP->layoutstyle, "onion"))
178 RP->map_layout_style = ONION_LAYOUT; 202 RP->map_layout_style = LAYOUT_ONION;
179 }
180 203
181 if(strstr(RP->layoutstyle,"maze")) { 204 if (strstr (RP->layoutstyle, "maze"))
182 RP->map_layout_style = MAZE_LAYOUT; 205 RP->map_layout_style = LAYOUT_MAZE;
183 }
184 206
185 if(strstr(RP->layoutstyle,"spiral")) { 207 if (strstr (RP->layoutstyle, "spiral"))
186 RP->map_layout_style = SPIRAL_LAYOUT; 208 RP->map_layout_style = LAYOUT_SPIRAL;
187 }
188 209
189 if(strstr(RP->layoutstyle,"rogue")) { 210 if (strstr (RP->layoutstyle, "rogue"))
190 RP->map_layout_style = ROGUELIKE_LAYOUT; 211 RP->map_layout_style = LAYOUT_ROGUELIKE;
191 }
192 212
193 if(strstr(RP->layoutstyle,"snake")) { 213 if (strstr (RP->layoutstyle, "snake"))
194 RP->map_layout_style = SNAKE_LAYOUT; 214 RP->map_layout_style = LAYOUT_SNAKE;
195 }
196 215
197 if(strstr(RP->layoutstyle,"squarespiral")) { 216 if (strstr (RP->layoutstyle, "squarespiral"))
198 RP->map_layout_style = SQUARE_SPIRAL_LAYOUT; 217 RP->map_layout_style = LAYOUT_SQUARE_SPIRAL;
199 } 218
200 /* No style found - choose one ranomdly */ 219 /* No style found - choose one ranomdly */
201 if (RP->map_layout_style == 0) { 220 if (RP->map_layout_style == LAYOUT_NONE)
202 RP->map_layout_style = (RANDOM() % NROFLAYOUTS) + 1; 221 RP->map_layout_style = (RANDOM () % (NROFLAYOUTS - 1)) + 1;
203 }
204 222
205 switch(RP->map_layout_style) { 223 switch (RP->map_layout_style)
206 224 {
207 case ONION_LAYOUT: 225 case LAYOUT_ONION:
208 maze = map_gen_onion(RP->Xsize,RP->Ysize,RP->layoutoptions1,RP->layoutoptions2); 226 maze = map_gen_onion (RP->Xsize, RP->Ysize, RP->layoutoptions1, RP->layoutoptions2);
209 if(!(RANDOM()%3)&& !(RP->layoutoptions1 & OPT_WALLS_ONLY)) roomify_layout(maze,RP); 227 if (!(RANDOM () % 3) && !(RP->layoutoptions1 & RMOPT_WALLS_ONLY))
210 break; 228 roomify_layout (maze, RP);
229 break;
211 230
212 case MAZE_LAYOUT: 231 case LAYOUT_MAZE:
213 maze = maze_gen(RP->Xsize,RP->Ysize,RANDOM()%2); 232 maze = maze_gen (RP->Xsize, RP->Ysize, RANDOM () % 2);
214 if(!(RANDOM()%2)) doorify_layout(maze,RP); 233 if (!(RANDOM () % 2))
215 break; 234 doorify_layout (maze, RP);
235 break;
216 236
217 case SPIRAL_LAYOUT: 237 case LAYOUT_SPIRAL:
218 maze = map_gen_spiral(RP->Xsize,RP->Ysize,RP->layoutoptions1); 238 maze = map_gen_spiral (RP->Xsize, RP->Ysize, RP->layoutoptions1);
219 if(!(RANDOM()%2)) doorify_layout(maze,RP); 239 if (!(RANDOM () % 2))
220 break; 240 doorify_layout (maze, RP);
241 break;
221 242
222 case ROGUELIKE_LAYOUT: 243 case LAYOUT_ROGUELIKE:
223 /* Don't put symmetry in rogue maps. There isn't much reason to 244 /* Don't put symmetry in rogue maps. There isn't much reason to
224 * do so in the first place (doesn't make it any more interesting), 245 * do so in the first place (doesn't make it any more interesting),
225 * but more importantly, the symmetry code presumes we are symmetrizing 246 * but more importantly, the symmetry code presumes we are symmetrizing
226 * spirals, or maps with lots of passages - making a symmetric rogue 247 * spirals, or maps with lots of passages - making a symmetric rogue
227 * map fails because its likely that the passages the symmetry process 248 * map fails because its likely that the passages the symmetry process
228 * creates may not connect the rooms. 249 * creates may not connect the rooms.
229 */ 250 */
230 RP->symmetry_used = NO_SYM; 251 RP->symmetry_used = SYMMETRY_NONE;
231 RP->Ysize = oysize; 252 RP->Ysize = oysize;
232 RP->Xsize = oxsize; 253 RP->Xsize = oxsize;
233 maze = roguelike_layout_gen(RP->Xsize,RP->Ysize,RP->layoutoptions1); 254 maze = roguelike_layout_gen (RP->Xsize, RP->Ysize, RP->layoutoptions1);
234 /* no doorifying... done already */ 255 /* no doorifying... done already */
235 break; 256 break;
236 257
237 case SNAKE_LAYOUT: 258 case LAYOUT_SNAKE:
238 maze = make_snake_layout(RP->Xsize,RP->Ysize,RP->layoutoptions1); 259 maze = make_snake_layout (RP->Xsize, RP->Ysize, RP->layoutoptions1);
239 if(RANDOM()%2) roomify_layout(maze,RP); 260 if (RANDOM () % 2)
240 break; 261 roomify_layout (maze, RP);
262 break;
241 263
242 case SQUARE_SPIRAL_LAYOUT: 264 case LAYOUT_SQUARE_SPIRAL:
243 maze = make_square_spiral_layout(RP->Xsize,RP->Ysize,RP->layoutoptions1); 265 maze = make_square_spiral_layout (RP->Xsize, RP->Ysize, RP->layoutoptions1);
244 if(RANDOM()%2) roomify_layout(maze,RP); 266 if (RANDOM () % 2)
245 break; 267 roomify_layout (maze, RP);
246 } 268 break;
269 }
247 270
248 maze = symmetrize_layout(maze, RP->symmetry_used,RP); 271 maze = symmetrize_layout (maze, RP->symmetry_used, RP);
272
249#ifdef RMAP_DEBUG 273#ifdef RMAP_DEBUG
250 dump_layout(maze,RP); 274 dump_layout (maze, RP);
251#endif 275#endif
276
252 if(RP->expand2x) { 277 if (RP->expand2x)
278 {
253 maze = expand2x(maze,RP->Xsize,RP->Ysize); 279 maze = expand2x (maze, RP->Xsize, RP->Ysize);
254 RP->Xsize = RP->Xsize * 2 -1; 280 RP->Xsize = RP->Xsize * 2 - 1;
255 RP->Ysize = RP->Ysize * 2 -1; 281 RP->Ysize = RP->Ysize * 2 - 1;
256 } 282 }
283
257 return maze; 284 return maze;
258} 285}
259
260 286
261/* takes a map and makes it symmetric: adjusts Xsize and 287/* takes a map and makes it symmetric: adjusts Xsize and
262Ysize to produce a symmetric map. */ 288Ysize to produce a symmetric map. */
263 289char **
264char **symmetrize_layout(char **maze, int sym,RMParms *RP) { 290symmetrize_layout (char **maze, int sym, random_map_params * RP)
291{
265 int i,j; 292 int i, j;
266 char **sym_maze; 293 char **sym_maze;
267 int Xsize_orig,Ysize_orig; 294 int Xsize_orig, Ysize_orig;
295
268 Xsize_orig = RP->Xsize; 296 Xsize_orig = RP->Xsize;
269 Ysize_orig = RP->Ysize; 297 Ysize_orig = RP->Ysize;
270 RP->symmetry_used = sym; /* tell everyone else what sort of symmetry is used.*/ 298 RP->symmetry_used = sym; /* tell everyone else what sort of symmetry is used. */
271 if(sym == NO_SYM) { 299 if (sym == SYMMETRY_NONE)
300 {
272 RP->Xsize = Xsize_orig; 301 RP->Xsize = Xsize_orig;
273 RP->Ysize = Ysize_orig; 302 RP->Ysize = Ysize_orig;
274 return maze; 303 return maze;
275 } 304 }
276 /* pick new sizes */ 305 /* pick new sizes */
277 RP->Xsize = ((sym==X_SYM||sym==XY_SYM)?RP->Xsize*2-3:RP->Xsize); 306 RP->Xsize = ((sym == SYMMETRY_X || sym == SYMMETRY_XY) ? RP->Xsize * 2 - 3 : RP->Xsize);
278 RP->Ysize = ((sym==Y_SYM||sym==XY_SYM)?RP->Ysize*2-3:RP->Ysize); 307 RP->Ysize = ((sym == SYMMETRY_Y || sym == SYMMETRY_XY) ? RP->Ysize * 2 - 3 : RP->Ysize);
279 308
280 sym_maze = (char **)calloc(sizeof(char*),RP->Xsize); 309 sym_maze = (char **) calloc (sizeof (char *), RP->Xsize);
281 for(i=0;i<RP->Xsize;i++) 310 for (i = 0; i < RP->Xsize; i++)
282 sym_maze[i] = (char *)calloc(sizeof(char),RP->Ysize); 311 sym_maze[i] = (char *) calloc (sizeof (char), RP->Ysize);
283 312
284 if(sym==X_SYM) 313 if (sym == SYMMETRY_X)
285 for(i=0;i<RP->Xsize/2+1;i++) 314 for (i = 0; i < RP->Xsize / 2 + 1; i++)
286 for(j=0;j<RP->Ysize;j++) { 315 for (j = 0; j < RP->Ysize; j++)
316 {
287 sym_maze[i][j] = maze[i][j]; 317 sym_maze[i][j] = maze[i][j];
288 sym_maze[RP->Xsize - i-1][j] = maze[i][j]; 318 sym_maze[RP->Xsize - i - 1][j] = maze[i][j];
289 }; 319 };
290 if(sym==Y_SYM) 320 if (sym == SYMMETRY_Y)
291 for(i=0;i<RP->Xsize;i++) 321 for (i = 0; i < RP->Xsize; i++)
292 for(j=0;j<RP->Ysize/2+1;j++) { 322 for (j = 0; j < RP->Ysize / 2 + 1; j++)
323 {
293 sym_maze[i][j] = maze[i][j]; 324 sym_maze[i][j] = maze[i][j];
294 sym_maze[i][RP->Ysize-j-1] = maze[i][j]; 325 sym_maze[i][RP->Ysize - j - 1] = maze[i][j];
295 } 326 }
296 if(sym==XY_SYM) 327 if (sym == SYMMETRY_XY)
297 for(i=0;i<RP->Xsize/2+1;i++) 328 for (i = 0; i < RP->Xsize / 2 + 1; i++)
298 for(j=0;j<RP->Ysize/2+1;j++) { 329 for (j = 0; j < RP->Ysize / 2 + 1; j++)
330 {
299 sym_maze[i][j] = maze[i][j]; 331 sym_maze[i][j] = maze[i][j];
300 sym_maze[i][RP->Ysize-j-1] = maze[i][j]; 332 sym_maze[i][RP->Ysize - j - 1] = maze[i][j];
301 sym_maze[RP->Xsize - i-1][j] = maze[i][j]; 333 sym_maze[RP->Xsize - i - 1][j] = maze[i][j];
302 sym_maze[RP->Xsize - i-1][RP->Ysize-j-1] = maze[i][j]; 334 sym_maze[RP->Xsize - i - 1][RP->Ysize - j - 1] = maze[i][j];
303 } 335 }
304 /* delete the old maze */ 336 /* delete the old maze */
305 for(i=0;i<Xsize_orig;i++) 337 for (i = 0; i < Xsize_orig; i++)
306 free(maze[i]); 338 free (maze[i]);
307 free(maze); 339 free (maze);
308 /* reconnect disjointed spirals */ 340 /* reconnect disjointed spirals */
309 if(RP->map_layout_style==SPIRAL_LAYOUT) 341 if (RP->map_layout_style == LAYOUT_SPIRAL)
310 connect_spirals(RP->Xsize,RP->Ysize,sym,sym_maze); 342 connect_spirals (RP->Xsize, RP->Ysize, sym, sym_maze);
311 /* reconnect disjointed nethackmazes: the routine for 343 /* reconnect disjointed nethackmazes: the routine for
312 spirals will do the trick?*/ 344 spirals will do the trick? */
313 if(RP->map_layout_style==ROGUELIKE_LAYOUT) 345 if (RP->map_layout_style == LAYOUT_ROGUELIKE)
314 connect_spirals(RP->Xsize,RP->Ysize,sym,sym_maze); 346 connect_spirals (RP->Xsize, RP->Ysize, sym, sym_maze);
315 347
316 return sym_maze; 348 return sym_maze;
317} 349}
318 350
319 351
320/* takes a map and rotates it. This completes the 352/* takes a map and rotates it. This completes the
321 onion layouts, making them possibly centered on any wall. 353 onion layouts, making them possibly centered on any wall.
322 It'll modify Xsize and Ysize if they're swapped. 354 It'll modify Xsize and Ysize if they're swapped.
323*/ 355*/
324 356
357char **
325char ** rotate_layout(char **maze,int rotation,RMParms *RP) { 358rotate_layout (char **maze, int rotation, random_map_params * RP)
359{
326 char **new_maze; 360 char **new_maze;
327 int i,j; 361 int i, j;
328 362
329 switch(rotation) { 363 switch (rotation)
364 {
330 case 0: 365 case 0:
331 return maze;
332 break;
333 case 2: /* a reflection */
334 {
335 char *newmaze= (char *) malloc(sizeof(char) * RP->Xsize*RP->Ysize);
336 for(i=0;i<RP->Xsize;i++) { /* make a copy */
337 for(j=0;j<RP->Ysize;j++) {
338 newmaze[i * RP->Ysize + j] = maze[i][j];
339 }
340 }
341 for(i=0;i<RP->Xsize;i++) { /* copy a reflection back */
342 for(j=0;j<RP->Ysize;j++) {
343 maze[i][j]= newmaze[(RP->Xsize-i-1)*RP->Ysize + RP->Ysize-j-1];
344 }
345 }
346 free(newmaze);
347 return maze; 366 return maze;
348 break; 367 break;
349 } 368 case 2: /* a reflection */
369 {
370 char *newmaze = (char *) malloc (sizeof (char) * RP->Xsize * RP->Ysize);
371
372 for (i = 0; i < RP->Xsize; i++)
373 { /* make a copy */
374 for (j = 0; j < RP->Ysize; j++)
375 {
376 newmaze[i * RP->Ysize + j] = maze[i][j];
377 }
378 }
379 for (i = 0; i < RP->Xsize; i++)
380 { /* copy a reflection back */
381 for (j = 0; j < RP->Ysize; j++)
382 {
383 maze[i][j] = newmaze[(RP->Xsize - i - 1) * RP->Ysize + RP->Ysize - j - 1];
384 }
385 }
386 free (newmaze);
387 return maze;
388 break;
389 }
350 case 1: 390 case 1:
351 case 3: 391 case 3:
392 {
352 { int swap; 393 int swap;
353 new_maze = (char **) calloc(sizeof(char *),RP->Ysize); 394 new_maze = (char **) calloc (sizeof (char *), RP->Ysize);
354 for(i=0;i<RP->Ysize;i++) { 395 for (i = 0; i < RP->Ysize; i++)
396 {
355 new_maze[i] = (char *) calloc(sizeof(char),RP->Xsize); 397 new_maze[i] = (char *) calloc (sizeof (char), RP->Xsize);
356 } 398 }
357 if(rotation == 1) /* swap x and y */ 399 if (rotation == 1) /* swap x and y */
358 for(i=0;i<RP->Xsize;i++) 400 for (i = 0; i < RP->Xsize; i++)
359 for(j=0;j<RP->Ysize;j++) 401 for (j = 0; j < RP->Ysize; j++)
360 new_maze[j][i] = maze[i][j]; 402 new_maze[j][i] = maze[i][j];
361 403
362 if(rotation == 3) { /* swap x and y */ 404 if (rotation == 3)
405 { /* swap x and y */
363 for(i=0;i<RP->Xsize;i++) 406 for (i = 0; i < RP->Xsize; i++)
364 for(j=0;j<RP->Ysize;j++) 407 for (j = 0; j < RP->Ysize; j++)
365 new_maze[j][i] = maze[RP->Xsize -i-1][RP->Ysize - j-1]; 408 new_maze[j][i] = maze[RP->Xsize - i - 1][RP->Ysize - j - 1];
366 } 409 }
367 410
368 /* delete the old layout */ 411 /* delete the old layout */
369 for(i=0;i<RP->Xsize;i++) 412 for (i = 0; i < RP->Xsize; i++)
370 free(maze[i]); 413 free (maze[i]);
371 free(maze); 414 free (maze);
372 415
373 swap = RP->Ysize; 416 swap = RP->Ysize;
374 RP->Ysize = RP->Xsize; 417 RP->Ysize = RP->Xsize;
375 RP->Xsize = swap; 418 RP->Xsize = swap;
376 return new_maze; 419 return new_maze;
377 break; 420 break;
378 } 421 }
379 } 422 }
380 return NULL; 423 return NULL;
381} 424}
382 425
383/* take a layout and make some rooms in it. 426/* take a layout and make some rooms in it.
384 --works best on onions.*/ 427 --works best on onions.*/
385void roomify_layout(char **maze,RMParms *RP) { 428void
429roomify_layout (char **maze, random_map_params * RP)
430{
386 int tries = RP->Xsize*RP->Ysize/30; 431 int tries = RP->Xsize * RP->Ysize / 30;
387 int ti; 432 int ti;
388 433
389 for(ti=0;ti<tries;ti++) { 434 for (ti = 0; ti < tries; ti++)
435 {
390 int dx,dy; /* starting location for looking at creating a door */ 436 int dx, dy; /* starting location for looking at creating a door */
391 int cx,cy; /* results of checking on creating walls. */ 437 int cx, cy; /* results of checking on creating walls. */
438
392 dx = RANDOM() % RP->Xsize; 439 dx = RANDOM () % RP->Xsize;
393 dy = RANDOM() % RP->Ysize; 440 dy = RANDOM () % RP->Ysize;
394 cx = can_make_wall(maze,dx,dy,0,RP); /* horizontal */ 441 cx = can_make_wall (maze, dx, dy, 0, RP); /* horizontal */
395 cy = can_make_wall(maze,dx,dy,1,RP); /* vertical */ 442 cy = can_make_wall (maze, dx, dy, 1, RP); /* vertical */
396 if(cx == -1) { 443 if (cx == -1)
444 {
445 if (cy != -1)
446 make_wall (maze, dx, dy, 1);
447 continue;
448 }
397 if(cy != -1) 449 if (cy == -1)
450 {
451 make_wall (maze, dx, dy, 0);
452 continue;
453 }
454 if (cx < cy)
455 make_wall (maze, dx, dy, 0);
456 else
398 make_wall(maze,dx,dy,1); 457 make_wall (maze, dx, dy, 1);
399 continue;
400 }
401 if(cy == -1) {
402 make_wall(maze,dx,dy,0);
403 continue;
404 }
405 if(cx < cy) make_wall(maze,dx,dy,0);
406 else make_wall(maze,dx,dy,1);
407 } 458 }
408} 459}
409 460
410/* checks the layout to see if I can stick a horizontal(dir = 0) wall 461/* checks the layout to see if I can stick a horizontal(dir = 0) wall
411 (or vertical, dir == 1) 462 (or vertical, dir == 1)
412 here which ends up on other walls sensibly. */ 463 here which ends up on other walls sensibly. */
413 464
465int
414int can_make_wall(char **maze,int dx,int dy,int dir,RMParms *RP) { 466can_make_wall (char **maze, int dx, int dy, int dir, random_map_params * RP)
467{
415 int i1; 468 int i1;
416 int length=0; 469 int length = 0;
417 470
418 /* dont make walls if we're on the edge. */ 471 /* dont make walls if we're on the edge. */
419 if(dx == 0 || dx == (RP->Xsize -1) || dy == 0 || dy == (RP->Ysize-1)) return -1; 472 if (dx == 0 || dx == (RP->Xsize - 1) || dy == 0 || dy == (RP->Ysize - 1))
473 return -1;
420 474
421 /* don't make walls if we're ON a wall. */ 475 /* don't make walls if we're ON a wall. */
422 if(maze[dx][dy]!=0) return -1; 476 if (maze[dx][dy] != 0)
477 return -1;
423 478
424 if(dir==0) /* horizontal */ 479 if (dir == 0) /* horizontal */
425 { 480 {
426 int y = dy; 481 int y = dy;
482
427 for(i1=dx-1;i1>0;i1--) { 483 for (i1 = dx - 1; i1 > 0; i1--)
484 {
428 int sindex=surround_flag2(maze,i1,y,RP); 485 int sindex = surround_flag2 (maze, i1, y, RP);
486
429 if(sindex == 1) break; 487 if (sindex == 1)
488 break;
489 if (sindex != 0)
430 if(sindex != 0) return -1; /* can't make horiz. wall here */ 490 return -1; /* can't make horiz. wall here */
491 if (maze[i1][y] != 0)
431 if(maze[i1][y]!=0) return -1; /* can't make horiz. wall here */ 492 return -1; /* can't make horiz. wall here */
432 length++; 493 length++;
433 } 494 }
434 495
435 for(i1=dx+1;i1<RP->Xsize-1;i1++) { 496 for (i1 = dx + 1; i1 < RP->Xsize - 1; i1++)
497 {
436 int sindex=surround_flag2(maze,i1,y,RP); 498 int sindex = surround_flag2 (maze, i1, y, RP);
499
437 if(sindex == 2) break; 500 if (sindex == 2)
501 break;
502 if (sindex != 0)
438 if(sindex != 0) return -1; /* can't make horiz. wall here */ 503 return -1; /* can't make horiz. wall here */
504 if (maze[i1][y] != 0)
439 if(maze[i1][y]!=0) return -1; /* can't make horiz. wall here */ 505 return -1; /* can't make horiz. wall here */
440 length++; 506 length++;
441 } 507 }
442 return length; 508 return length;
443 } 509 }
444 else { /* vertical */ 510 else
511 { /* vertical */
445 int x = dx; 512 int x = dx;
513
446 for(i1=dy-1;i1>0;i1--) { 514 for (i1 = dy - 1; i1 > 0; i1--)
515 {
447 int sindex=surround_flag2(maze,x,i1,RP); 516 int sindex = surround_flag2 (maze, x, i1, RP);
517
448 if(sindex == 4) break; 518 if (sindex == 4)
519 break;
520 if (sindex != 0)
449 if(sindex != 0) return -1; /* can't make vert. wall here */ 521 return -1; /* can't make vert. wall here */
522 if (maze[x][i1] != 0)
450 if(maze[x][i1]!=0) return -1; /* can't make horiz. wall here */ 523 return -1; /* can't make horiz. wall here */
451 length++; 524 length++;
452 } 525 }
453 526
454 for(i1=dy+1;i1<RP->Ysize-1;i1++) { 527 for (i1 = dy + 1; i1 < RP->Ysize - 1; i1++)
528 {
455 int sindex=surround_flag2(maze,x,i1,RP); 529 int sindex = surround_flag2 (maze, x, i1, RP);
530
456 if(sindex == 8) break; 531 if (sindex == 8)
532 break;
533 if (sindex != 0)
457 if(sindex != 0) return -1; /* can't make verti. wall here */ 534 return -1; /* can't make verti. wall here */
535 if (maze[x][i1] != 0)
458 if(maze[x][i1]!=0) return -1; /* can't make horiz. wall here */ 536 return -1; /* can't make horiz. wall here */
459 length++; 537 length++;
460 } 538 }
461 return length; 539 return length;
462 } 540 }
463 return -1; 541 return -1;
464} 542}
465 543
466 544
545int
467int make_wall(char **maze,int x, int y, int dir){ 546make_wall (char **maze, int x, int y, int dir)
547{
468 maze[x][y] = 'D'; /* mark a door */ 548 maze[x][y] = 'D'; /* mark a door */
469 switch(dir) { 549 switch (dir)
470 case 0: /* horizontal */
471 { 550 {
551 case 0: /* horizontal */
552 {
472 int i1; 553 int i1;
554
473 for(i1 = x-1;maze[i1][y]==0;i1--) 555 for (i1 = x - 1; maze[i1][y] == 0; i1--)
474 maze[i1][y]='#'; 556 maze[i1][y] = '#';
475 for(i1 = x+1;maze[i1][y]==0;i1++) 557 for (i1 = x + 1; maze[i1][y] == 0; i1++)
476 maze[i1][y]='#'; 558 maze[i1][y] = '#';
477 break; 559 break;
478 } 560 }
479 case 1: /* vertical */ 561 case 1: /* vertical */
480 { 562 {
481 int i1; 563 int i1;
564
482 for(i1 = y-1;maze[x][i1]==0;i1--) 565 for (i1 = y - 1; maze[x][i1] == 0; i1--)
483 maze[x][i1]='#'; 566 maze[x][i1] = '#';
484 for(i1 = y+1;maze[x][i1]==0;i1++) 567 for (i1 = y + 1; maze[x][i1] == 0; i1++)
485 maze[x][i1]='#'; 568 maze[x][i1] = '#';
486 break; 569 break;
570 }
487 } 571 }
488 }
489 572
490 return 0; 573 return 0;
491} 574}
492 575
493/* puts doors at appropriate locations in a layout. */ 576/* puts doors at appropriate locations in a layout. */
494 577void
495void doorify_layout(char **maze,RMParms *RP) { 578doorify_layout (char **maze, random_map_params * RP)
579{
496 int ndoors = RP->Xsize*RP->Ysize/60; /* reasonable number of doors. */ 580 int ndoors = RP->Xsize * RP->Ysize / 60; /* reasonable number of doors. */
497 char *doorlist_x; 581 char *doorlist_x;
498 char *doorlist_y; 582 char *doorlist_y;
499 int doorlocs = 0; /* # of available doorlocations */ 583 int doorlocs = 0; /* # of available doorlocations */
500 int i,j; 584 int i, j;
501 585
502 doorlist_x = (char *) malloc(sizeof(int) * RP->Xsize*RP->Ysize); 586 doorlist_x = (char *) malloc (sizeof (int) * RP->Xsize * RP->Ysize);
503 doorlist_y = (char *) malloc(sizeof(int) * RP->Xsize*RP->Ysize); 587 doorlist_y = (char *) malloc (sizeof (int) * RP->Xsize * RP->Ysize);
504 588
505 589
506 /* make a list of possible door locations */ 590 /* make a list of possible door locations */
507 for(i=1;i<RP->Xsize-1;i++) 591 for (i = 1; i < RP->Xsize - 1; i++)
508 for(j=1;j<RP->Ysize-1;j++) { 592 for (j = 1; j < RP->Ysize - 1; j++)
509 int sindex = surround_flag(maze,i,j,RP);
510 if(sindex == 3 || sindex == 12) /* these are possible door sindex*/
511 {
512 doorlist_x[doorlocs]=i;
513 doorlist_y[doorlocs]=j;
514 doorlocs++;
515 }
516 }
517 while(ndoors > 0 && doorlocs > 0) {
518 int di;
519 int sindex;
520 di = RANDOM() % doorlocs;
521 i=doorlist_x[di];
522 j=doorlist_y[di];
523 sindex= surround_flag(maze,i,j,RP);
524 if(sindex == 3 || sindex == 12) /* these are possible door sindex*/
525 { 593 {
526 maze[i][j] = 'D'; 594 int sindex = surround_flag (maze, i, j, RP);
527 ndoors--; 595
596 if (sindex == 3 || sindex == 12) /* these are possible door sindex */
597 {
598 doorlist_x[doorlocs] = i;
599 doorlist_y[doorlocs] = j;
600 doorlocs++;
601 }
528 } 602 }
603
604 while (ndoors > 0 && doorlocs > 0)
605 {
606 int di;
607 int sindex;
608
609 di = RANDOM () % doorlocs;
610 i = doorlist_x[di];
611 j = doorlist_y[di];
612 sindex = surround_flag (maze, i, j, RP);
613 if (sindex == 3 || sindex == 12) /* these are possible door sindex */
614 {
615 maze[i][j] = 'D';
616 ndoors--;
617 }
529 /* reduce the size of the list */ 618 /* reduce the size of the list */
530 doorlocs--; 619 doorlocs--;
531 doorlist_x[di]=doorlist_x[doorlocs]; 620 doorlist_x[di] = doorlist_x[doorlocs];
532 doorlist_y[di]=doorlist_y[doorlocs]; 621 doorlist_y[di] = doorlist_y[doorlocs];
533 } 622 }
623
534 free(doorlist_x); 624 free (doorlist_x);
535 free(doorlist_y); 625 free (doorlist_y);
536} 626}
537 627
538 628void
539void write_map_parameters_to_string(char *buf,RMParms *RP) { 629write_map_parameters_to_string (char *buf, random_map_params * RP)
540 630{
541 char small_buf[256]; 631 char small_buf[256];
632
542 sprintf(buf,"xsize %d\nysize %d\n",RP->Xsize,RP->Ysize); 633 sprintf (buf, "xsize %d\nysize %d\n", RP->Xsize, RP->Ysize);
543 634
544 if(RP->wallstyle[0]) { 635 if (RP->wallstyle[0])
636 {
545 sprintf(small_buf,"wallstyle %s\n",RP->wallstyle); 637 sprintf (small_buf, "wallstyle %s\n", RP->wallstyle);
546 strcat(buf,small_buf); 638 strcat (buf, small_buf);
547 } 639 }
548 640
549 if(RP->floorstyle[0]) { 641 if (RP->floorstyle[0])
642 {
550 sprintf(small_buf,"floorstyle %s\n",RP->floorstyle); 643 sprintf (small_buf, "floorstyle %s\n", RP->floorstyle);
551 strcat(buf,small_buf); 644 strcat (buf, small_buf);
552 } 645 }
553 646
554 if(RP->monsterstyle[0]) { 647 if (RP->monsterstyle[0])
648 {
555 sprintf(small_buf,"monsterstyle %s\n",RP->monsterstyle); 649 sprintf (small_buf, "monsterstyle %s\n", RP->monsterstyle);
556 strcat(buf,small_buf); 650 strcat (buf, small_buf);
557 } 651 }
558 652
559 if(RP->treasurestyle[0]) { 653 if (RP->treasurestyle[0])
654 {
560 sprintf(small_buf,"treasurestyle %s\n",RP->treasurestyle); 655 sprintf (small_buf, "treasurestyle %s\n", RP->treasurestyle);
561 strcat(buf,small_buf); 656 strcat (buf, small_buf);
562 } 657 }
563 658
564 if(RP->layoutstyle[0]) { 659 if (RP->layoutstyle[0])
660 {
565 sprintf(small_buf,"layoutstyle %s\n",RP->layoutstyle); 661 sprintf (small_buf, "layoutstyle %s\n", RP->layoutstyle);
566 strcat(buf,small_buf); 662 strcat (buf, small_buf);
567 } 663 }
568 664
569 if(RP->decorstyle[0]) { 665 if (RP->decorstyle[0])
666 {
570 sprintf(small_buf,"decorstyle %s\n",RP->decorstyle); 667 sprintf (small_buf, "decorstyle %s\n", RP->decorstyle);
571 strcat(buf,small_buf); 668 strcat (buf, small_buf);
572 } 669 }
573 670
574 if(RP->doorstyle[0]) { 671 if (RP->doorstyle[0])
672 {
575 sprintf(small_buf,"doorstyle %s\n",RP->doorstyle); 673 sprintf (small_buf, "doorstyle %s\n", RP->doorstyle);
576 strcat(buf,small_buf); 674 strcat (buf, small_buf);
577 } 675 }
578 676
579 if(RP->exitstyle[0]) { 677 if (RP->exitstyle[0])
678 {
580 sprintf(small_buf,"exitstyle %s\n",RP->exitstyle); 679 sprintf (small_buf, "exitstyle %s\n", RP->exitstyle);
581 strcat(buf,small_buf); 680 strcat (buf, small_buf);
582 } 681 }
583 682
584 if(RP->final_map[0]) { 683 if (RP->final_map[0])
684 {
585 sprintf(small_buf,"final_map %s\n",RP->final_map); 685 sprintf (small_buf, "final_map %s\n", RP->final_map);
586 strcat(buf,small_buf); 686 strcat (buf, small_buf);
587 } 687 }
588 688
589 if(RP->exit_on_final_map[0]) { 689 if (RP->exit_on_final_map[0])
690 {
590 sprintf(small_buf,"exit_on_final_map %s\n",RP->exit_on_final_map); 691 sprintf (small_buf, "exit_on_final_map %s\n", RP->exit_on_final_map);
591 strcat(buf,small_buf); 692 strcat (buf, small_buf);
592 } 693 }
593 694
594 if(RP->this_map[0]) { 695 if (RP->this_map[0])
696 {
595 sprintf(small_buf,"origin_map %s\n",RP->this_map); 697 sprintf (small_buf, "origin_map %s\n", RP->this_map);
596 strcat(buf,small_buf); 698 strcat (buf, small_buf);
597 } 699 }
598 700
599 if(RP->expand2x) { 701 if (RP->expand2x)
702 {
600 sprintf(small_buf,"expand2x %d\n",RP->expand2x); 703 sprintf (small_buf, "expand2x %d\n", RP->expand2x);
601 strcat(buf,small_buf); 704 strcat (buf, small_buf);
602 } 705 }
603 706
604 if(RP->layoutoptions1) { 707 if (RP->layoutoptions1)
708 {
605 sprintf(small_buf,"layoutoptions1 %d\n",RP->layoutoptions1); 709 sprintf (small_buf, "layoutoptions1 %d\n", RP->layoutoptions1);
606 strcat(buf,small_buf); 710 strcat (buf, small_buf);
607 } 711 }
608 712
609 713
610 if(RP->layoutoptions2) { 714 if (RP->layoutoptions2)
715 {
611 sprintf(small_buf,"layoutoptions2 %d\n",RP->layoutoptions2); 716 sprintf (small_buf, "layoutoptions2 %d\n", RP->layoutoptions2);
612 strcat(buf,small_buf); 717 strcat (buf, small_buf);
613 } 718 }
614 719
615 720
616 if(RP->layoutoptions3) { 721 if (RP->layoutoptions3)
722 {
617 sprintf(small_buf,"layoutoptions3 %d\n",RP->layoutoptions3); 723 sprintf (small_buf, "layoutoptions3 %d\n", RP->layoutoptions3);
618 strcat(buf,small_buf); 724 strcat (buf, small_buf);
619 } 725 }
620 726
621 if(RP->symmetry) { 727 if (RP->symmetry)
728 {
622 sprintf(small_buf,"symmetry %d\n",RP->symmetry); 729 sprintf (small_buf, "symmetry %d\n", RP->symmetry);
623 strcat(buf,small_buf); 730 strcat (buf, small_buf);
624 } 731 }
625 732
626 733
627 if(RP->difficulty && RP->difficulty_given ) { 734 if (RP->difficulty && RP->difficulty_given)
735 {
628 sprintf(small_buf,"difficulty %d\n",RP->difficulty); 736 sprintf (small_buf, "difficulty %d\n", RP->difficulty);
629 strcat(buf,small_buf); 737 strcat (buf, small_buf);
630 } 738 }
631 739
632 if(RP->difficulty_increase != 1.0 ) { 740 if (RP->difficulty_increase != 1.0)
741 {
633 sprintf(small_buf,"difficulty_increase %f\n",RP->difficulty_increase); 742 sprintf (small_buf, "difficulty_increase %f\n", RP->difficulty_increase);
634 strcat(buf,small_buf); 743 strcat (buf, small_buf);
635 } 744 }
636 745
637 sprintf(small_buf,"dungeon_level %d\n",RP->dungeon_level); 746 sprintf (small_buf, "dungeon_level %d\n", RP->dungeon_level);
638 strcat(buf,small_buf); 747 strcat (buf, small_buf);
639 748
640 if(RP->dungeon_depth) { 749 if (RP->dungeon_depth)
750 {
641 sprintf(small_buf,"dungeon_depth %d\n",RP->dungeon_depth); 751 sprintf (small_buf, "dungeon_depth %d\n", RP->dungeon_depth);
642 strcat(buf,small_buf); 752 strcat (buf, small_buf);
643 } 753 }
644 754
645 if(RP->decoroptions) { 755 if (RP->decoroptions)
756 {
646 sprintf(small_buf,"decoroptions %d\n",RP->decoroptions); 757 sprintf (small_buf, "decoroptions %d\n", RP->decoroptions);
647 strcat(buf,small_buf); 758 strcat (buf, small_buf);
648 } 759 }
649 760
650 if(RP->orientation) { 761 if (RP->orientation)
762 {
651 sprintf(small_buf,"orientation %d\n",RP->orientation); 763 sprintf (small_buf, "orientation %d\n", RP->orientation);
652 strcat(buf,small_buf); 764 strcat (buf, small_buf);
653 } 765 }
654 766
655 if(RP->origin_x) { 767 if (RP->origin_x)
768 {
656 sprintf(small_buf,"origin_x %d\n",RP->origin_x); 769 sprintf (small_buf, "origin_x %d\n", RP->origin_x);
657 strcat(buf,small_buf); 770 strcat (buf, small_buf);
658 } 771 }
659 772
660 if(RP->origin_y) { 773 if (RP->origin_y)
774 {
661 sprintf(small_buf,"origin_y %d\n",RP->origin_y); 775 sprintf (small_buf, "origin_y %d\n", RP->origin_y);
662 strcat(buf,small_buf); 776 strcat (buf, small_buf);
663 } 777 }
778
664 if(RP->random_seed) { 779 if (RP->random_seed)
780 {
665 /* Add one so that the next map is a bit different */ 781 /* Add one so that the next map is a bit different */
666 sprintf(small_buf,"random_seed %d\n",RP->random_seed + 1); 782 sprintf (small_buf, "random_seed %d\n", RP->random_seed + 1);
667 strcat(buf,small_buf); 783 strcat (buf, small_buf);
668 } 784 }
669 785
670 if(RP->treasureoptions) { 786 if (RP->treasureoptions)
787 {
671 sprintf(small_buf,"treasureoptions %d\n",RP->treasureoptions); 788 sprintf (small_buf, "treasureoptions %d\n", RP->treasureoptions);
672 strcat(buf,small_buf); 789 strcat (buf, small_buf);
673 } 790 }
674
675
676} 791}
677 792
793void
678void write_parameters_to_string(char *buf, 794write_parameters_to_string (char *buf,
679 int xsize_n, 795 int xsize_n,
680 int ysize_n, 796 int ysize_n,
681 char *wallstyle_n, 797 char *wallstyle_n,
682 char *floorstyle_n, 798 char *floorstyle_n,
683 char *monsterstyle_n, 799 char *monsterstyle_n,
684 char *treasurestyle_n, 800 char *treasurestyle_n,
685 char *layoutstyle_n, 801 char *layoutstyle_n,
686 char *decorstyle_n, 802 char *decorstyle_n,
687 char *doorstyle_n, 803 char *doorstyle_n,
688 char *exitstyle_n, 804 char *exitstyle_n,
689 char *final_map_n, 805 char *final_map_n,
690 char *exit_on_final_map_n, 806 char *exit_on_final_map_n,
691 char *this_map_n, 807 char *this_map_n,
692 int layoutoptions1_n, 808 int layoutoptions1_n,
693 int layoutoptions2_n, 809 int layoutoptions2_n,
694 int layoutoptions3_n, 810 int layoutoptions3_n,
695 int symmetry_n, 811 int symmetry_n,
696 int dungeon_depth_n, 812 int dungeon_depth_n,
697 int dungeon_level_n, 813 int dungeon_level_n,
698 int difficulty_n, 814 int difficulty_n,
699 int difficulty_given_n, 815 int difficulty_given_n,
700 int decoroptions_n, 816 int decoroptions_n,
701 int orientation_n, 817 int orientation_n,
702 int origin_x_n, 818 int origin_x_n, int origin_y_n, int random_seed_n, int treasureoptions_n, float difficulty_increase)
703 int origin_y_n,
704 int random_seed_n,
705 int treasureoptions_n,
706 float difficulty_increase)
707{ 819{
708 820
709 char small_buf[256]; 821 char small_buf[256];
822
710 sprintf(buf,"xsize %d\nysize %d\n",xsize_n,ysize_n); 823 sprintf (buf, "xsize %d\nysize %d\n", xsize_n, ysize_n);
711 824
712 if(wallstyle_n && wallstyle_n[0]) { 825 if (wallstyle_n && wallstyle_n[0])
826 {
713 sprintf(small_buf,"wallstyle %s\n",wallstyle_n); 827 sprintf (small_buf, "wallstyle %s\n", wallstyle_n);
714 strcat(buf,small_buf); 828 strcat (buf, small_buf);
715 } 829 }
716 830
717 if(floorstyle_n && floorstyle_n[0]) { 831 if (floorstyle_n && floorstyle_n[0])
832 {
718 sprintf(small_buf,"floorstyle %s\n",floorstyle_n); 833 sprintf (small_buf, "floorstyle %s\n", floorstyle_n);
719 strcat(buf,small_buf); 834 strcat (buf, small_buf);
720 } 835 }
721 836
722 if(monsterstyle_n && monsterstyle_n[0]) { 837 if (monsterstyle_n && monsterstyle_n[0])
838 {
723 sprintf(small_buf,"monsterstyle %s\n",monsterstyle_n); 839 sprintf (small_buf, "monsterstyle %s\n", monsterstyle_n);
724 strcat(buf,small_buf); 840 strcat (buf, small_buf);
725 } 841 }
726 842
727 if(treasurestyle_n && treasurestyle_n[0]) { 843 if (treasurestyle_n && treasurestyle_n[0])
844 {
728 sprintf(small_buf,"treasurestyle %s\n",treasurestyle_n); 845 sprintf (small_buf, "treasurestyle %s\n", treasurestyle_n);
729 strcat(buf,small_buf); 846 strcat (buf, small_buf);
730 } 847 }
731 848
732 if(layoutstyle_n &&layoutstyle_n[0]) { 849 if (layoutstyle_n && layoutstyle_n[0])
850 {
733 sprintf(small_buf,"layoutstyle %s\n",layoutstyle_n); 851 sprintf (small_buf, "layoutstyle %s\n", layoutstyle_n);
734 strcat(buf,small_buf); 852 strcat (buf, small_buf);
735 } 853 }
736 854
737 if(decorstyle_n && decorstyle_n[0]) { 855 if (decorstyle_n && decorstyle_n[0])
856 {
738 sprintf(small_buf,"decorstyle %s\n",decorstyle_n); 857 sprintf (small_buf, "decorstyle %s\n", decorstyle_n);
739 strcat(buf,small_buf); 858 strcat (buf, small_buf);
740 } 859 }
741 860
742 if(doorstyle_n && doorstyle_n[0]) { 861 if (doorstyle_n && doorstyle_n[0])
862 {
743 sprintf(small_buf,"doorstyle %s\n",doorstyle_n); 863 sprintf (small_buf, "doorstyle %s\n", doorstyle_n);
744 strcat(buf,small_buf); 864 strcat (buf, small_buf);
745 } 865 }
746 866
747 if(exitstyle_n && exitstyle_n[0]) { 867 if (exitstyle_n && exitstyle_n[0])
868 {
748 sprintf(small_buf,"exitstyle %s\n",exitstyle_n); 869 sprintf (small_buf, "exitstyle %s\n", exitstyle_n);
749 strcat(buf,small_buf); 870 strcat (buf, small_buf);
750 } 871 }
751 872
752 if(final_map_n && final_map_n[0]) { 873 if (final_map_n && final_map_n[0])
874 {
753 sprintf(small_buf,"final_map %s\n",final_map_n); 875 sprintf (small_buf, "final_map %s\n", final_map_n);
754 strcat(buf,small_buf); 876 strcat (buf, small_buf);
755 } 877 }
756 878
757 if(exit_on_final_map_n && exit_on_final_map_n[0]) { 879 if (exit_on_final_map_n && exit_on_final_map_n[0])
880 {
758 sprintf(small_buf,"exit_on_final_map %s\n",exit_on_final_map_n); 881 sprintf (small_buf, "exit_on_final_map %s\n", exit_on_final_map_n);
759 strcat(buf,small_buf); 882 strcat (buf, small_buf);
760 } 883 }
761 884
762 if(this_map_n && this_map_n[0]) { 885 if (this_map_n && this_map_n[0])
886 {
763 sprintf(small_buf,"origin_map %s\n",this_map_n); 887 sprintf (small_buf, "origin_map %s\n", this_map_n);
764 strcat(buf,small_buf); 888 strcat (buf, small_buf);
765 } 889 }
766 890
767 if(layoutoptions1_n) { 891 if (layoutoptions1_n)
892 {
768 sprintf(small_buf,"layoutoptions1 %d\n",layoutoptions1_n); 893 sprintf (small_buf, "layoutoptions1 %d\n", layoutoptions1_n);
769 strcat(buf,small_buf); 894 strcat (buf, small_buf);
770 } 895 }
771 896
772
773 if(layoutoptions2_n) { 897 if (layoutoptions2_n)
898 {
774 sprintf(small_buf,"layoutoptions2 %d\n",layoutoptions2_n); 899 sprintf (small_buf, "layoutoptions2 %d\n", layoutoptions2_n);
775 strcat(buf,small_buf); 900 strcat (buf, small_buf);
776 } 901 }
777 902
778 903
779 if(layoutoptions3_n) { 904 if (layoutoptions3_n)
905 {
780 sprintf(small_buf,"layoutoptions3 %d\n",layoutoptions3_n); 906 sprintf (small_buf, "layoutoptions3 %d\n", layoutoptions3_n);
781 strcat(buf,small_buf); 907 strcat (buf, small_buf);
782 } 908 }
783 909
784 if(symmetry_n) { 910 if (symmetry_n)
911 {
785 sprintf(small_buf,"symmetry %d\n",symmetry_n); 912 sprintf (small_buf, "symmetry %d\n", symmetry_n);
786 strcat(buf,small_buf); 913 strcat (buf, small_buf);
787 } 914 }
788 915
789 916
790 if(difficulty_n && difficulty_given_n ) { 917 if (difficulty_n && difficulty_given_n)
918 {
791 sprintf(small_buf,"difficulty %d\n",difficulty_n); 919 sprintf (small_buf, "difficulty %d\n", difficulty_n);
792 strcat(buf,small_buf); 920 strcat (buf, small_buf);
793 } 921 }
794 922
795 if(difficulty_increase > 0.001 ) { 923 if (difficulty_increase > 0.001)
924 {
796 sprintf(small_buf,"difficulty_increase %f\n",difficulty_increase); 925 sprintf (small_buf, "difficulty_increase %f\n", difficulty_increase);
797 strcat(buf,small_buf); 926 strcat (buf, small_buf);
798 } 927 }
799 928
800 sprintf(small_buf,"dungeon_level %d\n",dungeon_level_n); 929 sprintf (small_buf, "dungeon_level %d\n", dungeon_level_n);
801 strcat(buf,small_buf); 930 strcat (buf, small_buf);
802 931
803 if(dungeon_depth_n) { 932 if (dungeon_depth_n)
933 {
804 sprintf(small_buf,"dungeon_depth %d\n",dungeon_depth_n); 934 sprintf (small_buf, "dungeon_depth %d\n", dungeon_depth_n);
805 strcat(buf,small_buf); 935 strcat (buf, small_buf);
806 } 936 }
807 937
808 if(decoroptions_n) { 938 if (decoroptions_n)
939 {
809 sprintf(small_buf,"decoroptions %d\n",decoroptions_n); 940 sprintf (small_buf, "decoroptions %d\n", decoroptions_n);
810 strcat(buf,small_buf); 941 strcat (buf, small_buf);
811 } 942 }
812 943
813 if(orientation_n) { 944 if (orientation_n)
945 {
814 sprintf(small_buf,"orientation %d\n",orientation_n); 946 sprintf (small_buf, "orientation %d\n", orientation_n);
815 strcat(buf,small_buf); 947 strcat (buf, small_buf);
816 } 948 }
817 949
818 if(origin_x_n) { 950 if (origin_x_n)
951 {
819 sprintf(small_buf,"origin_x %d\n",origin_x_n); 952 sprintf (small_buf, "origin_x %d\n", origin_x_n);
820 strcat(buf,small_buf); 953 strcat (buf, small_buf);
821 } 954 }
822 955
823 if(origin_y_n) { 956 if (origin_y_n)
957 {
824 sprintf(small_buf,"origin_y %d\n",origin_y_n); 958 sprintf (small_buf, "origin_y %d\n", origin_y_n);
825 strcat(buf,small_buf); 959 strcat (buf, small_buf);
826 } 960 }
961
827 if(random_seed_n) { 962 if (random_seed_n)
963 {
828 /* Add one so that the next map is a bit different */ 964 /* Add one so that the next map is a bit different */
829 sprintf(small_buf,"random_seed %d\n",random_seed_n + 1); 965 sprintf (small_buf, "random_seed %d\n", random_seed_n + 1);
830 strcat(buf,small_buf); 966 strcat (buf, small_buf);
831 } 967 }
832 968
833 if(treasureoptions_n) { 969 if (treasureoptions_n)
970 {
834 sprintf(small_buf,"treasureoptions %d\n",treasureoptions_n); 971 sprintf (small_buf, "treasureoptions %d\n", treasureoptions_n);
835 strcat(buf,small_buf); 972 strcat (buf, small_buf);
836 } 973 }
837 974
838 975
839} 976}
840 977
841/* copy an object with an inventory... i.e., duplicate the inv too. */ 978/* copy an object with an inventory... i.e., duplicate the inv too. */
979void
842void copy_object_with_inv(object *src_ob, object *dest_ob) { 980copy_object_with_inv (object *src_ob, object *dest_ob)
981{
843 object *walk,*tmp; 982 object *walk, *tmp;
844 983
845 copy_object(src_ob,dest_ob); 984 src_ob->copy_to (dest_ob);
846 985
847 for(walk=src_ob->inv;walk!=NULL;walk=walk->below) { 986 for (walk = src_ob->inv; walk != NULL; walk = walk->below)
848 tmp=get_object(); 987 {
849 copy_object(walk,tmp); 988 tmp = object::create ();
989 walk->copy_to (tmp);
850 insert_ob_in_ob(tmp,dest_ob); 990 insert_ob_in_ob (tmp, dest_ob);
851 } 991 }
852} 992}

Diff Legend

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