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.14 by pippijn, Sat Jan 6 14:42:30 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;
… …
438 430
439/* a recursive routine which will return a monster, eventually,if there is one. 431/* 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 */ 432 it does a check-off on the layout, converting 0's to 1's */
441 433
442object * 434object *
443find_monster_in_room_recursive (char **layout, mapstruct *map, int x, int y, RMParms * RP) 435find_monster_in_room_recursive (char **layout, maptile *map, int x, int y, random_map_params *RP)
444{ 436{
445 int i, j; 437 int i, j;
446 438
447 /* if we've found a monster already, leave */ 439 /* if we've found a monster already, leave */
448 if (theMonsterToFind != NULL) 440 if (theMonsterToFind != NULL)
… …
459 /* check the current square for a monster. If there is one, 451 /* check the current square for a monster. If there is one,
460 set theMonsterToFind and return it. */ 452 set theMonsterToFind and return it. */
461 layout[x][y] = 1; 453 layout[x][y] = 1;
462 if (GET_MAP_FLAGS (map, x, y) & P_IS_ALIVE) 454 if (GET_MAP_FLAGS (map, x, y) & P_IS_ALIVE)
463 { 455 {
464 object *the_monster = get_map_ob (map, x, y); 456 object *the_monster = GET_MAP_OB (map, x, y);
465 457
466 /* check off this point */ 458 /* check off this point */
467 for (; the_monster != NULL && (!QUERY_FLAG (the_monster, FLAG_ALIVE)); the_monster = the_monster->above); 459 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)) 460 if (the_monster && QUERY_FLAG (the_monster, FLAG_ALIVE))
469 { 461 {
… …
485 477
486/* sets up some data structures: the _recursive form does the 478/* sets up some data structures: the _recursive form does the
487 real work. */ 479 real work. */
488 480
489object * 481object *
490find_monster_in_room (mapstruct *map, int x, int y, RMParms * RP) 482find_monster_in_room (maptile *map, int x, int y, random_map_params *RP)
491{ 483{
492 char **layout2; 484 char **layout2;
493 int i, j; 485 int i, j;
494 486
495 theMonsterToFind = 0; 487 theMonsterToFind = 0;
… …
527/* the workhorse routine, which finds the free spots in a room: 519/* the workhorse routine, which finds the free spots in a room:
528a datastructure of free points is set up, and a position chosen from 520a datastructure of free points is set up, and a position chosen from
529that datastructure. */ 521that datastructure. */
530 522
531void 523void
532find_spot_in_room_recursive (char **layout, int x, int y, RMParms * RP) 524find_spot_in_room_recursive (char **layout, int x, int y, random_map_params *RP)
533{ 525{
534 int i, j; 526 int i, j;
535 527
536 /* bounds check x and y */ 528 /* bounds check x and y */
537 if (!(x >= 0 && y >= 0 && x < RP->Xsize && y < RP->Ysize)) 529 if (!(x >= 0 && y >= 0 && x < RP->Xsize && y < RP->Ysize))
… …
556 548
557} 549}
558 550
559/* find a random non-blocked spot in this room to drop a key. */ 551/* find a random non-blocked spot in this room to drop a key. */
560void 552void
561find_spot_in_room (mapstruct *map, int x, int y, int *kx, int *ky, RMParms * RP) 553find_spot_in_room (maptile *map, int x, int y, int *kx, int *ky, random_map_params *RP)
562{ 554{
563 char **layout2; 555 char **layout2;
564 int i, j; 556 int i, j;
565 557
566 number_of_free_spots_in_room = 0; 558 number_of_free_spots_in_room = 0;
… …
603/* searches the map for a spot with walls around it. The more 595/* 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 596 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.*/ 597 it'll return 0 if no FREE spots are found.*/
606 598
607void 599void
608find_enclosed_spot (mapstruct *map, int *cx, int *cy, RMParms * RP) 600find_enclosed_spot (maptile *map, int *cx, int *cy, random_map_params *RP)
609{ 601{
610 int x, y; 602 int x, y;
611 int i; 603 int i;
612 604
613 x = *cx; 605 x = *cx;
… …
662 *cy = ly; 654 *cy = ly;
663 return; 655 return;
664 } 656 }
665 } 657 }
666 /* give up and return the closest free spot. */ 658 /* give up and return the closest free spot. */
667 i = find_first_free_spot (&find_archetype ("chest")->clone, map, x, y); 659 i = find_first_free_spot (&archetype::find ("chest")->clone, map, x, y);
668 if (i != -1 && i <= SIZEOFFREE1) 660 if (i != -1 && i <= SIZEOFFREE1)
669 { 661 {
670 *cx = x + freearr_x[i]; 662 *cx = x + freearr_x[i];
671 *cy = y + freearr_y[i]; 663 *cy = y + freearr_y[i];
672 return; 664 return;
… …
675 *cx = *cy = -1; 667 *cx = *cy = -1;
676} 668}
677 669
678 670
679void 671void
680remove_monsters (int x, int y, mapstruct *map) 672remove_monsters (int x, int y, maptile *map)
681{ 673{
682 object *tmp; 674 object *tmp;
683 675
684 for (tmp = get_map_ob (map, x, y); tmp != NULL; tmp = tmp->above) 676 for (tmp = GET_MAP_OB (map, x, y); tmp != NULL; tmp = tmp->above)
685 if (QUERY_FLAG (tmp, FLAG_ALIVE)) 677 if (QUERY_FLAG (tmp, FLAG_ALIVE))
686 { 678 {
687 if (tmp->head) 679 if (tmp->head)
688 tmp = tmp->head; 680 tmp = tmp->head;
689 remove_ob (tmp); 681 tmp->remove ();
690 free_object (tmp); 682 tmp->destroy ();
691 tmp = get_map_ob (map, x, y); 683 tmp = GET_MAP_OB (map, x, y);
692 if (tmp == NULL) 684 if (tmp == NULL)
693 break; 685 break;
694 }; 686 };
695} 687}
696 688
… …
698/* surrounds the point x,y by doors, so as to enclose something, like 690/* 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 691 a chest. It only goes as far as the 8 squares surrounding, and
700 it'll remove any monsters it finds.*/ 692 it'll remove any monsters it finds.*/
701 693
702object ** 694object **
703surround_by_doors (mapstruct *map, char **layout, int x, int y, int opts) 695surround_by_doors (maptile *map, char **layout, int x, int y, int opts)
704{ 696{
705 int i; 697 int i;
706 char *doors[2]; 698 char *doors[2];
707 object **doorlist; 699 object **doorlist;
708 int ndoors_made = 0; 700 int ndoors_made = 0;
… …
741} 733}
742 734
743 735
744/* returns the first door in this square, or NULL if there isn't a door. */ 736/* returns the first door in this square, or NULL if there isn't a door. */
745object * 737object *
746door_in_square (mapstruct *map, int x, int y) 738door_in_square (maptile *map, int x, int y)
747{ 739{
748 object *tmp; 740 object *tmp;
749 741
750 for (tmp = get_map_ob (map, x, y); tmp != NULL; tmp = tmp->above) 742 for (tmp = GET_MAP_OB (map, x, y); tmp != NULL; tmp = tmp->above)
751 if (tmp->type == DOOR || tmp->type == LOCKED_DOOR) 743 if (tmp->type == DOOR || tmp->type == LOCKED_DOOR)
752 return tmp; 744 return tmp;
753 return NULL; 745 return NULL;
754} 746}
755 747
756 748
757/* the workhorse routine, which finds the doors in a room */ 749/* the workhorse routine, which finds the doors in a room */
758void 750void
759find_doors_in_room_recursive (char **layout, mapstruct *map, int x, int y, object **doorlist, int *ndoors, RMParms * RP) 751find_doors_in_room_recursive (char **layout, maptile *map, int x, int y, object **doorlist, int *ndoors, random_map_params *RP)
760{ 752{
761 int i, j; 753 int i, j;
762 object *door; 754 object *door;
763 755
764 /* bounds check x and y */ 756 /* bounds check x and y */
… …
772 /* check off this point */ 764 /* check off this point */
773 if (layout[x][y] == '#') 765 if (layout[x][y] == '#')
774 { /* there could be a door here */ 766 { /* there could be a door here */
775 layout[x][y] = 1; 767 layout[x][y] = 1;
776 door = door_in_square (map, x, y); 768 door = door_in_square (map, x, y);
777 if (door != NULL) 769 if (door)
778 { 770 {
779 doorlist[*ndoors] = door; 771 doorlist[*ndoors] = door;
780 if (*ndoors > 254) /* eek! out of memory */ 772 if (*ndoors > 1022) /* eek! out of memory */
781 { 773 {
782 LOG (llevError, "find_doors_in_room_recursive:Too many doors for memory allocated!\n"); 774 LOG (llevError, "find_doors_in_room_recursive:Too many doors for memory allocated!\n");
783 return; 775 return;
784 } 776 }
777
785 *ndoors = *ndoors + 1; 778 *ndoors = *ndoors + 1;
786 } 779 }
787 } 780 }
788 else 781 else
789 { 782 {
790 layout[x][y] = 1; 783 layout[x][y] = 1;
791 /* now search all the 8 squares around recursively for free spots,in random order */ 784 /* 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++) 785 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); 786 find_doors_in_room_recursive (layout, map, x + freearr_x[i % 8 + 1], y + freearr_y[i % 8 + 1], doorlist, ndoors, RP);
795 }
796 } 787 }
797} 788}
798 789
799/* find a random non-blocked spot in this room to drop a key. */ 790/* find a random non-blocked spot in this room to drop a key. */
800object ** 791object **
801find_doors_in_room (mapstruct *map, int x, int y, RMParms * RP) 792find_doors_in_room (maptile *map, int x, int y, random_map_params *RP)
802{ 793{
803 char **layout2; 794 char **layout2;
804 object **doorlist; 795 object **doorlist;
805 int i, j; 796 int i, j;
806 int ndoors = 0; 797 int ndoors = 0;
807 798
808 doorlist = (object **) calloc (sizeof (int), 256); 799 doorlist = (object **) calloc (sizeof (int), 1024);
809
810 800
811 layout2 = (char **) calloc (sizeof (char *), RP->Xsize); 801 layout2 = (char **) calloc (sizeof (char *), RP->Xsize);
812 /* allocate and copy the layout, converting C to 0. */ 802 /* allocate and copy the layout, converting C to 0. */
813 for (i = 0; i < RP->Xsize; i++) 803 for (i = 0; i < RP->Xsize; i++)
814 { 804 {
… …
823 /* setup num_free_spots and room_free_spots */ 813 /* setup num_free_spots and room_free_spots */
824 find_doors_in_room_recursive (layout2, map, x, y, doorlist, &ndoors, RP); 814 find_doors_in_room_recursive (layout2, map, x, y, doorlist, &ndoors, RP);
825 815
826 /* deallocate the temp. layout */ 816 /* deallocate the temp. layout */
827 for (i = 0; i < RP->Xsize; i++) 817 for (i = 0; i < RP->Xsize; i++)
828 {
829 free (layout2[i]); 818 free (layout2[i]);
830 } 819
831 free (layout2); 820 free (layout2);
832 return doorlist; 821 return doorlist;
833} 822}
834 823
835 824
836 825
837/* locks and/or hides all the doors in doorlist, or does nothing if 826/* locks and/or hides all the doors in doorlist, or does nothing if
838 opts doesn't say to lock/hide doors. */ 827 opts doesn't say to lock/hide doors. */
839 828
840void 829void
841lock_and_hide_doors (object **doorlist, mapstruct *map, int opts, RMParms * RP) 830lock_and_hide_doors (object **doorlist, maptile *map, int opts, random_map_params *RP)
842{ 831{
843 object *door; 832 object *door;
844 int i; 833 int i;
845 834
846 /* lock the doors and hide the keys. */ 835 /* lock the doors and hide the keys. */
… …
848 if (opts & DOORED) 837 if (opts & DOORED)
849 { 838 {
850 for (i = 0, door = doorlist[0]; doorlist[i] != NULL; i++) 839 for (i = 0, door = doorlist[0]; doorlist[i] != NULL; i++)
851 { 840 {
852 object *new_door = get_archetype ("locked_door1"); 841 object *new_door = get_archetype ("locked_door1");
853 char keybuf[256]; 842 char keybuf[1024];
854 843
855 door = doorlist[i]; 844 door = doorlist[i];
856 new_door->face = door->face; 845 new_door->face = door->face;
857 new_door->x = door->x; 846 new_door->x = door->x;
858 new_door->y = door->y; 847 new_door->y = door->y;
859 remove_ob (door); 848 door->remove ();
860 free_object (door); 849 door->destroy ();
861 doorlist[i] = new_door; 850 doorlist[i] = new_door;
862 insert_ob_in_map (new_door, map, NULL, 0); 851 insert_ob_in_map (new_door, map, NULL, 0);
863 sprintf (keybuf, "%d", (int) RANDOM ()); 852 sprintf (keybuf, "%d", (int) RANDOM ());
864 new_door->slaying = keybuf; 853 new_door->slaying = keybuf;
865 keyplace (map, new_door->x, new_door->y, keybuf, NO_PASS_DOORS, 2, RP); 854 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); 870 retrofit_joined_wall (map, door->x + 1, door->y, 0, RP);
882 retrofit_joined_wall (map, door->x, door->y - 1, 0, RP); 871 retrofit_joined_wall (map, door->x, door->y - 1, 0, RP);
883 retrofit_joined_wall (map, door->x, door->y + 1, 0, RP); 872 retrofit_joined_wall (map, door->x, door->y + 1, 0, RP);
884 door->face = wallface->face; 873 door->face = wallface->face;
885 if (!QUERY_FLAG (wallface, FLAG_REMOVED)) 874 if (!QUERY_FLAG (wallface, FLAG_REMOVED))
886 remove_ob (wallface); 875 wallface->remove ();
887 free_object (wallface); 876 wallface->destroy ();
888 } 877 }
889 } 878 }
890 } 879 }
891} 880}

Diff Legend

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