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.30 by root, Sun Jul 1 05:00:19 2007 UTC

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

Diff Legend

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