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.41 by root, Thu May 8 13:47:19 2008 UTC

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

Diff Legend

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