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

Comparing deliantra/server/random_maps/random_map.C (file contents):
Revision 1.9 by root, Thu Dec 14 22:45:40 2006 UTC vs.
Revision 1.72 by root, Mon Jul 5 00:07:21 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
34random_map_params::random_map_params ()
35{
36 hv = newHV ();
37}
38
39random_map_params::random_map_params (random_map_params *RP)
40{
41 *this = *RP;
42
43 HV *copy = newHV ();
44
45 hv_iterinit (hv);
46
47 // does not work for utf-8 keys
48 while (HE *he = hv_iternext (hv))
49 {
50 STRLEN klen; const char *key = HePV (he, klen);
51 hv_store (copy, key, klen, newSVsv (HeVAL (he)), HeHASH (he));
52 }
53
54 hv = copy;
55}
56
57random_map_params::random_map_params (HV *hv)
58{
59 this->hv = (HV *)SvREFCNT_inc_NN ((SV *)hv);
60
61 assign (wall_name, get_str ("wall_name"));
62
63 xsize = get_iv ("xsize");
64 ysize = get_iv ("ysize");
65 expand2x = get_iv ("expand2x");
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 random_seed = get_uv ("random_seed");
75 total_map_hp = get_nv ("total_map_hp"); // actually val64, but I am too lazy
76 symmetry_used = get_iv ("symmetry_used");
77}
78
79random_map_params::~random_map_params ()
80{
81 SvREFCNT_dec (hv);
82}
83
84shstr_tmp
85random_map_params::as_shstr () const
86{
87 set ("xsize" , xsize);
88 set ("ysize" , ysize);
89 set ("layoutoptions1" , layoutoptions1);
90 set ("layoutoptions2" , layoutoptions2);
91 set ("layoutoptions3" , layoutoptions3);
92 set ("dungeon_depth" , dungeon_depth);
93 set ("random_seed" , (UV)random_seed);
94 set ("difficulty" , difficulty && difficulty_given ? difficulty : 0);
95 set ("difficulty_increase", difficulty_increase);
96 set ("dungeon_level" , dungeon_level);
97
98 dynbuf_text buf;
99 hv_iterinit (hv);
100
101 // does not work for utf-8 keys
102 while (HE *he = hv_iternext (hv))
103 {
104 STRLEN klen; const char *key = HePV (he, klen);
105 STRLEN vlen; const char *value = SvPVutf8 (HeVAL (he), vlen);
106
107 buf.fadd (key, klen);
108 buf << ' ';
109 buf.fadd (value, vlen);
110 buf << '\n';
111 }
112
113 return shstr (buf);
114}
115
116noinline SV *
117random_map_params::get_sv (const char *option) const
118{
119 SV **he = hv_fetch (hv, option, strlen (option), 0);
120
121 return he ? *he : 0;
122}
123
124noinline const_utf8_string
125random_map_params::get_str (const char *option, const_utf8_string fallback) const
126{
127 SV *sv = get_sv (option);
128 return sv ? cfSvPVutf8_nolen (sv) : fallback;
129}
130
131noinline IV
132random_map_params::get_iv (const char *option, IV fallback) const
133{
134 SV *sv = get_sv (option);
135 return sv ? SvIV (sv) : fallback;
136}
137
138noinline UV
139random_map_params::get_uv (const char *option, UV fallback) const
140{
141 SV *sv = get_sv (option);
142 return sv ? SvUV (sv) : fallback;
143}
144
145noinline NV
146random_map_params::get_nv (const char *option, NV fallback) const
147{
148 SV *sv = get_sv (option);
149 return sv ? SvNV (sv) : fallback;
150}
151
152noinline void
153random_map_params::set (const char *option, SV *value) const
154{
155 int len = strlen (option);
156
157 if (value)
158 hv_store (hv, option, len, value, 0);
159 else
160 hv_delete (hv, option, len, G_DISCARD);
161}
162
163noinline void
164random_map_params::set (const char *option, const_utf8_string value) const
165{
166 set (option, value && *value ? newSVpvn_utf8 (value, strlen (value), 1) : 0);
167}
168
33void 169void
34dump_layout (char **layout, RMParms * RP) 170random_map_params::set (const char *option, IV value) const
35{ 171{
36 { 172 set (option, newSViv (value));
37 int i, j;
38
39 for (i = 0; i < RP->Xsize; i++)
40 {
41 for (j = 0; j < RP->Ysize; j++)
42 {
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 }
51 }
52 printf ("\n");
53} 173}
54 174
55extern FILE *logfile; 175void
56 176random_map_params::set (const char *option, UV value) const
57maptile *
58generate_random_map (const char *OutFileName, RMParms * RP)
59{ 177{
60 char **layout, buf[HUGE_BUF]; 178 set (option, newSVuv (value));
61 maptile *theMap; 179}
62 int i; 180
181void
182random_map_params::set (const char *option, NV value) const
183{
184 set (option, newSVnv (value));
185}
186
187bool
188maptile::generate_random_map (random_map_params *RP)
189{
190 RP->Xsize = RP->xsize;
191 RP->Ysize = RP->ysize;
192
193 max_it (RP->dungeon_level, 1);
63 194
64 /* pick a random seed, or use the one from the input file */ 195 /* pick a random seed, or use the one from the input file */
65 if (RP->random_seed == 0) 196 RP->random_seed = RP->random_seed
66 RP->random_seed = time (0); 197 ? RP->random_seed + RP->dungeon_level
198 : pticks;
67 199
68 SRANDOM (RP->random_seed); 200 // we run "single-threaded"
201 rmg_rndm.seed (RP->random_seed);
69 202
70 write_map_parameters_to_string (buf, RP); 203 shstr buf = RP->as_shstr ();
71 204
72 if (RP->difficulty == 0) 205 if (RP->difficulty == 0)
73 { 206 {
74 RP->difficulty = RP->dungeon_level; /* use this instead of a map difficulty */ 207 RP->difficulty = RP->dungeon_level; /* use this instead of a map difficulty */
75 208
76 if (RP->difficulty_increase > 0.001) 209 if (RP->difficulty_increase > 0.001f)
77 RP->difficulty = (int) ((float) RP->dungeon_level * RP->difficulty_increase); 210 RP->difficulty = RP->dungeon_level * RP->difficulty_increase;
78 211
79 if (RP->difficulty < 1) 212 if (RP->difficulty < 1)
80 RP->difficulty = 1; 213 RP->difficulty = 1;
81 } 214 }
82 else 215 else
83 RP->difficulty_given = 1; 216 RP->difficulty_given = 1;
84 217
85 if (RP->Xsize < MIN_RANDOM_MAP_SIZE) 218 if (RP->Xsize < MIN_RANDOM_MAP_SIZE)
86 RP->Xsize = MIN_RANDOM_MAP_SIZE + RANDOM () % 25 + 5; 219 RP->Xsize = MIN_RANDOM_MAP_SIZE + rmg_rndm (25) + 5;
87 220
88 if (RP->Ysize < MIN_RANDOM_MAP_SIZE) 221 if (RP->Ysize < MIN_RANDOM_MAP_SIZE)
89 RP->Ysize = MIN_RANDOM_MAP_SIZE + RANDOM () % 25 + 5; 222 RP->Ysize = MIN_RANDOM_MAP_SIZE + rmg_rndm (25) + 5;
223
224 min_it (RP->Xsize, MAX_RANDOM_MAP_SIZE);
225 min_it (RP->Ysize, MAX_RANDOM_MAP_SIZE);
226
227 int symmetry = RP->get_iv ("symmetry", SYMMETRY_NONE);
228
229 if (symmetry == SYMMETRY_RANDOM)
230 RP->symmetry_used = rmg_rndm (SYMMETRY_XY) + 1;
231 else
232 RP->symmetry_used = symmetry;
233
234 if (RP->symmetry_used == SYMMETRY_Y || RP->symmetry_used == SYMMETRY_XY)
235 RP->Ysize = RP->Ysize / 2 + 1;
236
237 if (RP->symmetry_used == SYMMETRY_X || RP->symmetry_used == SYMMETRY_XY)
238 RP->Xsize = RP->Xsize / 2 + 1;
90 239
91 if (RP->expand2x > 0) 240 if (RP->expand2x > 0)
92 { 241 {
93 RP->Xsize /= 2; 242 RP->Xsize /= 2;
94 RP->Ysize /= 2; 243 RP->Ysize /= 2;
95 } 244 }
96 245
97 layout = layoutgen (RP); 246 const char *layoutstyle = RP->get_str ("layoutstyle", "");
98 247
99#ifdef RMAP_DEBUG 248 if (strstr (layoutstyle, "onion"))
100 dump_layout (layout, RP); 249 RP->map_layout_style = LAYOUT_ONION;
250 else if (strstr (layoutstyle, "maze"))
251 RP->map_layout_style = LAYOUT_MAZE;
252 else if (strstr (layoutstyle, "spiral"))
253 RP->map_layout_style = LAYOUT_SPIRAL;
254 else if (strstr (layoutstyle, "rogue"))
255 RP->map_layout_style = LAYOUT_ROGUELIKE;
256 else if (strstr (layoutstyle, "snake"))
257 RP->map_layout_style = LAYOUT_SNAKE;
258 else if (strstr (layoutstyle, "squarespiral"))
259 RP->map_layout_style = LAYOUT_SQUARE_SPIRAL;
260 else if (strstr (layoutstyle, "cave"))
261 RP->map_layout_style = LAYOUT_CAVE;
262 else if (strstr (layoutstyle, "castle"))
263 RP->map_layout_style = LAYOUT_CASTLE;
264 else if (strstr (layoutstyle, "multiple"))
265 RP->map_layout_style = LAYOUT_MULTIPLE;
266 else
267 RP->map_layout_style = rmg_rndm (NROFLAYOUTS - 1) + 1; /* No style found - choose one randomly */
268
269 layout maze (RP->Xsize, RP->Ysize);
270 maze.generate (RP);
271
272 if (RP->get_iv ("rotate", 1))
273 maze.rotate (rmg_rndm (4));
274
275 maze.symmetrize (RP->symmetry_used);
276
277 if (RP->expand2x)
278 maze.expand2x ();
279
280#if 0
281 maze.print ();//D
101#endif 282#endif
102 283
103 /* increment these for the current map */ 284 /* increment these for the current map */
104 RP->dungeon_level += 1; 285 ++RP->dungeon_level;
105 /* allow constant-difficulty maps. */
106 /* difficulty+=1; */
107 286
108 /* rotate the layout randomly */ 287 // need to patch RP becasue following code doesn't use the layout object
109 layout = rotate_layout (layout, RANDOM () % 4, RP); 288 RP->Xsize = maze.w;
110#ifdef RMAP_DEBUG 289 RP->Ysize = maze.h;
111 dump_layout (layout, RP);
112#endif
113 290
114 /* allocate the map and set the floor */ 291 /* allocate the map and set the floor */
115 theMap = make_map_floor (layout, RP->floorstyle, RP); 292 make_map_floor (maze, RP->get_str ("floorstyle", ""), RP);
116
117 /* set the name of the map. */
118 strcpy (theMap->path, OutFileName);
119 293
120 /* set region */ 294 /* set region */
121 theMap->region = RP->region; 295 default_region = region::find (RP->get_str ("region", 0));
296
297 CEDE;
298
299 place_specials_in_map (this, maze, RP);
300
301 CEDE;
302
303 const char *wallstyle = RP->get_str ("wallstyle", "");
122 304
123 /* create walls unless the wallstyle is "none" */ 305 /* create walls unless the wallstyle is "none" */
124 if (strcmp (RP->wallstyle, "none")) 306 if (strcmp (wallstyle, "none"))
125 { 307 {
126 make_map_walls (theMap, layout, RP->wallstyle, RP); 308 make_map_walls (this, maze, wallstyle, RP->get_str ("miningstyle", ""), RP);
309
310 const char *doorstyle = RP->get_str ("doorstyle", "");
127 311
128 /* place doors unless doorstyle or wallstyle is "none" */ 312 /* place doors unless doorstyle or wallstyle is "none" */
129 if (strcmp (RP->doorstyle, "none")) 313 if (strcmp (doorstyle, "none"))
130 put_doors (theMap, layout, RP->doorstyle, RP); 314 put_doors (this, maze, doorstyle, RP);
131
132 } 315 }
316
317 CEDE;
318
319 const char *exitstyle = RP->get_str ("exitstyle", "");
133 320
134 /* create exits unless the exitstyle is "none" */ 321 /* create exits unless the exitstyle is "none" */
135 if (strcmp (RP->exitstyle, "none")) 322 if (strcmp (exitstyle, "none"))
136 place_exits (theMap, layout, RP->exitstyle, RP->orientation, RP); 323 place_exits (this, maze, exitstyle, RP->get_iv ("orientation", 0), RP);
137 324
138 place_specials_in_map (theMap, layout, RP); 325 CEDE;
326
327 const char *monsterstyle = RP->get_str ("monsterstyle", "");
139 328
140 /* create monsters unless the monsterstyle is "none" */ 329 /* create monsters unless the monsterstyle is "none" */
141 if (strcmp (RP->monsterstyle, "none")) 330 if (strcmp (monsterstyle, "none"))
142 place_monsters (theMap, RP->monsterstyle, RP->difficulty, RP); 331 place_monsters (this, monsterstyle, RP->difficulty, RP);
332
333 CEDE;
143 334
144 /* treasures needs to have a proper difficulty set for the map. */ 335 /* treasures needs to have a proper difficulty set for the map. */
145 theMap->difficulty = calculate_difficulty (theMap); 336 difficulty = estimate_difficulty ();
337
338 CEDE;
339
340 const char *treasurestyle = RP->get_str ("treasurestyle", "");
146 341
147 /* create treasure unless the treasurestyle is "none" */ 342 /* create treasure unless the treasurestyle is "none" */
148 if (strcmp (RP->treasurestyle, "none"))
149 place_treasure (theMap, layout, RP->treasurestyle, RP->treasureoptions, RP); 343 place_treasure (this, maze, treasurestyle, RP->get_iv ("treasureoptions"), RP);
344
345 CEDE;
346
347 const char *decorstyle = RP->get_str ("treasurestyle", "");
150 348
151 /* create decor unless the decorstyle is "none" */ 349 /* create decor unless the decorstyle is "none" */
152 if (strcmp (RP->decorstyle, "none")) 350 if (strcmp (decorstyle, "none"))
153 put_decor (theMap, layout, RP->decorstyle, RP->decoroptions, RP); 351 put_decor (this, maze, decorstyle, RP->get_iv ("decoroptions"), RP);
352
353 CEDE;
154 354
155 /* generate treasures, etc. */ 355 /* generate treasures, etc. */
156 fix_auto_apply (theMap); 356 fix_auto_apply ();
157 357
158 unblock_exits (theMap, layout, RP); 358 CEDE;
159 359
160 /* free the layout */ 360 unblock_exits (this, maze);
161 for (i = 0; i < RP->Xsize; i++)
162 free (layout[i]);
163 free (layout);
164 361
165 theMap->msg = strdup (buf); 362 msg = buf;
363 in_memory = MAP_ACTIVE;
166 364
167 return theMap; 365 CEDE;
168}
169 366
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
298Ysize to produce a symmetric map. */
299
300char **
301symmetrize_layout (char **maze, int sym, RMParms * RP)
302{
303 int i, j;
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;
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
320 sym_maze = (char **) calloc (sizeof (char *), RP->Xsize);
321 for (i = 0; i < RP->Xsize; i++)
322 sym_maze[i] = (char *) calloc (sizeof (char), RP->Ysize);
323
324 if (sym == X_SYM)
325 for (i = 0; i < RP->Xsize / 2 + 1; i++)
326 for (j = 0; j < RP->Ysize; j++)
327 {
328 sym_maze[i][j] = maze[i][j];
329 sym_maze[RP->Xsize - i - 1][j] = maze[i][j];
330 };
331 if (sym == Y_SYM)
332 for (i = 0; i < RP->Xsize; i++)
333 for (j = 0; j < RP->Ysize / 2 + 1; j++)
334 {
335 sym_maze[i][j] = maze[i][j];
336 sym_maze[i][RP->Ysize - j - 1] = maze[i][j];
337 }
338 if (sym == XY_SYM)
339 for (i = 0; i < RP->Xsize / 2 + 1; i++)
340 for (j = 0; j < RP->Ysize / 2 + 1; j++)
341 {
342 sym_maze[i][j] = maze[i][j];
343 sym_maze[i][RP->Ysize - j - 1] = maze[i][j];
344 sym_maze[RP->Xsize - i - 1][j] = maze[i][j];
345 sym_maze[RP->Xsize - i - 1][RP->Ysize - j - 1] = maze[i][j];
346 }
347 /* delete the old maze */
348 for (i = 0; i < Xsize_orig; i++)
349 free (maze[i]);
350 free (maze);
351 /* 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
355 spirals will do the trick? */
356 if (RP->map_layout_style == ROGUELIKE_LAYOUT)
357 connect_spirals (RP->Xsize, RP->Ysize, sym, sym_maze);
358
359 return sym_maze;
360}
361
362
363/* takes a map and rotates it. This completes the
364 onion layouts, making them possibly centered on any wall.
365 It'll modify Xsize and Ysize if they're swapped.
366*/
367
368char **
369rotate_layout (char **maze, int rotation, RMParms * RP)
370{
371 char **new_maze;
372 int i, j;
373
374 switch (rotation)
375 {
376 case 0:
377 return maze;
378 break;
379 case 2: /* a reflection */
380 {
381 char *newmaze = (char *) malloc (sizeof (char) * RP->Xsize * RP->Ysize);
382
383 for (i = 0; i < RP->Xsize; i++)
384 { /* make a copy */
385 for (j = 0; j < RP->Ysize; j++)
386 {
387 newmaze[i * RP->Ysize + j] = maze[i][j];
388 }
389 }
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 }
401 case 1:
402 case 3:
403 {
404 int swap;
405 new_maze = (char **) calloc (sizeof (char *), RP->Ysize);
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 */
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++)
424 free (maze[i]);
425 free (maze);
426
427 swap = RP->Ysize;
428 RP->Ysize = RP->Xsize;
429 RP->Xsize = swap;
430 return new_maze;
431 break;
432 }
433 }
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 }
470}
471
472/* checks the layout to see if I can stick a horizontal(dir = 0) wall
473 (or vertical, dir == 1)
474 here which ends up on other walls sensibly. */
475
476int
477can_make_wall (char **maze, int dx, int dy, int dir, RMParms * RP)
478{
479 int i1;
480 int length = 0;
481
482 /* dont make walls if we're on the edge. */
483 if (dx == 0 || dx == (RP->Xsize - 1) || dy == 0 || dy == (RP->Ysize - 1))
484 return -1;
485
486 /* don't make walls if we're ON a wall. */
487 if (maze[dx][dy] != 0)
488 return -1;
489
490 if (dir == 0) /* horizontal */
491 {
492 int y = dy;
493
494 for (i1 = dx - 1; i1 > 0; i1--)
495 {
496 int sindex = surround_flag2 (maze, i1, y, RP);
497
498 if (sindex == 1)
499 break;
500 if (sindex != 0)
501 return -1; /* can't make horiz. wall here */
502 if (maze[i1][y] != 0)
503 return -1; /* can't make horiz. wall here */
504 length++;
505 }
506
507 for (i1 = dx + 1; i1 < RP->Xsize - 1; i1++)
508 {
509 int sindex = surround_flag2 (maze, i1, y, RP);
510
511 if (sindex == 2)
512 break;
513 if (sindex != 0)
514 return -1; /* can't make horiz. wall here */
515 if (maze[i1][y] != 0)
516 return -1; /* can't make horiz. wall here */
517 length++;
518 }
519 return length;
520 }
521 else
522 { /* vertical */
523 int x = dx;
524
525 for (i1 = dy - 1; i1 > 0; i1--)
526 {
527 int sindex = surround_flag2 (maze, x, i1, RP);
528
529 if (sindex == 4)
530 break;
531 if (sindex != 0)
532 return -1; /* can't make vert. wall here */
533 if (maze[x][i1] != 0)
534 return -1; /* can't make horiz. wall here */
535 length++;
536 }
537
538 for (i1 = dy + 1; i1 < RP->Ysize - 1; i1++)
539 {
540 int sindex = surround_flag2 (maze, x, i1, RP);
541
542 if (sindex == 8)
543 break;
544 if (sindex != 0)
545 return -1; /* can't make verti. wall here */
546 if (maze[x][i1] != 0)
547 return -1; /* can't make horiz. wall here */
548 length++;
549 }
550 return length;
551 }
552 return -1; 367 return 1;
553} 368}
554 369
555
556int
557make_wall (char **maze, int x, int y, int dir)
558{
559 maze[x][y] = 'D'; /* mark a door */
560 switch (dir)
561 {
562 case 0: /* horizontal */
563 {
564 int i1;
565
566 for (i1 = x - 1; maze[i1][y] == 0; i1--)
567 maze[i1][y] = '#';
568 for (i1 = x + 1; maze[i1][y] == 0; i1++)
569 maze[i1][y] = '#';
570 break;
571 }
572 case 1: /* vertical */
573 {
574 int i1;
575
576 for (i1 = y - 1; maze[x][i1] == 0; i1--)
577 maze[x][i1] = '#';
578 for (i1 = y + 1; maze[x][i1] == 0; i1++)
579 maze[x][i1] = '#';
580 break;
581 }
582 }
583
584 return 0;
585}
586
587/* puts doors at appropriate locations in a layout. */
588
589void
590doorify_layout (char **maze, RMParms * RP)
591{
592 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 */
596 int i, j;
597
598 doorlist_x = (char *) malloc (sizeof (int) * RP->Xsize * RP->Ysize);
599 doorlist_y = (char *) malloc (sizeof (int) * RP->Xsize * RP->Ysize);
600
601
602 /* make a list of possible door locations */
603 for (i = 1; i < RP->Xsize - 1; i++)
604 for (j = 1; j < RP->Ysize - 1; j++)
605 {
606 int sindex = surround_flag (maze, i, j, RP);
607
608 if (sindex == 3 || sindex == 12) /* these are possible door sindex */
609 {
610 doorlist_x[doorlocs] = i;
611 doorlist_y[doorlocs] = j;
612 doorlocs++;
613 }
614 }
615 while (ndoors > 0 && doorlocs > 0)
616 {
617 int di;
618 int sindex;
619
620 di = RANDOM () % doorlocs;
621 i = doorlist_x[di];
622 j = doorlist_y[di];
623 sindex = surround_flag (maze, i, j, RP);
624 if (sindex == 3 || sindex == 12) /* these are possible door sindex */
625 {
626 maze[i][j] = 'D';
627 ndoors--;
628 }
629 /* reduce the size of the list */
630 doorlocs--;
631 doorlist_x[di] = doorlist_x[doorlocs];
632 doorlist_y[di] = doorlist_y[doorlocs];
633 }
634 free (doorlist_x);
635 free (doorlist_y);
636}
637
638
639void
640write_map_parameters_to_string (char *buf, RMParms * RP)
641{
642
643 char small_buf[256];
644
645 sprintf (buf, "xsize %d\nysize %d\n", RP->Xsize, RP->Ysize);
646
647 if (RP->wallstyle[0])
648 {
649 sprintf (small_buf, "wallstyle %s\n", RP->wallstyle);
650 strcat (buf, small_buf);
651 }
652
653 if (RP->floorstyle[0])
654 {
655 sprintf (small_buf, "floorstyle %s\n", RP->floorstyle);
656 strcat (buf, small_buf);
657 }
658
659 if (RP->monsterstyle[0])
660 {
661 sprintf (small_buf, "monsterstyle %s\n", RP->monsterstyle);
662 strcat (buf, small_buf);
663 }
664
665 if (RP->treasurestyle[0])
666 {
667 sprintf (small_buf, "treasurestyle %s\n", RP->treasurestyle);
668 strcat (buf, small_buf);
669 }
670
671 if (RP->layoutstyle[0])
672 {
673 sprintf (small_buf, "layoutstyle %s\n", RP->layoutstyle);
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
713 if (RP->expand2x)
714 {
715 sprintf (small_buf, "expand2x %d\n", RP->expand2x);
716 strcat (buf, small_buf);
717 }
718
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)
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 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
982 if (treasureoptions_n)
983 {
984 sprintf (small_buf, "treasureoptions %d\n", treasureoptions_n);
985 strcat (buf, small_buf);
986 }
987
988
989}
990
991/* copy an object with an inventory... i.e., duplicate the inv too. */
992void
993copy_object_with_inv (object *src_ob, object *dest_ob)
994{
995 object *walk, *tmp;
996
997 src_ob->copy_to (dest_ob);
998
999 for (walk = src_ob->inv; walk != NULL; walk = walk->below)
1000 {
1001 tmp = object::create ();
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