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

Diff Legend

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