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

Diff Legend

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