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.33 by root, Mon Apr 14 22:41:17 2008 UTC vs.
Revision 1.85 by root, Sat Nov 17 23:40:02 2018 UTC

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

Diff Legend

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