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.9 by root, Thu Dec 14 22:45:40 2006 UTC vs.
Revision 1.23 by root, Fri Jan 19 15:38:01 2007 UTC

1/* 1/*
2 CrossFire, A Multiplayer game for X-windows 2 * CrossFire, A Multiplayer game for X-windows
3 3 *
4 * Copyright (C) 2005, 2006, 2007 Marc Lehmann & Crossfire+ Development Team
4 Copyright (C) 2001 Mark Wedel & Crossfire Development Team 5 * Copyright (C) 2001 Mark Wedel & Crossfire Development Team
5 Copyright (C) 1992 Frank Tore Johansen 6 * Copyright (C) 1992 Frank Tore Johansen
6 7 *
7 This program is free software; you can redistribute it and/or modify 8 * This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by 9 * it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or 10 * the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version. 11 * (at your option) any later version.
11 12 *
12 This program is distributed in the hope that it will be useful, 13 * This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of 14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details. 16 * GNU General Public License for more details.
16 17 *
17 You should have received a copy of the GNU General Public License 18 * You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software 19 * along with this program; if not, write to the Free Software
19 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 20 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
20 21 *
21 The authors can be reached via e-mail at <crossfire@schmorp.de> 22 * The authors can be reached via e-mail at <crossfire@schmorp.de>
22*/ 23 */
23 24
24#include <time.h> 25#include <time.h>
25#include <stdio.h> 26#include <stdio.h>
26#include <global.h> 27#include <global.h>
27#include <maze_gen.h> 28#include <maze_gen.h>
28#include <room_gen.h> 29#include <room_gen.h>
29#include <random_map.h> 30#include <random_map.h>
30#include <rproto.h> 31#include <rproto.h>
31#include <sproto.h> 32#include <sproto.h>
32 33
34#define CEDE coroapi::cede (); rndm.seed (RP->random_seed + __LINE__);
35
33void 36void
34dump_layout (char **layout, RMParms * RP) 37dump_layout (char **layout, random_map_params *RP)
35{ 38{
36 { 39 {
37 int i, j; 40 int i, j;
38 41
39 for (i = 0; i < RP->Xsize; i++) 42 for (i = 0; i < RP->Xsize; i++)
… …
50 } 53 }
51 } 54 }
52 printf ("\n"); 55 printf ("\n");
53} 56}
54 57
55extern FILE *logfile; 58bool
56 59maptile::generate_random_map (random_map_params *RP)
57maptile *
58generate_random_map (const char *OutFileName, RMParms * RP)
59{ 60{
60 char **layout, buf[HUGE_BUF]; 61 char **layout, buf[16384];
61 maptile *theMap;
62 int i; 62 int i;
63 63
64 /* pick a random seed, or use the one from the input file */ 64 /* pick a random seed, or use the one from the input file */
65 if (RP->random_seed == 0) 65 RP->random_seed = RP->random_seed
66 RP->random_seed = time (0); 66 ? RP->random_seed + RP->dungeon_level
67 67 : time (0);
68 SRANDOM (RP->random_seed); 68 CEDE;
69 69
70 write_map_parameters_to_string (buf, RP); 70 write_map_parameters_to_string (buf, RP);
71 71
72 if (RP->difficulty == 0) 72 if (RP->difficulty == 0)
73 { 73 {
… …
81 } 81 }
82 else 82 else
83 RP->difficulty_given = 1; 83 RP->difficulty_given = 1;
84 84
85 if (RP->Xsize < MIN_RANDOM_MAP_SIZE) 85 if (RP->Xsize < MIN_RANDOM_MAP_SIZE)
86 RP->Xsize = MIN_RANDOM_MAP_SIZE + RANDOM () % 25 + 5; 86 RP->Xsize = MIN_RANDOM_MAP_SIZE + rndm (25) + 5;
87 87
88 if (RP->Ysize < MIN_RANDOM_MAP_SIZE) 88 if (RP->Ysize < MIN_RANDOM_MAP_SIZE)
89 RP->Ysize = MIN_RANDOM_MAP_SIZE + RANDOM () % 25 + 5; 89 RP->Ysize = MIN_RANDOM_MAP_SIZE + rndm (25) + 5;
90
91 if (RP->symmetry == SYMMETRY_RANDOM)
92 RP->symmetry_used = (RANDOM () % (SYMMETRY_XY)) + 1;
93 else
94 RP->symmetry_used = RP->symmetry;
95
96 if (RP->symmetry_used == SYMMETRY_Y || RP->symmetry_used == SYMMETRY_XY)
97 RP->Ysize = RP->Ysize / 2 + 1;
98 if (RP->symmetry_used == SYMMETRY_X || RP->symmetry_used == SYMMETRY_XY)
99 RP->Xsize = RP->Xsize / 2 + 1;
90 100
91 if (RP->expand2x > 0) 101 if (RP->expand2x > 0)
92 { 102 {
93 RP->Xsize /= 2; 103 RP->Xsize /= 2;
94 RP->Ysize /= 2; 104 RP->Ysize /= 2;
95 } 105 }
96 106
97 layout = layoutgen (RP);
98
99#ifdef RMAP_DEBUG
100 dump_layout (layout, RP);
101#endif
102
103 /* increment these for the current map */
104 RP->dungeon_level += 1;
105 /* allow constant-difficulty maps. */
106 /* difficulty+=1; */
107
108 /* rotate the layout randomly */
109 layout = rotate_layout (layout, RANDOM () % 4, RP);
110#ifdef RMAP_DEBUG
111 dump_layout (layout, RP);
112#endif
113
114 /* allocate the map and set the floor */
115 theMap = make_map_floor (layout, RP->floorstyle, RP);
116
117 /* set the name of the map. */
118 strcpy (theMap->path, OutFileName);
119
120 /* set region */
121 theMap->region = RP->region;
122
123 /* create walls unless the wallstyle is "none" */
124 if (strcmp (RP->wallstyle, "none"))
125 {
126 make_map_walls (theMap, layout, RP->wallstyle, RP);
127
128 /* place doors unless doorstyle or wallstyle is "none" */
129 if (strcmp (RP->doorstyle, "none"))
130 put_doors (theMap, layout, RP->doorstyle, RP);
131
132 }
133
134 /* create exits unless the exitstyle is "none" */
135 if (strcmp (RP->exitstyle, "none"))
136 place_exits (theMap, layout, RP->exitstyle, RP->orientation, RP);
137
138 place_specials_in_map (theMap, layout, RP);
139
140 /* create monsters unless the monsterstyle is "none" */
141 if (strcmp (RP->monsterstyle, "none"))
142 place_monsters (theMap, RP->monsterstyle, RP->difficulty, RP);
143
144 /* treasures needs to have a proper difficulty set for the map. */
145 theMap->difficulty = calculate_difficulty (theMap);
146
147 /* create treasure unless the treasurestyle is "none" */
148 if (strcmp (RP->treasurestyle, "none"))
149 place_treasure (theMap, layout, RP->treasurestyle, RP->treasureoptions, RP);
150
151 /* create decor unless the decorstyle is "none" */
152 if (strcmp (RP->decorstyle, "none"))
153 put_decor (theMap, layout, RP->decorstyle, RP->decoroptions, RP);
154
155 /* generate treasures, etc. */
156 fix_auto_apply (theMap);
157
158 unblock_exits (theMap, layout, RP);
159
160 /* free the layout */
161 for (i = 0; i < RP->Xsize; i++)
162 free (layout[i]);
163 free (layout);
164
165 theMap->msg = strdup (buf);
166
167 return theMap;
168}
169
170/* function selects the layout function and gives it whatever
171 arguments it needs. */
172char **
173layoutgen (RMParms * RP)
174{
175 char **maze = 0;
176 int oxsize = RP->Xsize, oysize = RP->Ysize;
177
178 if (RP->symmetry == RANDOM_SYM)
179 RP->symmetry_used = (RANDOM () % (XY_SYM)) + 1;
180 else
181 RP->symmetry_used = RP->symmetry;
182
183 if (RP->symmetry_used == Y_SYM || RP->symmetry_used == XY_SYM)
184 RP->Ysize = RP->Ysize / 2 + 1;
185 if (RP->symmetry_used == X_SYM || RP->symmetry_used == XY_SYM)
186 RP->Xsize = RP->Xsize / 2 + 1;
187
188 if (RP->Xsize < MIN_RANDOM_MAP_SIZE)
189 RP->Xsize = MIN_RANDOM_MAP_SIZE + RANDOM () % 5;
190 if (RP->Ysize < MIN_RANDOM_MAP_SIZE)
191 RP->Ysize = MIN_RANDOM_MAP_SIZE + RANDOM () % 5;
192 RP->map_layout_style = 0; 107 RP->map_layout_style = LAYOUT_NONE;
193 108
194 /* Redo this - there was a lot of redundant code of checking for preset 109 /* Redo this - there was a lot of redundant code of checking for preset
195 * layout style and then random layout style. Instead, figure out 110 * layout style and then random layout style. Instead, figure out
196 * the numeric layoutstyle, so there is only one area that actually 111 * the numeric layoutstyle, so there is only one area that actually
197 * calls the code to make the maps. 112 * calls the code to make the maps.
198 */ 113 */
199 if (strstr (RP->layoutstyle, "onion")) 114 if (strstr (RP->layoutstyle, "onion"))
200 {
201 RP->map_layout_style = ONION_LAYOUT; 115 RP->map_layout_style = LAYOUT_ONION;
202 }
203 116
204 if (strstr (RP->layoutstyle, "maze")) 117 if (strstr (RP->layoutstyle, "maze"))
205 {
206 RP->map_layout_style = MAZE_LAYOUT; 118 RP->map_layout_style = LAYOUT_MAZE;
207 }
208 119
209 if (strstr (RP->layoutstyle, "spiral")) 120 if (strstr (RP->layoutstyle, "spiral"))
210 {
211 RP->map_layout_style = SPIRAL_LAYOUT; 121 RP->map_layout_style = LAYOUT_SPIRAL;
212 }
213 122
214 if (strstr (RP->layoutstyle, "rogue")) 123 if (strstr (RP->layoutstyle, "rogue"))
215 {
216 RP->map_layout_style = ROGUELIKE_LAYOUT; 124 RP->map_layout_style = LAYOUT_ROGUELIKE;
217 }
218 125
219 if (strstr (RP->layoutstyle, "snake")) 126 if (strstr (RP->layoutstyle, "snake"))
220 {
221 RP->map_layout_style = SNAKE_LAYOUT; 127 RP->map_layout_style = LAYOUT_SNAKE;
222 }
223 128
224 if (strstr (RP->layoutstyle, "squarespiral")) 129 if (strstr (RP->layoutstyle, "squarespiral"))
225 {
226 RP->map_layout_style = SQUARE_SPIRAL_LAYOUT; 130 RP->map_layout_style = LAYOUT_SQUARE_SPIRAL;
227 } 131
228 /* No style found - choose one ranomdly */ 132 /* No style found - choose one randomly */
229 if (RP->map_layout_style == 0) 133 if (RP->map_layout_style == LAYOUT_NONE)
230 {
231 RP->map_layout_style = (RANDOM () % NROFLAYOUTS) + 1; 134 RP->map_layout_style = (RANDOM () % (NROFLAYOUTS - 1)) + 1;
135
136 layout = layoutgen (RP);
137
138#ifdef RMAP_DEBUG
139 dump_layout (layout, RP);
140#endif
141
142 /* increment these for the current map */
143 RP->dungeon_level += 1;
144 /* allow constant-difficulty maps. */
145 /* difficulty+=1; */
146
147 /* rotate the layout randomly */
148 layout = rotate_layout (layout, rndm (4), RP);
149#ifdef RMAP_DEBUG
150 dump_layout (layout, RP);
151#endif
152
153 /* allocate the map and set the floor */
154 make_map_floor (layout, RP->floorstyle, RP);
155
156 /* set region */
157 region = RP->region;
158
159 CEDE;
160
161 /* create walls unless the wallstyle is "none" */
162 if (strcmp (RP->wallstyle, "none"))
232 } 163 {
164 make_map_walls (this, layout, RP->wallstyle, RP);
165
166 /* place doors unless doorstyle or wallstyle is "none" */
167 if (strcmp (RP->doorstyle, "none"))
168 put_doors (this, layout, RP->doorstyle, RP);
169 }
170
171 CEDE;
172
173 /* create exits unless the exitstyle is "none" */
174 if (strcmp (RP->exitstyle, "none"))
175 place_exits (this, layout, RP->exitstyle, RP->orientation, RP);
176
177 CEDE;
178
179 place_specials_in_map (this, layout, RP);
180
181 CEDE;
182
183 /* create monsters unless the monsterstyle is "none" */
184 if (strcmp (RP->monsterstyle, "none"))
185 place_monsters (this, RP->monsterstyle, RP->difficulty, RP);
186
187 CEDE;
188
189 /* treasures needs to have a proper difficulty set for the map. */
190 difficulty = estimate_difficulty ();
191
192 CEDE;
193
194 /* create treasure unless the treasurestyle is "none" */
195 if (strcmp (RP->treasurestyle, "none"))
196 place_treasure (this, layout, RP->treasurestyle, RP->treasureoptions, RP);
197
198 CEDE;
199
200 /* create decor unless the decorstyle is "none" */
201 if (strcmp (RP->decorstyle, "none"))
202 put_decor (this, layout, RP->decorstyle, RP->decoroptions, RP);
203
204 CEDE;
205
206 /* generate treasures, etc. */
207 fix_auto_apply ();
208
209 CEDE;
210
211 unblock_exits (this, layout, RP);
212
213 /* free the layout */
214 for (i = 0; i < RP->Xsize; i++)
215 free (layout[i]);
216
217 free (layout);
218
219 msg = strdup (buf);
220 in_memory = MAP_IN_MEMORY;
221
222 CEDE;
223
224 return 1;
225}
226
227/* function selects the layout function and gives it whatever
228 arguments it needs. */
229char **
230layoutgen (random_map_params *RP)
231{
232 char **maze = 0;
233 int oxsize = RP->Xsize, oysize = RP->Ysize;
233 234
234 switch (RP->map_layout_style) 235 switch (RP->map_layout_style)
235 { 236 {
236 237 case LAYOUT_ONION:
237 case ONION_LAYOUT:
238 maze = map_gen_onion (RP->Xsize, RP->Ysize, RP->layoutoptions1, RP->layoutoptions2); 238 maze = map_gen_onion (RP->Xsize, RP->Ysize, RP->layoutoptions1, RP->layoutoptions2);
239 if (!(RANDOM () % 3) && !(RP->layoutoptions1 & OPT_WALLS_ONLY)) 239 if (!(rndm (3)) && !(RP->layoutoptions1 & RMOPT_WALLS_ONLY))
240 roomify_layout (maze, RP); 240 roomify_layout (maze, RP);
241 break; 241 break;
242 242
243 case MAZE_LAYOUT: 243 case LAYOUT_MAZE:
244 maze = maze_gen (RP->Xsize, RP->Ysize, RANDOM () % 2); 244 maze = maze_gen (RP->Xsize, RP->Ysize, rndm (2));
245 if (!(RANDOM () % 2)) 245 if (!(rndm (2)))
246 doorify_layout (maze, RP); 246 doorify_layout (maze, RP);
247 break; 247 break;
248 248
249 case SPIRAL_LAYOUT: 249 case LAYOUT_SPIRAL:
250 maze = map_gen_spiral (RP->Xsize, RP->Ysize, RP->layoutoptions1); 250 maze = map_gen_spiral (RP->Xsize, RP->Ysize, RP->layoutoptions1);
251 if (!(RANDOM () % 2)) 251 if (!(rndm (2)))
252 doorify_layout (maze, RP); 252 doorify_layout (maze, RP);
253 break; 253 break;
254 254
255 case ROGUELIKE_LAYOUT: 255 case LAYOUT_ROGUELIKE:
256 /* Don't put symmetry in rogue maps. There isn't much reason to 256 /* Don't put symmetry in rogue maps. There isn't much reason to
257 * do so in the first place (doesn't make it any more interesting), 257 * do so in the first place (doesn't make it any more interesting),
258 * but more importantly, the symmetry code presumes we are symmetrizing 258 * but more importantly, the symmetry code presumes we are symmetrizing
259 * spirals, or maps with lots of passages - making a symmetric rogue 259 * spirals, or maps with lots of passages - making a symmetric rogue
260 * map fails because its likely that the passages the symmetry process 260 * map fails because its likely that the passages the symmetry process
261 * creates may not connect the rooms. 261 * creates may not connect the rooms.
262 */ 262 */
263 RP->symmetry_used = NO_SYM; 263 RP->symmetry_used = SYMMETRY_NONE;
264 RP->Ysize = oysize; 264 RP->Ysize = oysize;
265 RP->Xsize = oxsize; 265 RP->Xsize = oxsize;
266 maze = roguelike_layout_gen (RP->Xsize, RP->Ysize, RP->layoutoptions1); 266 maze = roguelike_layout_gen (RP->Xsize, RP->Ysize, RP->layoutoptions1);
267 /* no doorifying... done already */ 267 /* no doorifying... done already */
268 break; 268 break;
269 269
270 case SNAKE_LAYOUT: 270 case LAYOUT_SNAKE:
271 maze = make_snake_layout (RP->Xsize, RP->Ysize, RP->layoutoptions1); 271 maze = make_snake_layout (RP->Xsize, RP->Ysize, RP->layoutoptions1);
272 if (RANDOM () % 2) 272 if (rndm (2))
273 roomify_layout (maze, RP); 273 roomify_layout (maze, RP);
274 break; 274 break;
275 275
276 case SQUARE_SPIRAL_LAYOUT: 276 case LAYOUT_SQUARE_SPIRAL:
277 maze = make_square_spiral_layout (RP->Xsize, RP->Ysize, RP->layoutoptions1); 277 maze = make_square_spiral_layout (RP->Xsize, RP->Ysize, RP->layoutoptions1);
278 if (RANDOM () % 2) 278 if (rndm (2))
279 roomify_layout (maze, RP); 279 roomify_layout (maze, RP);
280 break; 280 break;
281 } 281 }
282 282
283 maze = symmetrize_layout (maze, RP->symmetry_used, RP); 283 maze = symmetrize_layout (maze, RP->symmetry_used, RP);
284
284#ifdef RMAP_DEBUG 285#ifdef RMAP_DEBUG
285 dump_layout (maze, RP); 286 dump_layout (maze, RP);
286#endif 287#endif
288
287 if (RP->expand2x) 289 if (RP->expand2x)
288 { 290 {
289 maze = expand2x (maze, RP->Xsize, RP->Ysize); 291 maze = expand2x (maze, RP->Xsize, RP->Ysize);
290 RP->Xsize = RP->Xsize * 2 - 1; 292 RP->Xsize = RP->Xsize * 2 - 1;
291 RP->Ysize = RP->Ysize * 2 - 1; 293 RP->Ysize = RP->Ysize * 2 - 1;
292 } 294 }
295
293 return maze; 296 return maze;
294} 297}
295
296 298
297/* takes a map and makes it symmetric: adjusts Xsize and 299/* takes a map and makes it symmetric: adjusts Xsize and
298Ysize to produce a symmetric map. */ 300Ysize to produce a symmetric map. */
299
300char ** 301char **
301symmetrize_layout (char **maze, int sym, RMParms * RP) 302symmetrize_layout (char **maze, int sym, random_map_params *RP)
302{ 303{
303 int i, j; 304 int i, j;
304 char **sym_maze; 305 char **sym_maze;
305 int Xsize_orig, Ysize_orig; 306 int Xsize_orig, Ysize_orig;
306 307
307 Xsize_orig = RP->Xsize; 308 Xsize_orig = RP->Xsize;
308 Ysize_orig = RP->Ysize; 309 Ysize_orig = RP->Ysize;
309 RP->symmetry_used = sym; /* tell everyone else what sort of symmetry is used. */ 310 RP->symmetry_used = sym; /* tell everyone else what sort of symmetry is used. */
310 if (sym == NO_SYM) 311 if (sym == SYMMETRY_NONE)
311 { 312 {
312 RP->Xsize = Xsize_orig; 313 RP->Xsize = Xsize_orig;
313 RP->Ysize = Ysize_orig; 314 RP->Ysize = Ysize_orig;
314 return maze; 315 return maze;
315 } 316 }
316 /* pick new sizes */ 317 /* pick new sizes */
317 RP->Xsize = ((sym == X_SYM || sym == XY_SYM) ? RP->Xsize * 2 - 3 : RP->Xsize); 318 RP->Xsize = ((sym == SYMMETRY_X || sym == SYMMETRY_XY) ? RP->Xsize * 2 - 3 : RP->Xsize);
318 RP->Ysize = ((sym == Y_SYM || sym == XY_SYM) ? RP->Ysize * 2 - 3 : RP->Ysize); 319 RP->Ysize = ((sym == SYMMETRY_Y || sym == SYMMETRY_XY) ? RP->Ysize * 2 - 3 : RP->Ysize);
319 320
320 sym_maze = (char **) calloc (sizeof (char *), RP->Xsize); 321 sym_maze = (char **) calloc (sizeof (char *), RP->Xsize);
321 for (i = 0; i < RP->Xsize; i++) 322 for (i = 0; i < RP->Xsize; i++)
322 sym_maze[i] = (char *) calloc (sizeof (char), RP->Ysize); 323 sym_maze[i] = (char *) calloc (sizeof (char), RP->Ysize);
323 324
324 if (sym == X_SYM) 325 if (sym == SYMMETRY_X)
325 for (i = 0; i < RP->Xsize / 2 + 1; i++) 326 for (i = 0; i < RP->Xsize / 2 + 1; i++)
326 for (j = 0; j < RP->Ysize; j++) 327 for (j = 0; j < RP->Ysize; j++)
327 { 328 {
328 sym_maze[i][j] = maze[i][j]; 329 sym_maze[i][j] = maze[i][j];
329 sym_maze[RP->Xsize - i - 1][j] = maze[i][j]; 330 sym_maze[RP->Xsize - i - 1][j] = maze[i][j];
330 }; 331 };
331 if (sym == Y_SYM) 332 if (sym == SYMMETRY_Y)
332 for (i = 0; i < RP->Xsize; i++) 333 for (i = 0; i < RP->Xsize; i++)
333 for (j = 0; j < RP->Ysize / 2 + 1; j++) 334 for (j = 0; j < RP->Ysize / 2 + 1; j++)
334 { 335 {
335 sym_maze[i][j] = maze[i][j]; 336 sym_maze[i][j] = maze[i][j];
336 sym_maze[i][RP->Ysize - j - 1] = maze[i][j]; 337 sym_maze[i][RP->Ysize - j - 1] = maze[i][j];
337 } 338 }
338 if (sym == XY_SYM) 339 if (sym == SYMMETRY_XY)
339 for (i = 0; i < RP->Xsize / 2 + 1; i++) 340 for (i = 0; i < RP->Xsize / 2 + 1; i++)
340 for (j = 0; j < RP->Ysize / 2 + 1; j++) 341 for (j = 0; j < RP->Ysize / 2 + 1; j++)
341 { 342 {
342 sym_maze[i][j] = maze[i][j]; 343 sym_maze[i][j] = maze[i][j];
343 sym_maze[i][RP->Ysize - j - 1] = maze[i][j]; 344 sym_maze[i][RP->Ysize - j - 1] = maze[i][j];
… …
347 /* delete the old maze */ 348 /* delete the old maze */
348 for (i = 0; i < Xsize_orig; i++) 349 for (i = 0; i < Xsize_orig; i++)
349 free (maze[i]); 350 free (maze[i]);
350 free (maze); 351 free (maze);
351 /* reconnect disjointed spirals */ 352 /* reconnect disjointed spirals */
352 if (RP->map_layout_style == SPIRAL_LAYOUT) 353 if (RP->map_layout_style == LAYOUT_SPIRAL)
353 connect_spirals (RP->Xsize, RP->Ysize, sym, sym_maze); 354 connect_spirals (RP->Xsize, RP->Ysize, sym, sym_maze);
354 /* reconnect disjointed nethackmazes: the routine for 355 /* reconnect disjointed nethackmazes: the routine for
355 spirals will do the trick? */ 356 spirals will do the trick? */
356 if (RP->map_layout_style == ROGUELIKE_LAYOUT) 357 if (RP->map_layout_style == LAYOUT_ROGUELIKE)
357 connect_spirals (RP->Xsize, RP->Ysize, sym, sym_maze); 358 connect_spirals (RP->Xsize, RP->Ysize, sym, sym_maze);
358 359
359 return sym_maze; 360 return sym_maze;
360} 361}
361 362
… …
364 onion layouts, making them possibly centered on any wall. 365 onion layouts, making them possibly centered on any wall.
365 It'll modify Xsize and Ysize if they're swapped. 366 It'll modify Xsize and Ysize if they're swapped.
366*/ 367*/
367 368
368char ** 369char **
369rotate_layout (char **maze, int rotation, RMParms * RP) 370rotate_layout (char **maze, int rotation, random_map_params *RP)
370{ 371{
371 char **new_maze; 372 char **new_maze;
372 int i, j; 373 int i, j;
373 374
374 switch (rotation) 375 switch (rotation)
375 { 376 {
376 case 0: 377 case 0:
378 return maze;
379 break;
380 case 2: /* a reflection */
381 {
382 char *newmaze = (char *) malloc (sizeof (char) * RP->Xsize * RP->Ysize);
383
384 for (i = 0; i < RP->Xsize; i++)
385 { /* make a copy */
386 for (j = 0; j < RP->Ysize; j++)
387 {
388 newmaze[i * RP->Ysize + j] = maze[i][j];
389 }
390 }
391 for (i = 0; i < RP->Xsize; i++)
392 { /* copy a reflection back */
393 for (j = 0; j < RP->Ysize; j++)
394 {
395 maze[i][j] = newmaze[(RP->Xsize - i - 1) * RP->Ysize + RP->Ysize - j - 1];
396 }
397 }
398 free (newmaze);
377 return maze; 399 return maze;
378 break; 400 break;
379 case 2: /* a reflection */ 401 }
402 case 1:
403 case 3:
404 {
405 int swap;
406 new_maze = (char **) calloc (sizeof (char *), RP->Ysize);
407 for (i = 0; i < RP->Ysize; i++)
380 { 408 {
381 char *newmaze = (char *) malloc (sizeof (char) * RP->Xsize * RP->Ysize); 409 new_maze[i] = (char *) calloc (sizeof (char), RP->Xsize);
382 410 }
411 if (rotation == 1) /* swap x and y */
383 for (i = 0; i < RP->Xsize; i++) 412 for (i = 0; i < RP->Xsize; i++)
384 { /* make a copy */
385 for (j = 0; j < RP->Ysize; j++) 413 for (j = 0; j < RP->Ysize; j++)
386 {
387 newmaze[i * RP->Ysize + j] = maze[i][j]; 414 new_maze[j][i] = maze[i][j];
388 } 415
389 } 416 if (rotation == 3)
390 for (i = 0; i < RP->Xsize; i++) 417 { /* swap x and y */
391 { /* copy a reflection back */
392 for (j = 0; j < RP->Ysize; j++)
393 {
394 maze[i][j] = newmaze[(RP->Xsize - i - 1) * RP->Ysize + RP->Ysize - j - 1];
395 }
396 }
397 free (newmaze);
398 return maze;
399 break;
400 }
401 case 1:
402 case 3:
403 {
404 int swap;
405 new_maze = (char **) calloc (sizeof (char *), RP->Ysize);
406 for (i = 0; i < RP->Ysize; i++)
407 {
408 new_maze[i] = (char *) calloc (sizeof (char), RP->Xsize);
409 }
410 if (rotation == 1) /* swap x and y */
411 for (i = 0; i < RP->Xsize; i++) 418 for (i = 0; i < RP->Xsize; i++)
412 for (j = 0; j < RP->Ysize; j++) 419 for (j = 0; j < RP->Ysize; j++)
413 new_maze[j][i] = maze[i][j];
414
415 if (rotation == 3)
416 { /* swap x and y */
417 for (i = 0; i < RP->Xsize; i++)
418 for (j = 0; j < RP->Ysize; j++)
419 new_maze[j][i] = maze[RP->Xsize - i - 1][RP->Ysize - j - 1]; 420 new_maze[j][i] = maze[RP->Xsize - i - 1][RP->Ysize - j - 1];
420 } 421 }
421 422
422 /* delete the old layout */ 423 /* delete the old layout */
423 for (i = 0; i < RP->Xsize; i++) 424 for (i = 0; i < RP->Xsize; i++)
424 free (maze[i]); 425 free (maze[i]);
425 free (maze); 426 free (maze);
426 427
427 swap = RP->Ysize; 428 swap = RP->Ysize;
428 RP->Ysize = RP->Xsize; 429 RP->Ysize = RP->Xsize;
429 RP->Xsize = swap; 430 RP->Xsize = swap;
430 return new_maze; 431 return new_maze;
431 break; 432 break;
432 } 433 }
433 } 434 }
434 return NULL; 435 return NULL;
435} 436}
436 437
437/* take a layout and make some rooms in it. 438/* take a layout and make some rooms in it.
438 --works best on onions.*/ 439 --works best on onions.*/
439void 440void
440roomify_layout (char **maze, RMParms * RP) 441roomify_layout (char **maze, random_map_params *RP)
441{ 442{
442 int tries = RP->Xsize * RP->Ysize / 30; 443 int tries = RP->Xsize * RP->Ysize / 30;
443 int ti; 444 int ti;
444 445
445 for (ti = 0; ti < tries; ti++) 446 for (ti = 0; ti < tries; ti++)
… …
472/* checks the layout to see if I can stick a horizontal(dir = 0) wall 473/* checks the layout to see if I can stick a horizontal(dir = 0) wall
473 (or vertical, dir == 1) 474 (or vertical, dir == 1)
474 here which ends up on other walls sensibly. */ 475 here which ends up on other walls sensibly. */
475 476
476int 477int
477can_make_wall (char **maze, int dx, int dy, int dir, RMParms * RP) 478can_make_wall (char **maze, int dx, int dy, int dir, random_map_params *RP)
478{ 479{
479 int i1; 480 int i1;
480 int length = 0; 481 int length = 0;
481 482
482 /* dont make walls if we're on the edge. */ 483 /* dont make walls if we're on the edge. */
… …
557make_wall (char **maze, int x, int y, int dir) 558make_wall (char **maze, int x, int y, int dir)
558{ 559{
559 maze[x][y] = 'D'; /* mark a door */ 560 maze[x][y] = 'D'; /* mark a door */
560 switch (dir) 561 switch (dir)
561 { 562 {
562 case 0: /* horizontal */ 563 case 0: /* horizontal */
563 { 564 {
564 int i1; 565 int i1;
565 566
566 for (i1 = x - 1; maze[i1][y] == 0; i1--) 567 for (i1 = x - 1; maze[i1][y] == 0; i1--)
567 maze[i1][y] = '#'; 568 maze[i1][y] = '#';
568 for (i1 = x + 1; maze[i1][y] == 0; i1++) 569 for (i1 = x + 1; maze[i1][y] == 0; i1++)
569 maze[i1][y] = '#'; 570 maze[i1][y] = '#';
570 break; 571 break;
571 } 572 }
572 case 1: /* vertical */ 573 case 1: /* vertical */
573 { 574 {
574 int i1; 575 int i1;
575 576
576 for (i1 = y - 1; maze[x][i1] == 0; i1--) 577 for (i1 = y - 1; maze[x][i1] == 0; i1--)
577 maze[x][i1] = '#'; 578 maze[x][i1] = '#';
578 for (i1 = y + 1; maze[x][i1] == 0; i1++) 579 for (i1 = y + 1; maze[x][i1] == 0; i1++)
579 maze[x][i1] = '#'; 580 maze[x][i1] = '#';
580 break; 581 break;
581 } 582 }
582 } 583 }
583 584
584 return 0; 585 return 0;
585} 586}
586 587
587/* puts doors at appropriate locations in a layout. */ 588/* puts doors at appropriate locations in a layout. */
588
589void 589void
590doorify_layout (char **maze, RMParms * RP) 590doorify_layout (char **maze, random_map_params *RP)
591{ 591{
592 int ndoors = RP->Xsize * RP->Ysize / 60; /* reasonable number of doors. */ 592 int ndoors = RP->Xsize * RP->Ysize / 60; /* reasonable number of doors. */
593 char *doorlist_x; 593 char *doorlist_x;
594 char *doorlist_y; 594 char *doorlist_y;
595 int doorlocs = 0; /* # of available doorlocations */ 595 int doorlocs = 0; /* # of available doorlocations */
… …
610 doorlist_x[doorlocs] = i; 610 doorlist_x[doorlocs] = i;
611 doorlist_y[doorlocs] = j; 611 doorlist_y[doorlocs] = j;
612 doorlocs++; 612 doorlocs++;
613 } 613 }
614 } 614 }
615
615 while (ndoors > 0 && doorlocs > 0) 616 while (ndoors > 0 && doorlocs > 0)
616 { 617 {
617 int di; 618 int di;
618 int sindex; 619 int sindex;
619 620
… …
629 /* reduce the size of the list */ 630 /* reduce the size of the list */
630 doorlocs--; 631 doorlocs--;
631 doorlist_x[di] = doorlist_x[doorlocs]; 632 doorlist_x[di] = doorlist_x[doorlocs];
632 doorlist_y[di] = doorlist_y[doorlocs]; 633 doorlist_y[di] = doorlist_y[doorlocs];
633 } 634 }
635
634 free (doorlist_x); 636 free (doorlist_x);
635 free (doorlist_y); 637 free (doorlist_y);
636} 638}
637 639
638
639void 640void
640write_map_parameters_to_string (char *buf, RMParms * RP) 641write_map_parameters_to_string (char *buf, random_map_params *RP)
641{ 642{
642
643 char small_buf[256]; 643 char small_buf[16384];
644 644
645 sprintf (buf, "xsize %d\nysize %d\n", RP->Xsize, RP->Ysize); 645 sprintf (buf, "xsize %d\nysize %d\n", RP->Xsize, RP->Ysize);
646 646
647 if (RP->wallstyle[0]) 647 if (RP->wallstyle[0])
648 { 648 {
… …
690 { 690 {
691 sprintf (small_buf, "exitstyle %s\n", RP->exitstyle); 691 sprintf (small_buf, "exitstyle %s\n", RP->exitstyle);
692 strcat (buf, small_buf); 692 strcat (buf, small_buf);
693 } 693 }
694 694
695 if (RP->final_map[0]) 695 if (RP->final_map.length ())
696 { 696 {
697 sprintf (small_buf, "final_map %s\n", RP->final_map); 697 sprintf (small_buf, "final_map %s\n", &RP->final_map);
698 strcat (buf, small_buf); 698 strcat (buf, small_buf);
699 } 699 }
700 700
701 if (RP->exit_on_final_map[0]) 701 if (RP->exit_on_final_map[0])
702 { 702 {
703 sprintf (small_buf, "exit_on_final_map %s\n", RP->exit_on_final_map); 703 sprintf (small_buf, "exit_on_final_map %s\n", RP->exit_on_final_map);
704 strcat (buf, small_buf); 704 strcat (buf, small_buf);
705 } 705 }
706 706
707 if (RP->this_map[0]) 707 if (RP->this_map.length ())
708 { 708 {
709 sprintf (small_buf, "origin_map %s\n", RP->this_map); 709 sprintf (small_buf, "origin_map %s\n", &RP->this_map);
710 strcat (buf, small_buf); 710 strcat (buf, small_buf);
711 } 711 }
712 712
713 if (RP->expand2x) 713 if (RP->expand2x)
714 { 714 {
… …
720 { 720 {
721 sprintf (small_buf, "layoutoptions1 %d\n", RP->layoutoptions1); 721 sprintf (small_buf, "layoutoptions1 %d\n", RP->layoutoptions1);
722 strcat (buf, small_buf); 722 strcat (buf, small_buf);
723 } 723 }
724 724
725
726 if (RP->layoutoptions2) 725 if (RP->layoutoptions2)
727 { 726 {
728 sprintf (small_buf, "layoutoptions2 %d\n", RP->layoutoptions2); 727 sprintf (small_buf, "layoutoptions2 %d\n", RP->layoutoptions2);
729 strcat (buf, small_buf); 728 strcat (buf, small_buf);
730 } 729 }
731 730
732
733 if (RP->layoutoptions3) 731 if (RP->layoutoptions3)
734 { 732 {
735 sprintf (small_buf, "layoutoptions3 %d\n", RP->layoutoptions3); 733 sprintf (small_buf, "layoutoptions3 %d\n", RP->layoutoptions3);
736 strcat (buf, small_buf); 734 strcat (buf, small_buf);
737 } 735 }
… …
739 if (RP->symmetry) 737 if (RP->symmetry)
740 { 738 {
741 sprintf (small_buf, "symmetry %d\n", RP->symmetry); 739 sprintf (small_buf, "symmetry %d\n", RP->symmetry);
742 strcat (buf, small_buf); 740 strcat (buf, small_buf);
743 } 741 }
744
745 742
746 if (RP->difficulty && RP->difficulty_given) 743 if (RP->difficulty && RP->difficulty_given)
747 { 744 {
748 sprintf (small_buf, "difficulty %d\n", RP->difficulty); 745 sprintf (small_buf, "difficulty %d\n", RP->difficulty);
749 strcat (buf, small_buf); 746 strcat (buf, small_buf);
… …
785 if (RP->origin_y) 782 if (RP->origin_y)
786 { 783 {
787 sprintf (small_buf, "origin_y %d\n", RP->origin_y); 784 sprintf (small_buf, "origin_y %d\n", RP->origin_y);
788 strcat (buf, small_buf); 785 strcat (buf, small_buf);
789 } 786 }
787
788 if (RP->treasureoptions)
789 {
790 sprintf (small_buf, "treasureoptions %d\n", RP->treasureoptions);
791 strcat (buf, small_buf);
792 }
793
790 if (RP->random_seed) 794 if (RP->random_seed)
791 { 795 {
792 /* Add one so that the next map is a bit different */
793 sprintf (small_buf, "random_seed %d\n", RP->random_seed + 1); 796 sprintf (small_buf, "random_seed %d\n", RP->random_seed);
794 strcat (buf, small_buf); 797 strcat (buf, small_buf);
795 }
796
797 if (RP->treasureoptions)
798 { 798 }
799 sprintf (small_buf, "treasureoptions %d\n", RP->treasureoptions); 799
800 strcat (buf, small_buf); 800 if (RP->custom)
801 } 801 {
802 802 sprintf (small_buf, "custom %s\n", RP->custom);
803 803 strcat (buf, small_buf);
804 }
804} 805}
805 806
806void 807void
807write_parameters_to_string (char *buf, 808write_parameters_to_string (char *buf,
808 int xsize_n, 809 int xsize_n,
… …
828 int difficulty_given_n, 829 int difficulty_given_n,
829 int decoroptions_n, 830 int decoroptions_n,
830 int orientation_n, 831 int orientation_n,
831 int origin_x_n, int origin_y_n, int random_seed_n, int treasureoptions_n, float difficulty_increase) 832 int origin_x_n, int origin_y_n, int random_seed_n, int treasureoptions_n, float difficulty_increase)
832{ 833{
833
834 char small_buf[256]; 834 char small_buf[16384];
835 835
836 sprintf (buf, "xsize %d\nysize %d\n", xsize_n, ysize_n); 836 sprintf (buf, "xsize %d\nysize %d\n", xsize_n, ysize_n);
837 837
838 if (wallstyle_n && wallstyle_n[0]) 838 if (wallstyle_n && wallstyle_n[0])
839 { 839 {
… …
904 if (layoutoptions1_n) 904 if (layoutoptions1_n)
905 { 905 {
906 sprintf (small_buf, "layoutoptions1 %d\n", layoutoptions1_n); 906 sprintf (small_buf, "layoutoptions1 %d\n", layoutoptions1_n);
907 strcat (buf, small_buf); 907 strcat (buf, small_buf);
908 } 908 }
909
910 909
911 if (layoutoptions2_n) 910 if (layoutoptions2_n)
912 { 911 {
913 sprintf (small_buf, "layoutoptions2 %d\n", layoutoptions2_n); 912 sprintf (small_buf, "layoutoptions2 %d\n", layoutoptions2_n);
914 strcat (buf, small_buf); 913 strcat (buf, small_buf);
… …
970 if (origin_y_n) 969 if (origin_y_n)
971 { 970 {
972 sprintf (small_buf, "origin_y %d\n", origin_y_n); 971 sprintf (small_buf, "origin_y %d\n", origin_y_n);
973 strcat (buf, small_buf); 972 strcat (buf, small_buf);
974 } 973 }
974
975 if (random_seed_n) 975 if (random_seed_n)
976 { 976 {
977 /* Add one so that the next map is a bit different */ 977 /* Add one so that the next map is a bit different */
978 sprintf (small_buf, "random_seed %d\n", random_seed_n + 1); 978 sprintf (small_buf, "random_seed %d\n", random_seed_n + 1);
979 strcat (buf, small_buf); 979 strcat (buf, small_buf);
… …
982 if (treasureoptions_n) 982 if (treasureoptions_n)
983 { 983 {
984 sprintf (small_buf, "treasureoptions %d\n", treasureoptions_n); 984 sprintf (small_buf, "treasureoptions %d\n", treasureoptions_n);
985 strcat (buf, small_buf); 985 strcat (buf, small_buf);
986 } 986 }
987
988
989} 987}
990 988
991/* copy an object with an inventory... i.e., duplicate the inv too. */ 989/* copy an object with an inventory... i.e., duplicate the inv too. */
992void 990void
993copy_object_with_inv (object *src_ob, object *dest_ob) 991copy_object_with_inv (object *src_ob, object *dest_ob)
994{ 992{
995 object *walk, *tmp; 993 object *walk, *tmp;
996 994
997 src_ob->copy_to (dest_ob); 995 src_ob->copy_to (dest_ob);
998 996
999 for (walk = src_ob->inv; walk != NULL; walk = walk->below) 997 for (walk = src_ob->inv; walk; walk = walk->below)
1000 { 998 {
1001 tmp = object::create (); 999 tmp = object::create ();
1000
1002 walk->copy_to (tmp); 1001 walk->copy_to (tmp);
1003 insert_ob_in_ob (tmp, dest_ob); 1002 insert_ob_in_ob (tmp, dest_ob);
1004 } 1003 }
1005} 1004}

Diff Legend

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