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

Diff Legend

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