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

Diff Legend

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