ViewVC Help
View File | Revision Log | Show Annotations | Download File
/cvs/deliantra/server/random_maps/random_map.C
(Generate patch)

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

Diff Legend

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