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

Diff Legend

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