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

Diff Legend

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