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.6 by root, Thu Sep 14 22:34:03 2006 UTC vs.
Revision 1.17 by root, Mon Jan 15 15:54:19 2007 UTC

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

Diff Legend

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