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.3 by root, Sun Sep 10 16:06:37 2006 UTC vs.
Revision 1.29 by root, Tue Apr 17 10:06:34 2007 UTC

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

Diff Legend

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