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.26 by root, Thu Jan 25 03:54:45 2007 UTC vs.
Revision 1.41 by root, Thu May 8 13:47:19 2008 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 (©) 2005,2006,2007,2008 Marc Alexander Lehmann / Robin Redeker / the Deliantra team
5 * Copyright (C) 2001 Mark Wedel & Crossfire Development Team 5 * Copyright (©) 2001,2007 Mark Wedel & Crossfire Development Team
6 * Copyright (C) 1992 Frank Tore Johansen 6 * Copyright (©) 1992,2007 Frank Tore Johansen
7 * 7 *
8 * This program is free software; you can redistribute it and/or modify 8 * Deliantra is free software: you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by 9 * it under the terms of the GNU General Public License as published by
10 * the Free Software Foundation; either version 2 of the License, or 10 * the Free Software Foundation, either version 3 of the License, or
11 * (at your option) any later version. 11 * (at your option) any later version.
12 * 12 *
13 * 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,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of 14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details. 16 * GNU General Public License for more details.
17 * 17 *
18 * You should have received a copy of the GNU General Public License 18 * You should have received a copy of the GNU General Public License
19 * along with this program; if not, write to the Free Software 19 * along with this program. If not, see <http://www.gnu.org/licenses/>.
20 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
21 * 20 *
22 * The authors can be reached via e-mail at <crossfire@schmorp.de> 21 * The authors can be reached via e-mail to <support@deliantra.net>
23 */ 22 */
24 23
25#include <time.h> 24#include <time.h>
26#include <stdio.h> 25#include <stdio.h>
27#include <global.h> 26#include <global.h>
28#include <maze_gen.h>
29#include <room_gen.h>
30#include <random_map.h> 27#include <random_map.h>
31#include <rproto.h> 28#include <rproto.h>
32#include <sproto.h> 29#include <sproto.h>
33 30
34#define CEDE coroapi::cede (); rndm.seed (RP->random_seed + __LINE__); 31#define CEDE coroapi::cede_to_tick ()
32
33static void symmetrize_layout (Layout maze, random_map_params *RP);
34static void rotate_layout (Layout maze, int rotation);
35 35
36void 36void
37dump_layout (char **layout, random_map_params *RP) 37dump_layout (Layout layout)
38{ 38{
39 { 39 for (int j = 0; j < layout->h; j++)
40 int i, j;
41
42 for (i = 0; i < RP->Xsize; i++)
43 { 40 {
44 for (j = 0; j < RP->Ysize; j++) 41 for (int i = 0; i < layout->w; i++)
45 { 42 putc (layout[i][j] ? layout[i][j] : ' ', stdout);
46 if (layout[i][j] == 0) 43
47 layout[i][j] = ' '; 44 putc ('\n', stdout);
48 printf ("%c", layout[i][j]);
49 if (layout[i][j] == ' ')
50 layout[i][j] = 0;
51 }
52 printf ("\n");
53 } 45 }
54 } 46
55 printf ("\n"); 47 putc ('\n', stdout);
56} 48}
57 49
58bool 50bool
59maptile::generate_random_map (random_map_params *RP) 51maptile::generate_random_map (random_map_params *RP)
60{ 52{
61 char **layout, buf[16384]; 53 char buf[16384];
62 int i; 54 int i;
63 55
64 RP->Xsize = RP->xsize; 56 RP->Xsize = RP->xsize;
65 RP->Ysize = RP->ysize; 57 RP->Ysize = RP->ysize;
66 58
67 /* pick a random seed, or use the one from the input file */ 59 /* pick a random seed, or use the one from the input file */
68 RP->random_seed = RP->random_seed 60 RP->random_seed = RP->random_seed
69 ? RP->random_seed + RP->dungeon_level 61 ? RP->random_seed + RP->dungeon_level
70 : time (0); 62 : time (0);
71 CEDE; 63
64 // we run "single-threaded"
65 rmg_rndm.seed (RP->random_seed);
72 66
73 write_map_parameters_to_string (buf, RP); 67 write_map_parameters_to_string (buf, RP);
74 68
75 if (RP->difficulty == 0) 69 if (RP->difficulty == 0)
76 { 70 {
… …
84 } 78 }
85 else 79 else
86 RP->difficulty_given = 1; 80 RP->difficulty_given = 1;
87 81
88 if (RP->Xsize < MIN_RANDOM_MAP_SIZE) 82 if (RP->Xsize < MIN_RANDOM_MAP_SIZE)
89 RP->Xsize = MIN_RANDOM_MAP_SIZE + rndm (25) + 5; 83 RP->Xsize = MIN_RANDOM_MAP_SIZE + rmg_rndm (25) + 5;
90 84
91 if (RP->Ysize < MIN_RANDOM_MAP_SIZE) 85 if (RP->Ysize < MIN_RANDOM_MAP_SIZE)
92 RP->Ysize = MIN_RANDOM_MAP_SIZE + rndm (25) + 5; 86 RP->Ysize = MIN_RANDOM_MAP_SIZE + rmg_rndm (25) + 5;
93 87
94 if (RP->symmetry == SYMMETRY_RANDOM) 88 if (RP->symmetry == SYMMETRY_RANDOM)
95 RP->symmetry_used = (RANDOM () % (SYMMETRY_XY)) + 1; 89 RP->symmetry_used = rmg_rndm (SYMMETRY_XY) + 1;
96 else 90 else
97 RP->symmetry_used = RP->symmetry; 91 RP->symmetry_used = RP->symmetry;
98 92
99 if (RP->symmetry_used == SYMMETRY_Y || RP->symmetry_used == SYMMETRY_XY) 93 if (RP->symmetry_used == SYMMETRY_Y || RP->symmetry_used == SYMMETRY_XY)
100 RP->Ysize = RP->Ysize / 2 + 1; 94 RP->Ysize = RP->Ysize / 2 + 1;
… …
115 * the numeric layoutstyle, so there is only one area that actually 109 * the numeric layoutstyle, so there is only one area that actually
116 * calls the code to make the maps. 110 * calls the code to make the maps.
117 */ 111 */
118 if (strstr (RP->layoutstyle, "onion")) 112 if (strstr (RP->layoutstyle, "onion"))
119 RP->map_layout_style = LAYOUT_ONION; 113 RP->map_layout_style = LAYOUT_ONION;
120
121 if (strstr (RP->layoutstyle, "maze")) 114 else if (strstr (RP->layoutstyle, "maze"))
122 RP->map_layout_style = LAYOUT_MAZE; 115 RP->map_layout_style = LAYOUT_MAZE;
123
124 if (strstr (RP->layoutstyle, "spiral")) 116 else if (strstr (RP->layoutstyle, "spiral"))
125 RP->map_layout_style = LAYOUT_SPIRAL; 117 RP->map_layout_style = LAYOUT_SPIRAL;
126
127 if (strstr (RP->layoutstyle, "rogue")) 118 else if (strstr (RP->layoutstyle, "rogue"))
128 RP->map_layout_style = LAYOUT_ROGUELIKE; 119 RP->map_layout_style = LAYOUT_ROGUELIKE;
129
130 if (strstr (RP->layoutstyle, "snake")) 120 else if (strstr (RP->layoutstyle, "snake"))
131 RP->map_layout_style = LAYOUT_SNAKE; 121 RP->map_layout_style = LAYOUT_SNAKE;
132
133 if (strstr (RP->layoutstyle, "squarespiral")) 122 else if (strstr (RP->layoutstyle, "squarespiral"))
134 RP->map_layout_style = LAYOUT_SQUARE_SPIRAL; 123 RP->map_layout_style = LAYOUT_SQUARE_SPIRAL;
135
136 /* No style found - choose one randomly */
137 if (RP->map_layout_style == LAYOUT_NONE) 124 else if (RP->map_layout_style == LAYOUT_NONE)
138 RP->map_layout_style = (RANDOM () % (NROFLAYOUTS - 1)) + 1; 125 RP->map_layout_style = rmg_rndm (NROFLAYOUTS - 1) + 1; /* No style found - choose one randomly */
126 else
127 abort ();
139 128
140 layout = layoutgen (RP); 129 Layout layout = layoutgen (RP);
141 130
142#ifdef RMAP_DEBUG 131#ifdef RMAP_DEBUG
143 dump_layout (layout, RP); 132 dump_layout (layout);
144#endif 133#endif
145 134
146 /* increment these for the current map */ 135 /* increment these for the current map */
147 RP->dungeon_level += 1; 136 ++RP->dungeon_level;
148 /* allow constant-difficulty maps. */
149 /* difficulty+=1; */
150 137
151 /* rotate the layout randomly */ 138 // need to patch RP becasue following code doesn't use the Layout object
152 layout = rotate_layout (layout, rndm (4), RP); 139 RP->Xsize = layout->w;
153#ifdef RMAP_DEBUG 140 RP->Ysize = layout->h;
154 dump_layout (layout, RP);
155#endif
156 141
157 /* allocate the map and set the floor */ 142 /* allocate the map and set the floor */
158 make_map_floor (layout, RP->floorstyle, RP); 143 make_map_floor (layout, RP->floorstyle, RP);
159 144
160 /* set region */ 145 /* set region */
161 default_region = RP->region; 146 default_region = RP->region;
147
148 CEDE;
149
150 place_specials_in_map (this, layout, RP);
162 151
163 CEDE; 152 CEDE;
164 153
165 /* create walls unless the wallstyle is "none" */ 154 /* create walls unless the wallstyle is "none" */
166 if (strcmp (RP->wallstyle, "none")) 155 if (strcmp (RP->wallstyle, "none"))
… …
178 if (strcmp (RP->exitstyle, "none")) 167 if (strcmp (RP->exitstyle, "none"))
179 place_exits (this, layout, RP->exitstyle, RP->orientation, RP); 168 place_exits (this, layout, RP->exitstyle, RP->orientation, RP);
180 169
181 CEDE; 170 CEDE;
182 171
183 place_specials_in_map (this, layout, RP);
184
185 CEDE;
186
187 /* create monsters unless the monsterstyle is "none" */ 172 /* create monsters unless the monsterstyle is "none" */
188 if (strcmp (RP->monsterstyle, "none")) 173 if (strcmp (RP->monsterstyle, "none"))
189 place_monsters (this, RP->monsterstyle, RP->difficulty, RP); 174 place_monsters (this, RP->monsterstyle, RP->difficulty, RP);
190 175
191 CEDE; 176 CEDE;
… …
194 difficulty = estimate_difficulty (); 179 difficulty = estimate_difficulty ();
195 180
196 CEDE; 181 CEDE;
197 182
198 /* create treasure unless the treasurestyle is "none" */ 183 /* create treasure unless the treasurestyle is "none" */
199 if (strcmp (RP->treasurestyle, "none"))
200 place_treasure (this, layout, RP->treasurestyle, RP->treasureoptions, RP); 184 place_treasure (this, layout, RP->treasurestyle, RP->treasureoptions, RP);
201 185
202 CEDE; 186 CEDE;
203 187
204 /* create decor unless the decorstyle is "none" */ 188 /* create decor unless the decorstyle is "none" */
205 if (strcmp (RP->decorstyle, "none")) 189 if (strcmp (RP->decorstyle, "none"))
… …
212 196
213 CEDE; 197 CEDE;
214 198
215 unblock_exits (this, layout, RP); 199 unblock_exits (this, layout, RP);
216 200
217 /* free the layout */
218 for (i = 0; i < RP->Xsize; i++)
219 free (layout[i]);
220
221 free (layout);
222
223 msg = strdup (buf); 201 msg = strdup (buf);
224 in_memory = MAP_IN_MEMORY; 202 in_memory = MAP_ACTIVE;
225 203
226 CEDE; 204 CEDE;
227 205
228 return 1; 206 return 1;
229} 207}
230 208
231/* function selects the layout function and gives it whatever 209/* function selects the layout function and gives it whatever
232 arguments it needs. */ 210 arguments it needs. */
233char ** 211Layout
234layoutgen (random_map_params *RP) 212layoutgen (random_map_params *RP)
235{ 213{
236 char **maze = 0; 214 Layout layout (RP);
237 int oxsize = RP->Xsize, oysize = RP->Ysize;
238 215
239 switch (RP->map_layout_style) 216 switch (RP->map_layout_style)
240 { 217 {
241 case LAYOUT_ONION: 218 case LAYOUT_ONION:
242 maze = map_gen_onion (RP->Xsize, RP->Ysize, RP->layoutoptions1, RP->layoutoptions2); 219 map_gen_onion (layout, RP->layoutoptions1, RP->layoutoptions2);
220
243 if (!(rndm (3)) && !(RP->layoutoptions1 & RMOPT_WALLS_ONLY)) 221 if (!(rmg_rndm (3)) && !(RP->layoutoptions1 & RMOPT_WALLS_ONLY))
244 roomify_layout (maze, RP); 222 roomify_layout (layout, RP);
223
245 break; 224 break;
246 225
247 case LAYOUT_MAZE: 226 case LAYOUT_MAZE:
248 maze = maze_gen (RP->Xsize, RP->Ysize, rndm (2)); 227 maze_gen (layout, rmg_rndm (2));
228
249 if (!(rndm (2))) 229 if (!(rmg_rndm (2)))
250 doorify_layout (maze, RP); 230 doorify_layout (layout, RP);
231
251 break; 232 break;
252 233
253 case LAYOUT_SPIRAL: 234 case LAYOUT_SPIRAL:
254 maze = map_gen_spiral (RP->Xsize, RP->Ysize, RP->layoutoptions1); 235 map_gen_spiral (layout, RP->layoutoptions1);
236
255 if (!(rndm (2))) 237 if (!(rmg_rndm (2)))
256 doorify_layout (maze, RP); 238 doorify_layout (layout, RP);
239
257 break; 240 break;
258 241
259 case LAYOUT_ROGUELIKE: 242 case LAYOUT_ROGUELIKE:
260 /* Don't put symmetry in rogue maps. There isn't much reason to 243 /* Don't put symmetry in rogue maps. There isn't much reason to
261 * do so in the first place (doesn't make it any more interesting), 244 * do so in the first place (doesn't make it any more interesting),
… …
263 * spirals, or maps with lots of passages - making a symmetric rogue 246 * spirals, or maps with lots of passages - making a symmetric rogue
264 * map fails because its likely that the passages the symmetry process 247 * map fails because its likely that the passages the symmetry process
265 * creates may not connect the rooms. 248 * creates may not connect the rooms.
266 */ 249 */
267 RP->symmetry_used = SYMMETRY_NONE; 250 RP->symmetry_used = SYMMETRY_NONE;
268 RP->Ysize = oysize;
269 RP->Xsize = oxsize;
270 maze = roguelike_layout_gen (RP->Xsize, RP->Ysize, RP->layoutoptions1); 251 roguelike_layout_gen (layout, RP->layoutoptions1);
271 /* no doorifying... done already */ 252 /* no doorifying... done already */
272 break; 253 break;
273 254
274 case LAYOUT_SNAKE: 255 case LAYOUT_SNAKE:
275 maze = make_snake_layout (RP->Xsize, RP->Ysize, RP->layoutoptions1); 256 make_snake_layout (layout, RP->layoutoptions1);
257
276 if (rndm (2)) 258 if (rmg_rndm (2))
277 roomify_layout (maze, RP); 259 roomify_layout (layout, RP);
260
278 break; 261 break;
279 262
280 case LAYOUT_SQUARE_SPIRAL: 263 case LAYOUT_SQUARE_SPIRAL:
281 maze = make_square_spiral_layout (RP->Xsize, RP->Ysize, RP->layoutoptions1); 264 make_square_spiral_layout (layout, RP->layoutoptions1);
265
282 if (rndm (2)) 266 if (rmg_rndm (2))
283 roomify_layout (maze, RP); 267 roomify_layout (layout, RP);
268
284 break; 269 break;
285 }
286 270
287 maze = symmetrize_layout (maze, RP->symmetry_used, RP); 271 default:
272 abort ();
273 }
274
275 /* rotate the layout randomly */
276 rotate_layout (layout, rmg_rndm (4));
277
278 symmetrize_layout (layout, RP);
288 279
289#ifdef RMAP_DEBUG 280#ifdef RMAP_DEBUG
290 dump_layout (maze, RP); 281 dump_layout (layout);
291#endif 282#endif
292 283
293 if (RP->expand2x) 284 if (RP->expand2x)
294 { 285 expand2x (layout);
295 maze = expand2x (maze, RP->Xsize, RP->Ysize);
296 RP->Xsize = RP->Xsize * 2 - 1;
297 RP->Ysize = RP->Ysize * 2 - 1;
298 }
299 286
300 return maze; 287 return layout;
301} 288}
302 289
303/* takes a map and makes it symmetric: adjusts Xsize and 290/* takes a map and makes it symmetric: adjusts Xsize and
304Ysize to produce a symmetric map. */ 291 * Ysize to produce a symmetric map.
305char ** 292 */
293static void
306symmetrize_layout (char **maze, int sym, random_map_params *RP) 294symmetrize_layout (Layout layout, random_map_params *RP)
307{ 295{
308 int i, j;
309 char **sym_maze;
310 int Xsize_orig, Ysize_orig;
311
312 Xsize_orig = RP->Xsize;
313 Ysize_orig = RP->Ysize;
314 RP->symmetry_used = sym; /* tell everyone else what sort of symmetry is used. */
315 if (sym == SYMMETRY_NONE) 296 if (RP->symmetry_used == SYMMETRY_NONE)
316 {
317 RP->Xsize = Xsize_orig;
318 RP->Ysize = Ysize_orig;
319 return maze; 297 return;
320 }
321 /* pick new sizes */
322 RP->Xsize = ((sym == SYMMETRY_X || sym == SYMMETRY_XY) ? RP->Xsize * 2 - 3 : RP->Xsize);
323 RP->Ysize = ((sym == SYMMETRY_Y || sym == SYMMETRY_XY) ? RP->Ysize * 2 - 3 : RP->Ysize);
324 298
325 sym_maze = (char **) calloc (sizeof (char *), RP->Xsize); 299 Layout sym_layout (
326 for (i = 0; i < RP->Xsize; i++) 300 RP->symmetry_used == SYMMETRY_X || RP->symmetry_used == SYMMETRY_XY ? layout->w * 2 - 3 : layout->w,
327 sym_maze[i] = (char *) calloc (sizeof (char), RP->Ysize); 301 RP->symmetry_used == SYMMETRY_Y || RP->symmetry_used == SYMMETRY_XY ? layout->h * 2 - 3 : layout->h
302 );
328 303
329 if (sym == SYMMETRY_X) 304 if (RP->symmetry_used == SYMMETRY_X)
330 for (i = 0; i < RP->Xsize / 2 + 1; i++) 305 for (int i = 0; i < sym_layout->w / 2 + 1; i++)
331 for (j = 0; j < RP->Ysize; j++) 306 for (int j = 0; j < sym_layout->h; j++)
332 { 307 {
333 sym_maze[i][j] = maze[i][j]; 308 sym_layout[i ][j] =
334 sym_maze[RP->Xsize - i - 1][j] = maze[i][j]; 309 sym_layout[sym_layout->w - i - 1][j] = layout[i][j];
335 }; 310 }
311
336 if (sym == SYMMETRY_Y) 312 if (RP->symmetry_used == SYMMETRY_Y)
337 for (i = 0; i < RP->Xsize; i++) 313 for (int i = 0; i < sym_layout->w; i++)
338 for (j = 0; j < RP->Ysize / 2 + 1; j++) 314 for (int j = 0; j < sym_layout->h / 2 + 1; j++)
339 {
340 sym_maze[i][j] = maze[i][j];
341 sym_maze[i][RP->Ysize - j - 1] = maze[i][j];
342 } 315 {
343 if (sym == SYMMETRY_XY) 316 sym_layout[i][j ] =
344 for (i = 0; i < RP->Xsize / 2 + 1; i++) 317 sym_layout[i][sym_layout->h - j - 1] = layout[i][j];
345 for (j = 0; j < RP->Ysize / 2 + 1; j++)
346 { 318 }
347 sym_maze[i][j] = maze[i][j]; 319
348 sym_maze[i][RP->Ysize - j - 1] = maze[i][j]; 320 if (RP->symmetry_used == SYMMETRY_XY)
349 sym_maze[RP->Xsize - i - 1][j] = maze[i][j]; 321 for (int i = 0; i < sym_layout->w / 2 + 1; i++)
350 sym_maze[RP->Xsize - i - 1][RP->Ysize - j - 1] = maze[i][j]; 322 for (int j = 0; j < sym_layout->h / 2 + 1; j++)
351 } 323 {
352 /* delete the old maze */ 324 sym_layout[i ][j ] =
353 for (i = 0; i < Xsize_orig; i++) 325 sym_layout[i ][sym_layout->h - j - 1] =
354 free (maze[i]); 326 sym_layout[sym_layout->w - i - 1][j ] =
355 free (maze); 327 sym_layout[sym_layout->w - i - 1][sym_layout->h - j - 1] = layout[i][j];
328 }
329
330 layout.swap (sym_layout);
331 sym_layout.free ();
332
356 /* reconnect disjointed spirals */ 333 /* reconnect disjointed spirals */
357 if (RP->map_layout_style == LAYOUT_SPIRAL)
358 connect_spirals (RP->Xsize, RP->Ysize, sym, sym_maze);
359 /* reconnect disjointed nethackmazes: the routine for 334 /* reconnect disjointed nethacklayouts: the routine for
360 spirals will do the trick? */ 335 spirals will do the trick? */
336 if (RP->map_layout_style == LAYOUT_SPIRAL
361 if (RP->map_layout_style == LAYOUT_ROGUELIKE) 337 || RP->map_layout_style == LAYOUT_ROGUELIKE)
362 connect_spirals (RP->Xsize, RP->Ysize, sym, sym_maze); 338 connect_spirals (layout->w, layout->h, RP->symmetry_used, layout);
363
364 return sym_maze;
365} 339}
366
367 340
368/* takes a map and rotates it. This completes the 341/* takes a map and rotates it. This completes the
369 onion layouts, making them possibly centered on any wall. 342 onion layouts, making them possibly centered on any wall.
370 It'll modify Xsize and Ysize if they're swapped. 343 It'll modify Xsize and Ysize if they're swapped.
371*/ 344*/
372 345static void
373char ** 346rotate_layout (Layout layout, int rotation)
374rotate_layout (char **maze, int rotation, random_map_params *RP)
375{ 347{
376 char **new_maze; 348 int w = layout->w;
377 int i, j; 349 int h = layout->h;
378 350
379 switch (rotation) 351 switch (rotation)
380 { 352 {
381 case 0: 353 case 2: /* a reflection */
382 return maze; 354 {
355 Layout new_layout (w, h);
356
357 for (int i = 0; i < w; i++) /* copy a reflection back */
358 for (int j = 0; j < h; j++)
359 new_layout[i][j] = layout[w - i - 1][h - j - 1];
360
361 layout.swap (new_layout);
362 new_layout.free ();
363 }
383 break; 364 break;
384 case 2: /* a reflection */
385 {
386 char *newmaze = (char *) malloc (sizeof (char) * RP->Xsize * RP->Ysize);
387 365
388 for (i = 0; i < RP->Xsize; i++)
389 { /* make a copy */
390 for (j = 0; j < RP->Ysize; j++)
391 {
392 newmaze[i * RP->Ysize + j] = maze[i][j];
393 }
394 }
395 for (i = 0; i < RP->Xsize; i++)
396 { /* copy a reflection back */
397 for (j = 0; j < RP->Ysize; j++)
398 {
399 maze[i][j] = newmaze[(RP->Xsize - i - 1) * RP->Ysize + RP->Ysize - j - 1];
400 }
401 }
402 free (newmaze);
403 return maze;
404 break;
405 }
406 case 1: 366 case 1:
407 case 3: 367 case 3:
408 { 368 {
409 int swap; 369 Layout new_layout (h, w);
410 new_maze = (char **) calloc (sizeof (char *), RP->Ysize); 370
411 for (i = 0; i < RP->Ysize; i++)
412 {
413 new_maze[i] = (char *) calloc (sizeof (char), RP->Xsize);
414 }
415 if (rotation == 1) /* swap x and y */ 371 if (rotation == 1) /* swap x and y */
416 for (i = 0; i < RP->Xsize; i++) 372 for (int i = 0; i < w; i++)
417 for (j = 0; j < RP->Ysize; j++) 373 for (int j = 0; j < h; j++)
418 new_maze[j][i] = maze[i][j]; 374 new_layout[j][i] = layout[i][j];
419 375
420 if (rotation == 3) 376 if (rotation == 3) /* swap x and y */
421 { /* swap x and y */
422 for (i = 0; i < RP->Xsize; i++) 377 for (int i = 0; i < w; i++)
423 for (j = 0; j < RP->Ysize; j++) 378 for (int j = 0; j < h; j++)
424 new_maze[j][i] = maze[RP->Xsize - i - 1][RP->Ysize - j - 1]; 379 new_layout[j][i] = layout[w - i - 1][h - j - 1];
380
381 layout.swap (new_layout);
382 new_layout.free ();
425 } 383 }
426
427 /* delete the old layout */
428 for (i = 0; i < RP->Xsize; i++)
429 free (maze[i]);
430 free (maze);
431
432 swap = RP->Ysize;
433 RP->Ysize = RP->Xsize;
434 RP->Xsize = swap;
435 return new_maze;
436 break; 384 break;
437 }
438 } 385 }
439 return NULL;
440} 386}
441 387
442/* take a layout and make some rooms in it. 388/* take a layout and make some rooms in it.
443 --works best on onions.*/ 389 --works best on onions.*/
444void 390void
… …
450 for (ti = 0; ti < tries; ti++) 396 for (ti = 0; ti < tries; ti++)
451 { 397 {
452 int dx, dy; /* starting location for looking at creating a door */ 398 int dx, dy; /* starting location for looking at creating a door */
453 int cx, cy; /* results of checking on creating walls. */ 399 int cx, cy; /* results of checking on creating walls. */
454 400
455 dx = RANDOM () % RP->Xsize; 401 dx = rmg_rndm (RP->Xsize);
456 dy = RANDOM () % RP->Ysize; 402 dy = rmg_rndm (RP->Ysize);
403
457 cx = can_make_wall (maze, dx, dy, 0, RP); /* horizontal */ 404 cx = can_make_wall (maze, dx, dy, 0, RP); /* horizontal */
458 cy = can_make_wall (maze, dx, dy, 1, RP); /* vertical */ 405 cy = can_make_wall (maze, dx, dy, 1, RP); /* vertical */
459 if (cx == -1) 406 if (cx == -1)
460 { 407 {
461 if (cy != -1) 408 if (cy != -1)
462 make_wall (maze, dx, dy, 1); 409 make_wall (maze, dx, dy, 1);
410
463 continue; 411 continue;
464 } 412 }
413
465 if (cy == -1) 414 if (cy == -1)
466 { 415 {
467 make_wall (maze, dx, dy, 0); 416 make_wall (maze, dx, dy, 0);
468 continue; 417 continue;
469 } 418 }
419
470 if (cx < cy) 420 if (cx < cy)
471 make_wall (maze, dx, dy, 0); 421 make_wall (maze, dx, dy, 0);
472 else 422 else
473 make_wall (maze, dx, dy, 1); 423 make_wall (maze, dx, dy, 1);
474 } 424 }
… …
592/* puts doors at appropriate locations in a layout. */ 542/* puts doors at appropriate locations in a layout. */
593void 543void
594doorify_layout (char **maze, random_map_params *RP) 544doorify_layout (char **maze, random_map_params *RP)
595{ 545{
596 int ndoors = RP->Xsize * RP->Ysize / 60; /* reasonable number of doors. */ 546 int ndoors = RP->Xsize * RP->Ysize / 60; /* reasonable number of doors. */
597 char *doorlist_x;
598 char *doorlist_y;
599 int doorlocs = 0; /* # of available doorlocations */ 547 int doorlocs = 0; /* # of available doorlocations */
600 int i, j;
601 548
602 doorlist_x = (char *) malloc (sizeof (int) * RP->Xsize * RP->Ysize); 549 uint16 *doorlist_x = salloc<uint16> (RP->Xsize * RP->Ysize);
603 doorlist_y = (char *) malloc (sizeof (int) * RP->Xsize * RP->Ysize); 550 uint16 *doorlist_y = salloc<uint16> (RP->Xsize * RP->Ysize);
604
605 551
606 /* make a list of possible door locations */ 552 /* make a list of possible door locations */
607 for (i = 1; i < RP->Xsize - 1; i++) 553 for (int i = 1; i < RP->Xsize - 1; i++)
608 for (j = 1; j < RP->Ysize - 1; j++) 554 for (int j = 1; j < RP->Ysize - 1; j++)
609 { 555 {
610 int sindex = surround_flag (maze, i, j, RP); 556 int sindex = surround_flag (maze, i, j, RP);
611 557
612 if (sindex == 3 || sindex == 12) /* these are possible door sindex */ 558 if (sindex == 3 || sindex == 12) /* these are possible door sindex */
613 { 559 {
… …
617 } 563 }
618 } 564 }
619 565
620 while (ndoors > 0 && doorlocs > 0) 566 while (ndoors > 0 && doorlocs > 0)
621 { 567 {
622 int di; 568 int di = rmg_rndm (doorlocs);
623 int sindex;
624
625 di = RANDOM () % doorlocs;
626 i = doorlist_x[di]; 569 int i = doorlist_x[di];
627 j = doorlist_y[di]; 570 int j = doorlist_y[di];
628 sindex = surround_flag (maze, i, j, RP); 571 int sindex = surround_flag (maze, i, j, RP);
572
629 if (sindex == 3 || sindex == 12) /* these are possible door sindex */ 573 if (sindex == 3 || sindex == 12) /* these are possible door sindex */
630 { 574 {
631 maze[i][j] = 'D'; 575 maze[i][j] = 'D';
632 ndoors--; 576 ndoors--;
633 } 577 }
578
634 /* reduce the size of the list */ 579 /* reduce the size of the list */
635 doorlocs--; 580 doorlocs--;
636 doorlist_x[di] = doorlist_x[doorlocs]; 581 doorlist_x[di] = doorlist_x[doorlocs];
637 doorlist_y[di] = doorlist_y[doorlocs]; 582 doorlist_y[di] = doorlist_y[doorlocs];
638 } 583 }
639 584
640 free (doorlist_x); 585 sfree (doorlist_x, RP->Xsize * RP->Ysize);
641 free (doorlist_y); 586 sfree (doorlist_y, RP->Xsize * RP->Ysize);
642} 587}
643 588
644void 589void
645write_map_parameters_to_string (char *buf, random_map_params *RP) 590write_map_parameters_to_string (char *buf, random_map_params *RP)
646{ 591{
… …
810 755
811void 756void
812write_parameters_to_string (char *buf, 757write_parameters_to_string (char *buf,
813 int xsize_n, 758 int xsize_n,
814 int ysize_n, 759 int ysize_n,
815 char *wallstyle_n, 760 const char *wallstyle_n,
816 char *floorstyle_n, 761 const char *floorstyle_n,
817 char *monsterstyle_n, 762 const char *monsterstyle_n,
818 char *treasurestyle_n, 763 const char *treasurestyle_n,
819 char *layoutstyle_n, 764 const char *layoutstyle_n,
820 char *decorstyle_n, 765 const char *decorstyle_n,
821 char *doorstyle_n, 766 const char *doorstyle_n,
822 char *exitstyle_n, 767 const char *exitstyle_n,
823 char *final_map_n, 768 const char *final_map_n,
824 char *exit_on_final_map_n, 769 const char *exit_on_final_map_n,
825 char *this_map_n, 770 const char *this_map_n,
826 int layoutoptions1_n, 771 int layoutoptions1_n,
827 int layoutoptions2_n, 772 int layoutoptions2_n,
828 int layoutoptions3_n, 773 int layoutoptions3_n,
829 int symmetry_n, 774 int symmetry_n,
830 int dungeon_depth_n, 775 int dungeon_depth_n,
831 int dungeon_level_n, 776 int dungeon_level_n,
832 int difficulty_n, 777 int difficulty_n,
833 int difficulty_given_n, 778 int difficulty_given_n,
834 int decoroptions_n, 779 int decoroptions_n,
835 int orientation_n, 780 int orientation_n,
836 int origin_x_n, int origin_y_n, uint32_t random_seed_n, int treasureoptions_n, float difficulty_increase) 781 int origin_x_n,
782 int origin_y_n,
783 uint32_t random_seed_n,
784 int treasureoptions_n,
785 float difficulty_increase)
837{ 786{
838 char small_buf[16384]; 787 char small_buf[16384];
839 788
840 sprintf (buf, "xsize %d\nysize %d\n", xsize_n, ysize_n); 789 sprintf (buf, "xsize %d\nysize %d\n", xsize_n, ysize_n);
841 790
… …
988 sprintf (small_buf, "treasureoptions %d\n", treasureoptions_n); 937 sprintf (small_buf, "treasureoptions %d\n", treasureoptions_n);
989 strcat (buf, small_buf); 938 strcat (buf, small_buf);
990 } 939 }
991} 940}
992 941
993/* copy an object with an inventory... i.e., duplicate the inv too. */ 942/////////////////////////////////////////////////////////////////////////////
994void
995copy_object_with_inv (object *src_ob, object *dest_ob)
996{
997 object *walk, *tmp;
998 943
999 src_ob->copy_to (dest_ob); 944LayoutData::LayoutData (int w, int h)
945: w(w), h(h)
946{
947 int size = (sizeof (char *) + sizeof (char) * h) * w;
1000 948
1001 for (walk = src_ob->inv; walk; walk = walk->below) 949 col = (char **)salloc<char> (size);
1002 {
1003 tmp = object::create ();
1004 950
1005 walk->copy_to (tmp); 951 char *data = (char *)(col + w);
1006 insert_ob_in_ob (tmp, dest_ob); 952
1007 } 953 for (int x = w; x--; )
954 col [x] = data + x * h;
1008} 955}
956
957LayoutData::~LayoutData ()
958{
959 int size = (sizeof (char *) + sizeof (char) * h) * w;
960
961 sfree ((char *)col, size);
962}
963
964void LayoutData::clear (char fill)
965{
966 memset (col [0], fill, w * h);
967}
968
969void LayoutData::border (char fill)
970{
971 for (int i = 0; i < w; i++) col [i][0] = col [i][h - 1] = fill;
972 for (int j = 0; j < h; j++) col [0][j] = col [w - 1][j] = fill;
973}
974

Diff Legend

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