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.2 by root, Tue Aug 29 08:01:36 2006 UTC vs.
Revision 1.6 by root, Fri Sep 29 20:12:32 2006 UTC

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

Diff Legend

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