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.42 by root, Mon Oct 12 14:00:58 2009 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 it under
9 * the terms of the Affero GNU General Public License as published by the
10 * Free Software Foundation, either version 3 of the License, or (at your
11 * 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 Affero GNU General Public License
19 * and the GNU General Public License along with this program. If not, see
20 * <http://www.gnu.org/licenses/>.
21 *
22 * The authors can be reached via e-mail to <support@deliantra.net>
4 */ 23 */
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 24
29#include <time.h> 25#include <time.h>
30#include <stdio.h> 26#include <stdio.h>
31#include <global.h> 27#include <global.h>
32#include <maze_gen.h>
33#include <room_gen.h>
34#include <random_map.h> 28#include <random_map.h>
35#include <rproto.h> 29#include <rproto.h>
36#include <sproto.h> 30#include <sproto.h>
37 31
38void dump_layout(char **layout,RMParms *RP) { 32#define CEDE coroapi::cede_to_tick ()
39 { int i,j; 33
40 for(i=0;i<RP->Xsize;i++) { 34static void symmetrize_layout (Layout maze, random_map_params *RP);
41 for(j=0;j<RP->Ysize;j++) { 35static void rotate_layout (Layout maze, int rotation);
42 if(layout[i][j]==0) layout[i][j]=' '; 36
43 printf("%c",layout[i][j]); 37void
44 if(layout[i][j]==' ') layout[i][j]=0; 38dump_layout (Layout layout)
39{
40 for (int j = 0; j < layout->h; j++)
45 } 41 {
46 printf("\n"); 42 for (int i = 0; i < layout->w; i++)
43 putc (layout[i][j] ? layout[i][j] : ' ', stdout);
44
45 putc ('\n', stdout);
47 }} 46 }
48 printf("\n"); 47
48 putc ('\n', stdout);
49} 49}
50EXTERN FILE *logfile; 50
51mapstruct *generate_random_map(const char *OutFileName, RMParms *RP) { 51bool
52 char **layout, buf[HUGE_BUF]; 52maptile::generate_random_map (random_map_params *RP)
53 mapstruct *theMap; 53{
54 char buf[16384];
54 int i; 55 int i;
55 56
57 RP->Xsize = RP->xsize;
58 RP->Ysize = RP->ysize;
59
56 /* pick a random seed, or use the one from the input file */ 60 /* pick a random seed, or use the one from the input file */
57 if(RP->random_seed == 0) 61 RP->random_seed = RP->random_seed
58 RP->random_seed=time(0); 62 ? RP->random_seed + RP->dungeon_level
63 : time (0);
59 64
60 SRANDOM(RP->random_seed); 65 // we run "single-threaded"
66 rmg_rndm.seed (RP->random_seed);
61 67
62 write_map_parameters_to_string(buf, RP); 68 write_map_parameters_to_string (buf, RP);
63 69
64 if(RP->difficulty==0) { 70 if (RP->difficulty == 0)
71 {
65 RP->difficulty = RP->dungeon_level; /* use this instead of a map difficulty */ 72 RP->difficulty = RP->dungeon_level; /* use this instead of a map difficulty */
73
66 if (RP->difficulty_increase > 0.001) { 74 if (RP->difficulty_increase > 0.001)
67 RP->difficulty = (int)((float)RP->dungeon_level * RP->difficulty_increase); 75 RP->difficulty = (int) ((float) RP->dungeon_level * RP->difficulty_increase);
68 if (RP->difficulty < 1) RP->difficulty=1; 76
69 } 77 if (RP->difficulty < 1)
78 RP->difficulty = 1;
70 } 79 }
71 else 80 else
72 RP->difficulty_given=1; 81 RP->difficulty_given = 1;
73 82
74 if(RP->Xsize<MIN_RANDOM_MAP_SIZE) RP->Xsize = MIN_RANDOM_MAP_SIZE + RANDOM()%25 + 5; 83 if (RP->Xsize < MIN_RANDOM_MAP_SIZE)
75 if(RP->Ysize<MIN_RANDOM_MAP_SIZE) RP->Ysize = MIN_RANDOM_MAP_SIZE + RANDOM()%25 + 5; 84 RP->Xsize = MIN_RANDOM_MAP_SIZE + rmg_rndm (25) + 5;
76 85
86 if (RP->Ysize < MIN_RANDOM_MAP_SIZE)
87 RP->Ysize = MIN_RANDOM_MAP_SIZE + rmg_rndm (25) + 5;
88
89 if (RP->symmetry == SYMMETRY_RANDOM)
90 RP->symmetry_used = rmg_rndm (SYMMETRY_XY) + 1;
91 else
92 RP->symmetry_used = RP->symmetry;
93
94 if (RP->symmetry_used == SYMMETRY_Y || RP->symmetry_used == SYMMETRY_XY)
95 RP->Ysize = RP->Ysize / 2 + 1;
96
97 if (RP->symmetry_used == SYMMETRY_X || RP->symmetry_used == SYMMETRY_XY)
98 RP->Xsize = RP->Xsize / 2 + 1;
99
77 if(RP->expand2x > 0) { 100 if (RP->expand2x > 0)
101 {
78 RP->Xsize /=2; 102 RP->Xsize /= 2;
79 RP->Ysize /=2; 103 RP->Ysize /= 2;
80 } 104 }
81 105
106 RP->map_layout_style = LAYOUT_NONE;
107
108 /* Redo this - there was a lot of redundant code of checking for preset
109 * layout style and then random layout style. Instead, figure out
110 * the numeric layoutstyle, so there is only one area that actually
111 * calls the code to make the maps.
112 */
113 if (strstr (RP->layoutstyle, "onion"))
114 RP->map_layout_style = LAYOUT_ONION;
115 else if (strstr (RP->layoutstyle, "maze"))
116 RP->map_layout_style = LAYOUT_MAZE;
117 else if (strstr (RP->layoutstyle, "spiral"))
118 RP->map_layout_style = LAYOUT_SPIRAL;
119 else if (strstr (RP->layoutstyle, "rogue"))
120 RP->map_layout_style = LAYOUT_ROGUELIKE;
121 else if (strstr (RP->layoutstyle, "snake"))
122 RP->map_layout_style = LAYOUT_SNAKE;
123 else if (strstr (RP->layoutstyle, "squarespiral"))
124 RP->map_layout_style = LAYOUT_SQUARE_SPIRAL;
125 else if (RP->map_layout_style == LAYOUT_NONE)
126 RP->map_layout_style = rmg_rndm (NROFLAYOUTS - 1) + 1; /* No style found - choose one randomly */
127 else
128 abort ();
129
82 layout = layoutgen(RP); 130 Layout layout = layoutgen (RP);
83 131
84#ifdef RMAP_DEBUG 132#ifdef RMAP_DEBUG
85 dump_layout(layout,RP); 133 dump_layout (layout);
86#endif 134#endif
87 135
88 /* increment these for the current map */ 136 /* increment these for the current map */
89 RP->dungeon_level+=1; 137 ++RP->dungeon_level;
90 /* allow constant-difficulty maps. */
91 /* difficulty+=1; */
92 138
93 /* rotate the layout randomly */ 139 // need to patch RP becasue following code doesn't use the Layout object
94 layout=rotate_layout(layout,RANDOM()%4,RP); 140 RP->Xsize = layout->w;
95#ifdef RMAP_DEBUG 141 RP->Ysize = layout->h;
96 dump_layout(layout,RP);
97#endif
98 142
99 /* allocate the map and set the floor */ 143 /* allocate the map and set the floor */
100 theMap = make_map_floor(layout,RP->floorstyle,RP); 144 make_map_floor (layout, RP->floorstyle, RP);
101 145
102 /* set the name of the map. */
103 strcpy(theMap->path,OutFileName);
104
105 /* set region */ 146 /* set region */
106 theMap->region=RP->region; 147 default_region = RP->region;
107 148
149 CEDE;
150
151 place_specials_in_map (this, layout, RP);
152
153 CEDE;
154
108 /* create walls unless the wallstyle is "none" */ 155 /* create walls unless the wallstyle is "none" */
109 if (strcmp (RP->wallstyle, "none")) { 156 if (strcmp (RP->wallstyle, "none"))
157 {
110 make_map_walls(theMap,layout,RP->wallstyle,RP); 158 make_map_walls (this, layout, RP->wallstyle, RP);
111 159
112 /* place doors unless doorstyle or wallstyle is "none"*/ 160 /* place doors unless doorstyle or wallstyle is "none" */
113 if (strcmp (RP->doorstyle, "none")) 161 if (strcmp (RP->doorstyle, "none"))
114 put_doors(theMap,layout,RP->doorstyle,RP); 162 put_doors (this, layout, RP->doorstyle, RP);
115
116 } 163 }
117 164
165 CEDE;
166
118 /* create exits unless the exitstyle is "none" */ 167 /* create exits unless the exitstyle is "none" */
119 if (strcmp (RP->exitstyle, "none")) 168 if (strcmp (RP->exitstyle, "none"))
120 place_exits(theMap,layout,RP->exitstyle,RP->orientation,RP); 169 place_exits (this, layout, RP->exitstyle, RP->orientation, RP);
121 170
122 place_specials_in_map(theMap,layout,RP); 171 CEDE;
123 172
124 /* create monsters unless the monsterstyle is "none" */ 173 /* create monsters unless the monsterstyle is "none" */
125 if (strcmp (RP->monsterstyle, "none")) 174 if (strcmp (RP->monsterstyle, "none"))
126 place_monsters(theMap,RP->monsterstyle,RP->difficulty,RP); 175 place_monsters (this, RP->monsterstyle, RP->difficulty, RP);
127 176
177 CEDE;
178
128 /* treasures needs to have a proper difficulty set for the map. */ 179 /* treasures needs to have a proper difficulty set for the map. */
129 theMap->difficulty=calculate_difficulty(theMap); 180 difficulty = estimate_difficulty ();
130 181
182 CEDE;
183
131 /* create treasure unless the treasurestyle is "none" */ 184 /* create treasure unless the treasurestyle is "none" */
132 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
550 uint16 *doorlist_x = salloc<uint16> (RP->Xsize * RP->Ysize);
551 uint16 *doorlist_y = salloc<uint16> (RP->Xsize * RP->Ysize);
552
553 /* make a list of possible door locations */
554 for (int i = 1; i < RP->Xsize - 1; i++)
555 for (int j = 1; j < RP->Ysize - 1; j++)
556 {
557 int sindex = surround_flag (maze, i, j, RP);
558
559 if (sindex == 3 || sindex == 12) /* these are possible door sindex */
560 {
561 doorlist_x[doorlocs] = i;
562 doorlist_y[doorlocs] = j;
563 doorlocs++;
564 }
433 } 565 }
434 566
435 for(i1=dx+1;i1<RP->Xsize-1;i1++) { 567 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 } 568 {
444 else { /* vertical */ 569 int di = rmg_rndm (doorlocs);
445 int x = dx; 570 int i = doorlist_x[di];
446 for(i1=dy-1;i1>0;i1--) { 571 int j = doorlist_y[di];
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;
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;
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
490 return 0;
491}
492
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); 572 int sindex = surround_flag (maze, i, j, RP);
573
510 if(sindex == 3 || sindex == 12) /* these are possible door sindex*/ 574 if (sindex == 3 || sindex == 12) /* these are possible door sindex */
511 {
512 doorlist_x[doorlocs]=i;
513 doorlist_y[doorlocs]=j;
514 doorlocs++;
515 } 575 {
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'; 576 maze[i][j] = 'D';
527 ndoors--; 577 ndoors--;
528 } 578 }
579
529 /* reduce the size of the list */ 580 /* reduce the size of the list */
530 doorlocs--; 581 doorlocs--;
531 doorlist_x[di]=doorlist_x[doorlocs]; 582 doorlist_x[di] = doorlist_x[doorlocs];
532 doorlist_y[di]=doorlist_y[doorlocs]; 583 doorlist_y[di] = doorlist_y[doorlocs];
533 } 584 }
534 free(doorlist_x);
535 free(doorlist_y);
536}
537 585
586 sfree (doorlist_x, RP->Xsize * RP->Ysize);
587 sfree (doorlist_y, RP->Xsize * RP->Ysize);
588}
538 589
590void
539void write_map_parameters_to_string(char *buf,RMParms *RP) { 591write_map_parameters_to_string (char *buf, random_map_params *RP)
540 592{
541 char small_buf[256]; 593 char small_buf[16384];
594
542 sprintf(buf,"xsize %d\nysize %d\n",RP->Xsize,RP->Ysize); 595 sprintf (buf, "xsize %d\nysize %d\n", RP->xsize, RP->ysize);
543 596
544 if(RP->wallstyle[0]) { 597 if (RP->wallstyle[0])
598 {
545 sprintf(small_buf,"wallstyle %s\n",RP->wallstyle); 599 sprintf (small_buf, "wallstyle %s\n", RP->wallstyle);
546 strcat(buf,small_buf); 600 strcat (buf, small_buf);
547 } 601 }
548 602
549 if(RP->floorstyle[0]) { 603 if (RP->floorstyle[0])
604 {
550 sprintf(small_buf,"floorstyle %s\n",RP->floorstyle); 605 sprintf (small_buf, "floorstyle %s\n", RP->floorstyle);
551 strcat(buf,small_buf); 606 strcat (buf, small_buf);
552 } 607 }
553 608
554 if(RP->monsterstyle[0]) { 609 if (RP->monsterstyle[0])
610 {
555 sprintf(small_buf,"monsterstyle %s\n",RP->monsterstyle); 611 sprintf (small_buf, "monsterstyle %s\n", RP->monsterstyle);
556 strcat(buf,small_buf); 612 strcat (buf, small_buf);
557 } 613 }
558 614
559 if(RP->treasurestyle[0]) { 615 if (RP->treasurestyle[0])
616 {
560 sprintf(small_buf,"treasurestyle %s\n",RP->treasurestyle); 617 sprintf (small_buf, "treasurestyle %s\n", RP->treasurestyle);
561 strcat(buf,small_buf); 618 strcat (buf, small_buf);
562 } 619 }
563 620
564 if(RP->layoutstyle[0]) { 621 if (RP->layoutstyle[0])
622 {
565 sprintf(small_buf,"layoutstyle %s\n",RP->layoutstyle); 623 sprintf (small_buf, "layoutstyle %s\n", RP->layoutstyle);
566 strcat(buf,small_buf); 624 strcat (buf, small_buf);
567 } 625 }
568 626
569 if(RP->decorstyle[0]) { 627 if (RP->decorstyle[0])
628 {
570 sprintf(small_buf,"decorstyle %s\n",RP->decorstyle); 629 sprintf (small_buf, "decorstyle %s\n", RP->decorstyle);
571 strcat(buf,small_buf); 630 strcat (buf, small_buf);
572 } 631 }
573 632
574 if(RP->doorstyle[0]) { 633 if (RP->doorstyle[0])
634 {
575 sprintf(small_buf,"doorstyle %s\n",RP->doorstyle); 635 sprintf (small_buf, "doorstyle %s\n", RP->doorstyle);
576 strcat(buf,small_buf); 636 strcat (buf, small_buf);
577 } 637 }
578 638
579 if(RP->exitstyle[0]) { 639 if (RP->exitstyle[0])
640 {
580 sprintf(small_buf,"exitstyle %s\n",RP->exitstyle); 641 sprintf (small_buf, "exitstyle %s\n", RP->exitstyle);
581 strcat(buf,small_buf); 642 strcat (buf, small_buf);
582 } 643 }
583 644
584 if(RP->final_map[0]) { 645 if (RP->final_map.length ())
646 {
585 sprintf(small_buf,"final_map %s\n",RP->final_map); 647 sprintf (small_buf, "final_map %s\n", &RP->final_map);
586 strcat(buf,small_buf); 648 strcat (buf, small_buf);
587 } 649 }
588 650
589 if(RP->exit_on_final_map[0]) { 651 if (RP->exit_on_final_map[0])
652 {
590 sprintf(small_buf,"exit_on_final_map %s\n",RP->exit_on_final_map); 653 sprintf (small_buf, "exit_on_final_map %s\n", RP->exit_on_final_map);
591 strcat(buf,small_buf); 654 strcat (buf, small_buf);
592 } 655 }
593 656
594 if(RP->this_map[0]) { 657 if (RP->this_map.length ())
658 {
595 sprintf(small_buf,"origin_map %s\n",RP->this_map); 659 sprintf (small_buf, "origin_map %s\n", &RP->this_map);
596 strcat(buf,small_buf); 660 strcat (buf, small_buf);
597 } 661 }
598 662
599 if(RP->expand2x) { 663 if (RP->expand2x)
664 {
600 sprintf(small_buf,"expand2x %d\n",RP->expand2x); 665 sprintf (small_buf, "expand2x %d\n", RP->expand2x);
601 strcat(buf,small_buf); 666 strcat (buf, small_buf);
602 } 667 }
603 668
604 if(RP->layoutoptions1) { 669 if (RP->layoutoptions1)
670 {
605 sprintf(small_buf,"layoutoptions1 %d\n",RP->layoutoptions1); 671 sprintf (small_buf, "layoutoptions1 %d\n", RP->layoutoptions1);
606 strcat(buf,small_buf); 672 strcat (buf, small_buf);
607 } 673 }
608 674
609
610 if(RP->layoutoptions2) { 675 if (RP->layoutoptions2)
676 {
611 sprintf(small_buf,"layoutoptions2 %d\n",RP->layoutoptions2); 677 sprintf (small_buf, "layoutoptions2 %d\n", RP->layoutoptions2);
612 strcat(buf,small_buf); 678 strcat (buf, small_buf);
613 } 679 }
614 680
615
616 if(RP->layoutoptions3) { 681 if (RP->layoutoptions3)
682 {
617 sprintf(small_buf,"layoutoptions3 %d\n",RP->layoutoptions3); 683 sprintf (small_buf, "layoutoptions3 %d\n", RP->layoutoptions3);
618 strcat(buf,small_buf); 684 strcat (buf, small_buf);
619 } 685 }
620 686
621 if(RP->symmetry) { 687 if (RP->symmetry)
688 {
622 sprintf(small_buf,"symmetry %d\n",RP->symmetry); 689 sprintf (small_buf, "symmetry %d\n", RP->symmetry);
623 strcat(buf,small_buf); 690 strcat (buf, small_buf);
624 } 691 }
625 692
626
627 if(RP->difficulty && RP->difficulty_given ) { 693 if (RP->difficulty && RP->difficulty_given)
694 {
628 sprintf(small_buf,"difficulty %d\n",RP->difficulty); 695 sprintf (small_buf, "difficulty %d\n", RP->difficulty);
629 strcat(buf,small_buf); 696 strcat (buf, small_buf);
630 } 697 }
631 698
632 if(RP->difficulty_increase != 1.0 ) { 699 if (RP->difficulty_increase != 1.0)
700 {
633 sprintf(small_buf,"difficulty_increase %f\n",RP->difficulty_increase); 701 sprintf (small_buf, "difficulty_increase %f\n", RP->difficulty_increase);
634 strcat(buf,small_buf); 702 strcat (buf, small_buf);
635 } 703 }
636 704
637 sprintf(small_buf,"dungeon_level %d\n",RP->dungeon_level); 705 sprintf (small_buf, "dungeon_level %d\n", RP->dungeon_level);
638 strcat(buf,small_buf); 706 strcat (buf, small_buf);
639 707
640 if(RP->dungeon_depth) { 708 if (RP->dungeon_depth)
709 {
641 sprintf(small_buf,"dungeon_depth %d\n",RP->dungeon_depth); 710 sprintf (small_buf, "dungeon_depth %d\n", RP->dungeon_depth);
642 strcat(buf,small_buf); 711 strcat (buf, small_buf);
643 } 712 }
644 713
645 if(RP->decoroptions) { 714 if (RP->decoroptions)
715 {
646 sprintf(small_buf,"decoroptions %d\n",RP->decoroptions); 716 sprintf (small_buf, "decoroptions %d\n", RP->decoroptions);
647 strcat(buf,small_buf); 717 strcat (buf, small_buf);
648 } 718 }
649 719
650 if(RP->orientation) { 720 if (RP->orientation)
721 {
651 sprintf(small_buf,"orientation %d\n",RP->orientation); 722 sprintf (small_buf, "orientation %d\n", RP->orientation);
652 strcat(buf,small_buf); 723 strcat (buf, small_buf);
653 } 724 }
654 725
655 if(RP->origin_x) { 726 if (RP->origin_x)
727 {
656 sprintf(small_buf,"origin_x %d\n",RP->origin_x); 728 sprintf (small_buf, "origin_x %d\n", RP->origin_x);
657 strcat(buf,small_buf); 729 strcat (buf, small_buf);
658 } 730 }
659 731
660 if(RP->origin_y) { 732 if (RP->origin_y)
733 {
661 sprintf(small_buf,"origin_y %d\n",RP->origin_y); 734 sprintf (small_buf, "origin_y %d\n", RP->origin_y);
662 strcat(buf,small_buf); 735 strcat (buf, small_buf);
663 } 736 }
737
738 if (RP->treasureoptions)
739 {
740 sprintf (small_buf, "treasureoptions %d\n", RP->treasureoptions);
741 strcat (buf, small_buf);
742 }
743
664 if(RP->random_seed) { 744 if (RP->random_seed)
745 {
746 sprintf (small_buf, "random_seed %u\n", RP->random_seed);
747 strcat (buf, small_buf);
748 }
749
750 if (RP->custom)
751 {
752 sprintf (small_buf, "custom %s\n", RP->custom);
753 strcat (buf, small_buf);
754 }
755}
756
757void
758write_parameters_to_string (char *buf,
759 int xsize_n,
760 int ysize_n,
761 const char *wallstyle_n,
762 const char *floorstyle_n,
763 const char *monsterstyle_n,
764 const char *treasurestyle_n,
765 const char *layoutstyle_n,
766 const char *decorstyle_n,
767 const char *doorstyle_n,
768 const char *exitstyle_n,
769 const char *final_map_n,
770 const char *exit_on_final_map_n,
771 const char *this_map_n,
772 int layoutoptions1_n,
773 int layoutoptions2_n,
774 int layoutoptions3_n,
775 int symmetry_n,
776 int dungeon_depth_n,
777 int dungeon_level_n,
778 int difficulty_n,
779 int difficulty_given_n,
780 int decoroptions_n,
781 int orientation_n,
782 int origin_x_n,
783 int origin_y_n,
784 uint32_t random_seed_n,
785 int treasureoptions_n,
786 float difficulty_increase)
787{
788 char small_buf[16384];
789
790 sprintf (buf, "xsize %d\nysize %d\n", xsize_n, ysize_n);
791
792 if (wallstyle_n && wallstyle_n[0])
793 {
794 sprintf (small_buf, "wallstyle %s\n", wallstyle_n);
795 strcat (buf, small_buf);
796 }
797
798 if (floorstyle_n && floorstyle_n[0])
799 {
800 sprintf (small_buf, "floorstyle %s\n", floorstyle_n);
801 strcat (buf, small_buf);
802 }
803
804 if (monsterstyle_n && monsterstyle_n[0])
805 {
806 sprintf (small_buf, "monsterstyle %s\n", monsterstyle_n);
807 strcat (buf, small_buf);
808 }
809
810 if (treasurestyle_n && treasurestyle_n[0])
811 {
812 sprintf (small_buf, "treasurestyle %s\n", treasurestyle_n);
813 strcat (buf, small_buf);
814 }
815
816 if (layoutstyle_n && layoutstyle_n[0])
817 {
818 sprintf (small_buf, "layoutstyle %s\n", layoutstyle_n);
819 strcat (buf, small_buf);
820 }
821
822 if (decorstyle_n && decorstyle_n[0])
823 {
824 sprintf (small_buf, "decorstyle %s\n", decorstyle_n);
825 strcat (buf, small_buf);
826 }
827
828 if (doorstyle_n && doorstyle_n[0])
829 {
830 sprintf (small_buf, "doorstyle %s\n", doorstyle_n);
831 strcat (buf, small_buf);
832 }
833
834 if (exitstyle_n && exitstyle_n[0])
835 {
836 sprintf (small_buf, "exitstyle %s\n", exitstyle_n);
837 strcat (buf, small_buf);
838 }
839
840 if (final_map_n && final_map_n[0])
841 {
842 sprintf (small_buf, "final_map %s\n", final_map_n);
843 strcat (buf, small_buf);
844 }
845
846 if (exit_on_final_map_n && exit_on_final_map_n[0])
847 {
848 sprintf (small_buf, "exit_on_final_map %s\n", exit_on_final_map_n);
849 strcat (buf, small_buf);
850 }
851
852 if (this_map_n && this_map_n[0])
853 {
854 sprintf (small_buf, "origin_map %s\n", this_map_n);
855 strcat (buf, small_buf);
856 }
857
858 if (layoutoptions1_n)
859 {
860 sprintf (small_buf, "layoutoptions1 %d\n", layoutoptions1_n);
861 strcat (buf, small_buf);
862 }
863
864 if (layoutoptions2_n)
865 {
866 sprintf (small_buf, "layoutoptions2 %d\n", layoutoptions2_n);
867 strcat (buf, small_buf);
868 }
869
870
871 if (layoutoptions3_n)
872 {
873 sprintf (small_buf, "layoutoptions3 %d\n", layoutoptions3_n);
874 strcat (buf, small_buf);
875 }
876
877 if (symmetry_n)
878 {
879 sprintf (small_buf, "symmetry %d\n", symmetry_n);
880 strcat (buf, small_buf);
881 }
882
883
884 if (difficulty_n && difficulty_given_n)
885 {
886 sprintf (small_buf, "difficulty %d\n", difficulty_n);
887 strcat (buf, small_buf);
888 }
889
890 if (difficulty_increase > 0.001)
891 {
892 sprintf (small_buf, "difficulty_increase %f\n", difficulty_increase);
893 strcat (buf, small_buf);
894 }
895
896 sprintf (small_buf, "dungeon_level %d\n", dungeon_level_n);
897 strcat (buf, small_buf);
898
899 if (dungeon_depth_n)
900 {
901 sprintf (small_buf, "dungeon_depth %d\n", dungeon_depth_n);
902 strcat (buf, small_buf);
903 }
904
905 if (decoroptions_n)
906 {
907 sprintf (small_buf, "decoroptions %d\n", decoroptions_n);
908 strcat (buf, small_buf);
909 }
910
911 if (orientation_n)
912 {
913 sprintf (small_buf, "orientation %d\n", orientation_n);
914 strcat (buf, small_buf);
915 }
916
917 if (origin_x_n)
918 {
919 sprintf (small_buf, "origin_x %d\n", origin_x_n);
920 strcat (buf, small_buf);
921 }
922
923 if (origin_y_n)
924 {
925 sprintf (small_buf, "origin_y %d\n", origin_y_n);
926 strcat (buf, small_buf);
927 }
928
929 if (random_seed_n)
930 {
665 /* Add one so that the next map is a bit different */ 931 /* 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); 932 sprintf (small_buf, "random_seed %u\n", random_seed_n + 1);
830 strcat(buf,small_buf); 933 strcat (buf, small_buf);
831 } 934 }
832 935
833 if(treasureoptions_n) { 936 if (treasureoptions_n)
937 {
834 sprintf(small_buf,"treasureoptions %d\n",treasureoptions_n); 938 sprintf (small_buf, "treasureoptions %d\n", treasureoptions_n);
835 strcat(buf,small_buf); 939 strcat (buf, small_buf);
836 } 940 }
837
838
839} 941}
840 942
841/* copy an object with an inventory... i.e., duplicate the inv too. */ 943/////////////////////////////////////////////////////////////////////////////
842void copy_object_with_inv(object *src_ob, object *dest_ob) {
843 object *walk,*tmp;
844 944
845 copy_object(src_ob,dest_ob); 945LayoutData::LayoutData (int w, int h)
946: w(w), h(h)
947{
948 int size = (sizeof (char *) + sizeof (char) * h) * w;
846 949
847 for(walk=src_ob->inv;walk!=NULL;walk=walk->below) { 950 col = (char **)salloc<char> (size);
848 tmp=get_object(); 951
849 copy_object(walk,tmp); 952 char *data = (char *)(col + w);
850 insert_ob_in_ob(tmp,dest_ob); 953
851 } 954 for (int x = w; x--; )
955 col [x] = data + x * h;
852} 956}
957
958LayoutData::~LayoutData ()
959{
960 int size = (sizeof (char *) + sizeof (char) * h) * w;
961
962 sfree ((char *)col, size);
963}
964
965void LayoutData::clear (char fill)
966{
967 memset (col [0], fill, w * h);
968}
969
970void LayoutData::border (char fill)
971{
972 for (int i = 0; i < w; i++) col [i][0] = col [i][h - 1] = fill;
973 for (int j = 0; j < h; j++) col [0][j] = col [w - 1][j] = fill;
974}
975

Diff Legend

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