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.10 by root, Sat Dec 30 10:16:11 2006 UTC vs.
Revision 1.30 by root, Sun Jul 1 05:00:19 2007 UTC

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

Diff Legend

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