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.8 by root, Wed Dec 13 21:27:09 2006 UTC vs.
Revision 1.28 by root, Sun Mar 18 03:05:40 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 RP->Xsize = RP->xsize;
65 RP->Ysize = RP->ysize;
66
64 /* pick a random seed, or use the one from the input file */ 67 /* pick a random seed, or use the one from the input file */
65 if (RP->random_seed == 0) 68 RP->random_seed = RP->random_seed
66 RP->random_seed = time (0); 69 ? RP->random_seed + RP->dungeon_level
67 70 : time (0);
68 SRANDOM (RP->random_seed); 71 CEDE;
69 72
70 write_map_parameters_to_string (buf, RP); 73 write_map_parameters_to_string (buf, RP);
71 74
72 if (RP->difficulty == 0) 75 if (RP->difficulty == 0)
73 { 76 {
… …
81 } 84 }
82 else 85 else
83 RP->difficulty_given = 1; 86 RP->difficulty_given = 1;
84 87
85 if (RP->Xsize < MIN_RANDOM_MAP_SIZE) 88 if (RP->Xsize < MIN_RANDOM_MAP_SIZE)
86 RP->Xsize = MIN_RANDOM_MAP_SIZE + RANDOM () % 25 + 5; 89 RP->Xsize = MIN_RANDOM_MAP_SIZE + rndm (25) + 5;
87 90
88 if (RP->Ysize < MIN_RANDOM_MAP_SIZE) 91 if (RP->Ysize < MIN_RANDOM_MAP_SIZE)
89 RP->Ysize = MIN_RANDOM_MAP_SIZE + RANDOM () % 25 + 5; 92 RP->Ysize = MIN_RANDOM_MAP_SIZE + rndm (25) + 5;
93
94 if (RP->symmetry == SYMMETRY_RANDOM)
95 RP->symmetry_used = rndm (SYMMETRY_XY) + 1;
96 else
97 RP->symmetry_used = RP->symmetry;
98
99 if (RP->symmetry_used == SYMMETRY_Y || RP->symmetry_used == SYMMETRY_XY)
100 RP->Ysize = RP->Ysize / 2 + 1;
101
102 if (RP->symmetry_used == SYMMETRY_X || RP->symmetry_used == SYMMETRY_XY)
103 RP->Xsize = RP->Xsize / 2 + 1;
90 104
91 if (RP->expand2x > 0) 105 if (RP->expand2x > 0)
92 { 106 {
93 RP->Xsize /= 2; 107 RP->Xsize /= 2;
94 RP->Ysize /= 2; 108 RP->Ysize /= 2;
95 } 109 }
96 110
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_local (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; 111 RP->map_layout_style = LAYOUT_NONE;
193 112
194 /* Redo this - there was a lot of redundant code of checking for preset 113 /* Redo this - there was a lot of redundant code of checking for preset
195 * layout style and then random layout style. Instead, figure out 114 * layout style and then random layout style. Instead, figure out
196 * the numeric layoutstyle, so there is only one area that actually 115 * the numeric layoutstyle, so there is only one area that actually
197 * calls the code to make the maps. 116 * calls the code to make the maps.
198 */ 117 */
199 if (strstr (RP->layoutstyle, "onion")) 118 if (strstr (RP->layoutstyle, "onion"))
200 {
201 RP->map_layout_style = ONION_LAYOUT; 119 RP->map_layout_style = LAYOUT_ONION;
202 }
203 120
204 if (strstr (RP->layoutstyle, "maze")) 121 if (strstr (RP->layoutstyle, "maze"))
205 {
206 RP->map_layout_style = MAZE_LAYOUT; 122 RP->map_layout_style = LAYOUT_MAZE;
207 }
208 123
209 if (strstr (RP->layoutstyle, "spiral")) 124 if (strstr (RP->layoutstyle, "spiral"))
210 {
211 RP->map_layout_style = SPIRAL_LAYOUT; 125 RP->map_layout_style = LAYOUT_SPIRAL;
212 }
213 126
214 if (strstr (RP->layoutstyle, "rogue")) 127 if (strstr (RP->layoutstyle, "rogue"))
215 {
216 RP->map_layout_style = ROGUELIKE_LAYOUT; 128 RP->map_layout_style = LAYOUT_ROGUELIKE;
217 }
218 129
219 if (strstr (RP->layoutstyle, "snake")) 130 if (strstr (RP->layoutstyle, "snake"))
220 {
221 RP->map_layout_style = SNAKE_LAYOUT; 131 RP->map_layout_style = LAYOUT_SNAKE;
222 }
223 132
224 if (strstr (RP->layoutstyle, "squarespiral")) 133 if (strstr (RP->layoutstyle, "squarespiral"))
225 {
226 RP->map_layout_style = SQUARE_SPIRAL_LAYOUT; 134 RP->map_layout_style = LAYOUT_SQUARE_SPIRAL;
227 } 135
228 /* No style found - choose one ranomdly */ 136 /* No style found - choose one randomly */
229 if (RP->map_layout_style == 0) 137 if (RP->map_layout_style == LAYOUT_NONE)
230 {
231 RP->map_layout_style = (RANDOM () % NROFLAYOUTS) + 1; 138 RP->map_layout_style = rndm (NROFLAYOUTS - 1) + 1;
139
140 layout = layoutgen (RP);
141
142#ifdef RMAP_DEBUG
143 dump_layout (layout, RP);
144#endif
145
146 /* increment these for the current map */
147 RP->dungeon_level += 1;
148 /* allow constant-difficulty maps. */
149 /* difficulty+=1; */
150
151 /* rotate the layout randomly */
152 layout = rotate_layout (layout, rndm (4), RP);
153#ifdef RMAP_DEBUG
154 dump_layout (layout, RP);
155#endif
156
157 /* allocate the map and set the floor */
158 make_map_floor (layout, RP->floorstyle, RP);
159
160 /* set region */
161 default_region = RP->region;
162
163 CEDE;
164
165 /* create walls unless the wallstyle is "none" */
166 if (strcmp (RP->wallstyle, "none"))
232 } 167 {
168 make_map_walls (this, layout, RP->wallstyle, RP);
169
170 /* place doors unless doorstyle or wallstyle is "none" */
171 if (strcmp (RP->doorstyle, "none"))
172 put_doors (this, layout, RP->doorstyle, RP);
173 }
174
175 CEDE;
176
177 /* create exits unless the exitstyle is "none" */
178 if (strcmp (RP->exitstyle, "none"))
179 place_exits (this, layout, RP->exitstyle, RP->orientation, RP);
180
181 CEDE;
182
183 place_specials_in_map (this, layout, RP);
184
185 CEDE;
186
187 /* create monsters unless the monsterstyle is "none" */
188 if (strcmp (RP->monsterstyle, "none"))
189 place_monsters (this, RP->monsterstyle, RP->difficulty, RP);
190
191 CEDE;
192
193 /* treasures needs to have a proper difficulty set for the map. */
194 difficulty = estimate_difficulty ();
195
196 CEDE;
197
198 /* create treasure unless the treasurestyle is "none" */
199 if (strcmp (RP->treasurestyle, "none"))
200 place_treasure (this, layout, RP->treasurestyle, RP->treasureoptions, RP);
201
202 CEDE;
203
204 /* create decor unless the decorstyle is "none" */
205 if (strcmp (RP->decorstyle, "none"))
206 put_decor (this, layout, RP->decorstyle, RP->decoroptions, RP);
207
208 CEDE;
209
210 /* generate treasures, etc. */
211 fix_auto_apply ();
212
213 CEDE;
214
215 unblock_exits (this, layout, RP);
216
217 /* free the layout */
218 for (i = 0; i < RP->Xsize; i++)
219 free (layout[i]);
220
221 free (layout);
222
223 msg = strdup (buf);
224 in_memory = MAP_IN_MEMORY;
225
226 CEDE;
227
228 return 1;
229}
230
231/* function selects the layout function and gives it whatever
232 arguments it needs. */
233char **
234layoutgen (random_map_params *RP)
235{
236 char **maze = 0;
237 int oxsize = RP->Xsize, oysize = RP->Ysize;
233 238
234 switch (RP->map_layout_style) 239 switch (RP->map_layout_style)
235 { 240 {
236 241 case LAYOUT_ONION:
237 case ONION_LAYOUT:
238 maze = map_gen_onion (RP->Xsize, RP->Ysize, RP->layoutoptions1, RP->layoutoptions2); 242 maze = map_gen_onion (RP->Xsize, RP->Ysize, RP->layoutoptions1, RP->layoutoptions2);
239 if (!(RANDOM () % 3) && !(RP->layoutoptions1 & OPT_WALLS_ONLY)) 243 if (!(rndm (3)) && !(RP->layoutoptions1 & RMOPT_WALLS_ONLY))
240 roomify_layout (maze, RP); 244 roomify_layout (maze, RP);
241 break; 245 break;
242 246
243 case MAZE_LAYOUT: 247 case LAYOUT_MAZE:
244 maze = maze_gen (RP->Xsize, RP->Ysize, RANDOM () % 2); 248 maze = maze_gen (RP->Xsize, RP->Ysize, rndm (2));
245 if (!(RANDOM () % 2)) 249 if (!(rndm (2)))
246 doorify_layout (maze, RP); 250 doorify_layout (maze, RP);
247 break; 251 break;
248 252
249 case SPIRAL_LAYOUT: 253 case LAYOUT_SPIRAL:
250 maze = map_gen_spiral (RP->Xsize, RP->Ysize, RP->layoutoptions1); 254 maze = map_gen_spiral (RP->Xsize, RP->Ysize, RP->layoutoptions1);
251 if (!(RANDOM () % 2)) 255 if (!(rndm (2)))
252 doorify_layout (maze, RP); 256 doorify_layout (maze, RP);
253 break; 257 break;
254 258
255 case ROGUELIKE_LAYOUT: 259 case LAYOUT_ROGUELIKE:
256 /* Don't put symmetry in rogue maps. There isn't much reason to 260 /* 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), 261 * do so in the first place (doesn't make it any more interesting),
258 * but more importantly, the symmetry code presumes we are symmetrizing 262 * but more importantly, the symmetry code presumes we are symmetrizing
259 * spirals, or maps with lots of passages - making a symmetric rogue 263 * spirals, or maps with lots of passages - making a symmetric rogue
260 * map fails because its likely that the passages the symmetry process 264 * map fails because its likely that the passages the symmetry process
261 * creates may not connect the rooms. 265 * creates may not connect the rooms.
262 */ 266 */
263 RP->symmetry_used = NO_SYM; 267 RP->symmetry_used = SYMMETRY_NONE;
264 RP->Ysize = oysize; 268 RP->Ysize = oysize;
265 RP->Xsize = oxsize; 269 RP->Xsize = oxsize;
266 maze = roguelike_layout_gen (RP->Xsize, RP->Ysize, RP->layoutoptions1); 270 maze = roguelike_layout_gen (RP->Xsize, RP->Ysize, RP->layoutoptions1);
267 /* no doorifying... done already */ 271 /* no doorifying... done already */
268 break; 272 break;
269 273
270 case SNAKE_LAYOUT: 274 case LAYOUT_SNAKE:
271 maze = make_snake_layout (RP->Xsize, RP->Ysize, RP->layoutoptions1); 275 maze = make_snake_layout (RP->Xsize, RP->Ysize, RP->layoutoptions1);
272 if (RANDOM () % 2) 276 if (rndm (2))
273 roomify_layout (maze, RP); 277 roomify_layout (maze, RP);
274 break; 278 break;
275 279
276 case SQUARE_SPIRAL_LAYOUT: 280 case LAYOUT_SQUARE_SPIRAL:
277 maze = make_square_spiral_layout (RP->Xsize, RP->Ysize, RP->layoutoptions1); 281 maze = make_square_spiral_layout (RP->Xsize, RP->Ysize, RP->layoutoptions1);
278 if (RANDOM () % 2) 282 if (rndm (2))
279 roomify_layout (maze, RP); 283 roomify_layout (maze, RP);
280 break; 284 break;
281 } 285 }
282 286
283 maze = symmetrize_layout (maze, RP->symmetry_used, RP); 287 maze = symmetrize_layout (maze, RP->symmetry_used, RP);
288
284#ifdef RMAP_DEBUG 289#ifdef RMAP_DEBUG
285 dump_layout (maze, RP); 290 dump_layout (maze, RP);
286#endif 291#endif
292
287 if (RP->expand2x) 293 if (RP->expand2x)
288 { 294 {
289 maze = expand2x (maze, RP->Xsize, RP->Ysize); 295 maze = expand2x (maze, RP->Xsize, RP->Ysize);
290 RP->Xsize = RP->Xsize * 2 - 1; 296 RP->Xsize = RP->Xsize * 2 - 1;
291 RP->Ysize = RP->Ysize * 2 - 1; 297 RP->Ysize = RP->Ysize * 2 - 1;
292 } 298 }
299
293 return maze; 300 return maze;
294} 301}
295
296 302
297/* takes a map and makes it symmetric: adjusts Xsize and 303/* takes a map and makes it symmetric: adjusts Xsize and
298Ysize to produce a symmetric map. */ 304Ysize to produce a symmetric map. */
299
300char ** 305char **
301symmetrize_layout (char **maze, int sym, RMParms * RP) 306symmetrize_layout (char **maze, int sym, random_map_params *RP)
302{ 307{
303 int i, j; 308 int i, j;
304 char **sym_maze; 309 char **sym_maze;
305 int Xsize_orig, Ysize_orig; 310 int Xsize_orig, Ysize_orig;
306 311
307 Xsize_orig = RP->Xsize; 312 Xsize_orig = RP->Xsize;
308 Ysize_orig = RP->Ysize; 313 Ysize_orig = RP->Ysize;
309 RP->symmetry_used = sym; /* tell everyone else what sort of symmetry is used. */ 314 RP->symmetry_used = sym; /* tell everyone else what sort of symmetry is used. */
310 if (sym == NO_SYM) 315 if (sym == SYMMETRY_NONE)
311 { 316 {
312 RP->Xsize = Xsize_orig; 317 RP->Xsize = Xsize_orig;
313 RP->Ysize = Ysize_orig; 318 RP->Ysize = Ysize_orig;
314 return maze; 319 return maze;
315 } 320 }
316 /* pick new sizes */ 321 /* pick new sizes */
317 RP->Xsize = ((sym == X_SYM || sym == XY_SYM) ? RP->Xsize * 2 - 3 : RP->Xsize); 322 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); 323 RP->Ysize = ((sym == SYMMETRY_Y || sym == SYMMETRY_XY) ? RP->Ysize * 2 - 3 : RP->Ysize);
319 324
320 sym_maze = (char **) calloc (sizeof (char *), RP->Xsize); 325 sym_maze = (char **) calloc (sizeof (char *), RP->Xsize);
321 for (i = 0; i < RP->Xsize; i++) 326 for (i = 0; i < RP->Xsize; i++)
322 sym_maze[i] = (char *) calloc (sizeof (char), RP->Ysize); 327 sym_maze[i] = (char *) calloc (sizeof (char), RP->Ysize);
323 328
324 if (sym == X_SYM) 329 if (sym == SYMMETRY_X)
325 for (i = 0; i < RP->Xsize / 2 + 1; i++) 330 for (i = 0; i < RP->Xsize / 2 + 1; i++)
326 for (j = 0; j < RP->Ysize; j++) 331 for (j = 0; j < RP->Ysize; j++)
327 { 332 {
328 sym_maze[i][j] = maze[i][j]; 333 sym_maze[i][j] = maze[i][j];
329 sym_maze[RP->Xsize - i - 1][j] = maze[i][j]; 334 sym_maze[RP->Xsize - i - 1][j] = maze[i][j];
330 }; 335 };
331 if (sym == Y_SYM) 336 if (sym == SYMMETRY_Y)
332 for (i = 0; i < RP->Xsize; i++) 337 for (i = 0; i < RP->Xsize; i++)
333 for (j = 0; j < RP->Ysize / 2 + 1; j++) 338 for (j = 0; j < RP->Ysize / 2 + 1; j++)
334 { 339 {
335 sym_maze[i][j] = maze[i][j]; 340 sym_maze[i][j] = maze[i][j];
336 sym_maze[i][RP->Ysize - j - 1] = maze[i][j]; 341 sym_maze[i][RP->Ysize - j - 1] = maze[i][j];
337 } 342 }
338 if (sym == XY_SYM) 343 if (sym == SYMMETRY_XY)
339 for (i = 0; i < RP->Xsize / 2 + 1; i++) 344 for (i = 0; i < RP->Xsize / 2 + 1; i++)
340 for (j = 0; j < RP->Ysize / 2 + 1; j++) 345 for (j = 0; j < RP->Ysize / 2 + 1; j++)
341 { 346 {
342 sym_maze[i][j] = maze[i][j]; 347 sym_maze[i][j] = maze[i][j];
343 sym_maze[i][RP->Ysize - j - 1] = maze[i][j]; 348 sym_maze[i][RP->Ysize - j - 1] = maze[i][j];
… …
347 /* delete the old maze */ 352 /* delete the old maze */
348 for (i = 0; i < Xsize_orig; i++) 353 for (i = 0; i < Xsize_orig; i++)
349 free (maze[i]); 354 free (maze[i]);
350 free (maze); 355 free (maze);
351 /* reconnect disjointed spirals */ 356 /* reconnect disjointed spirals */
352 if (RP->map_layout_style == SPIRAL_LAYOUT) 357 if (RP->map_layout_style == LAYOUT_SPIRAL)
353 connect_spirals (RP->Xsize, RP->Ysize, sym, sym_maze); 358 connect_spirals (RP->Xsize, RP->Ysize, sym, sym_maze);
354 /* reconnect disjointed nethackmazes: the routine for 359 /* reconnect disjointed nethackmazes: the routine for
355 spirals will do the trick? */ 360 spirals will do the trick? */
356 if (RP->map_layout_style == ROGUELIKE_LAYOUT) 361 if (RP->map_layout_style == LAYOUT_ROGUELIKE)
357 connect_spirals (RP->Xsize, RP->Ysize, sym, sym_maze); 362 connect_spirals (RP->Xsize, RP->Ysize, sym, sym_maze);
358 363
359 return sym_maze; 364 return sym_maze;
360} 365}
361 366
… …
364 onion layouts, making them possibly centered on any wall. 369 onion layouts, making them possibly centered on any wall.
365 It'll modify Xsize and Ysize if they're swapped. 370 It'll modify Xsize and Ysize if they're swapped.
366*/ 371*/
367 372
368char ** 373char **
369rotate_layout (char **maze, int rotation, RMParms * RP) 374rotate_layout (char **maze, int rotation, random_map_params *RP)
370{ 375{
371 char **new_maze; 376 char **new_maze;
372 int i, j; 377 int i, j;
373 378
374 switch (rotation) 379 switch (rotation)
375 { 380 {
376 case 0: 381 case 0:
382 return maze;
383 break;
384 case 2: /* a reflection */
385 {
386 char *newmaze = (char *) malloc (sizeof (char) * RP->Xsize * RP->Ysize);
387
388 for (i = 0; i < RP->Xsize; i++)
389 { /* make a copy */
390 for (j = 0; j < RP->Ysize; j++)
391 {
392 newmaze[i * RP->Ysize + j] = maze[i][j];
393 }
394 }
395 for (i = 0; i < RP->Xsize; i++)
396 { /* copy a reflection back */
397 for (j = 0; j < RP->Ysize; j++)
398 {
399 maze[i][j] = newmaze[(RP->Xsize - i - 1) * RP->Ysize + RP->Ysize - j - 1];
400 }
401 }
402 free (newmaze);
377 return maze; 403 return maze;
378 break; 404 break;
379 case 2: /* a reflection */ 405 }
406 case 1:
407 case 3:
408 {
409 int swap;
410 new_maze = (char **) calloc (sizeof (char *), RP->Ysize);
411 for (i = 0; i < RP->Ysize; i++)
380 { 412 {
381 char *newmaze = (char *) malloc (sizeof (char) * RP->Xsize * RP->Ysize); 413 new_maze[i] = (char *) calloc (sizeof (char), RP->Xsize);
382 414 }
415 if (rotation == 1) /* swap x and y */
383 for (i = 0; i < RP->Xsize; i++) 416 for (i = 0; i < RP->Xsize; i++)
384 { /* make a copy */
385 for (j = 0; j < RP->Ysize; j++) 417 for (j = 0; j < RP->Ysize; j++)
386 {
387 newmaze[i * RP->Ysize + j] = maze[i][j]; 418 new_maze[j][i] = maze[i][j];
388 } 419
389 } 420 if (rotation == 3)
390 for (i = 0; i < RP->Xsize; i++) 421 { /* 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++) 422 for (i = 0; i < RP->Xsize; i++)
412 for (j = 0; j < RP->Ysize; j++) 423 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]; 424 new_maze[j][i] = maze[RP->Xsize - i - 1][RP->Ysize - j - 1];
420 } 425 }
421 426
422 /* delete the old layout */ 427 /* delete the old layout */
423 for (i = 0; i < RP->Xsize; i++) 428 for (i = 0; i < RP->Xsize; i++)
424 free (maze[i]); 429 free (maze[i]);
425 free (maze); 430 free (maze);
426 431
427 swap = RP->Ysize; 432 swap = RP->Ysize;
428 RP->Ysize = RP->Xsize; 433 RP->Ysize = RP->Xsize;
429 RP->Xsize = swap; 434 RP->Xsize = swap;
430 return new_maze; 435 return new_maze;
431 break; 436 break;
432 } 437 }
433 } 438 }
434 return NULL; 439 return NULL;
435} 440}
436 441
437/* take a layout and make some rooms in it. 442/* take a layout and make some rooms in it.
438 --works best on onions.*/ 443 --works best on onions.*/
439void 444void
440roomify_layout (char **maze, RMParms * RP) 445roomify_layout (char **maze, random_map_params *RP)
441{ 446{
442 int tries = RP->Xsize * RP->Ysize / 30; 447 int tries = RP->Xsize * RP->Ysize / 30;
443 int ti; 448 int ti;
444 449
445 for (ti = 0; ti < tries; ti++) 450 for (ti = 0; ti < tries; ti++)
446 { 451 {
447 int dx, dy; /* starting location for looking at creating a door */ 452 int dx, dy; /* starting location for looking at creating a door */
448 int cx, cy; /* results of checking on creating walls. */ 453 int cx, cy; /* results of checking on creating walls. */
449 454
450 dx = RANDOM () % RP->Xsize; 455 dx = rndm (RP->Xsize);
451 dy = RANDOM () % RP->Ysize; 456 dy = rndm (RP->Ysize);
457
452 cx = can_make_wall (maze, dx, dy, 0, RP); /* horizontal */ 458 cx = can_make_wall (maze, dx, dy, 0, RP); /* horizontal */
453 cy = can_make_wall (maze, dx, dy, 1, RP); /* vertical */ 459 cy = can_make_wall (maze, dx, dy, 1, RP); /* vertical */
454 if (cx == -1) 460 if (cx == -1)
455 { 461 {
456 if (cy != -1) 462 if (cy != -1)
457 make_wall (maze, dx, dy, 1); 463 make_wall (maze, dx, dy, 1);
464
458 continue; 465 continue;
459 } 466 }
467
460 if (cy == -1) 468 if (cy == -1)
461 { 469 {
462 make_wall (maze, dx, dy, 0); 470 make_wall (maze, dx, dy, 0);
463 continue; 471 continue;
464 } 472 }
473
465 if (cx < cy) 474 if (cx < cy)
466 make_wall (maze, dx, dy, 0); 475 make_wall (maze, dx, dy, 0);
467 else 476 else
468 make_wall (maze, dx, dy, 1); 477 make_wall (maze, dx, dy, 1);
469 } 478 }
… …
472/* checks the layout to see if I can stick a horizontal(dir = 0) wall 481/* checks the layout to see if I can stick a horizontal(dir = 0) wall
473 (or vertical, dir == 1) 482 (or vertical, dir == 1)
474 here which ends up on other walls sensibly. */ 483 here which ends up on other walls sensibly. */
475 484
476int 485int
477can_make_wall (char **maze, int dx, int dy, int dir, RMParms * RP) 486can_make_wall (char **maze, int dx, int dy, int dir, random_map_params *RP)
478{ 487{
479 int i1; 488 int i1;
480 int length = 0; 489 int length = 0;
481 490
482 /* dont make walls if we're on the edge. */ 491 /* dont make walls if we're on the edge. */
… …
557make_wall (char **maze, int x, int y, int dir) 566make_wall (char **maze, int x, int y, int dir)
558{ 567{
559 maze[x][y] = 'D'; /* mark a door */ 568 maze[x][y] = 'D'; /* mark a door */
560 switch (dir) 569 switch (dir)
561 { 570 {
562 case 0: /* horizontal */ 571 case 0: /* horizontal */
563 { 572 {
564 int i1; 573 int i1;
565 574
566 for (i1 = x - 1; maze[i1][y] == 0; i1--) 575 for (i1 = x - 1; maze[i1][y] == 0; i1--)
567 maze[i1][y] = '#'; 576 maze[i1][y] = '#';
568 for (i1 = x + 1; maze[i1][y] == 0; i1++) 577 for (i1 = x + 1; maze[i1][y] == 0; i1++)
569 maze[i1][y] = '#'; 578 maze[i1][y] = '#';
570 break; 579 break;
571 } 580 }
572 case 1: /* vertical */ 581 case 1: /* vertical */
573 { 582 {
574 int i1; 583 int i1;
575 584
576 for (i1 = y - 1; maze[x][i1] == 0; i1--) 585 for (i1 = y - 1; maze[x][i1] == 0; i1--)
577 maze[x][i1] = '#'; 586 maze[x][i1] = '#';
578 for (i1 = y + 1; maze[x][i1] == 0; i1++) 587 for (i1 = y + 1; maze[x][i1] == 0; i1++)
579 maze[x][i1] = '#'; 588 maze[x][i1] = '#';
580 break; 589 break;
581 } 590 }
582 } 591 }
583 592
584 return 0; 593 return 0;
585} 594}
586 595
587/* puts doors at appropriate locations in a layout. */ 596/* puts doors at appropriate locations in a layout. */
588
589void 597void
590doorify_layout (char **maze, RMParms * RP) 598doorify_layout (char **maze, random_map_params *RP)
591{ 599{
592 int ndoors = RP->Xsize * RP->Ysize / 60; /* reasonable number of doors. */ 600 int ndoors = RP->Xsize * RP->Ysize / 60; /* reasonable number of doors. */
593 char *doorlist_x; 601 char *doorlist_x;
594 char *doorlist_y; 602 char *doorlist_y;
595 int doorlocs = 0; /* # of available doorlocations */ 603 int doorlocs = 0; /* # of available doorlocations */
… …
610 doorlist_x[doorlocs] = i; 618 doorlist_x[doorlocs] = i;
611 doorlist_y[doorlocs] = j; 619 doorlist_y[doorlocs] = j;
612 doorlocs++; 620 doorlocs++;
613 } 621 }
614 } 622 }
623
615 while (ndoors > 0 && doorlocs > 0) 624 while (ndoors > 0 && doorlocs > 0)
616 { 625 {
617 int di; 626 int di;
618 int sindex; 627 int sindex;
619 628
620 di = RANDOM () % doorlocs; 629 di = rndm (doorlocs);
621 i = doorlist_x[di]; 630 i = doorlist_x[di];
622 j = doorlist_y[di]; 631 j = doorlist_y[di];
623 sindex = surround_flag (maze, i, j, RP); 632 sindex = surround_flag (maze, i, j, RP);
633
624 if (sindex == 3 || sindex == 12) /* these are possible door sindex */ 634 if (sindex == 3 || sindex == 12) /* these are possible door sindex */
625 { 635 {
626 maze[i][j] = 'D'; 636 maze[i][j] = 'D';
627 ndoors--; 637 ndoors--;
628 } 638 }
639
629 /* reduce the size of the list */ 640 /* reduce the size of the list */
630 doorlocs--; 641 doorlocs--;
631 doorlist_x[di] = doorlist_x[doorlocs]; 642 doorlist_x[di] = doorlist_x[doorlocs];
632 doorlist_y[di] = doorlist_y[doorlocs]; 643 doorlist_y[di] = doorlist_y[doorlocs];
633 } 644 }
645
634 free (doorlist_x); 646 free (doorlist_x);
635 free (doorlist_y); 647 free (doorlist_y);
636} 648}
637 649
638
639void 650void
640write_map_parameters_to_string (char *buf, RMParms * RP) 651write_map_parameters_to_string (char *buf, random_map_params *RP)
641{ 652{
642
643 char small_buf[256]; 653 char small_buf[16384];
644 654
645 sprintf (buf, "xsize %d\nysize %d\n", RP->Xsize, RP->Ysize); 655 sprintf (buf, "xsize %d\nysize %d\n", RP->xsize, RP->ysize);
646 656
647 if (RP->wallstyle[0]) 657 if (RP->wallstyle[0])
648 { 658 {
649 sprintf (small_buf, "wallstyle %s\n", RP->wallstyle); 659 sprintf (small_buf, "wallstyle %s\n", RP->wallstyle);
650 strcat (buf, small_buf); 660 strcat (buf, small_buf);
… …
690 { 700 {
691 sprintf (small_buf, "exitstyle %s\n", RP->exitstyle); 701 sprintf (small_buf, "exitstyle %s\n", RP->exitstyle);
692 strcat (buf, small_buf); 702 strcat (buf, small_buf);
693 } 703 }
694 704
695 if (RP->final_map[0]) 705 if (RP->final_map.length ())
696 { 706 {
697 sprintf (small_buf, "final_map %s\n", RP->final_map); 707 sprintf (small_buf, "final_map %s\n", &RP->final_map);
698 strcat (buf, small_buf); 708 strcat (buf, small_buf);
699 } 709 }
700 710
701 if (RP->exit_on_final_map[0]) 711 if (RP->exit_on_final_map[0])
702 { 712 {
703 sprintf (small_buf, "exit_on_final_map %s\n", RP->exit_on_final_map); 713 sprintf (small_buf, "exit_on_final_map %s\n", RP->exit_on_final_map);
704 strcat (buf, small_buf); 714 strcat (buf, small_buf);
705 } 715 }
706 716
707 if (RP->this_map[0]) 717 if (RP->this_map.length ())
708 { 718 {
709 sprintf (small_buf, "origin_map %s\n", RP->this_map); 719 sprintf (small_buf, "origin_map %s\n", &RP->this_map);
710 strcat (buf, small_buf); 720 strcat (buf, small_buf);
711 } 721 }
712 722
713 if (RP->expand2x) 723 if (RP->expand2x)
714 { 724 {
… …
720 { 730 {
721 sprintf (small_buf, "layoutoptions1 %d\n", RP->layoutoptions1); 731 sprintf (small_buf, "layoutoptions1 %d\n", RP->layoutoptions1);
722 strcat (buf, small_buf); 732 strcat (buf, small_buf);
723 } 733 }
724 734
725
726 if (RP->layoutoptions2) 735 if (RP->layoutoptions2)
727 { 736 {
728 sprintf (small_buf, "layoutoptions2 %d\n", RP->layoutoptions2); 737 sprintf (small_buf, "layoutoptions2 %d\n", RP->layoutoptions2);
729 strcat (buf, small_buf); 738 strcat (buf, small_buf);
730 } 739 }
731 740
732
733 if (RP->layoutoptions3) 741 if (RP->layoutoptions3)
734 { 742 {
735 sprintf (small_buf, "layoutoptions3 %d\n", RP->layoutoptions3); 743 sprintf (small_buf, "layoutoptions3 %d\n", RP->layoutoptions3);
736 strcat (buf, small_buf); 744 strcat (buf, small_buf);
737 } 745 }
… …
739 if (RP->symmetry) 747 if (RP->symmetry)
740 { 748 {
741 sprintf (small_buf, "symmetry %d\n", RP->symmetry); 749 sprintf (small_buf, "symmetry %d\n", RP->symmetry);
742 strcat (buf, small_buf); 750 strcat (buf, small_buf);
743 } 751 }
744
745 752
746 if (RP->difficulty && RP->difficulty_given) 753 if (RP->difficulty && RP->difficulty_given)
747 { 754 {
748 sprintf (small_buf, "difficulty %d\n", RP->difficulty); 755 sprintf (small_buf, "difficulty %d\n", RP->difficulty);
749 strcat (buf, small_buf); 756 strcat (buf, small_buf);
… …
785 if (RP->origin_y) 792 if (RP->origin_y)
786 { 793 {
787 sprintf (small_buf, "origin_y %d\n", RP->origin_y); 794 sprintf (small_buf, "origin_y %d\n", RP->origin_y);
788 strcat (buf, small_buf); 795 strcat (buf, small_buf);
789 } 796 }
797
798 if (RP->treasureoptions)
799 {
800 sprintf (small_buf, "treasureoptions %d\n", RP->treasureoptions);
801 strcat (buf, small_buf);
802 }
803
790 if (RP->random_seed) 804 if (RP->random_seed)
791 { 805 {
792 /* Add one so that the next map is a bit different */
793 sprintf (small_buf, "random_seed %d\n", RP->random_seed + 1); 806 sprintf (small_buf, "random_seed %u\n", RP->random_seed);
794 strcat (buf, small_buf); 807 strcat (buf, small_buf);
795 }
796
797 if (RP->treasureoptions)
798 { 808 }
799 sprintf (small_buf, "treasureoptions %d\n", RP->treasureoptions); 809
800 strcat (buf, small_buf); 810 if (RP->custom)
801 } 811 {
802 812 sprintf (small_buf, "custom %s\n", RP->custom);
803 813 strcat (buf, small_buf);
814 }
804} 815}
805 816
806void 817void
807write_parameters_to_string (char *buf, 818write_parameters_to_string (char *buf,
808 int xsize_n, 819 int xsize_n,
809 int ysize_n, 820 int ysize_n,
810 char *wallstyle_n, 821 const char *wallstyle_n,
811 char *floorstyle_n, 822 const char *floorstyle_n,
812 char *monsterstyle_n, 823 const char *monsterstyle_n,
813 char *treasurestyle_n, 824 const char *treasurestyle_n,
814 char *layoutstyle_n, 825 const char *layoutstyle_n,
815 char *decorstyle_n, 826 const char *decorstyle_n,
816 char *doorstyle_n, 827 const char *doorstyle_n,
817 char *exitstyle_n, 828 const char *exitstyle_n,
818 char *final_map_n, 829 const char *final_map_n,
819 char *exit_on_final_map_n, 830 const char *exit_on_final_map_n,
820 char *this_map_n, 831 const char *this_map_n,
821 int layoutoptions1_n, 832 int layoutoptions1_n,
822 int layoutoptions2_n, 833 int layoutoptions2_n,
823 int layoutoptions3_n, 834 int layoutoptions3_n,
824 int symmetry_n, 835 int symmetry_n,
825 int dungeon_depth_n, 836 int dungeon_depth_n,
826 int dungeon_level_n, 837 int dungeon_level_n,
827 int difficulty_n, 838 int difficulty_n,
828 int difficulty_given_n, 839 int difficulty_given_n,
829 int decoroptions_n, 840 int decoroptions_n,
830 int orientation_n, 841 int orientation_n,
831 int origin_x_n, int origin_y_n, int random_seed_n, int treasureoptions_n, float difficulty_increase) 842 int origin_x_n,
843 int origin_y_n,
844 uint32_t random_seed_n,
845 int treasureoptions_n,
846 float difficulty_increase)
832{ 847{
833
834 char small_buf[256]; 848 char small_buf[16384];
835 849
836 sprintf (buf, "xsize %d\nysize %d\n", xsize_n, ysize_n); 850 sprintf (buf, "xsize %d\nysize %d\n", xsize_n, ysize_n);
837 851
838 if (wallstyle_n && wallstyle_n[0]) 852 if (wallstyle_n && wallstyle_n[0])
839 { 853 {
… …
904 if (layoutoptions1_n) 918 if (layoutoptions1_n)
905 { 919 {
906 sprintf (small_buf, "layoutoptions1 %d\n", layoutoptions1_n); 920 sprintf (small_buf, "layoutoptions1 %d\n", layoutoptions1_n);
907 strcat (buf, small_buf); 921 strcat (buf, small_buf);
908 } 922 }
909
910 923
911 if (layoutoptions2_n) 924 if (layoutoptions2_n)
912 { 925 {
913 sprintf (small_buf, "layoutoptions2 %d\n", layoutoptions2_n); 926 sprintf (small_buf, "layoutoptions2 %d\n", layoutoptions2_n);
914 strcat (buf, small_buf); 927 strcat (buf, small_buf);
… …
970 if (origin_y_n) 983 if (origin_y_n)
971 { 984 {
972 sprintf (small_buf, "origin_y %d\n", origin_y_n); 985 sprintf (small_buf, "origin_y %d\n", origin_y_n);
973 strcat (buf, small_buf); 986 strcat (buf, small_buf);
974 } 987 }
988
975 if (random_seed_n) 989 if (random_seed_n)
976 { 990 {
977 /* Add one so that the next map is a bit different */ 991 /* Add one so that the next map is a bit different */
978 sprintf (small_buf, "random_seed %d\n", random_seed_n + 1); 992 sprintf (small_buf, "random_seed %u\n", random_seed_n + 1);
979 strcat (buf, small_buf); 993 strcat (buf, small_buf);
980 } 994 }
981 995
982 if (treasureoptions_n) 996 if (treasureoptions_n)
983 { 997 {
984 sprintf (small_buf, "treasureoptions %d\n", treasureoptions_n); 998 sprintf (small_buf, "treasureoptions %d\n", treasureoptions_n);
985 strcat (buf, small_buf); 999 strcat (buf, small_buf);
986 } 1000 }
987
988
989} 1001}
990 1002
991/* copy an object with an inventory... i.e., duplicate the inv too. */ 1003/* copy an object with an inventory... i.e., duplicate the inv too. */
992void 1004void
993copy_object_with_inv (object *src_ob, object *dest_ob) 1005copy_object_with_inv (object *src_ob, object *dest_ob)
994{ 1006{
995 object *walk, *tmp; 1007 object *walk, *tmp;
996 1008
997 src_ob->copy_to (dest_ob); 1009 src_ob->copy_to (dest_ob);
998 1010
999 for (walk = src_ob->inv; walk != NULL; walk = walk->below) 1011 for (walk = src_ob->inv; walk; walk = walk->below)
1000 { 1012 {
1001 tmp = object::create (); 1013 tmp = object::create ();
1014
1002 walk->copy_to (tmp); 1015 walk->copy_to (tmp);
1003 insert_ob_in_ob (tmp, dest_ob); 1016 insert_ob_in_ob (tmp, dest_ob);
1004 } 1017 }
1005} 1018}

Diff Legend

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