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

Diff Legend

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