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.28 by root, Sun Mar 18 03:05:40 2007 UTC vs.
Revision 1.42 by root, Mon Oct 12 14:00:58 2009 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 it under
9 * 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
10 * the Free Software Foundation; either version 2 of the License, or 10 * Free Software Foundation, either version 3 of the License, or (at your
11 * (at your option) any later version. 11 * 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 Affero GNU General Public License
19 * 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
20 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 20 * <http://www.gnu.org/licenses/>.
21 * 21 *
22 * 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>
23 */ 23 */
24 24
25#include <time.h> 25#include <time.h>
26#include <stdio.h> 26#include <stdio.h>
27#include <global.h> 27#include <global.h>
28#include <maze_gen.h>
29#include <room_gen.h>
30#include <random_map.h> 28#include <random_map.h>
31#include <rproto.h> 29#include <rproto.h>
32#include <sproto.h> 30#include <sproto.h>
33 31
34#define CEDE coroapi::cede (); rndm.seed (RP->random_seed + __LINE__); 32#define CEDE coroapi::cede_to_tick ()
33
34static void symmetrize_layout (Layout maze, random_map_params *RP);
35static void rotate_layout (Layout maze, int rotation);
35 36
36void 37void
37dump_layout (char **layout, random_map_params *RP) 38dump_layout (Layout layout)
38{ 39{
39 { 40 for (int j = 0; j < layout->h; j++)
40 int i, j;
41
42 for (i = 0; i < RP->Xsize; i++)
43 { 41 {
44 for (j = 0; j < RP->Ysize; j++) 42 for (int i = 0; i < layout->w; i++)
45 { 43 putc (layout[i][j] ? layout[i][j] : ' ', stdout);
46 if (layout[i][j] == 0) 44
47 layout[i][j] = ' '; 45 putc ('\n', stdout);
48 printf ("%c", layout[i][j]);
49 if (layout[i][j] == ' ')
50 layout[i][j] = 0;
51 }
52 printf ("\n");
53 } 46 }
54 } 47
55 printf ("\n"); 48 putc ('\n', stdout);
56} 49}
57 50
58bool 51bool
59maptile::generate_random_map (random_map_params *RP) 52maptile::generate_random_map (random_map_params *RP)
60{ 53{
61 char **layout, buf[16384]; 54 char buf[16384];
62 int i; 55 int i;
63 56
64 RP->Xsize = RP->xsize; 57 RP->Xsize = RP->xsize;
65 RP->Ysize = RP->ysize; 58 RP->Ysize = RP->ysize;
66 59
67 /* pick a random seed, or use the one from the input file */ 60 /* pick a random seed, or use the one from the input file */
68 RP->random_seed = RP->random_seed 61 RP->random_seed = RP->random_seed
69 ? RP->random_seed + RP->dungeon_level 62 ? RP->random_seed + RP->dungeon_level
70 : time (0); 63 : time (0);
71 CEDE; 64
65 // we run "single-threaded"
66 rmg_rndm.seed (RP->random_seed);
72 67
73 write_map_parameters_to_string (buf, RP); 68 write_map_parameters_to_string (buf, RP);
74 69
75 if (RP->difficulty == 0) 70 if (RP->difficulty == 0)
76 { 71 {
… …
84 } 79 }
85 else 80 else
86 RP->difficulty_given = 1; 81 RP->difficulty_given = 1;
87 82
88 if (RP->Xsize < MIN_RANDOM_MAP_SIZE) 83 if (RP->Xsize < MIN_RANDOM_MAP_SIZE)
89 RP->Xsize = MIN_RANDOM_MAP_SIZE + rndm (25) + 5; 84 RP->Xsize = MIN_RANDOM_MAP_SIZE + rmg_rndm (25) + 5;
90 85
91 if (RP->Ysize < MIN_RANDOM_MAP_SIZE) 86 if (RP->Ysize < MIN_RANDOM_MAP_SIZE)
92 RP->Ysize = MIN_RANDOM_MAP_SIZE + rndm (25) + 5; 87 RP->Ysize = MIN_RANDOM_MAP_SIZE + rmg_rndm (25) + 5;
93 88
94 if (RP->symmetry == SYMMETRY_RANDOM) 89 if (RP->symmetry == SYMMETRY_RANDOM)
95 RP->symmetry_used = rndm (SYMMETRY_XY) + 1; 90 RP->symmetry_used = rmg_rndm (SYMMETRY_XY) + 1;
96 else 91 else
97 RP->symmetry_used = RP->symmetry; 92 RP->symmetry_used = RP->symmetry;
98 93
99 if (RP->symmetry_used == SYMMETRY_Y || RP->symmetry_used == SYMMETRY_XY) 94 if (RP->symmetry_used == SYMMETRY_Y || RP->symmetry_used == SYMMETRY_XY)
100 RP->Ysize = RP->Ysize / 2 + 1; 95 RP->Ysize = RP->Ysize / 2 + 1;
… …
115 * the numeric layoutstyle, so there is only one area that actually 110 * the numeric layoutstyle, so there is only one area that actually
116 * calls the code to make the maps. 111 * calls the code to make the maps.
117 */ 112 */
118 if (strstr (RP->layoutstyle, "onion")) 113 if (strstr (RP->layoutstyle, "onion"))
119 RP->map_layout_style = LAYOUT_ONION; 114 RP->map_layout_style = LAYOUT_ONION;
120
121 if (strstr (RP->layoutstyle, "maze")) 115 else if (strstr (RP->layoutstyle, "maze"))
122 RP->map_layout_style = LAYOUT_MAZE; 116 RP->map_layout_style = LAYOUT_MAZE;
123
124 if (strstr (RP->layoutstyle, "spiral")) 117 else if (strstr (RP->layoutstyle, "spiral"))
125 RP->map_layout_style = LAYOUT_SPIRAL; 118 RP->map_layout_style = LAYOUT_SPIRAL;
126
127 if (strstr (RP->layoutstyle, "rogue")) 119 else if (strstr (RP->layoutstyle, "rogue"))
128 RP->map_layout_style = LAYOUT_ROGUELIKE; 120 RP->map_layout_style = LAYOUT_ROGUELIKE;
129
130 if (strstr (RP->layoutstyle, "snake")) 121 else if (strstr (RP->layoutstyle, "snake"))
131 RP->map_layout_style = LAYOUT_SNAKE; 122 RP->map_layout_style = LAYOUT_SNAKE;
132
133 if (strstr (RP->layoutstyle, "squarespiral")) 123 else if (strstr (RP->layoutstyle, "squarespiral"))
134 RP->map_layout_style = LAYOUT_SQUARE_SPIRAL; 124 RP->map_layout_style = LAYOUT_SQUARE_SPIRAL;
135
136 /* No style found - choose one randomly */
137 if (RP->map_layout_style == LAYOUT_NONE) 125 else if (RP->map_layout_style == LAYOUT_NONE)
138 RP->map_layout_style = rndm (NROFLAYOUTS - 1) + 1; 126 RP->map_layout_style = rmg_rndm (NROFLAYOUTS - 1) + 1; /* No style found - choose one randomly */
127 else
128 abort ();
139 129
140 layout = layoutgen (RP); 130 Layout layout = layoutgen (RP);
141 131
142#ifdef RMAP_DEBUG 132#ifdef RMAP_DEBUG
143 dump_layout (layout, RP); 133 dump_layout (layout);
144#endif 134#endif
145 135
146 /* increment these for the current map */ 136 /* increment these for the current map */
147 RP->dungeon_level += 1; 137 ++RP->dungeon_level;
148 /* allow constant-difficulty maps. */
149 /* difficulty+=1; */
150 138
151 /* rotate the layout randomly */ 139 // need to patch RP becasue following code doesn't use the Layout object
152 layout = rotate_layout (layout, rndm (4), RP); 140 RP->Xsize = layout->w;
153#ifdef RMAP_DEBUG 141 RP->Ysize = layout->h;
154 dump_layout (layout, RP);
155#endif
156 142
157 /* allocate the map and set the floor */ 143 /* allocate the map and set the floor */
158 make_map_floor (layout, RP->floorstyle, RP); 144 make_map_floor (layout, RP->floorstyle, RP);
159 145
160 /* set region */ 146 /* set region */
161 default_region = RP->region; 147 default_region = RP->region;
148
149 CEDE;
150
151 place_specials_in_map (this, layout, RP);
162 152
163 CEDE; 153 CEDE;
164 154
165 /* create walls unless the wallstyle is "none" */ 155 /* create walls unless the wallstyle is "none" */
166 if (strcmp (RP->wallstyle, "none")) 156 if (strcmp (RP->wallstyle, "none"))
… …
178 if (strcmp (RP->exitstyle, "none")) 168 if (strcmp (RP->exitstyle, "none"))
179 place_exits (this, layout, RP->exitstyle, RP->orientation, RP); 169 place_exits (this, layout, RP->exitstyle, RP->orientation, RP);
180 170
181 CEDE; 171 CEDE;
182 172
183 place_specials_in_map (this, layout, RP);
184
185 CEDE;
186
187 /* create monsters unless the monsterstyle is "none" */ 173 /* create monsters unless the monsterstyle is "none" */
188 if (strcmp (RP->monsterstyle, "none")) 174 if (strcmp (RP->monsterstyle, "none"))
189 place_monsters (this, RP->monsterstyle, RP->difficulty, RP); 175 place_monsters (this, RP->monsterstyle, RP->difficulty, RP);
190 176
191 CEDE; 177 CEDE;
… …
194 difficulty = estimate_difficulty (); 180 difficulty = estimate_difficulty ();
195 181
196 CEDE; 182 CEDE;
197 183
198 /* create treasure unless the treasurestyle is "none" */ 184 /* create treasure unless the treasurestyle is "none" */
199 if (strcmp (RP->treasurestyle, "none"))
200 place_treasure (this, layout, RP->treasurestyle, RP->treasureoptions, RP); 185 place_treasure (this, layout, RP->treasurestyle, RP->treasureoptions, RP);
201 186
202 CEDE; 187 CEDE;
203 188
204 /* create decor unless the decorstyle is "none" */ 189 /* create decor unless the decorstyle is "none" */
205 if (strcmp (RP->decorstyle, "none")) 190 if (strcmp (RP->decorstyle, "none"))
… …
212 197
213 CEDE; 198 CEDE;
214 199
215 unblock_exits (this, layout, RP); 200 unblock_exits (this, layout, RP);
216 201
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); 202 msg = strdup (buf);
224 in_memory = MAP_IN_MEMORY; 203 in_memory = MAP_ACTIVE;
225 204
226 CEDE; 205 CEDE;
227 206
228 return 1; 207 return 1;
229} 208}
230 209
231/* function selects the layout function and gives it whatever 210/* function selects the layout function and gives it whatever
232 arguments it needs. */ 211 arguments it needs. */
233char ** 212Layout
234layoutgen (random_map_params *RP) 213layoutgen (random_map_params *RP)
235{ 214{
236 char **maze = 0; 215 Layout layout (RP);
237 int oxsize = RP->Xsize, oysize = RP->Ysize;
238 216
239 switch (RP->map_layout_style) 217 switch (RP->map_layout_style)
240 { 218 {
241 case LAYOUT_ONION: 219 case LAYOUT_ONION:
242 maze = map_gen_onion (RP->Xsize, RP->Ysize, RP->layoutoptions1, RP->layoutoptions2); 220 map_gen_onion (layout, RP->layoutoptions1, RP->layoutoptions2);
221
243 if (!(rndm (3)) && !(RP->layoutoptions1 & RMOPT_WALLS_ONLY)) 222 if (!(rmg_rndm (3)) && !(RP->layoutoptions1 & RMOPT_WALLS_ONLY))
244 roomify_layout (maze, RP); 223 roomify_layout (layout, RP);
224
245 break; 225 break;
246 226
247 case LAYOUT_MAZE: 227 case LAYOUT_MAZE:
248 maze = maze_gen (RP->Xsize, RP->Ysize, rndm (2)); 228 maze_gen (layout, rmg_rndm (2));
229
249 if (!(rndm (2))) 230 if (!(rmg_rndm (2)))
250 doorify_layout (maze, RP); 231 doorify_layout (layout, RP);
232
251 break; 233 break;
252 234
253 case LAYOUT_SPIRAL: 235 case LAYOUT_SPIRAL:
254 maze = map_gen_spiral (RP->Xsize, RP->Ysize, RP->layoutoptions1); 236 map_gen_spiral (layout, RP->layoutoptions1);
237
255 if (!(rndm (2))) 238 if (!(rmg_rndm (2)))
256 doorify_layout (maze, RP); 239 doorify_layout (layout, RP);
240
257 break; 241 break;
258 242
259 case LAYOUT_ROGUELIKE: 243 case LAYOUT_ROGUELIKE:
260 /* Don't put symmetry in rogue maps. There isn't much reason to 244 /* 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), 245 * 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 247 * spirals, or maps with lots of passages - making a symmetric rogue
264 * map fails because its likely that the passages the symmetry process 248 * map fails because its likely that the passages the symmetry process
265 * creates may not connect the rooms. 249 * creates may not connect the rooms.
266 */ 250 */
267 RP->symmetry_used = SYMMETRY_NONE; 251 RP->symmetry_used = SYMMETRY_NONE;
268 RP->Ysize = oysize;
269 RP->Xsize = oxsize;
270 maze = roguelike_layout_gen (RP->Xsize, RP->Ysize, RP->layoutoptions1); 252 roguelike_layout_gen (layout, RP->layoutoptions1);
271 /* no doorifying... done already */ 253 /* no doorifying... done already */
272 break; 254 break;
273 255
274 case LAYOUT_SNAKE: 256 case LAYOUT_SNAKE:
275 maze = make_snake_layout (RP->Xsize, RP->Ysize, RP->layoutoptions1); 257 make_snake_layout (layout, RP->layoutoptions1);
258
276 if (rndm (2)) 259 if (rmg_rndm (2))
277 roomify_layout (maze, RP); 260 roomify_layout (layout, RP);
261
278 break; 262 break;
279 263
280 case LAYOUT_SQUARE_SPIRAL: 264 case LAYOUT_SQUARE_SPIRAL:
281 maze = make_square_spiral_layout (RP->Xsize, RP->Ysize, RP->layoutoptions1); 265 make_square_spiral_layout (layout, RP->layoutoptions1);
266
282 if (rndm (2)) 267 if (rmg_rndm (2))
283 roomify_layout (maze, RP); 268 roomify_layout (layout, RP);
269
284 break; 270 break;
285 }
286 271
287 maze = symmetrize_layout (maze, RP->symmetry_used, RP); 272 default:
273 abort ();
274 }
275
276 /* rotate the layout randomly */
277 rotate_layout (layout, rmg_rndm (4));
278
279 symmetrize_layout (layout, RP);
288 280
289#ifdef RMAP_DEBUG 281#ifdef RMAP_DEBUG
290 dump_layout (maze, RP); 282 dump_layout (layout);
291#endif 283#endif
292 284
293 if (RP->expand2x) 285 if (RP->expand2x)
294 { 286 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 287
300 return maze; 288 return layout;
301} 289}
302 290
303/* takes a map and makes it symmetric: adjusts Xsize and 291/* takes a map and makes it symmetric: adjusts Xsize and
304Ysize to produce a symmetric map. */ 292 * Ysize to produce a symmetric map.
305char ** 293 */
294static void
306symmetrize_layout (char **maze, int sym, random_map_params *RP) 295symmetrize_layout (Layout layout, random_map_params *RP)
307{ 296{
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) 297 if (RP->symmetry_used == SYMMETRY_NONE)
316 {
317 RP->Xsize = Xsize_orig;
318 RP->Ysize = Ysize_orig;
319 return maze; 298 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 299
325 sym_maze = (char **) calloc (sizeof (char *), RP->Xsize); 300 Layout sym_layout (
326 for (i = 0; i < RP->Xsize; i++) 301 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); 302 RP->symmetry_used == SYMMETRY_Y || RP->symmetry_used == SYMMETRY_XY ? layout->h * 2 - 3 : layout->h
303 );
328 304
329 if (sym == SYMMETRY_X) 305 if (RP->symmetry_used == SYMMETRY_X)
330 for (i = 0; i < RP->Xsize / 2 + 1; i++) 306 for (int i = 0; i < sym_layout->w / 2 + 1; i++)
331 for (j = 0; j < RP->Ysize; j++) 307 for (int j = 0; j < sym_layout->h; j++)
332 { 308 {
333 sym_maze[i][j] = maze[i][j]; 309 sym_layout[i ][j] =
334 sym_maze[RP->Xsize - i - 1][j] = maze[i][j]; 310 sym_layout[sym_layout->w - i - 1][j] = layout[i][j];
335 }; 311 }
312
336 if (sym == SYMMETRY_Y) 313 if (RP->symmetry_used == SYMMETRY_Y)
337 for (i = 0; i < RP->Xsize; i++) 314 for (int i = 0; i < sym_layout->w; i++)
338 for (j = 0; j < RP->Ysize / 2 + 1; j++) 315 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 } 316 {
343 if (sym == SYMMETRY_XY) 317 sym_layout[i][j ] =
344 for (i = 0; i < RP->Xsize / 2 + 1; i++) 318 sym_layout[i][sym_layout->h - j - 1] = layout[i][j];
345 for (j = 0; j < RP->Ysize / 2 + 1; j++)
346 { 319 }
347 sym_maze[i][j] = maze[i][j]; 320
348 sym_maze[i][RP->Ysize - j - 1] = maze[i][j]; 321 if (RP->symmetry_used == SYMMETRY_XY)
349 sym_maze[RP->Xsize - i - 1][j] = maze[i][j]; 322 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]; 323 for (int j = 0; j < sym_layout->h / 2 + 1; j++)
351 } 324 {
352 /* delete the old maze */ 325 sym_layout[i ][j ] =
353 for (i = 0; i < Xsize_orig; i++) 326 sym_layout[i ][sym_layout->h - j - 1] =
354 free (maze[i]); 327 sym_layout[sym_layout->w - i - 1][j ] =
355 free (maze); 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
356 /* reconnect disjointed spirals */ 334 /* 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 335 /* reconnect disjointed nethacklayouts: the routine for
360 spirals will do the trick? */ 336 spirals will do the trick? */
337 if (RP->map_layout_style == LAYOUT_SPIRAL
361 if (RP->map_layout_style == LAYOUT_ROGUELIKE) 338 || RP->map_layout_style == LAYOUT_ROGUELIKE)
362 connect_spirals (RP->Xsize, RP->Ysize, sym, sym_maze); 339 connect_spirals (layout->w, layout->h, RP->symmetry_used, layout);
363
364 return sym_maze;
365} 340}
366
367 341
368/* takes a map and rotates it. This completes the 342/* takes a map and rotates it. This completes the
369 onion layouts, making them possibly centered on any wall. 343 onion layouts, making them possibly centered on any wall.
370 It'll modify Xsize and Ysize if they're swapped. 344 It'll modify Xsize and Ysize if they're swapped.
371*/ 345*/
372 346static void
373char ** 347rotate_layout (Layout layout, int rotation)
374rotate_layout (char **maze, int rotation, random_map_params *RP)
375{ 348{
376 char **new_maze; 349 int w = layout->w;
377 int i, j; 350 int h = layout->h;
378 351
379 switch (rotation) 352 switch (rotation)
380 { 353 {
381 case 0: 354 case 2: /* a reflection */
382 return maze; 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 }
383 break; 365 break;
384 case 2: /* a reflection */
385 {
386 char *newmaze = (char *) malloc (sizeof (char) * RP->Xsize * RP->Ysize);
387 366
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: 367 case 1:
407 case 3: 368 case 3:
408 { 369 {
409 int swap; 370 Layout new_layout (h, w);
410 new_maze = (char **) calloc (sizeof (char *), RP->Ysize); 371
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 */ 372 if (rotation == 1) /* swap x and y */
416 for (i = 0; i < RP->Xsize; i++) 373 for (int i = 0; i < w; i++)
417 for (j = 0; j < RP->Ysize; j++) 374 for (int j = 0; j < h; j++)
418 new_maze[j][i] = maze[i][j]; 375 new_layout[j][i] = layout[i][j];
419 376
420 if (rotation == 3) 377 if (rotation == 3) /* swap x and y */
421 { /* swap x and y */
422 for (i = 0; i < RP->Xsize; i++) 378 for (int i = 0; i < w; i++)
423 for (j = 0; j < RP->Ysize; j++) 379 for (int j = 0; j < h; j++)
424 new_maze[j][i] = maze[RP->Xsize - i - 1][RP->Ysize - j - 1]; 380 new_layout[j][i] = layout[w - i - 1][h - j - 1];
381
382 layout.swap (new_layout);
383 new_layout.free ();
425 } 384 }
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; 385 break;
437 }
438 } 386 }
439 return NULL;
440} 387}
441 388
442/* take a layout and make some rooms in it. 389/* take a layout and make some rooms in it.
443 --works best on onions.*/ 390 --works best on onions.*/
444void 391void
… …
450 for (ti = 0; ti < tries; ti++) 397 for (ti = 0; ti < tries; ti++)
451 { 398 {
452 int dx, dy; /* starting location for looking at creating a door */ 399 int dx, dy; /* starting location for looking at creating a door */
453 int cx, cy; /* results of checking on creating walls. */ 400 int cx, cy; /* results of checking on creating walls. */
454 401
455 dx = rndm (RP->Xsize); 402 dx = rmg_rndm (RP->Xsize);
456 dy = rndm (RP->Ysize); 403 dy = rmg_rndm (RP->Ysize);
457 404
458 cx = can_make_wall (maze, dx, dy, 0, RP); /* horizontal */ 405 cx = can_make_wall (maze, dx, dy, 0, RP); /* horizontal */
459 cy = can_make_wall (maze, dx, dy, 1, RP); /* vertical */ 406 cy = can_make_wall (maze, dx, dy, 1, RP); /* vertical */
460 if (cx == -1) 407 if (cx == -1)
461 { 408 {
… …
596/* puts doors at appropriate locations in a layout. */ 543/* puts doors at appropriate locations in a layout. */
597void 544void
598doorify_layout (char **maze, random_map_params *RP) 545doorify_layout (char **maze, random_map_params *RP)
599{ 546{
600 int ndoors = RP->Xsize * RP->Ysize / 60; /* reasonable number of doors. */ 547 int ndoors = RP->Xsize * RP->Ysize / 60; /* reasonable number of doors. */
601 char *doorlist_x;
602 char *doorlist_y;
603 int doorlocs = 0; /* # of available doorlocations */ 548 int doorlocs = 0; /* # of available doorlocations */
604 int i, j;
605 549
606 doorlist_x = (char *) malloc (sizeof (int) * RP->Xsize * RP->Ysize); 550 uint16 *doorlist_x = salloc<uint16> (RP->Xsize * RP->Ysize);
607 doorlist_y = (char *) malloc (sizeof (int) * RP->Xsize * RP->Ysize); 551 uint16 *doorlist_y = salloc<uint16> (RP->Xsize * RP->Ysize);
608
609 552
610 /* make a list of possible door locations */ 553 /* make a list of possible door locations */
611 for (i = 1; i < RP->Xsize - 1; i++) 554 for (int i = 1; i < RP->Xsize - 1; i++)
612 for (j = 1; j < RP->Ysize - 1; j++) 555 for (int j = 1; j < RP->Ysize - 1; j++)
613 { 556 {
614 int sindex = surround_flag (maze, i, j, RP); 557 int sindex = surround_flag (maze, i, j, RP);
615 558
616 if (sindex == 3 || sindex == 12) /* these are possible door sindex */ 559 if (sindex == 3 || sindex == 12) /* these are possible door sindex */
617 { 560 {
… …
621 } 564 }
622 } 565 }
623 566
624 while (ndoors > 0 && doorlocs > 0) 567 while (ndoors > 0 && doorlocs > 0)
625 { 568 {
626 int di;
627 int sindex;
628
629 di = rndm (doorlocs); 569 int di = rmg_rndm (doorlocs);
630 i = doorlist_x[di]; 570 int i = doorlist_x[di];
631 j = doorlist_y[di]; 571 int j = doorlist_y[di];
632 sindex = surround_flag (maze, i, j, RP); 572 int sindex = surround_flag (maze, i, j, RP);
633 573
634 if (sindex == 3 || sindex == 12) /* these are possible door sindex */ 574 if (sindex == 3 || sindex == 12) /* these are possible door sindex */
635 { 575 {
636 maze[i][j] = 'D'; 576 maze[i][j] = 'D';
637 ndoors--; 577 ndoors--;
… …
641 doorlocs--; 581 doorlocs--;
642 doorlist_x[di] = doorlist_x[doorlocs]; 582 doorlist_x[di] = doorlist_x[doorlocs];
643 doorlist_y[di] = doorlist_y[doorlocs]; 583 doorlist_y[di] = doorlist_y[doorlocs];
644 } 584 }
645 585
646 free (doorlist_x); 586 sfree (doorlist_x, RP->Xsize * RP->Ysize);
647 free (doorlist_y); 587 sfree (doorlist_y, RP->Xsize * RP->Ysize);
648} 588}
649 589
650void 590void
651write_map_parameters_to_string (char *buf, random_map_params *RP) 591write_map_parameters_to_string (char *buf, random_map_params *RP)
652{ 592{
… …
998 sprintf (small_buf, "treasureoptions %d\n", treasureoptions_n); 938 sprintf (small_buf, "treasureoptions %d\n", treasureoptions_n);
999 strcat (buf, small_buf); 939 strcat (buf, small_buf);
1000 } 940 }
1001} 941}
1002 942
1003/* copy an object with an inventory... i.e., duplicate the inv too. */ 943/////////////////////////////////////////////////////////////////////////////
1004void
1005copy_object_with_inv (object *src_ob, object *dest_ob)
1006{
1007 object *walk, *tmp;
1008 944
1009 src_ob->copy_to (dest_ob); 945LayoutData::LayoutData (int w, int h)
946: w(w), h(h)
947{
948 int size = (sizeof (char *) + sizeof (char) * h) * w;
1010 949
1011 for (walk = src_ob->inv; walk; walk = walk->below) 950 col = (char **)salloc<char> (size);
1012 {
1013 tmp = object::create ();
1014 951
1015 walk->copy_to (tmp); 952 char *data = (char *)(col + w);
1016 insert_ob_in_ob (tmp, dest_ob); 953
1017 } 954 for (int x = w; x--; )
955 col [x] = data + x * h;
1018} 956}
957
958LayoutData::~LayoutData ()
959{
960 int size = (sizeof (char *) + sizeof (char) * h) * w;
961
962 sfree ((char *)col, size);
963}
964
965void LayoutData::clear (char fill)
966{
967 memset (col [0], fill, w * h);
968}
969
970void LayoutData::border (char fill)
971{
972 for (int i = 0; i < w; i++) col [i][0] = col [i][h - 1] = fill;
973 for (int j = 0; j < h; j++) col [0][j] = col [w - 1][j] = fill;
974}
975

Diff Legend

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