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

Comparing deliantra/server/random_maps/treasure.C (file contents):
Revision 1.50 by root, Fri Mar 26 01:04:44 2010 UTC vs.
Revision 1.67 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,2009,2010 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 Mark Wedel & Crossfire Development Team 6 * Copyright (©) 2001 Mark Wedel & Crossfire Development Team
6 * Copyright (©) 1992 Frank Tore Johansen 7 * Copyright (©) 1992 Frank Tore Johansen
7 * 8 *
8 * Deliantra is free software: you can redistribute it and/or modify it under 9 * Deliantra is free software: you can redistribute it and/or modify it under
9 * the terms of the Affero GNU General Public License as published by the 10 * the terms of the Affero GNU General Public License as published by the
10 * Free Software Foundation, either version 3 of the License, or (at your 11 * Free Software Foundation, either version 3 of the License, or (at your
11 * 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 Affero GNU General Public License 19 * You should have received a copy of the Affero GNU General Public License
19 * and the GNU General Public License along with this program. If not, see 20 * and the GNU General Public License along with this program. If not, see
20 * <http://www.gnu.org/licenses/>. 21 * <http://www.gnu.org/licenses/>.
21 * 22 *
22 * 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>
23 */ 24 */
24 25
25/* placing treasure in maps, where appropriate. */ 26/* placing treasure in maps, where appropriate. */
26 27
27#include <global.h> 28#include <global.h>
28#include <random_map.h> 29#include <rmg.h>
29#include <rproto.h> 30#include <rproto.h>
30 31
31/* some defines for various options which can be set. */ 32/* some defines for various options which can be set. */
32 33
33#define CONCENTRATED 1 /* all the treasure is at the C's for onions. */ 34#define CONCENTRATED 1 /* all the treasure is at the C's for onions. */
… …
41#define LAST_OPTION 64 /* set this to the last real option, for random */ 42#define LAST_OPTION 64 /* set this to the last real option, for random */
42 43
43#define NO_PASS_DOORS 0 44#define NO_PASS_DOORS 0
44#define PASS_DOORS 1 45#define PASS_DOORS 1
45 46
46static object *find_closest_monster (maptile *map, int x, int y, random_map_params *RP); 47static object *find_closest_monster (maptile *map, int x, int y);
47static object *find_monster_in_room (maptile *map, int x, int y, random_map_params *RP); 48static object *find_monster_in_room (maptile *map, int x, int y);
48static void find_spot_in_room_recursive (char **layout, int x, int y, random_map_params *RP);
49static void find_spot_in_room (maptile *map, int x, int y, int *kx, int *ky, random_map_params *RP); 49static void find_spot_in_room (maptile *map, int x, int y, int *kx, int *ky);
50static object *place_chest (int treasureoptions, int x, int y, maptile *map, maptile *style_map, int n_treasures, random_map_params *RP); 50static object *place_chest (int treasureoptions, int x, int y, maptile *map, maptile *style_map, int n_treasures, random_map_params *RP);
51static object **find_doors_in_room (maptile *map, int x, int y, random_map_params *RP); 51static object **find_doors_in_room (maptile *map, int x, int y);
52static void lock_and_hide_doors (object **doorlist, maptile *map, int opts, random_map_params *RP); 52static void lock_and_hide_doors (object **doorlist, maptile *map, int opts, random_map_params *RP);
53static void find_enclosed_spot (maptile *map, int *cx, int *cy, random_map_params *RP); 53static void find_enclosed_spot (maptile *map, int *cx, int *cy);
54static object **surround_by_doors (maptile *map, char **layout, int x, int y, int opts); 54static object **surround_by_doors (maptile *map, char **maze, int x, int y, int opts);
55 55
56/* a macro to get a strongly centered random distribution, 56/* a macro to get a strongly centered random distribution,
57 from 0 to x, centered at x/2 */ 57 from 0 to x, centered at x/2 */
58static int 58static int
59bc_random (int x) 59bc_random (int x)
… …
68 object *key = archetype::get (shstr_key_random_map); 68 object *key = archetype::get (shstr_key_random_map);
69 key->slaying = keycode; 69 key->slaying = keycode;
70 return key; 70 return key;
71} 71}
72 72
73/* places keys in the map, preferably in something alive. 73/* places keys in the map, preferably in something alive.
74 keycode is the key's code, 74 keycode is the key's code,
75 door_flag is either PASS_DOORS or NO_PASS_DOORS. 75 door_flag is either PASS_DOORS or NO_PASS_DOORS.
76 NO_PASS_DOORS won't cross doors or walls to keyplace, PASS_DOORS will. 76 NO_PASS_DOORS won't cross doors or walls to keyplace, PASS_DOORS will.
77 if n_keys is 1, it will place 1 key. if n_keys >1, it will place 2-4 keys: 77 if n_keys is 1, it will place 1 key. if n_keys >1, it will place 2-4 keys:
78 it will place 2-4 keys regardless of what nkeys is provided nkeys > 1. 78 it will place 2-4 keys regardless of what nkeys is provided nkeys > 1.
79 79
80 The idea is that you call keyplace on x,y where a door is, and it'll make 80 The idea is that you call keyplace on x,y where a door is, and it'll make
81 sure a key is placed on both sides of the door. 81 sure a key is placed on both sides of the door.
82*/ 82*/
83static int 83static int
84keyplace (maptile *map, int x, int y, const shstr &keycode, int door_flag, int n_keys, random_map_params *RP) 84keyplace (maptile *map, int x, int y, const shstr &keycode, int door_flag, int n_keys)
85{ 85{
86 int i, j; 86 int i, j;
87 int kx = 0, ky = 0; 87 int kx = 0, ky = 0;
88 object *the_keymaster; /* the monster that gets the key. */ 88 object *the_keymaster; /* the monster that gets the key. */
89 object *the_key = gen_key (keycode); 89 object *the_key = gen_key (keycode);
… …
93 int tries = 0; 93 int tries = 0;
94 94
95 the_keymaster = 0; 95 the_keymaster = 0;
96 while (tries < 15 && !the_keymaster) 96 while (tries < 15 && !the_keymaster)
97 { 97 {
98 i = rmg_rndm (RP->Xsize - 2) + 1; 98 i = rmg_rndm (map->width - 2) + 1;
99 j = rmg_rndm (RP->Ysize - 2) + 1; 99 j = rmg_rndm (map->height - 2) + 1;
100 tries++; 100 tries++;
101 the_keymaster = find_closest_monster (map, i, j, RP); 101 the_keymaster = find_closest_monster (map, i, j);
102 } 102 }
103 103
104 /* if we don't find a good keymaster, drop the key on the ground. */ 104 /* if we don't find a good keymaster, drop the key on the ground. */
105 if (!the_keymaster) 105 if (!the_keymaster)
106 { 106 {
107 int freeindex; 107 int freeindex;
108 108
109 freeindex = -1; 109 freeindex = -1;
110 for (tries = 0; tries < 15 && freeindex == -1; tries++) 110 for (tries = 0; tries < 15 && freeindex == -1; tries++)
111 { 111 {
112 kx = rmg_rndm (RP->Xsize - 2) + 1; 112 kx = rmg_rndm (map->width - 2) + 1;
113 ky = rmg_rndm (RP->Ysize - 2) + 1; 113 ky = rmg_rndm (map->height - 2) + 1;
114 freeindex = find_free_spot (the_key, map, kx, ky, 1, SIZEOFFREE1 + 1); 114 freeindex = rmg_find_free_spot (the_key, map, kx, ky, 1, SIZEOFFREE1 + 1);
115 } 115 }
116 116
117 // can freeindex ever be < 0? 117 // can freeindex ever be < 0?
118 if (freeindex >= 0) 118 if (freeindex >= 0)
119 { 119 {
120 kx += freearr_x [freeindex]; 120 kx += DIRX (freeindex);
121 ky += freearr_y [freeindex]; 121 ky += DIRY (freeindex);
122 } 122 }
123 } 123 }
124 } 124 }
125 else 125 else
126 { /* NO_PASS_DOORS --we have to work harder. */ 126 { /* NO_PASS_DOORS --we have to work harder. */
… …
132 { 132 {
133 the_key->destroy (); 133 the_key->destroy ();
134 return 0; 134 return 0;
135 } 135 }
136 136
137 the_keymaster = find_monster_in_room (map, x, y, RP); 137 the_keymaster = find_monster_in_room (map, x, y);
138 if (!the_keymaster) /* if fail, find a spot to drop the key. */ 138 if (!the_keymaster) /* if fail, find a spot to drop the key. */
139 find_spot_in_room (map, x, y, &kx, &ky, RP); 139 find_spot_in_room (map, x, y, &kx, &ky);
140 } 140 }
141 else 141 else
142 { 142 {
143 int sum = 0; /* count how many keys we actually place */ 143 int sum = 0; /* count how many keys we actually place */
144 144
145 /* I'm lazy, so just try to place in all 4 directions. */ 145 /* I'm lazy, so just try to place in all 4 directions. */
146 sum += keyplace (map, x + 1, y, keycode, NO_PASS_DOORS, 1, RP); 146 sum += keyplace (map, x + 1, y, keycode, NO_PASS_DOORS, 1);
147 sum += keyplace (map, x, y + 1, keycode, NO_PASS_DOORS, 1, RP); 147 sum += keyplace (map, x, y + 1, keycode, NO_PASS_DOORS, 1);
148 sum += keyplace (map, x - 1, y, keycode, NO_PASS_DOORS, 1, RP); 148 sum += keyplace (map, x - 1, y, keycode, NO_PASS_DOORS, 1);
149 sum += keyplace (map, x, y - 1, keycode, NO_PASS_DOORS, 1, RP); 149 sum += keyplace (map, x, y - 1, keycode, NO_PASS_DOORS, 1);
150 150
151 if (sum < 2) /* we might have made a disconnected map-place more keys. */ 151 if (sum < 2) /* we might have made a disconnected map-place more keys. */
152 { /* diagonally this time. */ 152 { /* diagonally this time. */
153 keyplace (map, x + 1, y + 1, keycode, NO_PASS_DOORS, 1, RP); 153 keyplace (map, x + 1, y + 1, keycode, NO_PASS_DOORS, 1);
154 keyplace (map, x + 1, y - 1, keycode, NO_PASS_DOORS, 1, RP); 154 keyplace (map, x + 1, y - 1, keycode, NO_PASS_DOORS, 1);
155 keyplace (map, x - 1, y + 1, keycode, NO_PASS_DOORS, 1, RP); 155 keyplace (map, x - 1, y + 1, keycode, NO_PASS_DOORS, 1);
156 keyplace (map, x - 1, y - 1, keycode, NO_PASS_DOORS, 1, RP); 156 keyplace (map, x - 1, y - 1, keycode, NO_PASS_DOORS, 1);
157 } 157 }
158 158
159 the_key->destroy (); 159 the_key->destroy ();
160 return 1; 160 return 1;
161 } 161 }
… …
185 185
186 m->at (x, y).update (); 186 m->at (x, y).update ();
187 return GET_MAP_MOVE_BLOCK (m, x, y) & MOVE_WALK; 187 return GET_MAP_MOVE_BLOCK (m, x, y) & MOVE_WALK;
188} 188}
189 189
190/* place treasures in the map, given the 190/* place treasures in the map, given the
191map, (required) 191map, (required)
192layout, (required) 192maze, (required)
193treasure style (may be empty or NULL, or "none" to cause no treasure.) 193treasure style (may be empty or NULL, or "none" to cause no treasure.)
194treasureoptions (may be 0 for random choices or positive) 194treasureoptions (may be 0 for random choices or positive)
195*/ 195*/
196void 196void
197place_treasure (maptile *map, char **layout, char *treasure_style, int treasureoptions, random_map_params *RP) 197place_treasure (maptile *map, layout &maze, const char *treasure_style, int treasureoptions, random_map_params *RP)
198{ 198{
199 char styledirname[1024];
200 char stylefilepath[1024];
201 maptile *style_map = 0;
202 int num_treasures; 199 int num_treasures;
203 200
204 /* bail out if treasure isn't wanted. */ 201 /* bail out if treasure isn't wanted. */
205 if (treasure_style) 202 if (treasure_style)
206 if (!strcmp (treasure_style, "none")) 203 if (!strcmp (treasure_style, "none"))
… …
228 225
229 if (num_treasures <= 0) 226 if (num_treasures <= 0)
230 return; 227 return;
231 228
232 /* get the style map */ 229 /* get the style map */
233 sprintf (styledirname, "%s", "/styles/treasurestyles"); 230 maptile *style_map = find_style ("/styles/treasurestyles", treasure_style, RP->difficulty);
234 sprintf (stylefilepath, "%s/%s", styledirname, treasure_style);
235 style_map = find_style (styledirname, treasure_style, -1);
236 231
237 if (!style_map) 232 if (!style_map)
238 { 233 {
239 LOG (llevError, "unable to load style map %s %s.\n", styledirname, treasure_style); 234 LOG (llevError, "unable to load style map %s %s.\n", "/styles/treasurestyles", treasure_style);
240 return; 235 return;
241 } 236 }
242 237
243 /* all the treasure at one spot in the map. */ 238 /* all the treasure at one spot in the map. */
244 if (treasureoptions & CONCENTRATED) 239 if (treasureoptions & CONCENTRATED)
… …
255 /* search the onion for C's or '>', and put treasure there. */ 250 /* search the onion for C's or '>', and put treasure there. */
256 for (i = 0; i < RP->Xsize; i++) 251 for (i = 0; i < RP->Xsize; i++)
257 { 252 {
258 for (j = 0; j < RP->Ysize; j++) 253 for (j = 0; j < RP->Ysize; j++)
259 { 254 {
260 if (layout[i][j] == 'C' || layout[i][j] == '>') 255 if (maze[i][j] == 'C' || maze[i][j] == '>')
261 { 256 {
262 int tdiv = RP->symmetry_used; 257 int tdiv = RP->symmetry_used;
263 object *chest; 258 object *chest;
264 259
265 if (tdiv == 3) 260 if (tdiv == 3)
… …
271 if (!chest) 266 if (!chest)
272 continue; /* if no chest was placed NEXT */ 267 continue; /* if no chest was placed NEXT */
273 268
274 if (treasureoptions & (DOORED | HIDDEN)) 269 if (treasureoptions & (DOORED | HIDDEN))
275 { 270 {
276 object **doorlist = find_doors_in_room (map, i, j, RP); 271 object **doorlist = find_doors_in_room (map, i, j);
277 lock_and_hide_doors (doorlist, map, treasureoptions, RP); 272 lock_and_hide_doors (doorlist, map, treasureoptions, RP);
278 free (doorlist); 273 free (doorlist);
279 } 274 }
280 } 275 }
281 } 276 }
… …
293 tries = 0; 288 tries = 0;
294 while (i == -1 && tries < 100) 289 while (i == -1 && tries < 100)
295 { 290 {
296 i = rmg_rndm (RP->Xsize - 2) + 1; 291 i = rmg_rndm (RP->Xsize - 2) + 1;
297 j = rmg_rndm (RP->Ysize - 2) + 1; 292 j = rmg_rndm (RP->Ysize - 2) + 1;
293
298 find_enclosed_spot (map, &i, &j, RP); 294 find_enclosed_spot (map, &i, &j);
299 295
300 if (wall_blocked (map, i, j)) 296 if (wall_blocked (map, i, j))
301 i = -1; 297 i = -1;
302 298
303 tries++; 299 tries++;
… …
310 306
311 i = chest->x; 307 i = chest->x;
312 j = chest->y; 308 j = chest->y;
313 if (treasureoptions & (DOORED | HIDDEN)) 309 if (treasureoptions & (DOORED | HIDDEN))
314 { 310 {
315 doorlist = surround_by_doors (map, layout, i, j, treasureoptions); 311 doorlist = surround_by_doors (map, maze, i, j, treasureoptions);
316 lock_and_hide_doors (doorlist, map, treasureoptions, RP); 312 lock_and_hide_doors (doorlist, map, treasureoptions, RP);
317 free (doorlist); 313 free (doorlist);
318 } 314 }
319 } 315 }
320 } 316 }
321 } 317 }
322 else 318 else
323 { /* DIFFUSE treasure layout */ 319 { /* DIFFUSE treasure maze */
324 int ti, i, j; 320 int ti, i, j;
325 321
326 for (ti = 0; ti < num_treasures; ti++) 322 for (ti = 0; ti < num_treasures; ti++)
327 { 323 {
328 i = rmg_rndm (RP->Xsize - 2) + 1; 324 i = rmg_rndm (RP->Xsize - 2) + 1;
… …
346 { 342 {
347 the_chest->destroy (); 343 the_chest->destroy ();
348 return NULL; 344 return NULL;
349 } 345 }
350 346
351 int xl = x + freearr_x[i]; 347 int xl = x + DIRX (i);
352 int yl = y + freearr_y[i]; 348 int yl = y + DIRY (i);
353 349
354 /* if the placement is blocked, return a fail. */ 350 /* if the placement is blocked, return a fail. */
355 if (wall_blocked (map, xl, yl)) 351 if (wall_blocked (map, xl, yl))
356 return 0; 352 return 0;
357 353
… …
384 } 380 }
385 381
386 /* stick a trap in the chest if required */ 382 /* stick a trap in the chest if required */
387 if (treasureoptions & TRAPPED) 383 if (treasureoptions & TRAPPED)
388 { 384 {
389 maptile *trap_map = find_style ("/styles/trapstyles", "traps", -1); 385 maptile *trap_map = find_style ("/styles/trapstyles", "traps", RP->difficulty);
390 386
391 if (trap_map) 387 if (trap_map)
392 { 388 {
393 object *the_trap = trap_map->pick_random_object (rmg_rndm); 389 object *the_trap = trap_map->pick_random_object (rmg_rndm);
394 390
… …
410 the lockcode. It's not worth bothering to lock the chest if 406 the lockcode. It's not worth bothering to lock the chest if
411 there's only 1 treasure.... */ 407 there's only 1 treasure.... */
412 if ((treasureoptions & KEYREQUIRED) && n_treasures > 1) 408 if ((treasureoptions & KEYREQUIRED) && n_treasures > 1)
413 { 409 {
414 the_chest->slaying = format ("RMG-%d-%d", (int)rmg_rndm (1000000000), (int)rmg_rndm (1000000000)); 410 the_chest->slaying = format ("RMG-%d-%d", (int)rmg_rndm (1000000000), (int)rmg_rndm (1000000000));
415 keyplace (map, x, y, the_chest->slaying, PASS_DOORS, 1, RP); 411 keyplace (map, x, y, the_chest->slaying, PASS_DOORS, 1);
416 } 412 }
417 413
418 /* actually place the chest. */ 414 /* actually place the chest. */
419 the_chest->x = xl; 415 the_chest->x = xl;
420 the_chest->y = yl; 416 the_chest->y = yl;
… …
422 return the_chest; 418 return the_chest;
423} 419}
424 420
425/* finds the closest monster and returns him, regardless of doors or walls */ 421/* finds the closest monster and returns him, regardless of doors or walls */
426static object * 422static object *
427find_closest_monster (maptile *map, int x, int y, random_map_params *RP) 423find_closest_monster (maptile *map, int x, int y)
428{ 424{
429 int i; 425 int i;
430 426
431 for (i = 0; i < SIZEOFFREE; i++) 427 for (i = 0; i < SIZEOFFREE; i++)
432 { 428 {
433 int lx, ly; 429 int lx, ly;
434 430
435 lx = x + freearr_x[i]; 431 lx = x + DIRX (i);
436 ly = y + freearr_y[i]; 432 ly = y + DIRY (i);
437 /* boundscheck */ 433 /* boundscheck */
438 if (lx >= 0 && ly >= 0 && lx < RP->Xsize && ly < RP->Ysize) 434 if (lx >= 0 && ly >= 0 && lx < map->width && ly < map->height)
439 /* don't bother searching this square unless the map says life exists. */ 435 /* don't bother searching this square unless the map says life exists. */
440 if (GET_MAP_FLAGS (map, lx, ly) & P_IS_ALIVE) 436 if (GET_MAP_FLAGS (map, lx, ly) & P_IS_ALIVE)
441 { 437 {
442 object *the_monster = GET_MAP_OB (map, lx, ly); 438 object *the_monster = GET_MAP_OB (map, lx, ly);
443 439
444 for (; the_monster != NULL && (!QUERY_FLAG (the_monster, FLAG_MONSTER)); the_monster = the_monster->above); 440 for (; the_monster && !the_monster->flag [FLAG_MONSTER]; the_monster = the_monster->above)
441 ;
442
445 if (the_monster && QUERY_FLAG (the_monster, FLAG_MONSTER)) 443 if (the_monster && the_monster->flag [FLAG_MONSTER])
446 return the_monster; 444 return the_monster;
447 } 445 }
448 } 446 }
449 return NULL; 447 return NULL;
450} 448}
… …
452/* both find_monster_in_room routines need to have access to this. */ 450/* both find_monster_in_room routines need to have access to this. */
453 451
454static object *theMonsterToFind; 452static object *theMonsterToFind;
455 453
456/* a recursive routine which will return a monster, eventually,if there is one. 454/* a recursive routine which will return a monster, eventually,if there is one.
457 it does a check-off on the layout, converting 0's to 1's */ 455 it does a check-off on the maze, converting 0's to 1's */
458static object * 456static object *
459find_monster_in_room_recursive (char **layout, maptile *map, int x, int y, random_map_params *RP) 457find_monster_in_room_recursive (layout &maze, maptile *map, int x, int y)
460{ 458{
461 int i, j; 459 int i, j;
462 460
463 /* if we've found a monster already, leave */ 461 /* if we've found a monster already, leave */
464 if (theMonsterToFind != NULL) 462 if (theMonsterToFind != NULL)
465 return theMonsterToFind; 463 return theMonsterToFind;
466 464
467 /* bounds check x and y */ 465 /* bounds check x and y */
468 if (!(x >= 0 && y >= 0 && x < RP->Xsize && y < RP->Ysize)) 466 if (!(x >= 0 && y >= 0 && x < maze.w && y < maze.h))
469 return theMonsterToFind; 467 return theMonsterToFind;
470 468
471 /* if the square is blocked or searched already, leave */ 469 /* if the square is blocked or searched already, leave */
472 if (layout[x][y] != 0) 470 if (maze[x][y] != 0)
473 return theMonsterToFind; /* might be NULL, that's fine. */ 471 return theMonsterToFind; /* might be NULL, that's fine. */
474 472
475 /* check the current square for a monster. If there is one, 473 /* check the current square for a monster. If there is one,
476 set theMonsterToFind and return it. */ 474 set theMonsterToFind and return it. */
477 layout[x][y] = 1; 475 maze[x][y] = 1;
478 if (GET_MAP_FLAGS (map, x, y) & P_IS_ALIVE) 476 if (GET_MAP_FLAGS (map, x, y) & P_IS_ALIVE)
479 { 477 {
480 object *the_monster = GET_MAP_OB (map, x, y); 478 object *the_monster = GET_MAP_OB (map, x, y);
481 479
482 /* check off this point */ 480 /* check off this point */
483 for (; the_monster != NULL && (!QUERY_FLAG (the_monster, FLAG_ALIVE)); the_monster = the_monster->above); 481 for (; the_monster && (!the_monster->flag [FLAG_ALIVE]); the_monster = the_monster->above);
484 if (the_monster && QUERY_FLAG (the_monster, FLAG_ALIVE)) 482 if (the_monster && the_monster->flag [FLAG_ALIVE])
485 { 483 {
486 theMonsterToFind = the_monster; 484 theMonsterToFind = the_monster;
487 return theMonsterToFind; 485 return theMonsterToFind;
488 } 486 }
489 } 487 }
490 488
491 /* now search all the 8 squares around recursively for a monster,in random order */ 489 /* now search all the 8 squares around recursively for a monster,in random order */
492 for (i = rmg_rndm (8), j = 0; j < 8 && theMonsterToFind == NULL; i++, j++) 490 for (i = rmg_rndm (8), j = 0; j < 8 && !theMonsterToFind; i++, j++)
493 { 491 {
494 theMonsterToFind = find_monster_in_room_recursive (layout, map, x + freearr_x[i % 8 + 1], y + freearr_y[i % 8 + 1], RP); 492 theMonsterToFind = find_monster_in_room_recursive (maze, map, x + DIRX (i % 8 + 1), y + DIRY (i % 8 + 1));
495 if (theMonsterToFind != NULL) 493 if (theMonsterToFind)
496 return theMonsterToFind; 494 return theMonsterToFind;
497 } 495 }
498 496
499 return theMonsterToFind; 497 return theMonsterToFind;
500} 498}
501 499
502/* sets up some data structures: the _recursive form does the 500/* sets up some data structures: the _recursive form does the
503 real work. */ 501 real work. */
504static object * 502static object *
505find_monster_in_room (maptile *map, int x, int y, random_map_params *RP) 503find_monster_in_room (maptile *map, int x, int y)
506{ 504{
507 Layout layout2 (RP); 505 layout layout2 (map->width, map->height);
508 506
509 layout2->clear (); 507 // find walls
510
511 /* allocate and copy the layout, converting C to 0. */
512 for (int i = 0; i < layout2->w; i++) 508 for (int i = 0; i < layout2.w; i++)
513 for (int j = 0; j < layout2->h; j++) 509 for (int j = 0; j < layout2.h; j++)
514 if (wall_blocked (map, i, j)) 510 layout2[i][j] = wall_blocked (map, i, j) ? '#' : 0;
515 layout2[i][j] = '#';
516 511
517 theMonsterToFind = 0; 512 theMonsterToFind = 0;
518 theMonsterToFind = find_monster_in_room_recursive (layout2, map, x, y, RP); 513 theMonsterToFind = find_monster_in_room_recursive (layout2, map, x, y);
519
520 layout2.free ();
521 514
522 return theMonsterToFind; 515 return theMonsterToFind;
523} 516}
524
525/* a datastructure needed by find_spot_in_room and find_spot_in_room_recursive */
526static int *room_free_spots_x;
527static int *room_free_spots_y;
528static int number_of_free_spots_in_room;
529 517
530/* the workhorse routine, which finds the free spots in a room: 518/* the workhorse routine, which finds the free spots in a room:
531a datastructure of free points is set up, and a position chosen from 519a datastructure of free points is set up, and a position chosen from
532that datastructure. */ 520that datastructure. */
533static void 521static void
534find_spot_in_room_recursive (char **layout, int x, int y, random_map_params *RP) 522find_spot_in_room_recursive (layout &maze, fixed_stack<point> &spots, int x, int y)
535{ 523{
536 int i, j;
537
538 /* bounds check x and y */ 524 /* bounds check x and y */
539 if (!(x >= 0 && y >= 0 && x < RP->Xsize && y < RP->Ysize)) 525 if (!(x >= 0 && y >= 0 && x < maze.w && y < maze.h))
540 return; 526 return;
541 527
542 /* if the square is blocked or searched already, leave */ 528 /* if the square is blocked or searched already, leave */
543 if (layout[x][y] != 0) 529 if (maze[x][y] != 0)
544 return; 530 return;
545 531
546 /* set the current square as checked, and add it to the list. 532 /* set the current square as checked, and add it to the list.
547 set theMonsterToFind and return it. */ 533 set theMonsterToFind and return it. */
548 /* check off this point */ 534 /* check off this point */
549 layout[x][y] = 1; 535 maze[x][y] = 1;
550 room_free_spots_x[number_of_free_spots_in_room] = x; 536 spots.push (point (x, y));
551 room_free_spots_y[number_of_free_spots_in_room] = y;
552 number_of_free_spots_in_room++;
553 537
554 /* now search all the 8 squares around recursively for free spots,in random order */ 538 /* now search all the 8 squares around recursively for free spots,in random order */
555 for (i = rmg_rndm (8), j = 0; j < 8 && theMonsterToFind == NULL; i++, j++) 539 for (int i = rmg_rndm (8), j = 0; j < 8 && !theMonsterToFind; i++, j++)
556 find_spot_in_room_recursive (layout, x + freearr_x[i % 8 + 1], y + freearr_y[i % 8 + 1], RP); 540 find_spot_in_room_recursive (maze, spots, x + DIRX (i % 8 + 1), y + DIRY (i % 8 + 1));
557 541
558} 542}
559 543
560/* find a random non-blocked spot in this room to drop a key. */ 544/* find a random non-blocked spot in this room to drop a key. */
561static void 545static void
562find_spot_in_room (maptile *map, int x, int y, int *kx, int *ky, random_map_params *RP) 546find_spot_in_room (maptile *map, int x, int y, int *kx, int *ky)
563{ 547{
564 char **layout2; 548 fixed_stack<point> spots (map->width * map->height);
565 int i, j;
566 549
567 number_of_free_spots_in_room = 0; 550 layout layout2 (map->width, map->height);
568 room_free_spots_x = (int *) calloc (sizeof (int), RP->Xsize * RP->Ysize);
569 room_free_spots_y = (int *) calloc (sizeof (int), RP->Xsize * RP->Ysize);
570 551
571 layout2 = (char **) calloc (sizeof (char *), RP->Xsize);
572 /* allocate and copy the layout, converting C to 0. */ 552 /* allocate and copy the maze, converting C to 0. */
573 for (i = 0; i < RP->Xsize; i++) 553 for (int i = 0; i < map->width; i++)
574 { 554 for (int j = 0; j < map->height; j++)
575 layout2[i] = (char *) calloc (sizeof (char), RP->Ysize); 555 layout2 [i][j] = wall_blocked (map, i, j) ? '#' : 0;
576 for (j = 0; j < RP->Ysize; j++)
577 if (wall_blocked (map, i, j))
578 layout2[i][j] = '#';
579 }
580 556
581 /* setup num_free_spots and room_free_spots */ 557 /* setup num_free_spots and room_free_spots */
582 find_spot_in_room_recursive (layout2, x, y, RP); 558 find_spot_in_room_recursive (layout2, spots, x, y);
583 559
584 if (number_of_free_spots_in_room > 0) 560 if (spots.size)
585 {
586 i = rmg_rndm (number_of_free_spots_in_room);
587 *kx = room_free_spots_x[i];
588 *ky = room_free_spots_y[i];
589 } 561 {
562 point p = spots [rmg_rndm (spots.size)];
590 563
591 /* deallocate the temp. layout */ 564 *kx = p.x;
592 for (i = 0; i < RP->Xsize; i++) 565 *ky = p.y;
593 free (layout2[i]); 566 }
594
595 free (layout2);
596 free (room_free_spots_x);
597 free (room_free_spots_y);
598} 567}
599
600 568
601/* searches the map for a spot with walls around it. The more 569/* searches the map for a spot with walls around it. The more
602 walls the better, but it'll settle for 1 wall, or even 0, but 570 walls the better, but it'll settle for 1 wall, or even 0, but
603 it'll return 0 if no FREE spots are found.*/ 571 it'll return 0 if no FREE spots are found.*/
604static void 572static void
605find_enclosed_spot (maptile *map, int *cx, int *cy, random_map_params *RP) 573find_enclosed_spot (maptile *map, int *cx, int *cy)
606{ 574{
607 int x, y; 575 int x, y;
608 int i; 576 int i;
609 577
610 x = *cx; 578 x = *cx;
… …
612 580
613 for (i = 0; i <= SIZEOFFREE1; i++) 581 for (i = 0; i <= SIZEOFFREE1; i++)
614 { 582 {
615 int lx, ly, sindex; 583 int lx, ly, sindex;
616 584
617 lx = x + freearr_x[i]; 585 lx = x + DIRX (i);
618 ly = y + freearr_y[i]; 586 ly = y + DIRY (i);
619 sindex = surround_flag3 (map, lx, ly, RP); 587 sindex = surround_flag3 (map, lx, ly);
620 /* if it's blocked on 3 sides, it's enclosed */ 588 /* if it's blocked on 3 sides, it's enclosed */
621 if (sindex == 7 || sindex == 11 || sindex == 13 || sindex == 14) 589 if (sindex == 7 || sindex == 11 || sindex == 13 || sindex == 14)
622 { 590 {
623 *cx = lx; 591 *cx = lx;
624 *cy = ly; 592 *cy = ly;
… …
630 spots--try to find someplace which is 2x enclosed. */ 598 spots--try to find someplace which is 2x enclosed. */
631 for (i = 0; i <= SIZEOFFREE1; i++) 599 for (i = 0; i <= SIZEOFFREE1; i++)
632 { 600 {
633 int lx, ly, sindex; 601 int lx, ly, sindex;
634 602
635 lx = x + freearr_x[i]; 603 lx = x + DIRX (i);
636 ly = y + freearr_y[i]; 604 ly = y + DIRY (i);
637 sindex = surround_flag3 (map, lx, ly, RP); 605 sindex = surround_flag3 (map, lx, ly);
638 /* if it's blocked on 3 sides, it's enclosed */ 606 /* if it's blocked on 3 sides, it's enclosed */
639 if (sindex == 3 || sindex == 5 || sindex == 9 || sindex == 6 || sindex == 10 || sindex == 12) 607 if (sindex == 3 || sindex == 5 || sindex == 9 || sindex == 6 || sindex == 10 || sindex == 12)
640 { 608 {
641 *cx = lx; 609 *cx = lx;
642 *cy = ly; 610 *cy = ly;
… …
647 /* settle for one surround point */ 615 /* settle for one surround point */
648 for (i = 0; i <= SIZEOFFREE1; i++) 616 for (i = 0; i <= SIZEOFFREE1; i++)
649 { 617 {
650 int lx, ly, sindex; 618 int lx, ly, sindex;
651 619
652 lx = x + freearr_x[i]; 620 lx = x + DIRX (i);
653 ly = y + freearr_y[i]; 621 ly = y + DIRY (i);
654 sindex = surround_flag3 (map, lx, ly, RP); 622 sindex = surround_flag3 (map, lx, ly);
655 /* if it's blocked on 3 sides, it's enclosed */ 623 /* if it's blocked on 3 sides, it's enclosed */
656 if (sindex) 624 if (sindex)
657 { 625 {
658 *cx = lx; 626 *cx = lx;
659 *cy = ly; 627 *cy = ly;
660 return; 628 return;
661 } 629 }
662 } 630 }
663 /* give up and return the closest free spot. */ 631 /* give up and return the closest free spot. */
664 i = find_free_spot (archetype::find (shstr_chest), map, x, y, 1, SIZEOFFREE1 + 1); 632 i = rmg_find_free_spot (archetype::find (shstr_chest), map, x, y, 1, SIZEOFFREE1 + 1);
665 633
666 if (i != -1) 634 if (i != -1)
667 { 635 {
668 *cx = x + freearr_x[i]; 636 *cx = x + DIRX (i);
669 *cy = y + freearr_y[i]; 637 *cy = y + DIRY (i);
670 } 638 }
671 else 639 else
672 { 640 {
673 /* indicate failure */ 641 /* indicate failure */
674 *cx = -1; 642 *cx = -1;
… …
692 660
693/* surrounds the point x,y by doors, so as to enclose something, like 661/* surrounds the point x,y by doors, so as to enclose something, like
694 a chest. It only goes as far as the 8 squares surrounding, and 662 a chest. It only goes as far as the 8 squares surrounding, and
695 it'll remove any monsters it finds.*/ 663 it'll remove any monsters it finds.*/
696static object ** 664static object **
697surround_by_doors (maptile *map, char **layout, int x, int y, int opts) 665surround_by_doors (maptile *map, char **maze, int x, int y, int opts)
698{ 666{
699 int i; 667 int i;
700 const char *doors[2]; 668 const char *doors[2];
701 object **doorlist; 669 object **doorlist;
702 int ndoors_made = 0; 670 int ndoors_made = 0;
… …
715 } 683 }
716 684
717 /* place doors in all the 8 adjacent unblocked squares. */ 685 /* place doors in all the 8 adjacent unblocked squares. */
718 for (i = 1; i < 9; i++) 686 for (i = 1; i < 9; i++)
719 { 687 {
720 int x1 = x + freearr_x[i], y1 = y + freearr_y[i]; 688 int x1 = x + DIRX (i), y1 = y + DIRY (i);
721 689
722 if (!wall_blocked (map, x1, y1) && layout[x1][y1] == '>') 690 if (!wall_blocked (map, x1, y1) && maze[x1][y1] == '>')
723 { /* place a door */ 691 { /* place a door */
724 remove_monsters (x1, y1, map); 692 remove_monsters (x1, y1, map);
725 693
726 object *new_door = get_archetype (freearr_x[i] == 0 ? doors[1] : doors[0]); 694 object *new_door = archetype::get (DIRX (i) == 0 ? doors[1] : doors[0]);
727 map->insert (new_door, x1, y1); 695 map->insert (new_door, x1, y1);
728 doorlist[ndoors_made] = new_door; 696 doorlist[ndoors_made] = new_door;
729 ndoors_made++; 697 ndoors_made++;
730 } 698 }
731 } 699 }
… …
744 return NULL; 712 return NULL;
745} 713}
746 714
747/* the workhorse routine, which finds the doors in a room */ 715/* the workhorse routine, which finds the doors in a room */
748static void 716static void
749find_doors_in_room_recursive (char **layout, maptile *map, int x, int y, object **doorlist, int *ndoors, random_map_params *RP) 717find_doors_in_room_recursive (layout &maze, maptile *map, int x, int y, object **doorlist, int *ndoors)
750{ 718{
751 int i, j; 719 int i, j;
752 object *door; 720 object *door;
753 721
754 /* bounds check x and y */ 722 /* bounds check x and y */
755 if (!(x >= 0 && y >= 0 && x < RP->Xsize && y < RP->Ysize)) 723 if (!(x >= 0 && y >= 0 && x < maze.w && y < maze.h))
756 return; 724 return;
757 725
758 /* if the square is blocked or searched already, leave */ 726 /* if the square is blocked or searched already, leave */
759 if (layout[x][y] == 1) 727 if (maze[x][y] == 1)
760 return; 728 return;
761 729
762 /* check off this point */ 730 /* check off this point */
763 if (layout[x][y] == '#') 731 if (maze[x][y] == '#')
764 { /* there could be a door here */ 732 { /* there could be a door here */
765 layout[x][y] = 1; 733 maze[x][y] = 1;
766 door = door_in_square (map, x, y); 734 door = door_in_square (map, x, y);
767 if (door) 735 if (door)
768 { 736 {
769 doorlist[*ndoors] = door; 737 doorlist[*ndoors] = door;
770 738
… …
777 *ndoors = *ndoors + 1; 745 *ndoors = *ndoors + 1;
778 } 746 }
779 } 747 }
780 else 748 else
781 { 749 {
782 layout[x][y] = 1; 750 maze[x][y] = 1;
783 751
784 /* now search all the 8 squares around recursively for free spots,in random order */ 752 /* now search all the 8 squares around recursively for free spots,in random order */
785 for (i = rmg_rndm (8), j = 0; j < 8 && !theMonsterToFind; i++, j++) 753 for (i = rmg_rndm (8), j = 0; j < 8 && !theMonsterToFind; i++, j++)
786 find_doors_in_room_recursive (layout, map, 754 find_doors_in_room_recursive (maze, map,
787 x + freearr_x[i % 8 + 1], y + freearr_y[i % 8 + 1], 755 x + DIRX (i % 8 + 1), y + DIRY (i % 8 + 1),
788 doorlist, ndoors, RP); 756 doorlist, ndoors);
789 } 757 }
790} 758}
791 759
792/* find a random non-blocked spot in this room to drop a key. */ 760/* find a random non-blocked spot in this room to drop a key. */
793static object ** 761static object **
794find_doors_in_room (maptile *map, int x, int y, random_map_params *RP) 762find_doors_in_room (maptile *map, int x, int y)
795{ 763{
796 int i, j; 764 int i, j;
797 int ndoors = 0; 765 int ndoors = 0;
798 766
799 object **doorlist = (object **)calloc (sizeof (int), 1024); 767 object **doorlist = (object **)calloc (sizeof (int), 1024);
800 768
801 LayoutData layout2 (RP->Xsize, RP->Ysize); 769 layout layout2 (map->width, map->height);
802 layout2.clear (); 770 layout2.clear ();
803 771
804 /* allocate and copy the layout, converting C to 0. */ 772 /* allocate and copy the maze, converting C to 0. */
805 for (i = 0; i < RP->Xsize; i++) 773 for (i = 0; i < map->width; i++)
806 for (j = 0; j < RP->Ysize; j++) 774 for (j = 0; j < map->height; j++)
807 layout2[i][j] = wall_blocked (map, i, j) ? '#' : 0; 775 layout2[i][j] = wall_blocked (map, i, j) ? '#' : 0;
808 776
809 /* setup num_free_spots and room_free_spots */ 777 /* setup num_free_spots and room_free_spots */
810 find_doors_in_room_recursive (layout2, map, x, y, doorlist, &ndoors, RP); 778 find_doors_in_room_recursive (layout2, map, x, y, doorlist, &ndoors);
811 779
812 return doorlist; 780 return doorlist;
813} 781}
814 782
815/* locks and/or hides all the doors in doorlist, or does nothing if 783/* locks and/or hides all the doors in doorlist, or does nothing if
… …
824 792
825 if (opts & DOORED) 793 if (opts & DOORED)
826 { 794 {
827 for (i = 0, door = doorlist[0]; doorlist[i]; i++) 795 for (i = 0, door = doorlist[0]; doorlist[i]; i++)
828 { 796 {
829 object *new_door = get_archetype (shstr_locked_door1); 797 object *new_door = archetype::get (shstr_locked_door1);
830 798
831 door = doorlist[i]; 799 door = doorlist[i];
832 new_door->face = door->face; 800 new_door->face = door->face;
833 new_door->x = door->x; 801 new_door->x = door->x;
834 new_door->y = door->y; 802 new_door->y = door->y;
835 door->destroy (); 803 door->destroy ();
836 doorlist[i] = new_door; 804 doorlist[i] = new_door;
837 insert_ob_in_map (new_door, map, NULL, 0); 805 insert_ob_in_map (new_door, map, NULL, 0);
838 new_door->slaying = format ("RMG-%d-%d", (int)rmg_rndm (1000000000), (int)rmg_rndm (1000000000)); 806 new_door->slaying = format ("RMG-%d-%d", (int)rmg_rndm (1000000000), (int)rmg_rndm (1000000000));
839 keyplace (map, new_door->x, new_door->y, new_door->slaying, NO_PASS_DOORS, 2, RP); 807 keyplace (map, new_door->x, new_door->y, new_door->slaying, NO_PASS_DOORS, 2);
840 } 808 }
841 } 809 }
842 810
843 /* change the faces of the doors and surrounding walls to hide them. */ 811 /* change the faces of the doors and surrounding walls to hide them. */
844 if (opts & HIDDEN) 812 if (opts & HIDDEN)

Diff Legend

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