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

Diff Legend

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