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.5 by root, Thu Sep 14 21:16:12 2006 UTC vs.
Revision 1.17 by root, Mon Jan 15 15:54:19 2007 UTC

1
2/*
3 * static char *rcsid_treasure_c =
4 * "$Id: treasure.C,v 1.5 2006/09/14 21:16:12 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 }
217
223 xl = x + freearr_x[i]; 218 xl = x + freearr_x[i];
224 yl = y + freearr_y[i]; 219 yl = y + freearr_y[i];
225 220
226 /* if the placement is blocked, return a fail. */ 221 /* if the placement is blocked, return a fail. */
227 if (wall_blocked (map, xl, yl)) 222 if (wall_blocked (map, xl, yl))
228 return 0; 223 return 0;
229
230 224
231 /* put the treasures in the chest. */ 225 /* put the treasures in the chest. */
232 /* if(style_map) { */ 226 /* if(style_map) { */
233#if 0 /* don't use treasure style maps for now! */ 227#if 0 /* don't use treasure style maps for now! */
234 int ti; 228 int ti;
… …
247 { /* use the style map */ 241 { /* use the style map */
248 the_chest->randomitems = tlist; 242 the_chest->randomitems = tlist;
249 the_chest->stats.hp = n_treasures; 243 the_chest->stats.hp = n_treasures;
250 } 244 }
251#endif 245#endif
252 else
253 { /* neither style_map no treasure list given */ 246 { /* neither style_map no treasure list given */
254 treasurelist *tlist = find_treasurelist ("chest"); 247 treasurelist *tlist = find_treasurelist ("chest");
255 248
256 the_chest->randomitems = tlist; 249 the_chest->randomitems = tlist;
257 the_chest->stats.hp = n_treasures; 250 the_chest->stats.hp = n_treasures;
258 } 251 }
259 252
260 /* stick a trap in the chest if required */ 253 /* stick a trap in the chest if required */
261 if (treasureoptions & TRAPPED) 254 if (treasureoptions & TRAPPED)
262 { 255 {
263 mapstruct *trap_map = find_style ("/styles/trapstyles", "traps", -1); 256 maptile *trap_map = find_style ("/styles/trapstyles", "traps", -1);
264 object *the_trap; 257 object *the_trap;
265 258
266 if (trap_map) 259 if (trap_map)
267 { 260 {
268 the_trap = pick_random_object (trap_map); 261 the_trap = pick_random_object (trap_map);
… …
271 if (the_trap) 264 if (the_trap)
272 { 265 {
273 object *new_trap; 266 object *new_trap;
274 267
275 new_trap = arch_to_object (the_trap->arch); 268 new_trap = arch_to_object (the_trap->arch);
276 copy_object (new_trap, the_trap); 269 new_trap->copy_to (the_trap);
277 new_trap->x = x; 270 new_trap->x = x;
278 new_trap->y = y; 271 new_trap->y = y;
279 insert_ob_in_ob (new_trap, the_chest); 272 insert_ob_in_ob (new_trap, the_chest);
280 } 273 }
281 } 274 }
… …
285 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
286 there's only 1 treasure.... */ 279 there's only 1 treasure.... */
287 280
288 if ((treasureoptions & KEYREQUIRED) && n_treasures > 1) 281 if ((treasureoptions & KEYREQUIRED) && n_treasures > 1)
289 { 282 {
290 char keybuf[256]; 283 char keybuf[1024];
291 284
292 sprintf (keybuf, "%d", (int) RANDOM ()); 285 sprintf (keybuf, "%d", (int) RANDOM ());
293 the_chest->slaying = keybuf; 286 the_chest->slaying = keybuf;
294 keyplace (map, x, y, keybuf, PASS_DOORS, 1, RP); 287 keyplace (map, x, y, keybuf, PASS_DOORS, 1, RP);
295 } 288 }
… …
303 296
304 297
305/* finds the closest monster and returns him, regardless of doors 298/* finds the closest monster and returns him, regardless of doors
306 or walls */ 299 or walls */
307object * 300object *
308find_closest_monster (mapstruct *map, int x, int y, RMParms * RP) 301find_closest_monster (maptile *map, int x, int y, random_map_params *RP)
309{ 302{
310 int i; 303 int i;
311 304
312 for (i = 0; i < SIZEOFFREE; i++) 305 for (i = 0; i < SIZEOFFREE; i++)
313 { 306 {
… …
318 /* boundscheck */ 311 /* boundscheck */
319 if (lx >= 0 && ly >= 0 && lx < RP->Xsize && ly < RP->Ysize) 312 if (lx >= 0 && ly >= 0 && lx < RP->Xsize && ly < RP->Ysize)
320 /* 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. */
321 if (GET_MAP_FLAGS (map, lx, ly) & P_IS_ALIVE) 314 if (GET_MAP_FLAGS (map, lx, ly) & P_IS_ALIVE)
322 { 315 {
323 object *the_monster = get_map_ob (map, lx, ly); 316 object *the_monster = GET_MAP_OB (map, lx, ly);
324 317
325 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);
326 if (the_monster && QUERY_FLAG (the_monster, FLAG_MONSTER)) 319 if (the_monster && QUERY_FLAG (the_monster, FLAG_MONSTER))
327 return the_monster; 320 return the_monster;
328 } 321 }
… …
342 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
343 sure a key is placed on both sides of the door. 336 sure a key is placed on both sides of the door.
344*/ 337*/
345 338
346int 339int
347keyplace (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)
348{ 341{
349 int i, j; 342 int i, j;
350 int kx, ky; 343 int kx, ky;
351 object *the_keymaster; /* the monster that gets the key. */ 344 object *the_keymaster; /* the monster that gets the key. */
352 object *the_key; 345 object *the_key;
… …
375 freeindex = -1; 368 freeindex = -1;
376 for (tries = 0; tries < 15 && freeindex == -1; tries++) 369 for (tries = 0; tries < 15 && freeindex == -1; tries++)
377 { 370 {
378 kx = (RANDOM () % (RP->Xsize - 2)) + 1; 371 kx = (RANDOM () % (RP->Xsize - 2)) + 1;
379 ky = (RANDOM () % (RP->Ysize - 2)) + 1; 372 ky = (RANDOM () % (RP->Ysize - 2)) + 1;
380 freeindex = find_first_free_spot (the_key, map, kx, ky); 373 freeindex = find_free_spot (the_key, map, kx, ky, 1, SIZEOFFREE1 + 1);
381 } 374 }
375
382 if (freeindex != -1) 376 if (freeindex != -1)
383 { 377 {
384 kx += freearr_x[freeindex]; 378 kx += freearr_x[freeindex];
385 ky += freearr_y[freeindex]; 379 ky += freearr_y[freeindex];
386 } 380 }
… …
392 NO_PASS_DOORS is set. */ 386 NO_PASS_DOORS is set. */
393 if (n_keys == 1) 387 if (n_keys == 1)
394 { 388 {
395 if (wall_blocked (map, x, y)) 389 if (wall_blocked (map, x, y))
396 return 0; 390 return 0;
391
397 the_keymaster = find_monster_in_room (map, x, y, RP); 392 the_keymaster = find_monster_in_room (map, x, y, RP);
398 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. */
399 find_spot_in_room (map, x, y, &kx, &ky, RP); 394 find_spot_in_room (map, x, y, &kx, &ky, RP);
400 } 395 }
401 else 396 else
… …
438 433
439/* 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.
440 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 */
441 436
442object * 437object *
443find_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)
444{ 439{
445 int i, j; 440 int i, j;
446 441
447 /* if we've found a monster already, leave */ 442 /* if we've found a monster already, leave */
448 if (theMonsterToFind != NULL) 443 if (theMonsterToFind != NULL)
… …
459 /* check the current square for a monster. If there is one, 454 /* check the current square for a monster. If there is one,
460 set theMonsterToFind and return it. */ 455 set theMonsterToFind and return it. */
461 layout[x][y] = 1; 456 layout[x][y] = 1;
462 if (GET_MAP_FLAGS (map, x, y) & P_IS_ALIVE) 457 if (GET_MAP_FLAGS (map, x, y) & P_IS_ALIVE)
463 { 458 {
464 object *the_monster = get_map_ob (map, x, y); 459 object *the_monster = GET_MAP_OB (map, x, y);
465 460
466 /* check off this point */ 461 /* check off this point */
467 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);
468 if (the_monster && QUERY_FLAG (the_monster, FLAG_ALIVE)) 463 if (the_monster && QUERY_FLAG (the_monster, FLAG_ALIVE))
469 { 464 {
… …
485 480
486/* sets up some data structures: the _recursive form does the 481/* sets up some data structures: the _recursive form does the
487 real work. */ 482 real work. */
488 483
489object * 484object *
490find_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)
491{ 486{
492 char **layout2; 487 char **layout2;
493 int i, j; 488 int i, j;
494 489
495 theMonsterToFind = 0; 490 theMonsterToFind = 0;
… …
527/* the workhorse routine, which finds the free spots in a room: 522/* the workhorse routine, which finds the free spots in a room:
528a 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
529that datastructure. */ 524that datastructure. */
530 525
531void 526void
532find_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)
533{ 528{
534 int i, j; 529 int i, j;
535 530
536 /* bounds check x and y */ 531 /* bounds check x and y */
537 if (!(x >= 0 && y >= 0 && x < RP->Xsize && y < RP->Ysize)) 532 if (!(x >= 0 && y >= 0 && x < RP->Xsize && y < RP->Ysize))
… …
556 551
557} 552}
558 553
559/* 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. */
560void 555void
561find_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)
562{ 557{
563 char **layout2; 558 char **layout2;
564 int i, j; 559 int i, j;
565 560
566 number_of_free_spots_in_room = 0; 561 number_of_free_spots_in_room = 0;
… …
603/* 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
604 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
605 it'll return 0 if no FREE spots are found.*/ 600 it'll return 0 if no FREE spots are found.*/
606 601
607void 602void
608find_enclosed_spot (mapstruct *map, int *cx, int *cy, RMParms * RP) 603find_enclosed_spot (maptile *map, int *cx, int *cy, random_map_params *RP)
609{ 604{
610 int x, y; 605 int x, y;
611 int i; 606 int i;
612 607
613 x = *cx; 608 x = *cx;
… …
662 *cy = ly; 657 *cy = ly;
663 return; 658 return;
664 } 659 }
665 } 660 }
666 /* give up and return the closest free spot. */ 661 /* give up and return the closest free spot. */
667 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);
668 if (i != -1 && i <= SIZEOFFREE1) 663
664 if (i != -1)
669 { 665 {
670 *cx = x + freearr_x[i]; 666 *cx = x + freearr_x[i];
671 *cy = y + freearr_y[i]; 667 *cy = y + freearr_y[i];
672 return; 668 }
669 else
673 } 670 {
674 /* indicate failure */ 671 /* indicate failure */
672 *cx = -1;
675 *cx = *cy = -1; 673 *cy = -1;
674 }
676} 675}
677 676
678 677
679void 678void
680remove_monsters (int x, int y, mapstruct *map) 679remove_monsters (int x, int y, maptile *map)
681{ 680{
682 object *tmp; 681 object *tmp;
683 682
684 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)
685 if (QUERY_FLAG (tmp, FLAG_ALIVE)) 684 if (QUERY_FLAG (tmp, FLAG_ALIVE))
686 { 685 {
687 if (tmp->head) 686 if (tmp->head)
688 tmp = tmp->head; 687 tmp = tmp->head;
689 remove_ob (tmp); 688 tmp->remove ();
690 free_object (tmp); 689 tmp->destroy ();
691 tmp = get_map_ob (map, x, y); 690 tmp = GET_MAP_OB (map, x, y);
692 if (tmp == NULL) 691 if (tmp == NULL)
693 break; 692 break;
694 }; 693 };
695} 694}
696 695
… …
698/* 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
699 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
700 it'll remove any monsters it finds.*/ 699 it'll remove any monsters it finds.*/
701 700
702object ** 701object **
703surround_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)
704{ 703{
705 int i; 704 int i;
706 char *doors[2]; 705 char *doors[2];
707 object **doorlist; 706 object **doorlist;
708 int ndoors_made = 0; 707 int ndoors_made = 0;
… …
741} 740}
742 741
743 742
744/* 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. */
745object * 744object *
746door_in_square (mapstruct *map, int x, int y) 745door_in_square (maptile *map, int x, int y)
747{ 746{
748 object *tmp; 747 object *tmp;
749 748
750 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)
751 if (tmp->type == DOOR || tmp->type == LOCKED_DOOR) 750 if (tmp->type == DOOR || tmp->type == LOCKED_DOOR)
752 return tmp; 751 return tmp;
753 return NULL; 752 return NULL;
754} 753}
755 754
756 755
757/* the workhorse routine, which finds the doors in a room */ 756/* the workhorse routine, which finds the doors in a room */
758void 757void
759find_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)
760{ 759{
761 int i, j; 760 int i, j;
762 object *door; 761 object *door;
763 762
764 /* bounds check x and y */ 763 /* bounds check x and y */
… …
772 /* check off this point */ 771 /* check off this point */
773 if (layout[x][y] == '#') 772 if (layout[x][y] == '#')
774 { /* there could be a door here */ 773 { /* there could be a door here */
775 layout[x][y] = 1; 774 layout[x][y] = 1;
776 door = door_in_square (map, x, y); 775 door = door_in_square (map, x, y);
777 if (door != NULL) 776 if (door)
778 { 777 {
779 doorlist[*ndoors] = door; 778 doorlist[*ndoors] = door;
780 if (*ndoors > 254) /* eek! out of memory */ 779 if (*ndoors > 1022) /* eek! out of memory */
781 { 780 {
782 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");
783 return; 782 return;
784 } 783 }
784
785 *ndoors = *ndoors + 1; 785 *ndoors = *ndoors + 1;
786 } 786 }
787 } 787 }
788 else 788 else
789 { 789 {
790 layout[x][y] = 1; 790 layout[x][y] = 1;
791 /* 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 */
792 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++)
793 {
794 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);
795 }
796 } 794 }
797} 795}
798 796
799/* 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. */
800object ** 798object **
801find_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)
802{ 800{
803 char **layout2; 801 char **layout2;
804 object **doorlist; 802 object **doorlist;
805 int i, j; 803 int i, j;
806 int ndoors = 0; 804 int ndoors = 0;
807 805
808 doorlist = (object **) calloc (sizeof (int), 256); 806 doorlist = (object **) calloc (sizeof (int), 1024);
809
810 807
811 layout2 = (char **) calloc (sizeof (char *), RP->Xsize); 808 layout2 = (char **) calloc (sizeof (char *), RP->Xsize);
812 /* allocate and copy the layout, converting C to 0. */ 809 /* allocate and copy the layout, converting C to 0. */
813 for (i = 0; i < RP->Xsize; i++) 810 for (i = 0; i < RP->Xsize; i++)
814 { 811 {
… …
823 /* setup num_free_spots and room_free_spots */ 820 /* setup num_free_spots and room_free_spots */
824 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);
825 822
826 /* deallocate the temp. layout */ 823 /* deallocate the temp. layout */
827 for (i = 0; i < RP->Xsize; i++) 824 for (i = 0; i < RP->Xsize; i++)
828 {
829 free (layout2[i]); 825 free (layout2[i]);
830 } 826
831 free (layout2); 827 free (layout2);
832 return doorlist; 828 return doorlist;
833} 829}
834 830
835 831
836 832
837/* 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
838 opts doesn't say to lock/hide doors. */ 834 opts doesn't say to lock/hide doors. */
839 835
840void 836void
841lock_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)
842{ 838{
843 object *door; 839 object *door;
844 int i; 840 int i;
845 841
846 /* lock the doors and hide the keys. */ 842 /* lock the doors and hide the keys. */
… …
848 if (opts & DOORED) 844 if (opts & DOORED)
849 { 845 {
850 for (i = 0, door = doorlist[0]; doorlist[i] != NULL; i++) 846 for (i = 0, door = doorlist[0]; doorlist[i] != NULL; i++)
851 { 847 {
852 object *new_door = get_archetype ("locked_door1"); 848 object *new_door = get_archetype ("locked_door1");
853 char keybuf[256]; 849 char keybuf[1024];
854 850
855 door = doorlist[i]; 851 door = doorlist[i];
856 new_door->face = door->face; 852 new_door->face = door->face;
857 new_door->x = door->x; 853 new_door->x = door->x;
858 new_door->y = door->y; 854 new_door->y = door->y;
859 remove_ob (door); 855 door->remove ();
860 free_object (door); 856 door->destroy ();
861 doorlist[i] = new_door; 857 doorlist[i] = new_door;
862 insert_ob_in_map (new_door, map, NULL, 0); 858 insert_ob_in_map (new_door, map, NULL, 0);
863 sprintf (keybuf, "%d", (int) RANDOM ()); 859 sprintf (keybuf, "%d", (int) RANDOM ());
864 new_door->slaying = keybuf; 860 new_door->slaying = keybuf;
865 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);
… …
881 retrofit_joined_wall (map, door->x + 1, door->y, 0, RP); 877 retrofit_joined_wall (map, door->x + 1, door->y, 0, RP);
882 retrofit_joined_wall (map, door->x, door->y - 1, 0, RP); 878 retrofit_joined_wall (map, door->x, door->y - 1, 0, RP);
883 retrofit_joined_wall (map, door->x, door->y + 1, 0, RP); 879 retrofit_joined_wall (map, door->x, door->y + 1, 0, RP);
884 door->face = wallface->face; 880 door->face = wallface->face;
885 if (!QUERY_FLAG (wallface, FLAG_REMOVED)) 881 if (!QUERY_FLAG (wallface, FLAG_REMOVED))
886 remove_ob (wallface); 882 wallface->remove ();
887 free_object (wallface); 883 wallface->destroy ();
888 } 884 }
889 } 885 }
890 } 886 }
891} 887}

Diff Legend

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