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

Diff Legend

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