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.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 = rndm (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 = rndm (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 = rndm (RP->Xsize); 401 dx = rmg_rndm (RP->Xsize);
456 dy = rndm (RP->Ysize); 402 dy = rmg_rndm (RP->Ysize);
457 403
458 cx = can_make_wall (maze, dx, dy, 0, RP); /* horizontal */ 404 cx = can_make_wall (maze, dx, dy, 0, RP); /* horizontal */
459 cy = can_make_wall (maze, dx, dy, 1, RP); /* vertical */ 405 cy = can_make_wall (maze, dx, dy, 1, RP); /* vertical */
460 if (cx == -1) 406 if (cx == -1)
461 { 407 {
… …
596/* puts doors at appropriate locations in a layout. */ 542/* puts doors at appropriate locations in a layout. */
597void 543void
598doorify_layout (char **maze, random_map_params *RP) 544doorify_layout (char **maze, random_map_params *RP)
599{ 545{
600 int ndoors = RP->Xsize * RP->Ysize / 60; /* reasonable number of doors. */ 546 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 */ 547 int doorlocs = 0; /* # of available doorlocations */
604 int i, j;
605 548
606 doorlist_x = (char *) malloc (sizeof (int) * RP->Xsize * RP->Ysize); 549 uint16 *doorlist_x = salloc<uint16> (RP->Xsize * RP->Ysize);
607 doorlist_y = (char *) malloc (sizeof (int) * RP->Xsize * RP->Ysize); 550 uint16 *doorlist_y = salloc<uint16> (RP->Xsize * RP->Ysize);
608
609 551
610 /* make a list of possible door locations */ 552 /* make a list of possible door locations */
611 for (i = 1; i < RP->Xsize - 1; i++) 553 for (int i = 1; i < RP->Xsize - 1; i++)
612 for (j = 1; j < RP->Ysize - 1; j++) 554 for (int j = 1; j < RP->Ysize - 1; j++)
613 { 555 {
614 int sindex = surround_flag (maze, i, j, RP); 556 int sindex = surround_flag (maze, i, j, RP);
615 557
616 if (sindex == 3 || sindex == 12) /* these are possible door sindex */ 558 if (sindex == 3 || sindex == 12) /* these are possible door sindex */
617 { 559 {
… …
621 } 563 }
622 } 564 }
623 565
624 while (ndoors > 0 && doorlocs > 0) 566 while (ndoors > 0 && doorlocs > 0)
625 { 567 {
626 int di;
627 int sindex;
628
629 di = rndm (doorlocs); 568 int di = rmg_rndm (doorlocs);
630 i = doorlist_x[di]; 569 int i = doorlist_x[di];
631 j = doorlist_y[di]; 570 int j = doorlist_y[di];
632 sindex = surround_flag (maze, i, j, RP); 571 int sindex = surround_flag (maze, i, j, RP);
633 572
634 if (sindex == 3 || sindex == 12) /* these are possible door sindex */ 573 if (sindex == 3 || sindex == 12) /* these are possible door sindex */
635 { 574 {
636 maze[i][j] = 'D'; 575 maze[i][j] = 'D';
637 ndoors--; 576 ndoors--;
… …
641 doorlocs--; 580 doorlocs--;
642 doorlist_x[di] = doorlist_x[doorlocs]; 581 doorlist_x[di] = doorlist_x[doorlocs];
643 doorlist_y[di] = doorlist_y[doorlocs]; 582 doorlist_y[di] = doorlist_y[doorlocs];
644 } 583 }
645 584
646 free (doorlist_x); 585 sfree (doorlist_x, RP->Xsize * RP->Ysize);
647 free (doorlist_y); 586 sfree (doorlist_y, RP->Xsize * RP->Ysize);
648} 587}
649 588
650void 589void
651write_map_parameters_to_string (char *buf, random_map_params *RP) 590write_map_parameters_to_string (char *buf, random_map_params *RP)
652{ 591{
… …
998 sprintf (small_buf, "treasureoptions %d\n", treasureoptions_n); 937 sprintf (small_buf, "treasureoptions %d\n", treasureoptions_n);
999 strcat (buf, small_buf); 938 strcat (buf, small_buf);
1000 } 939 }
1001} 940}
1002 941
1003/* copy an object with an inventory... i.e., duplicate the inv too. */ 942/////////////////////////////////////////////////////////////////////////////
1004void
1005copy_object_with_inv (object *src_ob, object *dest_ob)
1006{
1007 object *walk, *tmp;
1008 943
1009 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;
1010 948
1011 for (walk = src_ob->inv; walk; walk = walk->below) 949 col = (char **)salloc<char> (size);
1012 {
1013 tmp = object::create ();
1014 950
1015 walk->copy_to (tmp); 951 char *data = (char *)(col + w);
1016 insert_ob_in_ob (tmp, dest_ob); 952
1017 } 953 for (int x = w; x--; )
954 col [x] = data + x * h;
1018} 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