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.9 by root, Thu Dec 14 22:45:40 2006 UTC vs.
Revision 1.38 by root, Fri May 2 21:22:22 2008 UTC

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

Diff Legend

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