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

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

Diff Legend

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