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.11 by root, Sat Dec 30 18:45:28 2006 UTC vs.
Revision 1.36 by root, Tue Apr 15 18:43:11 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, random_map_params * 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 }
52 printf ("\n");
53}
54 46
55extern FILE *logfile; 47 putc ('\n', stdout);
48}
56 49
57maptile * 50bool
58generate_random_map (const char *OutFileName, random_map_params * RP) 51maptile::generate_random_map (random_map_params *RP)
59{ 52{
60 char **layout, buf[HUGE_BUF]; 53 char buf[16384];
61 maptile *theMap;
62 int i; 54 int i;
63 55
56 RP->Xsize = RP->xsize;
57 RP->Ysize = RP->ysize;
58
64 /* 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 */
65 if (RP->random_seed == 0) 60 RP->random_seed = RP->random_seed
66 RP->random_seed = time (0); 61 ? RP->random_seed + RP->dungeon_level
67 62 : time (0);
68 SRANDOM (RP->random_seed); 63 CEDE;
69 64
70 write_map_parameters_to_string (buf, RP); 65 write_map_parameters_to_string (buf, RP);
71 66
72 if (RP->difficulty == 0) 67 if (RP->difficulty == 0)
73 { 68 {
… …
81 } 76 }
82 else 77 else
83 RP->difficulty_given = 1; 78 RP->difficulty_given = 1;
84 79
85 if (RP->Xsize < MIN_RANDOM_MAP_SIZE) 80 if (RP->Xsize < MIN_RANDOM_MAP_SIZE)
86 RP->Xsize = MIN_RANDOM_MAP_SIZE + RANDOM () % 25 + 5; 81 RP->Xsize = MIN_RANDOM_MAP_SIZE + rndm (25) + 5;
87 82
88 if (RP->Ysize < MIN_RANDOM_MAP_SIZE) 83 if (RP->Ysize < MIN_RANDOM_MAP_SIZE)
89 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;
90 96
91 if (RP->expand2x > 0) 97 if (RP->expand2x > 0)
92 { 98 {
93 RP->Xsize /= 2; 99 RP->Xsize /= 2;
94 RP->Ysize /= 2; 100 RP->Ysize /= 2;
95 } 101 }
96 102
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 theMap->fix_auto_apply ();
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 (random_map_params * RP)
174{
175 char **maze = 0;
176 int oxsize = RP->Xsize, oysize = RP->Ysize;
177
178 if (RP->symmetry == SYMMETRY_RANDOM)
179 RP->symmetry_used = (RANDOM () % (SYMMETRY_XY)) + 1;
180 else
181 RP->symmetry_used = RP->symmetry;
182
183 if (RP->symmetry_used == SYMMETRY_Y || RP->symmetry_used == SYMMETRY_XY)
184 RP->Ysize = RP->Ysize / 2 + 1;
185 if (RP->symmetry_used == SYMMETRY_X || RP->symmetry_used == SYMMETRY_XY)
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; 103 RP->map_layout_style = LAYOUT_NONE;
193 104
194 /* 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
195 * layout style and then random layout style. Instead, figure out 106 * layout style and then random layout style. Instead, figure out
196 * the numeric layoutstyle, so there is only one area that actually 107 * the numeric layoutstyle, so there is only one area that actually
197 * calls the code to make the maps. 108 * calls the code to make the maps.
198 */ 109 */
199 if (strstr (RP->layoutstyle, "onion")) 110 if (strstr (RP->layoutstyle, "onion"))
200 RP->map_layout_style = LAYOUT_ONION; 111 RP->map_layout_style = LAYOUT_ONION;
201
202 if (strstr (RP->layoutstyle, "maze")) 112 else if (strstr (RP->layoutstyle, "maze"))
203 RP->map_layout_style = LAYOUT_MAZE; 113 RP->map_layout_style = LAYOUT_MAZE;
204
205 if (strstr (RP->layoutstyle, "spiral")) 114 else if (strstr (RP->layoutstyle, "spiral"))
206 RP->map_layout_style = LAYOUT_SPIRAL; 115 RP->map_layout_style = LAYOUT_SPIRAL;
207
208 if (strstr (RP->layoutstyle, "rogue")) 116 else if (strstr (RP->layoutstyle, "rogue"))
209 RP->map_layout_style = LAYOUT_ROGUELIKE; 117 RP->map_layout_style = LAYOUT_ROGUELIKE;
210
211 if (strstr (RP->layoutstyle, "snake")) 118 else if (strstr (RP->layoutstyle, "snake"))
212 RP->map_layout_style = LAYOUT_SNAKE; 119 RP->map_layout_style = LAYOUT_SNAKE;
213
214 if (strstr (RP->layoutstyle, "squarespiral")) 120 else if (strstr (RP->layoutstyle, "squarespiral"))
215 RP->map_layout_style = LAYOUT_SQUARE_SPIRAL; 121 RP->map_layout_style = LAYOUT_SQUARE_SPIRAL;
216
217 /* No style found - choose one ranomdly */
218 if (RP->map_layout_style == LAYOUT_NONE) 122 else if (RP->map_layout_style == LAYOUT_NONE)
219 RP->map_layout_style = (RANDOM () % (NROFLAYOUTS - 1)) + 1; 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"))
150 {
151 make_map_walls (this, layout, RP->wallstyle, RP);
152
153 /* place doors unless doorstyle or wallstyle is "none" */
154 if (strcmp (RP->doorstyle, "none"))
155 put_doors (this, layout, RP->doorstyle, RP);
156 }
157
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);
220 214
221 switch (RP->map_layout_style) 215 switch (RP->map_layout_style)
222 { 216 {
223 case LAYOUT_ONION: 217 case LAYOUT_ONION:
224 maze = map_gen_onion (RP->Xsize, RP->Ysize, RP->layoutoptions1, RP->layoutoptions2); 218 map_gen_onion (layout, RP->layoutoptions1, RP->layoutoptions2);
219
225 if (!(RANDOM () % 3) && !(RP->layoutoptions1 & RMOPT_WALLS_ONLY)) 220 if (!(rndm (3)) && !(RP->layoutoptions1 & RMOPT_WALLS_ONLY))
226 roomify_layout (maze, RP); 221 roomify_layout (layout, RP);
222
227 break; 223 break;
228 224
229 case LAYOUT_MAZE: 225 case LAYOUT_MAZE:
230 maze = maze_gen (RP->Xsize, RP->Ysize, RANDOM () % 2); 226 maze_gen (layout, rndm (2));
231 if (!(RANDOM () % 2)) 227
228 if (!(rndm (2)))
232 doorify_layout (maze, RP); 229 doorify_layout (layout, RP);
230
233 break; 231 break;
234 232
235 case LAYOUT_SPIRAL: 233 case LAYOUT_SPIRAL:
236 maze = map_gen_spiral (RP->Xsize, RP->Ysize, RP->layoutoptions1); 234 map_gen_spiral (layout, RP->layoutoptions1);
237 if (!(RANDOM () % 2)) 235
236 if (!(rndm (2)))
238 doorify_layout (maze, RP); 237 doorify_layout (layout, RP);
238
239 break; 239 break;
240 240
241 case LAYOUT_ROGUELIKE: 241 case LAYOUT_ROGUELIKE:
242 /* 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
243 * 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),
… …
245 * spirals, or maps with lots of passages - making a symmetric rogue 245 * spirals, or maps with lots of passages - making a symmetric rogue
246 * map fails because its likely that the passages the symmetry process 246 * map fails because its likely that the passages the symmetry process
247 * creates may not connect the rooms. 247 * creates may not connect the rooms.
248 */ 248 */
249 RP->symmetry_used = SYMMETRY_NONE; 249 RP->symmetry_used = SYMMETRY_NONE;
250 RP->Ysize = oysize;
251 RP->Xsize = oxsize;
252 maze = roguelike_layout_gen (RP->Xsize, RP->Ysize, RP->layoutoptions1); 250 roguelike_layout_gen (layout, RP->layoutoptions1);
253 /* no doorifying... done already */ 251 /* no doorifying... done already */
254 break; 252 break;
255 253
256 case LAYOUT_SNAKE: 254 case LAYOUT_SNAKE:
257 maze = make_snake_layout (RP->Xsize, RP->Ysize, RP->layoutoptions1); 255 make_snake_layout (layout, RP->layoutoptions1);
258 if (RANDOM () % 2) 256
257 if (rndm (2))
259 roomify_layout (maze, RP); 258 roomify_layout (layout, RP);
259
260 break; 260 break;
261 261
262 case LAYOUT_SQUARE_SPIRAL: 262 case LAYOUT_SQUARE_SPIRAL:
263 maze = make_square_spiral_layout (RP->Xsize, RP->Ysize, RP->layoutoptions1); 263 make_square_spiral_layout (layout, RP->layoutoptions1);
264 if (RANDOM () % 2) 264
265 if (rndm (2))
265 roomify_layout (maze, RP); 266 roomify_layout (layout, RP);
267
266 break; 268 break;
267 }
268 269
269 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);
270 278
271#ifdef RMAP_DEBUG 279#ifdef RMAP_DEBUG
272 dump_layout (maze, RP); 280 dump_layout (layout);
273#endif 281#endif
274 282
275 if (RP->expand2x) 283 if (RP->expand2x)
276 { 284 expand2x (layout);
277 maze = expand2x (maze, RP->Xsize, RP->Ysize);
278 RP->Xsize = RP->Xsize * 2 - 1;
279 RP->Ysize = RP->Ysize * 2 - 1;
280 }
281 285
282 return maze; 286 return layout;
283} 287}
284 288
285/* takes a map and makes it symmetric: adjusts Xsize and 289/* takes a map and makes it symmetric: adjusts Xsize and
286Ysize to produce a symmetric map. */ 290 * Ysize to produce a symmetric map.
287char ** 291 */
292static void
288symmetrize_layout (char **maze, int sym, random_map_params * RP) 293symmetrize_layout (Layout layout, random_map_params *RP)
289{ 294{
290 int i, j;
291 char **sym_maze;
292 int Xsize_orig, Ysize_orig;
293
294 Xsize_orig = RP->Xsize;
295 Ysize_orig = RP->Ysize;
296 RP->symmetry_used = sym; /* tell everyone else what sort of symmetry is used. */
297 if (sym == SYMMETRY_NONE) 295 if (RP->symmetry_used == SYMMETRY_NONE)
298 {
299 RP->Xsize = Xsize_orig;
300 RP->Ysize = Ysize_orig;
301 return maze; 296 return;
302 }
303 /* pick new sizes */
304 RP->Xsize = ((sym == SYMMETRY_X || sym == SYMMETRY_XY) ? RP->Xsize * 2 - 3 : RP->Xsize);
305 RP->Ysize = ((sym == SYMMETRY_Y || sym == SYMMETRY_XY) ? RP->Ysize * 2 - 3 : RP->Ysize);
306 297
307 sym_maze = (char **) calloc (sizeof (char *), RP->Xsize); 298 Layout sym_layout (
308 for (i = 0; i < RP->Xsize; i++) 299 RP->symmetry_used == SYMMETRY_X || RP->symmetry_used == SYMMETRY_XY ? layout->w * 2 - 3 : layout->w,
309 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 );
310 302
311 if (sym == SYMMETRY_X) 303 if (RP->symmetry_used == SYMMETRY_X)
312 for (i = 0; i < RP->Xsize / 2 + 1; i++) 304 for (int i = 0; i < sym_layout->w / 2 + 1; i++)
313 for (j = 0; j < RP->Ysize; j++) 305 for (int j = 0; j < sym_layout->h; j++)
314 { 306 {
315 sym_maze[i][j] = maze[i][j]; 307 sym_layout[i ][j] =
316 sym_maze[RP->Xsize - i - 1][j] = maze[i][j]; 308 sym_layout[sym_layout->w - i - 1][j] = layout[i][j];
317 }; 309 }
310
318 if (sym == SYMMETRY_Y) 311 if (RP->symmetry_used == SYMMETRY_Y)
319 for (i = 0; i < RP->Xsize; i++) 312 for (int i = 0; i < sym_layout->w; i++)
320 for (j = 0; j < RP->Ysize / 2 + 1; j++) 313 for (int j = 0; j < sym_layout->h / 2 + 1; j++)
321 {
322 sym_maze[i][j] = maze[i][j];
323 sym_maze[i][RP->Ysize - j - 1] = maze[i][j];
324 } 314 {
325 if (sym == SYMMETRY_XY) 315 sym_layout[i][j ] =
326 for (i = 0; i < RP->Xsize / 2 + 1; i++) 316 sym_layout[i][sym_layout->h - j - 1] = layout[i][j];
327 for (j = 0; j < RP->Ysize / 2 + 1; j++)
328 { 317 }
329 sym_maze[i][j] = maze[i][j]; 318
330 sym_maze[i][RP->Ysize - j - 1] = maze[i][j]; 319 if (RP->symmetry_used == SYMMETRY_XY)
331 sym_maze[RP->Xsize - i - 1][j] = maze[i][j]; 320 for (int i = 0; i < sym_layout->w / 2 + 1; i++)
332 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++)
333 } 322 {
334 /* delete the old maze */ 323 sym_layout[i ][j ] =
335 for (i = 0; i < Xsize_orig; i++) 324 sym_layout[i ][sym_layout->h - j - 1] =
336 free (maze[i]); 325 sym_layout[sym_layout->w - i - 1][j ] =
337 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
338 /* reconnect disjointed spirals */ 332 /* reconnect disjointed spirals */
339 if (RP->map_layout_style == LAYOUT_SPIRAL)
340 connect_spirals (RP->Xsize, RP->Ysize, sym, sym_maze);
341 /* reconnect disjointed nethackmazes: the routine for 333 /* reconnect disjointed nethacklayouts: the routine for
342 spirals will do the trick? */ 334 spirals will do the trick? */
335 if (RP->map_layout_style == LAYOUT_SPIRAL
343 if (RP->map_layout_style == LAYOUT_ROGUELIKE) 336 || RP->map_layout_style == LAYOUT_ROGUELIKE)
344 connect_spirals (RP->Xsize, RP->Ysize, sym, sym_maze); 337 connect_spirals (layout->w, layout->h, RP->symmetry_used, layout);
345
346 return sym_maze;
347} 338}
348
349 339
350/* takes a map and rotates it. This completes the 340/* takes a map and rotates it. This completes the
351 onion layouts, making them possibly centered on any wall. 341 onion layouts, making them possibly centered on any wall.
352 It'll modify Xsize and Ysize if they're swapped. 342 It'll modify Xsize and Ysize if they're swapped.
353*/ 343*/
354 344static void
355char ** 345rotate_layout (Layout layout, int rotation)
356rotate_layout (char **maze, int rotation, random_map_params * RP)
357{ 346{
358 char **new_maze; 347 int w = layout->w;
359 int i, j; 348 int h = layout->h;
360 349
361 switch (rotation) 350 switch (rotation)
362 { 351 {
363 case 0: 352 case 2: /* a reflection */
364 return maze; 353 {
354 Layout new_layout (w, h);
355
356 for (int i = 0; i < w; i++) /* copy a reflection back */
357 for (int j = 0; j < h; j++)
358 new_layout[i][j] = layout[w - i - 1][h - j - 1];
359
360 layout.swap (new_layout);
361 new_layout.free ();
362 }
365 break; 363 break;
366 case 2: /* a reflection */
367 {
368 char *newmaze = (char *) malloc (sizeof (char) * RP->Xsize * RP->Ysize);
369 364
370 for (i = 0; i < RP->Xsize; i++)
371 { /* make a copy */
372 for (j = 0; j < RP->Ysize; j++)
373 {
374 newmaze[i * RP->Ysize + j] = maze[i][j];
375 }
376 }
377 for (i = 0; i < RP->Xsize; i++)
378 { /* copy a reflection back */
379 for (j = 0; j < RP->Ysize; j++)
380 {
381 maze[i][j] = newmaze[(RP->Xsize - i - 1) * RP->Ysize + RP->Ysize - j - 1];
382 }
383 }
384 free (newmaze);
385 return maze;
386 break;
387 }
388 case 1: 365 case 1:
389 case 3: 366 case 3:
390 { 367 {
391 int swap; 368 Layout new_layout (h, w);
392 new_maze = (char **) calloc (sizeof (char *), RP->Ysize); 369
393 for (i = 0; i < RP->Ysize; i++)
394 {
395 new_maze[i] = (char *) calloc (sizeof (char), RP->Xsize);
396 }
397 if (rotation == 1) /* swap x and y */ 370 if (rotation == 1) /* swap x and y */
398 for (i = 0; i < RP->Xsize; i++) 371 for (int i = 0; i < w; i++)
399 for (j = 0; j < RP->Ysize; j++) 372 for (int j = 0; j < h; j++)
400 new_maze[j][i] = maze[i][j]; 373 new_layout[j][i] = layout[i][j];
401 374
402 if (rotation == 3) 375 if (rotation == 3) /* swap x and y */
403 { /* swap x and y */
404 for (i = 0; i < RP->Xsize; i++) 376 for (int i = 0; i < w; i++)
405 for (j = 0; j < RP->Ysize; j++) 377 for (int j = 0; j < h; j++)
406 new_maze[j][i] = maze[RP->Xsize - i - 1][RP->Ysize - j - 1]; 378 new_layout[j][i] = layout[w - i - 1][h - j - 1];
379
380 layout.swap (new_layout);
381 new_layout.free ();
407 } 382 }
408
409 /* delete the old layout */
410 for (i = 0; i < RP->Xsize; i++)
411 free (maze[i]);
412 free (maze);
413
414 swap = RP->Ysize;
415 RP->Ysize = RP->Xsize;
416 RP->Xsize = swap;
417 return new_maze;
418 break; 383 break;
419 }
420 } 384 }
421 return NULL;
422} 385}
423 386
424/* take a layout and make some rooms in it. 387/* take a layout and make some rooms in it.
425 --works best on onions.*/ 388 --works best on onions.*/
426void 389void
427roomify_layout (char **maze, random_map_params * RP) 390roomify_layout (char **maze, random_map_params *RP)
428{ 391{
429 int tries = RP->Xsize * RP->Ysize / 30; 392 int tries = RP->Xsize * RP->Ysize / 30;
430 int ti; 393 int ti;
431 394
432 for (ti = 0; ti < tries; ti++) 395 for (ti = 0; ti < tries; ti++)
433 { 396 {
434 int dx, dy; /* starting location for looking at creating a door */ 397 int dx, dy; /* starting location for looking at creating a door */
435 int cx, cy; /* results of checking on creating walls. */ 398 int cx, cy; /* results of checking on creating walls. */
436 399
437 dx = RANDOM () % RP->Xsize; 400 dx = rndm (RP->Xsize);
438 dy = RANDOM () % RP->Ysize; 401 dy = rndm (RP->Ysize);
402
439 cx = can_make_wall (maze, dx, dy, 0, RP); /* horizontal */ 403 cx = can_make_wall (maze, dx, dy, 0, RP); /* horizontal */
440 cy = can_make_wall (maze, dx, dy, 1, RP); /* vertical */ 404 cy = can_make_wall (maze, dx, dy, 1, RP); /* vertical */
441 if (cx == -1) 405 if (cx == -1)
442 { 406 {
443 if (cy != -1) 407 if (cy != -1)
444 make_wall (maze, dx, dy, 1); 408 make_wall (maze, dx, dy, 1);
409
445 continue; 410 continue;
446 } 411 }
412
447 if (cy == -1) 413 if (cy == -1)
448 { 414 {
449 make_wall (maze, dx, dy, 0); 415 make_wall (maze, dx, dy, 0);
450 continue; 416 continue;
451 } 417 }
418
452 if (cx < cy) 419 if (cx < cy)
453 make_wall (maze, dx, dy, 0); 420 make_wall (maze, dx, dy, 0);
454 else 421 else
455 make_wall (maze, dx, dy, 1); 422 make_wall (maze, dx, dy, 1);
456 } 423 }
… …
459/* 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
460 (or vertical, dir == 1) 427 (or vertical, dir == 1)
461 here which ends up on other walls sensibly. */ 428 here which ends up on other walls sensibly. */
462 429
463int 430int
464can_make_wall (char **maze, int dx, int dy, int dir, random_map_params * RP) 431can_make_wall (char **maze, int dx, int dy, int dir, random_map_params *RP)
465{ 432{
466 int i1; 433 int i1;
467 int length = 0; 434 int length = 0;
468 435
469 /* dont make walls if we're on the edge. */ 436 /* dont make walls if we're on the edge. */
… …
544make_wall (char **maze, int x, int y, int dir) 511make_wall (char **maze, int x, int y, int dir)
545{ 512{
546 maze[x][y] = 'D'; /* mark a door */ 513 maze[x][y] = 'D'; /* mark a door */
547 switch (dir) 514 switch (dir)
548 { 515 {
549 case 0: /* horizontal */ 516 case 0: /* horizontal */
550 { 517 {
551 int i1; 518 int i1;
552 519
553 for (i1 = x - 1; maze[i1][y] == 0; i1--) 520 for (i1 = x - 1; maze[i1][y] == 0; i1--)
554 maze[i1][y] = '#'; 521 maze[i1][y] = '#';
555 for (i1 = x + 1; maze[i1][y] == 0; i1++) 522 for (i1 = x + 1; maze[i1][y] == 0; i1++)
556 maze[i1][y] = '#'; 523 maze[i1][y] = '#';
557 break; 524 break;
558 } 525 }
559 case 1: /* vertical */ 526 case 1: /* vertical */
560 { 527 {
561 int i1; 528 int i1;
562 529
563 for (i1 = y - 1; maze[x][i1] == 0; i1--) 530 for (i1 = y - 1; maze[x][i1] == 0; i1--)
564 maze[x][i1] = '#'; 531 maze[x][i1] = '#';
565 for (i1 = y + 1; maze[x][i1] == 0; i1++) 532 for (i1 = y + 1; maze[x][i1] == 0; i1++)
566 maze[x][i1] = '#'; 533 maze[x][i1] = '#';
567 break; 534 break;
568 } 535 }
569 } 536 }
570 537
571 return 0; 538 return 0;
572} 539}
573 540
574/* puts doors at appropriate locations in a layout. */ 541/* puts doors at appropriate locations in a layout. */
575
576void 542void
577doorify_layout (char **maze, random_map_params * RP) 543doorify_layout (char **maze, random_map_params *RP)
578{ 544{
579 int ndoors = RP->Xsize * RP->Ysize / 60; /* reasonable number of doors. */ 545 int ndoors = RP->Xsize * RP->Ysize / 60; /* reasonable number of doors. */
580 char *doorlist_x;
581 char *doorlist_y;
582 int doorlocs = 0; /* # of available doorlocations */ 546 int doorlocs = 0; /* # of available doorlocations */
583 int i, j; 547 int i, j;
584 548
585 doorlist_x = (char *) malloc (sizeof (int) * RP->Xsize * RP->Ysize); 549 char *doorlist_x = salloc<char> (RP->Xsize * RP->Ysize);
586 doorlist_y = (char *) malloc (sizeof (int) * RP->Xsize * RP->Ysize); 550 char *doorlist_y = salloc<char> (RP->Xsize * RP->Ysize);
587
588 551
589 /* make a list of possible door locations */ 552 /* make a list of possible door locations */
590 for (i = 1; i < RP->Xsize - 1; i++) 553 for (i = 1; i < RP->Xsize - 1; i++)
591 for (j = 1; j < RP->Ysize - 1; j++) 554 for (j = 1; j < RP->Ysize - 1; j++)
592 { 555 {
… …
597 doorlist_x[doorlocs] = i; 560 doorlist_x[doorlocs] = i;
598 doorlist_y[doorlocs] = j; 561 doorlist_y[doorlocs] = j;
599 doorlocs++; 562 doorlocs++;
600 } 563 }
601 } 564 }
565
602 while (ndoors > 0 && doorlocs > 0) 566 while (ndoors > 0 && doorlocs > 0)
603 { 567 {
604 int di; 568 int di;
605 int sindex; 569 int sindex;
606 570
607 di = RANDOM () % doorlocs; 571 di = rndm (doorlocs);
608 i = doorlist_x[di]; 572 i = doorlist_x[di];
609 j = doorlist_y[di]; 573 j = doorlist_y[di];
610 sindex = surround_flag (maze, i, j, RP); 574 sindex = surround_flag (maze, i, j, RP);
575
611 if (sindex == 3 || sindex == 12) /* these are possible door sindex */ 576 if (sindex == 3 || sindex == 12) /* these are possible door sindex */
612 { 577 {
613 maze[i][j] = 'D'; 578 maze[i][j] = 'D';
614 ndoors--; 579 ndoors--;
615 } 580 }
581
616 /* reduce the size of the list */ 582 /* reduce the size of the list */
617 doorlocs--; 583 doorlocs--;
618 doorlist_x[di] = doorlist_x[doorlocs]; 584 doorlist_x[di] = doorlist_x[doorlocs];
619 doorlist_y[di] = doorlist_y[doorlocs]; 585 doorlist_y[di] = doorlist_y[doorlocs];
620 } 586 }
621 free (doorlist_x);
622 free (doorlist_y);
623}
624 587
588 sfree (doorlist_x, RP->Xsize * RP->Ysize);
589 sfree (doorlist_y, RP->Xsize * RP->Ysize);
590}
625 591
626void 592void
627write_map_parameters_to_string (char *buf, random_map_params * RP) 593write_map_parameters_to_string (char *buf, random_map_params *RP)
628{ 594{
629 char small_buf[256]; 595 char small_buf[16384];
630 596
631 sprintf (buf, "xsize %d\nysize %d\n", RP->Xsize, RP->Ysize); 597 sprintf (buf, "xsize %d\nysize %d\n", RP->xsize, RP->ysize);
632 598
633 if (RP->wallstyle[0]) 599 if (RP->wallstyle[0])
634 { 600 {
635 sprintf (small_buf, "wallstyle %s\n", RP->wallstyle); 601 sprintf (small_buf, "wallstyle %s\n", RP->wallstyle);
636 strcat (buf, small_buf); 602 strcat (buf, small_buf);
… …
676 { 642 {
677 sprintf (small_buf, "exitstyle %s\n", RP->exitstyle); 643 sprintf (small_buf, "exitstyle %s\n", RP->exitstyle);
678 strcat (buf, small_buf); 644 strcat (buf, small_buf);
679 } 645 }
680 646
681 if (RP->final_map[0]) 647 if (RP->final_map.length ())
682 { 648 {
683 sprintf (small_buf, "final_map %s\n", RP->final_map); 649 sprintf (small_buf, "final_map %s\n", &RP->final_map);
684 strcat (buf, small_buf); 650 strcat (buf, small_buf);
685 } 651 }
686 652
687 if (RP->exit_on_final_map[0]) 653 if (RP->exit_on_final_map[0])
688 { 654 {
689 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);
690 strcat (buf, small_buf); 656 strcat (buf, small_buf);
691 } 657 }
692 658
693 if (RP->this_map[0]) 659 if (RP->this_map.length ())
694 { 660 {
695 sprintf (small_buf, "origin_map %s\n", RP->this_map); 661 sprintf (small_buf, "origin_map %s\n", &RP->this_map);
696 strcat (buf, small_buf); 662 strcat (buf, small_buf);
697 } 663 }
698 664
699 if (RP->expand2x) 665 if (RP->expand2x)
700 { 666 {
… …
706 { 672 {
707 sprintf (small_buf, "layoutoptions1 %d\n", RP->layoutoptions1); 673 sprintf (small_buf, "layoutoptions1 %d\n", RP->layoutoptions1);
708 strcat (buf, small_buf); 674 strcat (buf, small_buf);
709 } 675 }
710 676
711
712 if (RP->layoutoptions2) 677 if (RP->layoutoptions2)
713 { 678 {
714 sprintf (small_buf, "layoutoptions2 %d\n", RP->layoutoptions2); 679 sprintf (small_buf, "layoutoptions2 %d\n", RP->layoutoptions2);
715 strcat (buf, small_buf); 680 strcat (buf, small_buf);
716 } 681 }
717 682
718
719 if (RP->layoutoptions3) 683 if (RP->layoutoptions3)
720 { 684 {
721 sprintf (small_buf, "layoutoptions3 %d\n", RP->layoutoptions3); 685 sprintf (small_buf, "layoutoptions3 %d\n", RP->layoutoptions3);
722 strcat (buf, small_buf); 686 strcat (buf, small_buf);
723 } 687 }
… …
725 if (RP->symmetry) 689 if (RP->symmetry)
726 { 690 {
727 sprintf (small_buf, "symmetry %d\n", RP->symmetry); 691 sprintf (small_buf, "symmetry %d\n", RP->symmetry);
728 strcat (buf, small_buf); 692 strcat (buf, small_buf);
729 } 693 }
730
731 694
732 if (RP->difficulty && RP->difficulty_given) 695 if (RP->difficulty && RP->difficulty_given)
733 { 696 {
734 sprintf (small_buf, "difficulty %d\n", RP->difficulty); 697 sprintf (small_buf, "difficulty %d\n", RP->difficulty);
735 strcat (buf, small_buf); 698 strcat (buf, small_buf);
… …
772 { 735 {
773 sprintf (small_buf, "origin_y %d\n", RP->origin_y); 736 sprintf (small_buf, "origin_y %d\n", RP->origin_y);
774 strcat (buf, small_buf); 737 strcat (buf, small_buf);
775 } 738 }
776 739
740 if (RP->treasureoptions)
741 {
742 sprintf (small_buf, "treasureoptions %d\n", RP->treasureoptions);
743 strcat (buf, small_buf);
744 }
745
777 if (RP->random_seed) 746 if (RP->random_seed)
778 { 747 {
779 /* Add one so that the next map is a bit different */
780 sprintf (small_buf, "random_seed %d\n", RP->random_seed + 1); 748 sprintf (small_buf, "random_seed %u\n", RP->random_seed);
781 strcat (buf, small_buf); 749 strcat (buf, small_buf);
782 }
783
784 if (RP->treasureoptions)
785 { 750 }
786 sprintf (small_buf, "treasureoptions %d\n", RP->treasureoptions); 751
752 if (RP->custom)
753 {
754 sprintf (small_buf, "custom %s\n", RP->custom);
787 strcat (buf, small_buf); 755 strcat (buf, small_buf);
788 } 756 }
789} 757}
790 758
791void 759void
792write_parameters_to_string (char *buf, 760write_parameters_to_string (char *buf,
793 int xsize_n, 761 int xsize_n,
794 int ysize_n, 762 int ysize_n,
795 char *wallstyle_n, 763 const char *wallstyle_n,
796 char *floorstyle_n, 764 const char *floorstyle_n,
797 char *monsterstyle_n, 765 const char *monsterstyle_n,
798 char *treasurestyle_n, 766 const char *treasurestyle_n,
799 char *layoutstyle_n, 767 const char *layoutstyle_n,
800 char *decorstyle_n, 768 const char *decorstyle_n,
801 char *doorstyle_n, 769 const char *doorstyle_n,
802 char *exitstyle_n, 770 const char *exitstyle_n,
803 char *final_map_n, 771 const char *final_map_n,
804 char *exit_on_final_map_n, 772 const char *exit_on_final_map_n,
805 char *this_map_n, 773 const char *this_map_n,
806 int layoutoptions1_n, 774 int layoutoptions1_n,
807 int layoutoptions2_n, 775 int layoutoptions2_n,
808 int layoutoptions3_n, 776 int layoutoptions3_n,
809 int symmetry_n, 777 int symmetry_n,
810 int dungeon_depth_n, 778 int dungeon_depth_n,
811 int dungeon_level_n, 779 int dungeon_level_n,
812 int difficulty_n, 780 int difficulty_n,
813 int difficulty_given_n, 781 int difficulty_given_n,
814 int decoroptions_n, 782 int decoroptions_n,
815 int orientation_n, 783 int orientation_n,
816 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)
817{ 789{
818
819 char small_buf[256]; 790 char small_buf[16384];
820 791
821 sprintf (buf, "xsize %d\nysize %d\n", xsize_n, ysize_n); 792 sprintf (buf, "xsize %d\nysize %d\n", xsize_n, ysize_n);
822 793
823 if (wallstyle_n && wallstyle_n[0]) 794 if (wallstyle_n && wallstyle_n[0])
824 { 795 {
… …
889 if (layoutoptions1_n) 860 if (layoutoptions1_n)
890 { 861 {
891 sprintf (small_buf, "layoutoptions1 %d\n", layoutoptions1_n); 862 sprintf (small_buf, "layoutoptions1 %d\n", layoutoptions1_n);
892 strcat (buf, small_buf); 863 strcat (buf, small_buf);
893 } 864 }
894
895 865
896 if (layoutoptions2_n) 866 if (layoutoptions2_n)
897 { 867 {
898 sprintf (small_buf, "layoutoptions2 %d\n", layoutoptions2_n); 868 sprintf (small_buf, "layoutoptions2 %d\n", layoutoptions2_n);
899 strcat (buf, small_buf); 869 strcat (buf, small_buf);
… …
959 } 929 }
960 930
961 if (random_seed_n) 931 if (random_seed_n)
962 { 932 {
963 /* Add one so that the next map is a bit different */ 933 /* Add one so that the next map is a bit different */
964 sprintf (small_buf, "random_seed %d\n", random_seed_n + 1); 934 sprintf (small_buf, "random_seed %u\n", random_seed_n + 1);
965 strcat (buf, small_buf); 935 strcat (buf, small_buf);
966 } 936 }
967 937
968 if (treasureoptions_n) 938 if (treasureoptions_n)
969 { 939 {
970 sprintf (small_buf, "treasureoptions %d\n", treasureoptions_n); 940 sprintf (small_buf, "treasureoptions %d\n", treasureoptions_n);
971 strcat (buf, small_buf); 941 strcat (buf, small_buf);
972 } 942 }
973
974
975} 943}
976 944
977/* copy an object with an inventory... i.e., duplicate the inv too. */ 945/* copy an object with an inventory... i.e., duplicate the inv too. */
978void 946void
979copy_object_with_inv (object *src_ob, object *dest_ob) 947copy_object_with_inv (object *src_ob, object *dest_ob)
980{ 948{
981 object *walk, *tmp; 949 object *walk, *tmp;
982 950
983 src_ob->copy_to (dest_ob); 951 src_ob->copy_to (dest_ob);
984 952
985 for (walk = src_ob->inv; walk != NULL; walk = walk->below) 953 for (walk = src_ob->inv; walk; walk = walk->below)
986 { 954 {
987 tmp = object::create (); 955 tmp = object::create ();
956
988 walk->copy_to (tmp); 957 walk->copy_to (tmp);
989 insert_ob_in_ob (tmp, dest_ob); 958 insert_ob_in_ob (tmp, dest_ob);
990 } 959 }
991} 960}
961
962/////////////////////////////////////////////////////////////////////////////
963
964LayoutData::LayoutData (int w, int h)
965: w(w), h(h)
966{
967 int size = (sizeof (char *) + sizeof (char) * h) * w;
968
969 col = (char **)salloc<char> (size);
970
971 char *data = (char *)(col + w);
972
973 for (int x = w; x--; )
974 col [x] = data + x * h;
975}
976
977LayoutData::~LayoutData ()
978{
979 int size = (sizeof (char *) + sizeof (char) * h) * w;
980
981 sfree ((char *)col, size);
982}
983
984void LayoutData::clear (char fill)
985{
986 memset (col [0], fill, w * h);
987}
988
989void LayoutData::border (char fill)
990{
991 for (int i = 0; i < w; i++) col [i][0] = col [i][h - 1] = fill;
992 for (int j = 0; j < h; j++) col [0][j] = col [w - 1][j] = fill;
993}
994

Diff Legend

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