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.39 by root, Sun May 4 14:12:37 2008 UTC

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

Diff Legend

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