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

Diff Legend

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