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.4 by root, Sun Sep 10 16:06:37 2006 UTC vs.
Revision 1.15 by root, Mon Jan 15 01:50:33 2007 UTC

1
2/*
3 * static char *rcsid_treasure_c =
4 * "$Id: treasure.C,v 1.4 2006/09/10 16:06:37 root Exp $";
5 */
6 1
7/* 2/*
8 CrossFire, A Multiplayer game for X-windows 3 CrossFire, A Multiplayer game for X-windows
9 4
5 Copyright (C) 2005, 2006, 2007 Marc Lehmann & Crossfire+ Development Team
10 Copyright (C) 2001 Mark Wedel & Crossfire Development Team 6 Copyright (C) 2001 Mark Wedel & Crossfire Development Team
11 Copyright (C) 1992 Frank Tore Johansen 7 Copyright (C) 1992 Frank Tore Johansen
12 8
13 This program is free software; you can redistribute it and/or modify 9 This program is free software; you can redistribute it and/or modify
14 it under the terms of the GNU General Public License as published by 10 it under the terms of the GNU General Public License as published by
… …
22 18
23 You should have received a copy of the GNU General Public License 19 You should have received a copy of the GNU General Public License
24 along with this program; if not, write to the Free Software 20 along with this program; if not, write to the Free Software
25 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 21 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
26 22
27 The authors can be reached via e-mail at crossfire-devel@real-time.com 23 The authors can be reached via e-mail at <crossfire@schmorp.de>
28*/ 24*/
29 25
30/* placing treasure in maps, where appropriate. */ 26/* placing treasure in maps, where appropriate. */
31 27
32 28
… …
55 * and doors but not monsters. 51 * and doors but not monsters.
56 * This function is not map tile aware. 52 * This function is not map tile aware.
57 */ 53 */
58 54
59int 55int
60wall_blocked (mapstruct *m, int x, int y) 56wall_blocked (maptile *m, int x, int y)
61{ 57{
62 int r; 58 int r;
63 59
64 if (OUT_OF_REAL_MAP (m, x, y)) 60 if (OUT_OF_REAL_MAP (m, x, y))
65 return 1; 61 return 1;
… …
73treasure style (may be empty or NULL, or "none" to cause no treasure.) 69treasure style (may be empty or NULL, or "none" to cause no treasure.)
74treasureoptions (may be 0 for random choices or positive) 70treasureoptions (may be 0 for random choices or positive)
75*/ 71*/
76 72
77void 73void
78place_treasure (mapstruct *map, char **layout, char *treasure_style, int treasureoptions, RMParms * RP) 74place_treasure (maptile *map, char **layout, char *treasure_style, int treasureoptions, random_map_params *RP)
79{ 75{
80 char styledirname[256]; 76 char styledirname[1024];
81 char stylefilepath[256]; 77 char stylefilepath[1024];
82 mapstruct *style_map = 0; 78 maptile *style_map = 0;
83 int num_treasures; 79 int num_treasures;
84 80
85 /* bail out if treasure isn't wanted. */ 81 /* bail out if treasure isn't wanted. */
86 if (treasure_style) 82 if (treasure_style)
87 if (!strcmp (treasure_style, "none")) 83 if (!strcmp (treasure_style, "none"))
… …
119 { 115 {
120 116
121 /* map_layout_style global, and is previously set */ 117 /* map_layout_style global, and is previously set */
122 switch (RP->map_layout_style) 118 switch (RP->map_layout_style)
123 { 119 {
124 case ONION_LAYOUT: 120 case LAYOUT_ONION:
125 case SPIRAL_LAYOUT: 121 case LAYOUT_SPIRAL:
126 case SQUARE_SPIRAL_LAYOUT: 122 case LAYOUT_SQUARE_SPIRAL:
127 { 123 {
128 int i, j; 124 int i, j;
129 125
130 /* search the onion for C's or '>', and put treasure there. */ 126 /* search the onion for C's or '>', and put treasure there. */
131 for (i = 0; i < RP->Xsize; i++) 127 for (i = 0; i < RP->Xsize; i++)
132 { 128 {
133 for (j = 0; j < RP->Ysize; j++) 129 for (j = 0; j < RP->Ysize; j++)
134 { 130 {
135 if (layout[i][j] == 'C' || layout[i][j] == '>') 131 if (layout[i][j] == 'C' || layout[i][j] == '>')
136 { 132 {
137 int tdiv = RP->symmetry_used; 133 int tdiv = RP->symmetry_used;
138 object **doorlist; 134 object **doorlist;
139 object *chest; 135 object *chest;
140 136
141 if (tdiv == 3) 137 if (tdiv == 3)
142 tdiv = 2; /* this symmetry uses a divisor of 2 */ 138 tdiv = 2; /* this symmetry uses a divisor of 2 */
143 /* don't put a chest on an exit. */ 139 /* don't put a chest on an exit. */
144 chest = place_chest (treasureoptions, i, j, map, style_map, num_treasures / tdiv, RP); 140 chest = place_chest (treasureoptions, i, j, map, style_map, num_treasures / tdiv, RP);
145 if (!chest) 141 if (!chest)
146 continue; /* if no chest was placed NEXT */ 142 continue; /* if no chest was placed NEXT */
147 if (treasureoptions & (DOORED | HIDDEN)) 143 if (treasureoptions & (DOORED | HIDDEN))
148 { 144 {
149 doorlist = find_doors_in_room (map, i, j, RP); 145 doorlist = find_doors_in_room (map, i, j, RP);
150 lock_and_hide_doors (doorlist, map, treasureoptions, RP); 146 lock_and_hide_doors (doorlist, map, treasureoptions, RP);
151 free (doorlist); 147 free (doorlist);
152 } 148 }
153 } 149 }
154 } 150 }
155 } 151 }
156 break; 152 break;
157 } 153 }
158 default: 154 default:
159 { 155 {
160 int i, j, tries; 156 int i, j, tries;
161 object *chest; 157 object *chest;
162 object **doorlist; 158 object **doorlist;
163 159
164 i = j = -1; 160 i = j = -1;
165 tries = 0; 161 tries = 0;
166 while (i == -1 && tries < 100) 162 while (i == -1 && tries < 100)
167 { 163 {
168 i = RANDOM () % (RP->Xsize - 2) + 1; 164 i = RANDOM () % (RP->Xsize - 2) + 1;
169 j = RANDOM () % (RP->Ysize - 2) + 1; 165 j = RANDOM () % (RP->Ysize - 2) + 1;
170 find_enclosed_spot (map, &i, &j, RP); 166 find_enclosed_spot (map, &i, &j, RP);
171 if (wall_blocked (map, i, j)) 167 if (wall_blocked (map, i, j))
172 i = -1; 168 i = -1;
173 tries++; 169 tries++;
174 } 170 }
175 chest = place_chest (treasureoptions, i, j, map, style_map, num_treasures, RP); 171 chest = place_chest (treasureoptions, i, j, map, style_map, num_treasures, RP);
176 if (!chest) 172 if (!chest)
177 return; 173 return;
178 i = chest->x; 174 i = chest->x;
179 j = chest->y; 175 j = chest->y;
180 if (treasureoptions & (DOORED | HIDDEN)) 176 if (treasureoptions & (DOORED | HIDDEN))
181 { 177 {
182 doorlist = surround_by_doors (map, layout, i, j, treasureoptions); 178 doorlist = surround_by_doors (map, layout, i, j, treasureoptions);
183 lock_and_hide_doors (doorlist, map, treasureoptions, RP); 179 lock_and_hide_doors (doorlist, map, treasureoptions, RP);
184 free (doorlist); 180 free (doorlist);
185 } 181 }
186 } 182 }
187 } 183 }
188 } 184 }
189 else 185 else
190 { /* DIFFUSE treasure layout */ 186 { /* DIFFUSE treasure layout */
191 int ti, i, j; 187 int ti, i, j;
… …
197 place_chest (treasureoptions, i, j, map, style_map, 1, RP); 193 place_chest (treasureoptions, i, j, map, style_map, 1, RP);
198 } 194 }
199 } 195 }
200} 196}
201 197
202
203
204/* put a chest into the map, near x and y, with the treasure style 198/* put a chest into the map, near x and y, with the treasure style
205 determined (may be null, or may be a treasure list from lib/treasures, 199 determined (may be null, or may be a treasure list from lib/treasures,
206 if the global variable "treasurestyle" is set to that treasure list's name */ 200 if the global variable "treasurestyle" is set to that treasure list's name */
207 201
208object * 202object *
209place_chest (int treasureoptions, int x, int y, mapstruct *map, mapstruct *style_map, int n_treasures, RMParms * RP) 203place_chest (int treasureoptions, int x, int y, maptile *map, maptile *style_map, int n_treasures, random_map_params *RP)
210{ 204{
211 object *the_chest; 205 object *the_chest;
212 int i, xl, yl; 206 int i, xl, yl;
213 207
214 the_chest = get_archetype ("chest"); /* was "chest_2" */ 208 the_chest = get_archetype ("chest"); /* was "chest_2" */
215 209
216 /* first, find a place to put the chest. */ 210 /* first, find a place to put the chest. */
217 i = find_first_free_spot (the_chest, map, x, y); 211 i = find_first_free_spot (the_chest, map, x, y);
218 if (i == -1) 212 if (i == -1)
219 { 213 {
220 free_object (the_chest); 214 the_chest->destroy ();
221 return NULL; 215 return NULL;
222 } 216 }
223 xl = x + freearr_x[i]; 217 xl = x + freearr_x[i];
224 yl = y + freearr_y[i]; 218 yl = y + freearr_y[i];
225 219
226 /* if the placement is blocked, return a fail. */ 220 /* if the placement is blocked, return a fail. */
227 if (wall_blocked (map, xl, yl)) 221 if (wall_blocked (map, xl, yl))
228 return 0; 222 return 0;
229
230 223
231 /* put the treasures in the chest. */ 224 /* put the treasures in the chest. */
232 /* if(style_map) { */ 225 /* if(style_map) { */
233#if 0 /* don't use treasure style maps for now! */ 226#if 0 /* don't use treasure style maps for now! */
234 int ti; 227 int ti;
… …
247 { /* use the style map */ 240 { /* use the style map */
248 the_chest->randomitems = tlist; 241 the_chest->randomitems = tlist;
249 the_chest->stats.hp = n_treasures; 242 the_chest->stats.hp = n_treasures;
250 } 243 }
251#endif 244#endif
252 else
253 { /* neither style_map no treasure list given */ 245 { /* neither style_map no treasure list given */
254 treasurelist *tlist = find_treasurelist ("chest"); 246 treasurelist *tlist = find_treasurelist ("chest");
255 247
256 the_chest->randomitems = tlist; 248 the_chest->randomitems = tlist;
257 the_chest->stats.hp = n_treasures; 249 the_chest->stats.hp = n_treasures;
258 } 250 }
259 251
260 /* stick a trap in the chest if required */ 252 /* stick a trap in the chest if required */
261 if (treasureoptions & TRAPPED) 253 if (treasureoptions & TRAPPED)
262 { 254 {
263 mapstruct *trap_map = find_style ("/styles/trapstyles", "traps", -1); 255 maptile *trap_map = find_style ("/styles/trapstyles", "traps", -1);
264 object *the_trap; 256 object *the_trap;
265 257
266 if (trap_map) 258 if (trap_map)
267 { 259 {
268 the_trap = pick_random_object (trap_map); 260 the_trap = pick_random_object (trap_map);
… …
271 if (the_trap) 263 if (the_trap)
272 { 264 {
273 object *new_trap; 265 object *new_trap;
274 266
275 new_trap = arch_to_object (the_trap->arch); 267 new_trap = arch_to_object (the_trap->arch);
276 copy_object (new_trap, the_trap); 268 new_trap->copy_to (the_trap);
277 new_trap->x = x; 269 new_trap->x = x;
278 new_trap->y = y; 270 new_trap->y = y;
279 insert_ob_in_ob (new_trap, the_chest); 271 insert_ob_in_ob (new_trap, the_chest);
280 } 272 }
281 } 273 }
… …
285 the lockcode. It's not worth bothering to lock the chest if 277 the lockcode. It's not worth bothering to lock the chest if
286 there's only 1 treasure.... */ 278 there's only 1 treasure.... */
287 279
288 if ((treasureoptions & KEYREQUIRED) && n_treasures > 1) 280 if ((treasureoptions & KEYREQUIRED) && n_treasures > 1)
289 { 281 {
290 char keybuf[256]; 282 char keybuf[1024];
291 283
292 sprintf (keybuf, "%d", (int) RANDOM ()); 284 sprintf (keybuf, "%d", (int) RANDOM ());
293 the_chest->slaying = keybuf; 285 the_chest->slaying = keybuf;
294 keyplace (map, x, y, keybuf, PASS_DOORS, 1, RP); 286 keyplace (map, x, y, keybuf, PASS_DOORS, 1, RP);
295 } 287 }
… …
303 295
304 296
305/* finds the closest monster and returns him, regardless of doors 297/* finds the closest monster and returns him, regardless of doors
306 or walls */ 298 or walls */
307object * 299object *
308find_closest_monster (mapstruct *map, int x, int y, RMParms * RP) 300find_closest_monster (maptile *map, int x, int y, random_map_params *RP)
309{ 301{
310 int i; 302 int i;
311 303
312 for (i = 0; i < SIZEOFFREE; i++) 304 for (i = 0; i < SIZEOFFREE; i++)
313 { 305 {
… …
318 /* boundscheck */ 310 /* boundscheck */
319 if (lx >= 0 && ly >= 0 && lx < RP->Xsize && ly < RP->Ysize) 311 if (lx >= 0 && ly >= 0 && lx < RP->Xsize && ly < RP->Ysize)
320 /* don't bother searching this square unless the map says life exists. */ 312 /* don't bother searching this square unless the map says life exists. */
321 if (GET_MAP_FLAGS (map, lx, ly) & P_IS_ALIVE) 313 if (GET_MAP_FLAGS (map, lx, ly) & P_IS_ALIVE)
322 { 314 {
323 object *the_monster = get_map_ob (map, lx, ly); 315 object *the_monster = GET_MAP_OB (map, lx, ly);
324 316
325 for (; the_monster != NULL && (!QUERY_FLAG (the_monster, FLAG_MONSTER)); the_monster = the_monster->above); 317 for (; the_monster != NULL && (!QUERY_FLAG (the_monster, FLAG_MONSTER)); the_monster = the_monster->above);
326 if (the_monster && QUERY_FLAG (the_monster, FLAG_MONSTER)) 318 if (the_monster && QUERY_FLAG (the_monster, FLAG_MONSTER))
327 return the_monster; 319 return the_monster;
328 } 320 }
… …
342 The idea is that you call keyplace on x,y where a door is, and it'll make 334 The idea is that you call keyplace on x,y where a door is, and it'll make
343 sure a key is placed on both sides of the door. 335 sure a key is placed on both sides of the door.
344*/ 336*/
345 337
346int 338int
347keyplace (mapstruct *map, int x, int y, char *keycode, int door_flag, int n_keys, RMParms * RP) 339keyplace (maptile *map, int x, int y, char *keycode, int door_flag, int n_keys, random_map_params *RP)
348{ 340{
349 int i, j; 341 int i, j;
350 int kx, ky; 342 int kx, ky;
351 object *the_keymaster; /* the monster that gets the key. */ 343 object *the_keymaster; /* the monster that gets the key. */
352 object *the_key; 344 object *the_key;
… …
377 { 369 {
378 kx = (RANDOM () % (RP->Xsize - 2)) + 1; 370 kx = (RANDOM () % (RP->Xsize - 2)) + 1;
379 ky = (RANDOM () % (RP->Ysize - 2)) + 1; 371 ky = (RANDOM () % (RP->Ysize - 2)) + 1;
380 freeindex = find_first_free_spot (the_key, map, kx, ky); 372 freeindex = find_first_free_spot (the_key, map, kx, ky);
381 } 373 }
374
382 if (freeindex != -1) 375 if (freeindex != -1)
383 { 376 {
384 kx += freearr_x[freeindex]; 377 kx += freearr_x[freeindex];
385 ky += freearr_y[freeindex]; 378 ky += freearr_y[freeindex];
386 } 379 }
… …
392 NO_PASS_DOORS is set. */ 385 NO_PASS_DOORS is set. */
393 if (n_keys == 1) 386 if (n_keys == 1)
394 { 387 {
395 if (wall_blocked (map, x, y)) 388 if (wall_blocked (map, x, y))
396 return 0; 389 return 0;
390
397 the_keymaster = find_monster_in_room (map, x, y, RP); 391 the_keymaster = find_monster_in_room (map, x, y, RP);
398 if (the_keymaster == NULL) /* if fail, find a spot to drop the key. */ 392 if (the_keymaster == NULL) /* if fail, find a spot to drop the key. */
399 find_spot_in_room (map, x, y, &kx, &ky, RP); 393 find_spot_in_room (map, x, y, &kx, &ky, RP);
400 } 394 }
401 else 395 else
… …
438 432
439/* a recursive routine which will return a monster, eventually,if there is one. 433/* a recursive routine which will return a monster, eventually,if there is one.
440 it does a check-off on the layout, converting 0's to 1's */ 434 it does a check-off on the layout, converting 0's to 1's */
441 435
442object * 436object *
443find_monster_in_room_recursive (char **layout, mapstruct *map, int x, int y, RMParms * RP) 437find_monster_in_room_recursive (char **layout, maptile *map, int x, int y, random_map_params *RP)
444{ 438{
445 int i, j; 439 int i, j;
446 440
447 /* if we've found a monster already, leave */ 441 /* if we've found a monster already, leave */
448 if (theMonsterToFind != NULL) 442 if (theMonsterToFind != NULL)
… …
459 /* check the current square for a monster. If there is one, 453 /* check the current square for a monster. If there is one,
460 set theMonsterToFind and return it. */ 454 set theMonsterToFind and return it. */
461 layout[x][y] = 1; 455 layout[x][y] = 1;
462 if (GET_MAP_FLAGS (map, x, y) & P_IS_ALIVE) 456 if (GET_MAP_FLAGS (map, x, y) & P_IS_ALIVE)
463 { 457 {
464 object *the_monster = get_map_ob (map, x, y); 458 object *the_monster = GET_MAP_OB (map, x, y);
465 459
466 /* check off this point */ 460 /* check off this point */
467 for (; the_monster != NULL && (!QUERY_FLAG (the_monster, FLAG_ALIVE)); the_monster = the_monster->above); 461 for (; the_monster != NULL && (!QUERY_FLAG (the_monster, FLAG_ALIVE)); the_monster = the_monster->above);
468 if (the_monster && QUERY_FLAG (the_monster, FLAG_ALIVE)) 462 if (the_monster && QUERY_FLAG (the_monster, FLAG_ALIVE))
469 { 463 {
… …
485 479
486/* sets up some data structures: the _recursive form does the 480/* sets up some data structures: the _recursive form does the
487 real work. */ 481 real work. */
488 482
489object * 483object *
490find_monster_in_room (mapstruct *map, int x, int y, RMParms * RP) 484find_monster_in_room (maptile *map, int x, int y, random_map_params *RP)
491{ 485{
492 char **layout2; 486 char **layout2;
493 int i, j; 487 int i, j;
494 488
495 theMonsterToFind = 0; 489 theMonsterToFind = 0;
… …
527/* the workhorse routine, which finds the free spots in a room: 521/* the workhorse routine, which finds the free spots in a room:
528a datastructure of free points is set up, and a position chosen from 522a datastructure of free points is set up, and a position chosen from
529that datastructure. */ 523that datastructure. */
530 524
531void 525void
532find_spot_in_room_recursive (char **layout, int x, int y, RMParms * RP) 526find_spot_in_room_recursive (char **layout, int x, int y, random_map_params *RP)
533{ 527{
534 int i, j; 528 int i, j;
535 529
536 /* bounds check x and y */ 530 /* bounds check x and y */
537 if (!(x >= 0 && y >= 0 && x < RP->Xsize && y < RP->Ysize)) 531 if (!(x >= 0 && y >= 0 && x < RP->Xsize && y < RP->Ysize))
… …
556 550
557} 551}
558 552
559/* find a random non-blocked spot in this room to drop a key. */ 553/* find a random non-blocked spot in this room to drop a key. */
560void 554void
561find_spot_in_room (mapstruct *map, int x, int y, int *kx, int *ky, RMParms * RP) 555find_spot_in_room (maptile *map, int x, int y, int *kx, int *ky, random_map_params *RP)
562{ 556{
563 char **layout2; 557 char **layout2;
564 int i, j; 558 int i, j;
565 559
566 number_of_free_spots_in_room = 0; 560 number_of_free_spots_in_room = 0;
… …
603/* searches the map for a spot with walls around it. The more 597/* searches the map for a spot with walls around it. The more
604 walls the better, but it'll settle for 1 wall, or even 0, but 598 walls the better, but it'll settle for 1 wall, or even 0, but
605 it'll return 0 if no FREE spots are found.*/ 599 it'll return 0 if no FREE spots are found.*/
606 600
607void 601void
608find_enclosed_spot (mapstruct *map, int *cx, int *cy, RMParms * RP) 602find_enclosed_spot (maptile *map, int *cx, int *cy, random_map_params *RP)
609{ 603{
610 int x, y; 604 int x, y;
611 int i; 605 int i;
612 606
613 x = *cx; 607 x = *cx;
… …
662 *cy = ly; 656 *cy = ly;
663 return; 657 return;
664 } 658 }
665 } 659 }
666 /* give up and return the closest free spot. */ 660 /* give up and return the closest free spot. */
667 i = find_first_free_spot (&find_archetype ("chest")->clone, map, x, y); 661 i = find_first_free_spot (&archetype::find ("chest")->clone, map, x, y);
668 if (i != -1 && i <= SIZEOFFREE1) 662 if (i != -1 && i <= SIZEOFFREE1)
669 { 663 {
670 *cx = x + freearr_x[i]; 664 *cx = x + freearr_x[i];
671 *cy = y + freearr_y[i]; 665 *cy = y + freearr_y[i];
672 return; 666 return;
… …
675 *cx = *cy = -1; 669 *cx = *cy = -1;
676} 670}
677 671
678 672
679void 673void
680remove_monsters (int x, int y, mapstruct *map) 674remove_monsters (int x, int y, maptile *map)
681{ 675{
682 object *tmp; 676 object *tmp;
683 677
684 for (tmp = get_map_ob (map, x, y); tmp != NULL; tmp = tmp->above) 678 for (tmp = GET_MAP_OB (map, x, y); tmp != NULL; tmp = tmp->above)
685 if (QUERY_FLAG (tmp, FLAG_ALIVE)) 679 if (QUERY_FLAG (tmp, FLAG_ALIVE))
686 { 680 {
687 if (tmp->head) 681 if (tmp->head)
688 tmp = tmp->head; 682 tmp = tmp->head;
689 remove_ob (tmp); 683 tmp->remove ();
690 free_object (tmp); 684 tmp->destroy ();
691 tmp = get_map_ob (map, x, y); 685 tmp = GET_MAP_OB (map, x, y);
692 if (tmp == NULL) 686 if (tmp == NULL)
693 break; 687 break;
694 }; 688 };
695} 689}
696 690
… …
698/* surrounds the point x,y by doors, so as to enclose something, like 692/* surrounds the point x,y by doors, so as to enclose something, like
699 a chest. It only goes as far as the 8 squares surrounding, and 693 a chest. It only goes as far as the 8 squares surrounding, and
700 it'll remove any monsters it finds.*/ 694 it'll remove any monsters it finds.*/
701 695
702object ** 696object **
703surround_by_doors (mapstruct *map, char **layout, int x, int y, int opts) 697surround_by_doors (maptile *map, char **layout, int x, int y, int opts)
704{ 698{
705 int i; 699 int i;
706 char *doors[2]; 700 char *doors[2];
707 object **doorlist; 701 object **doorlist;
708 int ndoors_made = 0; 702 int ndoors_made = 0;
… …
741} 735}
742 736
743 737
744/* returns the first door in this square, or NULL if there isn't a door. */ 738/* returns the first door in this square, or NULL if there isn't a door. */
745object * 739object *
746door_in_square (mapstruct *map, int x, int y) 740door_in_square (maptile *map, int x, int y)
747{ 741{
748 object *tmp; 742 object *tmp;
749 743
750 for (tmp = get_map_ob (map, x, y); tmp != NULL; tmp = tmp->above) 744 for (tmp = GET_MAP_OB (map, x, y); tmp != NULL; tmp = tmp->above)
751 if (tmp->type == DOOR || tmp->type == LOCKED_DOOR) 745 if (tmp->type == DOOR || tmp->type == LOCKED_DOOR)
752 return tmp; 746 return tmp;
753 return NULL; 747 return NULL;
754} 748}
755 749
756 750
757/* the workhorse routine, which finds the doors in a room */ 751/* the workhorse routine, which finds the doors in a room */
758void 752void
759find_doors_in_room_recursive (char **layout, mapstruct *map, int x, int y, object **doorlist, int *ndoors, RMParms * RP) 753find_doors_in_room_recursive (char **layout, maptile *map, int x, int y, object **doorlist, int *ndoors, random_map_params *RP)
760{ 754{
761 int i, j; 755 int i, j;
762 object *door; 756 object *door;
763 757
764 /* bounds check x and y */ 758 /* bounds check x and y */
… …
772 /* check off this point */ 766 /* check off this point */
773 if (layout[x][y] == '#') 767 if (layout[x][y] == '#')
774 { /* there could be a door here */ 768 { /* there could be a door here */
775 layout[x][y] = 1; 769 layout[x][y] = 1;
776 door = door_in_square (map, x, y); 770 door = door_in_square (map, x, y);
777 if (door != NULL) 771 if (door)
778 { 772 {
779 doorlist[*ndoors] = door; 773 doorlist[*ndoors] = door;
780 if (*ndoors > 254) /* eek! out of memory */ 774 if (*ndoors > 1022) /* eek! out of memory */
781 { 775 {
782 LOG (llevError, "find_doors_in_room_recursive:Too many doors for memory allocated!\n"); 776 LOG (llevError, "find_doors_in_room_recursive:Too many doors for memory allocated!\n");
783 return; 777 return;
784 } 778 }
779
785 *ndoors = *ndoors + 1; 780 *ndoors = *ndoors + 1;
786 } 781 }
787 } 782 }
788 else 783 else
789 { 784 {
790 layout[x][y] = 1; 785 layout[x][y] = 1;
791 /* now search all the 8 squares around recursively for free spots,in random order */ 786 /* now search all the 8 squares around recursively for free spots,in random order */
792 for (i = RANDOM () % 8, j = 0; j < 8 && theMonsterToFind == NULL; i++, j++) 787 for (i = RANDOM () % 8, j = 0; j < 8 && theMonsterToFind == NULL; i++, j++)
793 {
794 find_doors_in_room_recursive (layout, map, x + freearr_x[i % 8 + 1], y + freearr_y[i % 8 + 1], doorlist, ndoors, RP); 788 find_doors_in_room_recursive (layout, map, x + freearr_x[i % 8 + 1], y + freearr_y[i % 8 + 1], doorlist, ndoors, RP);
795 }
796 } 789 }
797} 790}
798 791
799/* find a random non-blocked spot in this room to drop a key. */ 792/* find a random non-blocked spot in this room to drop a key. */
800object ** 793object **
801find_doors_in_room (mapstruct *map, int x, int y, RMParms * RP) 794find_doors_in_room (maptile *map, int x, int y, random_map_params *RP)
802{ 795{
803 char **layout2; 796 char **layout2;
804 object **doorlist; 797 object **doorlist;
805 int i, j; 798 int i, j;
806 int ndoors = 0; 799 int ndoors = 0;
807 800
808 doorlist = (object **) calloc (sizeof (int), 256); 801 doorlist = (object **) calloc (sizeof (int), 1024);
809
810 802
811 layout2 = (char **) calloc (sizeof (char *), RP->Xsize); 803 layout2 = (char **) calloc (sizeof (char *), RP->Xsize);
812 /* allocate and copy the layout, converting C to 0. */ 804 /* allocate and copy the layout, converting C to 0. */
813 for (i = 0; i < RP->Xsize; i++) 805 for (i = 0; i < RP->Xsize; i++)
814 { 806 {
… …
823 /* setup num_free_spots and room_free_spots */ 815 /* setup num_free_spots and room_free_spots */
824 find_doors_in_room_recursive (layout2, map, x, y, doorlist, &ndoors, RP); 816 find_doors_in_room_recursive (layout2, map, x, y, doorlist, &ndoors, RP);
825 817
826 /* deallocate the temp. layout */ 818 /* deallocate the temp. layout */
827 for (i = 0; i < RP->Xsize; i++) 819 for (i = 0; i < RP->Xsize; i++)
828 {
829 free (layout2[i]); 820 free (layout2[i]);
830 } 821
831 free (layout2); 822 free (layout2);
832 return doorlist; 823 return doorlist;
833} 824}
834 825
835 826
836 827
837/* locks and/or hides all the doors in doorlist, or does nothing if 828/* locks and/or hides all the doors in doorlist, or does nothing if
838 opts doesn't say to lock/hide doors. */ 829 opts doesn't say to lock/hide doors. */
839 830
840void 831void
841lock_and_hide_doors (object **doorlist, mapstruct *map, int opts, RMParms * RP) 832lock_and_hide_doors (object **doorlist, maptile *map, int opts, random_map_params *RP)
842{ 833{
843 object *door; 834 object *door;
844 int i; 835 int i;
845 836
846 /* lock the doors and hide the keys. */ 837 /* lock the doors and hide the keys. */
… …
848 if (opts & DOORED) 839 if (opts & DOORED)
849 { 840 {
850 for (i = 0, door = doorlist[0]; doorlist[i] != NULL; i++) 841 for (i = 0, door = doorlist[0]; doorlist[i] != NULL; i++)
851 { 842 {
852 object *new_door = get_archetype ("locked_door1"); 843 object *new_door = get_archetype ("locked_door1");
853 char keybuf[256]; 844 char keybuf[1024];
854 845
855 door = doorlist[i]; 846 door = doorlist[i];
856 new_door->face = door->face; 847 new_door->face = door->face;
857 new_door->x = door->x; 848 new_door->x = door->x;
858 new_door->y = door->y; 849 new_door->y = door->y;
859 remove_ob (door); 850 door->remove ();
860 free_object (door); 851 door->destroy ();
861 doorlist[i] = new_door; 852 doorlist[i] = new_door;
862 insert_ob_in_map (new_door, map, NULL, 0); 853 insert_ob_in_map (new_door, map, NULL, 0);
863 sprintf (keybuf, "%d", (int) RANDOM ()); 854 sprintf (keybuf, "%d", (int) RANDOM ());
864 new_door->slaying = keybuf; 855 new_door->slaying = keybuf;
865 keyplace (map, new_door->x, new_door->y, keybuf, NO_PASS_DOORS, 2, RP); 856 keyplace (map, new_door->x, new_door->y, keybuf, NO_PASS_DOORS, 2, RP);
… …
881 retrofit_joined_wall (map, door->x + 1, door->y, 0, RP); 872 retrofit_joined_wall (map, door->x + 1, door->y, 0, RP);
882 retrofit_joined_wall (map, door->x, door->y - 1, 0, RP); 873 retrofit_joined_wall (map, door->x, door->y - 1, 0, RP);
883 retrofit_joined_wall (map, door->x, door->y + 1, 0, RP); 874 retrofit_joined_wall (map, door->x, door->y + 1, 0, RP);
884 door->face = wallface->face; 875 door->face = wallface->face;
885 if (!QUERY_FLAG (wallface, FLAG_REMOVED)) 876 if (!QUERY_FLAG (wallface, FLAG_REMOVED))
886 remove_ob (wallface); 877 wallface->remove ();
887 free_object (wallface); 878 wallface->destroy ();
888 } 879 }
889 } 880 }
890 } 881 }
891} 882}

Diff Legend

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