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.38 by root, Fri May 2 21:22:22 2008 UTC

1/* 1/*
2 CrossFire, A Multiplayer game for X-windows 2 * This file is part of Deliantra, the Roguelike Realtime MMORPG.
3 3 *
4 * Copyright (©) 2005,2006,2007,2008 Marc Alexander Lehmann / Robin Redeker / the Deliantra 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 * Deliantra 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 to <support@deliantra.net>
21 The authors can be reached via e-mail at <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>
28#include <room_gen.h>
29#include <random_map.h> 27#include <random_map.h>
30#include <rproto.h> 28#include <rproto.h>
31#include <sproto.h> 29#include <sproto.h>
32 30
31#define CEDE coroapi::cede_to_tick (); rndm.seed (RP->random_seed + __LINE__);
32
33static void symmetrize_layout (Layout maze, random_map_params *RP);
34static void rotate_layout (Layout maze, int rotation);
35
33void 36void
34dump_layout (char **layout, RMParms * RP) 37dump_layout (Layout layout)
35{ 38{
36 { 39 for (int j = 0; j < layout->h; j++)
37 int i, j;
38
39 for (i = 0; i < RP->Xsize; i++)
40 { 40 {
41 for (j = 0; j < RP->Ysize; j++) 41 for (int i = 0; i < layout->w; i++)
42 { 42 putc (layout[i][j] ? layout[i][j] : ' ', stdout);
43 if (layout[i][j] == 0) 43
44 layout[i][j] = ' '; 44 putc ('\n', stdout);
45 printf ("%c", layout[i][j]);
46 if (layout[i][j] == ' ')
47 layout[i][j] = 0;
48 }
49 printf ("\n");
50 } 45 }
51 } 46
52 printf ("\n"); 47 putc ('\n', stdout);
53} 48}
54EXTERN FILE *logfile; 49
55maptile * 50bool
56generate_random_map (const char *OutFileName, RMParms * RP) 51maptile::generate_random_map (random_map_params *RP)
57{ 52{
58 char **layout, buf[HUGE_BUF]; 53 char buf[16384];
59 maptile *theMap;
60 int i; 54 int i;
61 55
56 RP->Xsize = RP->xsize;
57 RP->Ysize = RP->ysize;
58
62 /* pick a random seed, or use the one from the input file */ 59 /* pick a random seed, or use the one from the input file */
63 if (RP->random_seed == 0) 60 RP->random_seed = RP->random_seed
64 RP->random_seed = time (0); 61 ? RP->random_seed + RP->dungeon_level
65 62 : time (0);
66 SRANDOM (RP->random_seed); 63 CEDE;
67 64
68 write_map_parameters_to_string (buf, RP); 65 write_map_parameters_to_string (buf, RP);
69 66
70 if (RP->difficulty == 0) 67 if (RP->difficulty == 0)
71 { 68 {
72 RP->difficulty = RP->dungeon_level; /* use this instead of a map difficulty */ 69 RP->difficulty = RP->dungeon_level; /* use this instead of a map difficulty */
70
73 if (RP->difficulty_increase > 0.001) 71 if (RP->difficulty_increase > 0.001)
74 {
75 RP->difficulty = (int) ((float) RP->dungeon_level * RP->difficulty_increase); 72 RP->difficulty = (int) ((float) RP->dungeon_level * RP->difficulty_increase);
73
76 if (RP->difficulty < 1) 74 if (RP->difficulty < 1)
77 RP->difficulty = 1; 75 RP->difficulty = 1;
78 }
79 } 76 }
80 else 77 else
81 RP->difficulty_given = 1; 78 RP->difficulty_given = 1;
82 79
83 if (RP->Xsize < MIN_RANDOM_MAP_SIZE) 80 if (RP->Xsize < MIN_RANDOM_MAP_SIZE)
84 RP->Xsize = MIN_RANDOM_MAP_SIZE + RANDOM () % 25 + 5; 81 RP->Xsize = MIN_RANDOM_MAP_SIZE + rndm (25) + 5;
82
85 if (RP->Ysize < MIN_RANDOM_MAP_SIZE) 83 if (RP->Ysize < MIN_RANDOM_MAP_SIZE)
86 RP->Ysize = MIN_RANDOM_MAP_SIZE + RANDOM () % 25 + 5; 84 RP->Ysize = MIN_RANDOM_MAP_SIZE + rndm (25) + 5;
85
86 if (RP->symmetry == SYMMETRY_RANDOM)
87 RP->symmetry_used = rndm (SYMMETRY_XY) + 1;
88 else
89 RP->symmetry_used = RP->symmetry;
90
91 if (RP->symmetry_used == SYMMETRY_Y || RP->symmetry_used == SYMMETRY_XY)
92 RP->Ysize = RP->Ysize / 2 + 1;
93
94 if (RP->symmetry_used == SYMMETRY_X || RP->symmetry_used == SYMMETRY_XY)
95 RP->Xsize = RP->Xsize / 2 + 1;
87 96
88 if (RP->expand2x > 0) 97 if (RP->expand2x > 0)
89 { 98 {
90 RP->Xsize /= 2; 99 RP->Xsize /= 2;
91 RP->Ysize /= 2; 100 RP->Ysize /= 2;
92 } 101 }
93 102
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; 103 RP->map_layout_style = LAYOUT_NONE;
191 104
192 /* Redo this - there was a lot of redundant code of checking for preset 105 /* Redo this - there was a lot of redundant code of checking for preset
193 * layout style and then random layout style. Instead, figure out 106 * layout style and then random layout style. Instead, figure out
194 * the numeric layoutstyle, so there is only one area that actually 107 * the numeric layoutstyle, so there is only one area that actually
195 * calls the code to make the maps. 108 * calls the code to make the maps.
196 */ 109 */
197 if (strstr (RP->layoutstyle, "onion")) 110 if (strstr (RP->layoutstyle, "onion"))
198 {
199 RP->map_layout_style = ONION_LAYOUT; 111 RP->map_layout_style = LAYOUT_ONION;
200 }
201
202 if (strstr (RP->layoutstyle, "maze")) 112 else if (strstr (RP->layoutstyle, "maze"))
203 {
204 RP->map_layout_style = MAZE_LAYOUT; 113 RP->map_layout_style = LAYOUT_MAZE;
205 }
206
207 if (strstr (RP->layoutstyle, "spiral")) 114 else if (strstr (RP->layoutstyle, "spiral"))
208 {
209 RP->map_layout_style = SPIRAL_LAYOUT; 115 RP->map_layout_style = LAYOUT_SPIRAL;
210 }
211
212 if (strstr (RP->layoutstyle, "rogue")) 116 else if (strstr (RP->layoutstyle, "rogue"))
213 {
214 RP->map_layout_style = ROGUELIKE_LAYOUT; 117 RP->map_layout_style = LAYOUT_ROGUELIKE;
215 }
216
217 if (strstr (RP->layoutstyle, "snake")) 118 else if (strstr (RP->layoutstyle, "snake"))
218 {
219 RP->map_layout_style = SNAKE_LAYOUT; 119 RP->map_layout_style = LAYOUT_SNAKE;
220 }
221
222 if (strstr (RP->layoutstyle, "squarespiral")) 120 else if (strstr (RP->layoutstyle, "squarespiral"))
223 {
224 RP->map_layout_style = SQUARE_SPIRAL_LAYOUT; 121 RP->map_layout_style = LAYOUT_SQUARE_SPIRAL;
122 else if (RP->map_layout_style == LAYOUT_NONE)
123 RP->map_layout_style = rndm (NROFLAYOUTS - 1) + 1; /* No style found - choose one randomly */
124 else
125 abort ();
126
127 Layout layout = layoutgen (RP);
128
129#ifdef RMAP_DEBUG
130 dump_layout (layout);
131#endif
132
133 /* increment these for the current map */
134 ++RP->dungeon_level;
135
136 // need to patch RP becasue following code doesn't use the Layout object
137 RP->Xsize = layout->w;
138 RP->Ysize = layout->h;
139
140 /* allocate the map and set the floor */
141 make_map_floor (layout, RP->floorstyle, RP);
142
143 /* set region */
144 default_region = RP->region;
145
146 CEDE;
147
148 /* create walls unless the wallstyle is "none" */
149 if (strcmp (RP->wallstyle, "none"))
225 } 150 {
226 /* No style found - choose one ranomdly */ 151 make_map_walls (this, layout, RP->wallstyle, RP);
227 if (RP->map_layout_style == 0) 152
153 /* place doors unless doorstyle or wallstyle is "none" */
154 if (strcmp (RP->doorstyle, "none"))
155 put_doors (this, layout, RP->doorstyle, RP);
228 { 156 }
229 RP->map_layout_style = (RANDOM () % NROFLAYOUTS) + 1; 157
230 } 158 CEDE;
159
160 /* create exits unless the exitstyle is "none" */
161 if (strcmp (RP->exitstyle, "none"))
162 place_exits (this, layout, RP->exitstyle, RP->orientation, RP);
163
164 CEDE;
165
166 place_specials_in_map (this, layout, RP);
167
168 CEDE;
169
170 /* create monsters unless the monsterstyle is "none" */
171 if (strcmp (RP->monsterstyle, "none"))
172 place_monsters (this, RP->monsterstyle, RP->difficulty, RP);
173
174 CEDE;
175
176 /* treasures needs to have a proper difficulty set for the map. */
177 difficulty = estimate_difficulty ();
178
179 CEDE;
180
181 /* create treasure unless the treasurestyle is "none" */
182 if (strcmp (RP->treasurestyle, "none"))
183 place_treasure (this, layout, RP->treasurestyle, RP->treasureoptions, RP);
184
185 CEDE;
186
187 /* create decor unless the decorstyle is "none" */
188 if (strcmp (RP->decorstyle, "none"))
189 put_decor (this, layout, RP->decorstyle, RP->decoroptions, RP);
190
191 CEDE;
192
193 /* generate treasures, etc. */
194 fix_auto_apply ();
195
196 CEDE;
197
198 unblock_exits (this, layout, RP);
199
200 msg = strdup (buf);
201 in_memory = MAP_ACTIVE;
202
203 CEDE;
204
205 return 1;
206}
207
208/* function selects the layout function and gives it whatever
209 arguments it needs. */
210Layout
211layoutgen (random_map_params *RP)
212{
213 Layout layout (RP);
231 214
232 switch (RP->map_layout_style) 215 switch (RP->map_layout_style)
233 { 216 {
234 217 case LAYOUT_ONION:
235 case ONION_LAYOUT:
236 maze = map_gen_onion (RP->Xsize, RP->Ysize, RP->layoutoptions1, RP->layoutoptions2); 218 map_gen_onion (layout, RP->layoutoptions1, RP->layoutoptions2);
219
237 if (!(RANDOM () % 3) && !(RP->layoutoptions1 & OPT_WALLS_ONLY)) 220 if (!(rndm (3)) && !(RP->layoutoptions1 & RMOPT_WALLS_ONLY))
238 roomify_layout (maze, RP); 221 roomify_layout (layout, RP);
222
239 break; 223 break;
240 224
241 case MAZE_LAYOUT: 225 case LAYOUT_MAZE:
242 maze = maze_gen (RP->Xsize, RP->Ysize, RANDOM () % 2); 226 maze_gen (layout, rndm (2));
243 if (!(RANDOM () % 2)) 227
228 if (!(rndm (2)))
244 doorify_layout (maze, RP); 229 doorify_layout (layout, RP);
230
245 break; 231 break;
246 232
247 case SPIRAL_LAYOUT: 233 case LAYOUT_SPIRAL:
248 maze = map_gen_spiral (RP->Xsize, RP->Ysize, RP->layoutoptions1); 234 map_gen_spiral (layout, RP->layoutoptions1);
249 if (!(RANDOM () % 2)) 235
236 if (!(rndm (2)))
250 doorify_layout (maze, RP); 237 doorify_layout (layout, RP);
238
251 break; 239 break;
252 240
253 case ROGUELIKE_LAYOUT: 241 case LAYOUT_ROGUELIKE:
254 /* Don't put symmetry in rogue maps. There isn't much reason to 242 /* 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), 243 * do so in the first place (doesn't make it any more interesting),
256 * but more importantly, the symmetry code presumes we are symmetrizing 244 * but more importantly, the symmetry code presumes we are symmetrizing
257 * spirals, or maps with lots of passages - making a symmetric rogue 245 * spirals, or maps with lots of passages - making a symmetric rogue
258 * map fails because its likely that the passages the symmetry process 246 * map fails because its likely that the passages the symmetry process
259 * creates may not connect the rooms. 247 * creates may not connect the rooms.
260 */ 248 */
261 RP->symmetry_used = NO_SYM; 249 RP->symmetry_used = SYMMETRY_NONE;
262 RP->Ysize = oysize; 250 roguelike_layout_gen (layout, RP->layoutoptions1);
263 RP->Xsize = oxsize;
264 maze = roguelike_layout_gen (RP->Xsize, RP->Ysize, RP->layoutoptions1);
265 /* no doorifying... done already */ 251 /* no doorifying... done already */
266 break; 252 break;
267 253
268 case SNAKE_LAYOUT: 254 case LAYOUT_SNAKE:
269 maze = make_snake_layout (RP->Xsize, RP->Ysize, RP->layoutoptions1); 255 make_snake_layout (layout, RP->layoutoptions1);
270 if (RANDOM () % 2) 256
257 if (rndm (2))
271 roomify_layout (maze, RP); 258 roomify_layout (layout, RP);
259
272 break; 260 break;
273 261
274 case SQUARE_SPIRAL_LAYOUT: 262 case LAYOUT_SQUARE_SPIRAL:
275 maze = make_square_spiral_layout (RP->Xsize, RP->Ysize, RP->layoutoptions1); 263 make_square_spiral_layout (layout, RP->layoutoptions1);
276 if (RANDOM () % 2) 264
265 if (rndm (2))
277 roomify_layout (maze, RP); 266 roomify_layout (layout, RP);
267
278 break; 268 break;
279 }
280 269
281 maze = symmetrize_layout (maze, RP->symmetry_used, RP); 270 default:
271 abort ();
272 }
273
274 /* rotate the layout randomly */
275 rotate_layout (layout, rndm (4));
276
277 symmetrize_layout (layout, RP);
278
282#ifdef RMAP_DEBUG 279#ifdef RMAP_DEBUG
283 dump_layout (maze, RP); 280 dump_layout (layout);
284#endif 281#endif
282
285 if (RP->expand2x) 283 if (RP->expand2x)
286 { 284 expand2x (layout);
287 maze = expand2x (maze, RP->Xsize, RP->Ysize);
288 RP->Xsize = RP->Xsize * 2 - 1;
289 RP->Ysize = RP->Ysize * 2 - 1;
290 }
291 return maze;
292}
293 285
286 return layout;
287}
294 288
295/* takes a map and makes it symmetric: adjusts Xsize and 289/* takes a map and makes it symmetric: adjusts Xsize and
296Ysize to produce a symmetric map. */ 290 * Ysize to produce a symmetric map.
297 291 */
298char ** 292static void
299symmetrize_layout (char **maze, int sym, RMParms * RP) 293symmetrize_layout (Layout layout, random_map_params *RP)
300{ 294{
301 int i, j; 295 if (RP->symmetry_used == SYMMETRY_NONE)
302 char **sym_maze;
303 int Xsize_orig, Ysize_orig;
304
305 Xsize_orig = RP->Xsize;
306 Ysize_orig = RP->Ysize;
307 RP->symmetry_used = sym; /* tell everyone else what sort of symmetry is used. */
308 if (sym == NO_SYM)
309 {
310 RP->Xsize = Xsize_orig;
311 RP->Ysize = Ysize_orig;
312 return maze; 296 return;
313 }
314 /* pick new sizes */
315 RP->Xsize = ((sym == X_SYM || sym == XY_SYM) ? RP->Xsize * 2 - 3 : RP->Xsize);
316 RP->Ysize = ((sym == Y_SYM || sym == XY_SYM) ? RP->Ysize * 2 - 3 : RP->Ysize);
317 297
318 sym_maze = (char **) calloc (sizeof (char *), RP->Xsize); 298 Layout sym_layout (
319 for (i = 0; i < RP->Xsize; i++) 299 RP->symmetry_used == SYMMETRY_X || RP->symmetry_used == SYMMETRY_XY ? layout->w * 2 - 3 : layout->w,
320 sym_maze[i] = (char *) calloc (sizeof (char), RP->Ysize); 300 RP->symmetry_used == SYMMETRY_Y || RP->symmetry_used == SYMMETRY_XY ? layout->h * 2 - 3 : layout->h
301 );
321 302
322 if (sym == X_SYM) 303 if (RP->symmetry_used == SYMMETRY_X)
323 for (i = 0; i < RP->Xsize / 2 + 1; i++) 304 for (int i = 0; i < sym_layout->w / 2 + 1; i++)
324 for (j = 0; j < RP->Ysize; j++) 305 for (int j = 0; j < sym_layout->h; j++)
325 { 306 {
326 sym_maze[i][j] = maze[i][j]; 307 sym_layout[i ][j] =
327 sym_maze[RP->Xsize - i - 1][j] = maze[i][j]; 308 sym_layout[sym_layout->w - i - 1][j] = layout[i][j];
328 }; 309 }
329 if (sym == Y_SYM) 310
330 for (i = 0; i < RP->Xsize; i++) 311 if (RP->symmetry_used == SYMMETRY_Y)
312 for (int i = 0; i < sym_layout->w; i++)
331 for (j = 0; j < RP->Ysize / 2 + 1; j++) 313 for (int j = 0; j < sym_layout->h / 2 + 1; j++)
332 {
333 sym_maze[i][j] = maze[i][j];
334 sym_maze[i][RP->Ysize - j - 1] = maze[i][j];
335 } 314 {
336 if (sym == XY_SYM) 315 sym_layout[i][j ] =
337 for (i = 0; i < RP->Xsize / 2 + 1; i++) 316 sym_layout[i][sym_layout->h - j - 1] = layout[i][j];
338 for (j = 0; j < RP->Ysize / 2 + 1; j++)
339 { 317 }
340 sym_maze[i][j] = maze[i][j]; 318
341 sym_maze[i][RP->Ysize - j - 1] = maze[i][j]; 319 if (RP->symmetry_used == SYMMETRY_XY)
342 sym_maze[RP->Xsize - i - 1][j] = maze[i][j]; 320 for (int i = 0; i < sym_layout->w / 2 + 1; i++)
343 sym_maze[RP->Xsize - i - 1][RP->Ysize - j - 1] = maze[i][j]; 321 for (int j = 0; j < sym_layout->h / 2 + 1; j++)
344 } 322 {
345 /* delete the old maze */ 323 sym_layout[i ][j ] =
346 for (i = 0; i < Xsize_orig; i++) 324 sym_layout[i ][sym_layout->h - j - 1] =
347 free (maze[i]); 325 sym_layout[sym_layout->w - i - 1][j ] =
348 free (maze); 326 sym_layout[sym_layout->w - i - 1][sym_layout->h - j - 1] = layout[i][j];
327 }
328
329 layout.swap (sym_layout);
330 sym_layout.free ();
331
349 /* reconnect disjointed spirals */ 332 /* reconnect disjointed spirals */
350 if (RP->map_layout_style == SPIRAL_LAYOUT)
351 connect_spirals (RP->Xsize, RP->Ysize, sym, sym_maze);
352 /* reconnect disjointed nethackmazes: the routine for 333 /* reconnect disjointed nethacklayouts: the routine for
353 spirals will do the trick? */ 334 spirals will do the trick? */
354 if (RP->map_layout_style == ROGUELIKE_LAYOUT) 335 if (RP->map_layout_style == LAYOUT_SPIRAL
355 connect_spirals (RP->Xsize, RP->Ysize, sym, sym_maze); 336 || RP->map_layout_style == LAYOUT_ROGUELIKE)
356 337 connect_spirals (layout->w, layout->h, RP->symmetry_used, layout);
357 return sym_maze;
358} 338}
359
360 339
361/* takes a map and rotates it. This completes the 340/* takes a map and rotates it. This completes the
362 onion layouts, making them possibly centered on any wall. 341 onion layouts, making them possibly centered on any wall.
363 It'll modify Xsize and Ysize if they're swapped. 342 It'll modify Xsize and Ysize if they're swapped.
364*/ 343*/
365 344static void
366char ** 345rotate_layout (Layout layout, int rotation)
367rotate_layout (char **maze, int rotation, RMParms * RP)
368{ 346{
369 char **new_maze; 347 int w = layout->w;
370 int i, j; 348 int h = layout->h;
371 349
372 switch (rotation) 350 switch (rotation)
373 { 351 {
374 case 0:
375 return maze;
376 break;
377 case 2: /* a reflection */ 352 case 2: /* a reflection */
378 { 353 {
379 char *newmaze = (char *) malloc (sizeof (char) * RP->Xsize * RP->Ysize); 354 Layout new_layout (w, h);
380 355
381 for (i = 0; i < RP->Xsize; i++) 356 for (int i = 0; i < w; i++) /* copy a reflection back */
382 { /* make a copy */
383 for (j = 0; j < RP->Ysize; j++) 357 for (int j = 0; j < h; j++)
384 { 358 new_layout[i][j] = layout[w - i - 1][h - j - 1];
385 newmaze[i * RP->Ysize + j] = maze[i][j]; 359
386 } 360 layout.swap (new_layout);
387 } 361 new_layout.free ();
388 for (i = 0; i < RP->Xsize; i++)
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 } 362 }
363 break;
364
399 case 1: 365 case 1:
400 case 3: 366 case 3:
401 { 367 {
402 int swap; 368 Layout new_layout (h, w);
403 new_maze = (char **) calloc (sizeof (char *), RP->Ysize); 369
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 */ 370 if (rotation == 1) /* swap x and y */
409 for (i = 0; i < RP->Xsize; i++)
410 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];
418 }
419
420 /* delete the old layout */
421 for (i = 0; i < RP->Xsize; i++) 371 for (int i = 0; i < w; i++)
422 free (maze[i]); 372 for (int j = 0; j < h; j++)
423 free (maze); 373 new_layout[j][i] = layout[i][j];
424 374
425 swap = RP->Ysize; 375 if (rotation == 3) /* swap x and y */
426 RP->Ysize = RP->Xsize; 376 for (int i = 0; i < w; i++)
427 RP->Xsize = swap; 377 for (int j = 0; j < h; j++)
428 return new_maze; 378 new_layout[j][i] = layout[w - i - 1][h - j - 1];
429 break; 379
380 layout.swap (new_layout);
381 new_layout.free ();
430 } 382 }
383 break;
431 } 384 }
432 return NULL;
433} 385}
434 386
435/* take a layout and make some rooms in it. 387/* take a layout and make some rooms in it.
436 --works best on onions.*/ 388 --works best on onions.*/
437void 389void
438roomify_layout (char **maze, RMParms * RP) 390roomify_layout (char **maze, random_map_params *RP)
439{ 391{
440 int tries = RP->Xsize * RP->Ysize / 30; 392 int tries = RP->Xsize * RP->Ysize / 30;
441 int ti; 393 int ti;
442 394
443 for (ti = 0; ti < tries; ti++) 395 for (ti = 0; ti < tries; ti++)
444 { 396 {
445 int dx, dy; /* starting location for looking at creating a door */ 397 int dx, dy; /* starting location for looking at creating a door */
446 int cx, cy; /* results of checking on creating walls. */ 398 int cx, cy; /* results of checking on creating walls. */
447 399
448 dx = RANDOM () % RP->Xsize; 400 dx = rndm (RP->Xsize);
449 dy = RANDOM () % RP->Ysize; 401 dy = rndm (RP->Ysize);
402
450 cx = can_make_wall (maze, dx, dy, 0, RP); /* horizontal */ 403 cx = can_make_wall (maze, dx, dy, 0, RP); /* horizontal */
451 cy = can_make_wall (maze, dx, dy, 1, RP); /* vertical */ 404 cy = can_make_wall (maze, dx, dy, 1, RP); /* vertical */
452 if (cx == -1) 405 if (cx == -1)
453 { 406 {
454 if (cy != -1) 407 if (cy != -1)
455 make_wall (maze, dx, dy, 1); 408 make_wall (maze, dx, dy, 1);
409
456 continue; 410 continue;
457 } 411 }
412
458 if (cy == -1) 413 if (cy == -1)
459 { 414 {
460 make_wall (maze, dx, dy, 0); 415 make_wall (maze, dx, dy, 0);
461 continue; 416 continue;
462 } 417 }
418
463 if (cx < cy) 419 if (cx < cy)
464 make_wall (maze, dx, dy, 0); 420 make_wall (maze, dx, dy, 0);
465 else 421 else
466 make_wall (maze, dx, dy, 1); 422 make_wall (maze, dx, dy, 1);
467 } 423 }
… …
470/* checks the layout to see if I can stick a horizontal(dir = 0) wall 426/* checks the layout to see if I can stick a horizontal(dir = 0) wall
471 (or vertical, dir == 1) 427 (or vertical, dir == 1)
472 here which ends up on other walls sensibly. */ 428 here which ends up on other walls sensibly. */
473 429
474int 430int
475can_make_wall (char **maze, int dx, int dy, int dir, RMParms * RP) 431can_make_wall (char **maze, int dx, int dy, int dir, random_map_params *RP)
476{ 432{
477 int i1; 433 int i1;
478 int length = 0; 434 int length = 0;
479 435
480 /* dont make walls if we're on the edge. */ 436 /* dont make walls if we're on the edge. */
… …
555make_wall (char **maze, int x, int y, int dir) 511make_wall (char **maze, int x, int y, int dir)
556{ 512{
557 maze[x][y] = 'D'; /* mark a door */ 513 maze[x][y] = 'D'; /* mark a door */
558 switch (dir) 514 switch (dir)
559 { 515 {
560 case 0: /* horizontal */ 516 case 0: /* horizontal */
561 { 517 {
562 int i1; 518 int i1;
563 519
564 for (i1 = x - 1; maze[i1][y] == 0; i1--) 520 for (i1 = x - 1; maze[i1][y] == 0; i1--)
565 maze[i1][y] = '#'; 521 maze[i1][y] = '#';
566 for (i1 = x + 1; maze[i1][y] == 0; i1++) 522 for (i1 = x + 1; maze[i1][y] == 0; i1++)
567 maze[i1][y] = '#'; 523 maze[i1][y] = '#';
568 break; 524 break;
569 } 525 }
570 case 1: /* vertical */ 526 case 1: /* vertical */
571 { 527 {
572 int i1; 528 int i1;
573 529
574 for (i1 = y - 1; maze[x][i1] == 0; i1--) 530 for (i1 = y - 1; maze[x][i1] == 0; i1--)
575 maze[x][i1] = '#'; 531 maze[x][i1] = '#';
576 for (i1 = y + 1; maze[x][i1] == 0; i1++) 532 for (i1 = y + 1; maze[x][i1] == 0; i1++)
577 maze[x][i1] = '#'; 533 maze[x][i1] = '#';
578 break; 534 break;
579 } 535 }
580 } 536 }
581 537
582 return 0; 538 return 0;
583} 539}
584 540
585/* puts doors at appropriate locations in a layout. */ 541/* puts doors at appropriate locations in a layout. */
586
587void 542void
588doorify_layout (char **maze, RMParms * RP) 543doorify_layout (char **maze, random_map_params *RP)
589{ 544{
590 int ndoors = RP->Xsize * RP->Ysize / 60; /* reasonable number of doors. */ 545 int ndoors = RP->Xsize * RP->Ysize / 60; /* reasonable number of doors. */
591 char *doorlist_x;
592 char *doorlist_y;
593 int doorlocs = 0; /* # of available doorlocations */ 546 int doorlocs = 0; /* # of available doorlocations */
594 int i, j; 547 int i, j;
595 548
596 doorlist_x = (char *) malloc (sizeof (int) * RP->Xsize * RP->Ysize); 549 char *doorlist_x = salloc<char> (RP->Xsize * RP->Ysize);
597 doorlist_y = (char *) malloc (sizeof (int) * RP->Xsize * RP->Ysize); 550 char *doorlist_y = salloc<char> (RP->Xsize * RP->Ysize);
598
599 551
600 /* make a list of possible door locations */ 552 /* make a list of possible door locations */
601 for (i = 1; i < RP->Xsize - 1; i++) 553 for (i = 1; i < RP->Xsize - 1; i++)
602 for (j = 1; j < RP->Ysize - 1; j++) 554 for (j = 1; j < RP->Ysize - 1; j++)
603 { 555 {
… …
608 doorlist_x[doorlocs] = i; 560 doorlist_x[doorlocs] = i;
609 doorlist_y[doorlocs] = j; 561 doorlist_y[doorlocs] = j;
610 doorlocs++; 562 doorlocs++;
611 } 563 }
612 } 564 }
565
613 while (ndoors > 0 && doorlocs > 0) 566 while (ndoors > 0 && doorlocs > 0)
614 { 567 {
615 int di; 568 int di;
616 int sindex; 569 int sindex;
617 570
618 di = RANDOM () % doorlocs; 571 di = rndm (doorlocs);
619 i = doorlist_x[di]; 572 i = doorlist_x[di];
620 j = doorlist_y[di]; 573 j = doorlist_y[di];
621 sindex = surround_flag (maze, i, j, RP); 574 sindex = surround_flag (maze, i, j, RP);
575
622 if (sindex == 3 || sindex == 12) /* these are possible door sindex */ 576 if (sindex == 3 || sindex == 12) /* these are possible door sindex */
623 { 577 {
624 maze[i][j] = 'D'; 578 maze[i][j] = 'D';
625 ndoors--; 579 ndoors--;
626 } 580 }
581
627 /* reduce the size of the list */ 582 /* reduce the size of the list */
628 doorlocs--; 583 doorlocs--;
629 doorlist_x[di] = doorlist_x[doorlocs]; 584 doorlist_x[di] = doorlist_x[doorlocs];
630 doorlist_y[di] = doorlist_y[doorlocs]; 585 doorlist_y[di] = doorlist_y[doorlocs];
631 } 586 }
632 free (doorlist_x);
633 free (doorlist_y);
634}
635 587
588 sfree (doorlist_x, RP->Xsize * RP->Ysize);
589 sfree (doorlist_y, RP->Xsize * RP->Ysize);
590}
636 591
637void 592void
638write_map_parameters_to_string (char *buf, RMParms * RP) 593write_map_parameters_to_string (char *buf, random_map_params *RP)
639{ 594{
640
641 char small_buf[256]; 595 char small_buf[16384];
642 596
643 sprintf (buf, "xsize %d\nysize %d\n", RP->Xsize, RP->Ysize); 597 sprintf (buf, "xsize %d\nysize %d\n", RP->xsize, RP->ysize);
644 598
645 if (RP->wallstyle[0]) 599 if (RP->wallstyle[0])
646 { 600 {
647 sprintf (small_buf, "wallstyle %s\n", RP->wallstyle); 601 sprintf (small_buf, "wallstyle %s\n", RP->wallstyle);
648 strcat (buf, small_buf); 602 strcat (buf, small_buf);
… …
688 { 642 {
689 sprintf (small_buf, "exitstyle %s\n", RP->exitstyle); 643 sprintf (small_buf, "exitstyle %s\n", RP->exitstyle);
690 strcat (buf, small_buf); 644 strcat (buf, small_buf);
691 } 645 }
692 646
693 if (RP->final_map[0]) 647 if (RP->final_map.length ())
694 { 648 {
695 sprintf (small_buf, "final_map %s\n", RP->final_map); 649 sprintf (small_buf, "final_map %s\n", &RP->final_map);
696 strcat (buf, small_buf); 650 strcat (buf, small_buf);
697 } 651 }
698 652
699 if (RP->exit_on_final_map[0]) 653 if (RP->exit_on_final_map[0])
700 { 654 {
701 sprintf (small_buf, "exit_on_final_map %s\n", RP->exit_on_final_map); 655 sprintf (small_buf, "exit_on_final_map %s\n", RP->exit_on_final_map);
702 strcat (buf, small_buf); 656 strcat (buf, small_buf);
703 } 657 }
704 658
705 if (RP->this_map[0]) 659 if (RP->this_map.length ())
706 { 660 {
707 sprintf (small_buf, "origin_map %s\n", RP->this_map); 661 sprintf (small_buf, "origin_map %s\n", &RP->this_map);
708 strcat (buf, small_buf); 662 strcat (buf, small_buf);
709 } 663 }
710 664
711 if (RP->expand2x) 665 if (RP->expand2x)
712 { 666 {
… …
718 { 672 {
719 sprintf (small_buf, "layoutoptions1 %d\n", RP->layoutoptions1); 673 sprintf (small_buf, "layoutoptions1 %d\n", RP->layoutoptions1);
720 strcat (buf, small_buf); 674 strcat (buf, small_buf);
721 } 675 }
722 676
723
724 if (RP->layoutoptions2) 677 if (RP->layoutoptions2)
725 { 678 {
726 sprintf (small_buf, "layoutoptions2 %d\n", RP->layoutoptions2); 679 sprintf (small_buf, "layoutoptions2 %d\n", RP->layoutoptions2);
727 strcat (buf, small_buf); 680 strcat (buf, small_buf);
728 } 681 }
729 682
730
731 if (RP->layoutoptions3) 683 if (RP->layoutoptions3)
732 { 684 {
733 sprintf (small_buf, "layoutoptions3 %d\n", RP->layoutoptions3); 685 sprintf (small_buf, "layoutoptions3 %d\n", RP->layoutoptions3);
734 strcat (buf, small_buf); 686 strcat (buf, small_buf);
735 } 687 }
… …
737 if (RP->symmetry) 689 if (RP->symmetry)
738 { 690 {
739 sprintf (small_buf, "symmetry %d\n", RP->symmetry); 691 sprintf (small_buf, "symmetry %d\n", RP->symmetry);
740 strcat (buf, small_buf); 692 strcat (buf, small_buf);
741 } 693 }
742
743 694
744 if (RP->difficulty && RP->difficulty_given) 695 if (RP->difficulty && RP->difficulty_given)
745 { 696 {
746 sprintf (small_buf, "difficulty %d\n", RP->difficulty); 697 sprintf (small_buf, "difficulty %d\n", RP->difficulty);
747 strcat (buf, small_buf); 698 strcat (buf, small_buf);
… …
783 if (RP->origin_y) 734 if (RP->origin_y)
784 { 735 {
785 sprintf (small_buf, "origin_y %d\n", RP->origin_y); 736 sprintf (small_buf, "origin_y %d\n", RP->origin_y);
786 strcat (buf, small_buf); 737 strcat (buf, small_buf);
787 } 738 }
739
740 if (RP->treasureoptions)
741 {
742 sprintf (small_buf, "treasureoptions %d\n", RP->treasureoptions);
743 strcat (buf, small_buf);
744 }
745
788 if (RP->random_seed) 746 if (RP->random_seed)
789 { 747 {
790 /* Add one so that the next map is a bit different */
791 sprintf (small_buf, "random_seed %d\n", RP->random_seed + 1); 748 sprintf (small_buf, "random_seed %u\n", RP->random_seed);
792 strcat (buf, small_buf); 749 strcat (buf, small_buf);
793 }
794
795 if (RP->treasureoptions)
796 { 750 }
797 sprintf (small_buf, "treasureoptions %d\n", RP->treasureoptions); 751
798 strcat (buf, small_buf); 752 if (RP->custom)
799 } 753 {
800 754 sprintf (small_buf, "custom %s\n", RP->custom);
801 755 strcat (buf, small_buf);
756 }
802} 757}
803 758
804void 759void
805write_parameters_to_string (char *buf, 760write_parameters_to_string (char *buf,
806 int xsize_n, 761 int xsize_n,
807 int ysize_n, 762 int ysize_n,
808 char *wallstyle_n, 763 const char *wallstyle_n,
809 char *floorstyle_n, 764 const char *floorstyle_n,
810 char *monsterstyle_n, 765 const char *monsterstyle_n,
811 char *treasurestyle_n, 766 const char *treasurestyle_n,
812 char *layoutstyle_n, 767 const char *layoutstyle_n,
813 char *decorstyle_n, 768 const char *decorstyle_n,
814 char *doorstyle_n, 769 const char *doorstyle_n,
815 char *exitstyle_n, 770 const char *exitstyle_n,
816 char *final_map_n, 771 const char *final_map_n,
817 char *exit_on_final_map_n, 772 const char *exit_on_final_map_n,
818 char *this_map_n, 773 const char *this_map_n,
819 int layoutoptions1_n, 774 int layoutoptions1_n,
820 int layoutoptions2_n, 775 int layoutoptions2_n,
821 int layoutoptions3_n, 776 int layoutoptions3_n,
822 int symmetry_n, 777 int symmetry_n,
823 int dungeon_depth_n, 778 int dungeon_depth_n,
824 int dungeon_level_n, 779 int dungeon_level_n,
825 int difficulty_n, 780 int difficulty_n,
826 int difficulty_given_n, 781 int difficulty_given_n,
827 int decoroptions_n, 782 int decoroptions_n,
828 int orientation_n, 783 int orientation_n,
829 int origin_x_n, int origin_y_n, int random_seed_n, int treasureoptions_n, float difficulty_increase) 784 int origin_x_n,
785 int origin_y_n,
786 uint32_t random_seed_n,
787 int treasureoptions_n,
788 float difficulty_increase)
830{ 789{
831
832 char small_buf[256]; 790 char small_buf[16384];
833 791
834 sprintf (buf, "xsize %d\nysize %d\n", xsize_n, ysize_n); 792 sprintf (buf, "xsize %d\nysize %d\n", xsize_n, ysize_n);
835 793
836 if (wallstyle_n && wallstyle_n[0]) 794 if (wallstyle_n && wallstyle_n[0])
837 { 795 {
… …
902 if (layoutoptions1_n) 860 if (layoutoptions1_n)
903 { 861 {
904 sprintf (small_buf, "layoutoptions1 %d\n", layoutoptions1_n); 862 sprintf (small_buf, "layoutoptions1 %d\n", layoutoptions1_n);
905 strcat (buf, small_buf); 863 strcat (buf, small_buf);
906 } 864 }
907
908 865
909 if (layoutoptions2_n) 866 if (layoutoptions2_n)
910 { 867 {
911 sprintf (small_buf, "layoutoptions2 %d\n", layoutoptions2_n); 868 sprintf (small_buf, "layoutoptions2 %d\n", layoutoptions2_n);
912 strcat (buf, small_buf); 869 strcat (buf, small_buf);
… …
968 if (origin_y_n) 925 if (origin_y_n)
969 { 926 {
970 sprintf (small_buf, "origin_y %d\n", origin_y_n); 927 sprintf (small_buf, "origin_y %d\n", origin_y_n);
971 strcat (buf, small_buf); 928 strcat (buf, small_buf);
972 } 929 }
930
973 if (random_seed_n) 931 if (random_seed_n)
974 { 932 {
975 /* Add one so that the next map is a bit different */ 933 /* Add one so that the next map is a bit different */
976 sprintf (small_buf, "random_seed %d\n", random_seed_n + 1); 934 sprintf (small_buf, "random_seed %u\n", random_seed_n + 1);
977 strcat (buf, small_buf); 935 strcat (buf, small_buf);
978 } 936 }
979 937
980 if (treasureoptions_n) 938 if (treasureoptions_n)
981 { 939 {
982 sprintf (small_buf, "treasureoptions %d\n", treasureoptions_n); 940 sprintf (small_buf, "treasureoptions %d\n", treasureoptions_n);
983 strcat (buf, small_buf); 941 strcat (buf, small_buf);
984 } 942 }
985
986
987} 943}
988 944
989/* copy an object with an inventory... i.e., duplicate the inv too. */ 945/////////////////////////////////////////////////////////////////////////////
990void
991copy_object_with_inv (object *src_ob, object *dest_ob)
992{
993 object *walk, *tmp;
994 946
995 copy_object (src_ob, dest_ob); 947LayoutData::LayoutData (int w, int h)
948: w(w), h(h)
949{
950 int size = (sizeof (char *) + sizeof (char) * h) * w;
996 951
997 for (walk = src_ob->inv; walk != NULL; walk = walk->below) 952 col = (char **)salloc<char> (size);
998 { 953
999 tmp = get_object (); 954 char *data = (char *)(col + w);
1000 copy_object (walk, tmp); 955
1001 insert_ob_in_ob (tmp, dest_ob); 956 for (int x = w; x--; )
1002 } 957 col [x] = data + x * h;
1003} 958}
959
960LayoutData::~LayoutData ()
961{
962 int size = (sizeof (char *) + sizeof (char) * h) * w;
963
964 sfree ((char *)col, size);
965}
966
967void LayoutData::clear (char fill)
968{
969 memset (col [0], fill, w * h);
970}
971
972void LayoutData::border (char fill)
973{
974 for (int i = 0; i < w; i++) col [i][0] = col [i][h - 1] = fill;
975 for (int j = 0; j < h; j++) col [0][j] = col [w - 1][j] = fill;
976}
977

Diff Legend

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