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.14 by pippijn, Sat Jan 6 14:42:30 2007 UTC vs.
Revision 1.22 by root, Fri Jan 19 21:49:58 2007 UTC

1
2/* 1/*
3 CrossFire, A Multiplayer game for X-windows 2 * CrossFire, A Multiplayer game
4 3 *
5 Copyright (C) 2005, 2006, 2007 Marc Lehmann & Crossfire+ Development Team 4 * Copyright (C) 2005, 2006, 2007 Marc Lehmann & Crossfire+ Development Team
6 Copyright (C) 2001 Mark Wedel & Crossfire Development Team 5 * Copyright (C) 2001 Mark Wedel & Crossfire Development Team
7 Copyright (C) 1992 Frank Tore Johansen 6 * Copyright (C) 1992 Frank Tore Johansen
8 7 *
9 This program is free software; you can redistribute it and/or modify 8 * This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by 9 * it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 2 of the License, or 10 * the Free Software Foundation; either version 2 of the License, or
12 (at your option) any later version. 11 * (at your option) any later version.
13 12 *
14 This program is distributed in the hope that it will be useful, 13 * This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of 14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details. 16 * GNU General Public License for more details.
18 17 *
19 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
20 along with this program; if not, write to the Free Software 19 * along with this program; if not, write to the Free Software
21 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 20 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
22 21 *
23 The authors can be reached via e-mail at <crossfire@schmorp.de> 22 * The authors can be reached via e-mail at <crossfire@schmorp.de>
24*/ 23 */
25 24
26/* placing treasure in maps, where appropriate. */ 25/* placing treasure in maps, where appropriate. */
27
28
29 26
30#include <global.h> 27#include <global.h>
31#include <random_map.h> 28#include <random_map.h>
32#include <rproto.h> 29#include <rproto.h>
33 30
… …
49 46
50/* returns true if square x,y has P_NO_PASS set, which is true for walls 47/* returns true if square x,y has P_NO_PASS set, which is true for walls
51 * and doors but not monsters. 48 * and doors but not monsters.
52 * This function is not map tile aware. 49 * This function is not map tile aware.
53 */ 50 */
54
55int 51int
56wall_blocked (maptile *m, int x, int y) 52wall_blocked (maptile *m, int x, int y)
57{ 53{
58 int r;
59
60 if (OUT_OF_REAL_MAP (m, x, y)) 54 if (OUT_OF_REAL_MAP (m, x, y))
61 return 1; 55 return 1;
56
62 r = GET_MAP_MOVE_BLOCK (m, x, y) & ~MOVE_BLOCK_DEFAULT; 57 int r = GET_MAP_MOVE_BLOCK (m, x, y) & ~MOVE_BLOCK_DEFAULT;
63 return r; 58 return r;
64} 59}
65 60
66/* place treasures in the map, given the 61/* place treasures in the map, given the
67map, (required) 62map, (required)
68layout, (required) 63layout, (required)
69treasure style (may be empty or NULL, or "none" to cause no treasure.) 64treasure style (may be empty or NULL, or "none" to cause no treasure.)
70treasureoptions (may be 0 for random choices or positive) 65treasureoptions (may be 0 for random choices or positive)
71*/ 66*/
72
73void 67void
74place_treasure (maptile *map, char **layout, char *treasure_style, int treasureoptions, random_map_params *RP) 68place_treasure (maptile *map, char **layout, char *treasure_style, int treasureoptions, random_map_params *RP)
75{ 69{
76 char styledirname[1024]; 70 char styledirname[1024];
77 char stylefilepath[1024]; 71 char stylefilepath[1024];
… …
80 74
81 /* bail out if treasure isn't wanted. */ 75 /* bail out if treasure isn't wanted. */
82 if (treasure_style) 76 if (treasure_style)
83 if (!strcmp (treasure_style, "none")) 77 if (!strcmp (treasure_style, "none"))
84 return; 78 return;
79
85 if (treasureoptions <= 0) 80 if (treasureoptions <= 0)
86 treasureoptions = RANDOM () % (2 * LAST_OPTION); 81 treasureoptions = RANDOM () % (2 * LAST_OPTION);
87 82
88 /* filter out the mutually exclusive options */ 83 /* filter out the mutually exclusive options */
89 if ((treasureoptions & RICH) && (treasureoptions & SPARSE)) 84 if ((treasureoptions & RICH) && (treasureoptions & SPARSE))
90 { 85 {
91 if (RANDOM () % 2) 86 if (rndm (2))
92 treasureoptions -= 1; 87 treasureoptions -= 1;
93 else 88 else
94 treasureoptions -= 2; 89 treasureoptions -= 2;
95 } 90 }
96 91
… …
212 if (i == -1) 207 if (i == -1)
213 { 208 {
214 the_chest->destroy (); 209 the_chest->destroy ();
215 return NULL; 210 return NULL;
216 } 211 }
212
217 xl = x + freearr_x[i]; 213 xl = x + freearr_x[i];
218 yl = y + freearr_y[i]; 214 yl = y + freearr_y[i];
219 215
220 /* if the placement is blocked, return a fail. */ 216 /* if the placement is blocked, return a fail. */
221 if (wall_blocked (map, xl, yl)) 217 if (wall_blocked (map, xl, yl))
… …
332 it will place 2-4 keys regardless of what nkeys is provided nkeys > 1. 328 it will place 2-4 keys regardless of what nkeys is provided nkeys > 1.
333 329
334 The idea is that you call keyplace on x,y where a door is, and it'll make 330 The idea is that you call keyplace on x,y where a door is, and it'll make
335 sure a key is placed on both sides of the door. 331 sure a key is placed on both sides of the door.
336*/ 332*/
337
338int 333int
339keyplace (maptile *map, int x, int y, char *keycode, int door_flag, int n_keys, random_map_params *RP) 334keyplace (maptile *map, int x, int y, char *keycode, int door_flag, int n_keys, random_map_params *RP)
340{ 335{
341 int i, j; 336 int i, j;
342 int kx, ky; 337 int kx = 0, ky = 0;
343 object *the_keymaster; /* the monster that gets the key. */ 338 object *the_keymaster; /* the monster that gets the key. */
344 object *the_key; 339 object *the_key;
345 340
346 /* get a key and set its keycode */ 341 /* get a key and set its keycode */
347 the_key = get_archetype ("key2"); 342 the_key = get_archetype ("key2");
… …
349 344
350 if (door_flag == PASS_DOORS) 345 if (door_flag == PASS_DOORS)
351 { 346 {
352 int tries = 0; 347 int tries = 0;
353 348
354 the_keymaster = NULL; 349 the_keymaster = 0;
355 while (tries < 15 && the_keymaster == NULL) 350 while (tries < 15 && !the_keymaster)
356 { 351 {
357 i = (RANDOM () % (RP->Xsize - 2)) + 1; 352 i = (RANDOM () % (RP->Xsize - 2)) + 1;
358 j = (RANDOM () % (RP->Ysize - 2)) + 1; 353 j = (RANDOM () % (RP->Ysize - 2)) + 1;
359 tries++; 354 tries++;
360 the_keymaster = find_closest_monster (map, i, j, RP); 355 the_keymaster = find_closest_monster (map, i, j, RP);
361 } 356 }
357
362 /* if we don't find a good keymaster, drop the key on the ground. */ 358 /* if we don't find a good keymaster, drop the key on the ground. */
363 if (the_keymaster == NULL) 359 if (!the_keymaster)
364 { 360 {
365 int freeindex; 361 int freeindex;
366 362
367 freeindex = -1; 363 freeindex = -1;
368 for (tries = 0; tries < 15 && freeindex == -1; tries++) 364 for (tries = 0; tries < 15 && freeindex == -1; tries++)
369 { 365 {
370 kx = (RANDOM () % (RP->Xsize - 2)) + 1; 366 kx = (RANDOM () % (RP->Xsize - 2)) + 1;
371 ky = (RANDOM () % (RP->Ysize - 2)) + 1; 367 ky = (RANDOM () % (RP->Ysize - 2)) + 1;
372 freeindex = find_first_free_spot (the_key, map, kx, ky); 368 freeindex = find_free_spot (the_key, map, kx, ky, 1, SIZEOFFREE1 + 1);
373 } 369 }
370
371 // can freeindex ever be < 0?
374 if (freeindex != -1) 372 if (freeindex >= 0)
375 { 373 {
376 kx += freearr_x[freeindex]; 374 kx += freearr_x [freeindex];
377 ky += freearr_y[freeindex]; 375 ky += freearr_y [freeindex];
378 } 376 }
379 } 377 }
380 } 378 }
381 else 379 else
382 { /* NO_PASS_DOORS --we have to work harder. */ 380 { /* NO_PASS_DOORS --we have to work harder. */
… …
384 NO_PASS_DOORS is set. */ 382 NO_PASS_DOORS is set. */
385 if (n_keys == 1) 383 if (n_keys == 1)
386 { 384 {
387 if (wall_blocked (map, x, y)) 385 if (wall_blocked (map, x, y))
388 return 0; 386 return 0;
387
389 the_keymaster = find_monster_in_room (map, x, y, RP); 388 the_keymaster = find_monster_in_room (map, x, y, RP);
390 if (the_keymaster == NULL) /* if fail, find a spot to drop the key. */ 389 if (!the_keymaster) /* if fail, find a spot to drop the key. */
391 find_spot_in_room (map, x, y, &kx, &ky, RP); 390 find_spot_in_room (map, x, y, &kx, &ky, RP);
392 } 391 }
393 else 392 else
394 { 393 {
395 int sum = 0; /* count how many keys we actually place */ 394 int sum = 0; /* count how many keys we actually place */
… …
397 /* I'm lazy, so just try to place in all 4 directions. */ 396 /* I'm lazy, so just try to place in all 4 directions. */
398 sum += keyplace (map, x + 1, y, keycode, NO_PASS_DOORS, 1, RP); 397 sum += keyplace (map, x + 1, y, keycode, NO_PASS_DOORS, 1, RP);
399 sum += keyplace (map, x, y + 1, keycode, NO_PASS_DOORS, 1, RP); 398 sum += keyplace (map, x, y + 1, keycode, NO_PASS_DOORS, 1, RP);
400 sum += keyplace (map, x - 1, y, keycode, NO_PASS_DOORS, 1, RP); 399 sum += keyplace (map, x - 1, y, keycode, NO_PASS_DOORS, 1, RP);
401 sum += keyplace (map, x, y - 1, keycode, NO_PASS_DOORS, 1, RP); 400 sum += keyplace (map, x, y - 1, keycode, NO_PASS_DOORS, 1, RP);
401
402 if (sum < 2) /* we might have made a disconnected map-place more keys. */ 402 if (sum < 2) /* we might have made a disconnected map-place more keys. */
403 { /* diagnoally this time. */ 403 { /* diagonally this time. */
404 keyplace (map, x + 1, y + 1, keycode, NO_PASS_DOORS, 1, RP); 404 keyplace (map, x + 1, y + 1, keycode, NO_PASS_DOORS, 1, RP);
405 keyplace (map, x + 1, y - 1, keycode, NO_PASS_DOORS, 1, RP); 405 keyplace (map, x + 1, y - 1, keycode, NO_PASS_DOORS, 1, RP);
406 keyplace (map, x - 1, y + 1, keycode, NO_PASS_DOORS, 1, RP); 406 keyplace (map, x - 1, y + 1, keycode, NO_PASS_DOORS, 1, RP);
407 keyplace (map, x - 1, y - 1, keycode, NO_PASS_DOORS, 1, RP); 407 keyplace (map, x - 1, y - 1, keycode, NO_PASS_DOORS, 1, RP);
408 } 408 }
409
409 return 1; 410 return 1;
410 } 411 }
411 } 412 }
412 413
413 if (the_keymaster == NULL) 414 if (!the_keymaster)
414 { 415 {
415 the_key->x = kx; 416 the_key->x = kx;
416 the_key->y = ky; 417 the_key->y = ky;
417 insert_ob_in_map (the_key, map, NULL, 0); 418 insert_ob_in_map (the_key, map, NULL, 0);
418 return 1; 419 return 1;
… …
463 return theMonsterToFind; 464 return theMonsterToFind;
464 } 465 }
465 } 466 }
466 467
467 /* now search all the 8 squares around recursively for a monster,in random order */ 468 /* now search all the 8 squares around recursively for a monster,in random order */
468 for (i = RANDOM () % 8, j = 0; j < 8 && theMonsterToFind == NULL; i++, j++) 469 for (i = rndm (8), j = 0; j < 8 && theMonsterToFind == NULL; i++, j++)
469 { 470 {
470 theMonsterToFind = find_monster_in_room_recursive (layout, map, x + freearr_x[i % 8 + 1], y + freearr_y[i % 8 + 1], RP); 471 theMonsterToFind = find_monster_in_room_recursive (layout, map, x + freearr_x[i % 8 + 1], y + freearr_y[i % 8 + 1], RP);
471 if (theMonsterToFind != NULL) 472 if (theMonsterToFind != NULL)
472 return theMonsterToFind; 473 return theMonsterToFind;
473 } 474 }
… …
506 free (layout2); 507 free (layout2);
507 508
508 return theMonsterToFind; 509 return theMonsterToFind;
509} 510}
510 511
511
512
513
514/* a datastructure needed by find_spot_in_room and find_spot_in_room_recursive */ 512/* a datastructure needed by find_spot_in_room and find_spot_in_room_recursive */
515int *room_free_spots_x; 513int *room_free_spots_x;
516int *room_free_spots_y; 514int *room_free_spots_y;
517int number_of_free_spots_in_room; 515int number_of_free_spots_in_room;
518 516
519/* the workhorse routine, which finds the free spots in a room: 517/* the workhorse routine, which finds the free spots in a room:
520a datastructure of free points is set up, and a position chosen from 518a datastructure of free points is set up, and a position chosen from
521that datastructure. */ 519that datastructure. */
522
523void 520void
524find_spot_in_room_recursive (char **layout, int x, int y, random_map_params *RP) 521find_spot_in_room_recursive (char **layout, int x, int y, random_map_params *RP)
525{ 522{
526 int i, j; 523 int i, j;
527 524
… …
538 /* check off this point */ 535 /* check off this point */
539 layout[x][y] = 1; 536 layout[x][y] = 1;
540 room_free_spots_x[number_of_free_spots_in_room] = x; 537 room_free_spots_x[number_of_free_spots_in_room] = x;
541 room_free_spots_y[number_of_free_spots_in_room] = y; 538 room_free_spots_y[number_of_free_spots_in_room] = y;
542 number_of_free_spots_in_room++; 539 number_of_free_spots_in_room++;
540
543 /* now search all the 8 squares around recursively for free spots,in random order */ 541 /* now search all the 8 squares around recursively for free spots,in random order */
544 for (i = RANDOM () % 8, j = 0; j < 8 && theMonsterToFind == NULL; i++, j++) 542 for (i = rndm (8), j = 0; j < 8 && theMonsterToFind == NULL; i++, j++)
545 {
546 find_spot_in_room_recursive (layout, x + freearr_x[i % 8 + 1], y + freearr_y[i % 8 + 1], RP); 543 find_spot_in_room_recursive (layout, x + freearr_x[i % 8 + 1], y + freearr_y[i % 8 + 1], RP);
547 }
548 544
549} 545}
550 546
551/* find a random non-blocked spot in this room to drop a key. */ 547/* find a random non-blocked spot in this room to drop a key. */
552void 548void
… …
563 /* allocate and copy the layout, converting C to 0. */ 559 /* allocate and copy the layout, converting C to 0. */
564 for (i = 0; i < RP->Xsize; i++) 560 for (i = 0; i < RP->Xsize; i++)
565 { 561 {
566 layout2[i] = (char *) calloc (sizeof (char), RP->Ysize); 562 layout2[i] = (char *) calloc (sizeof (char), RP->Ysize);
567 for (j = 0; j < RP->Ysize; j++) 563 for (j = 0; j < RP->Ysize; j++)
568 {
569 if (wall_blocked (map, i, j)) 564 if (wall_blocked (map, i, j))
570 layout2[i][j] = '#'; 565 layout2[i][j] = '#';
571 }
572 } 566 }
573 567
574 /* setup num_free_spots and room_free_spots */ 568 /* setup num_free_spots and room_free_spots */
575 find_spot_in_room_recursive (layout2, x, y, RP); 569 find_spot_in_room_recursive (layout2, x, y, RP);
576 570
… …
581 *ky = room_free_spots_y[i]; 575 *ky = room_free_spots_y[i];
582 } 576 }
583 577
584 /* deallocate the temp. layout */ 578 /* deallocate the temp. layout */
585 for (i = 0; i < RP->Xsize; i++) 579 for (i = 0; i < RP->Xsize; i++)
586 {
587 free (layout2[i]); 580 free (layout2[i]);
588 } 581
589 free (layout2); 582 free (layout2);
590 free (room_free_spots_x); 583 free (room_free_spots_x);
591 free (room_free_spots_y); 584 free (room_free_spots_y);
592} 585}
593 586
594 587
595/* searches the map for a spot with walls around it. The more 588/* searches the map for a spot with walls around it. The more
596 walls the better, but it'll settle for 1 wall, or even 0, but 589 walls the better, but it'll settle for 1 wall, or even 0, but
597 it'll return 0 if no FREE spots are found.*/ 590 it'll return 0 if no FREE spots are found.*/
598
599void 591void
600find_enclosed_spot (maptile *map, int *cx, int *cy, random_map_params *RP) 592find_enclosed_spot (maptile *map, int *cx, int *cy, random_map_params *RP)
601{ 593{
602 int x, y; 594 int x, y;
603 int i; 595 int i;
… …
654 *cy = ly; 646 *cy = ly;
655 return; 647 return;
656 } 648 }
657 } 649 }
658 /* give up and return the closest free spot. */ 650 /* give up and return the closest free spot. */
659 i = find_first_free_spot (&archetype::find ("chest")->clone, map, x, y); 651 i = find_free_spot (&archetype::find ("chest")->clone, map, x, y, 1, SIZEOFFREE1 + 1);
660 if (i != -1 && i <= SIZEOFFREE1) 652
653 if (i != -1)
661 { 654 {
662 *cx = x + freearr_x[i]; 655 *cx = x + freearr_x[i];
663 *cy = y + freearr_y[i]; 656 *cy = y + freearr_y[i];
664 return; 657 }
658 else
665 } 659 {
666 /* indicate failure */ 660 /* indicate failure */
661 *cx = -1;
667 *cx = *cy = -1; 662 *cy = -1;
663 }
668} 664}
669
670 665
671void 666void
672remove_monsters (int x, int y, maptile *map) 667remove_monsters (int x, int y, maptile *map)
673{ 668{
674 object *tmp; 669 object *tmp;
675 670
676 for (tmp = GET_MAP_OB (map, x, y); tmp != NULL; tmp = tmp->above) 671 for (tmp = GET_MAP_OB (map, x, y); tmp; tmp = tmp->above)
677 if (QUERY_FLAG (tmp, FLAG_ALIVE)) 672 if (QUERY_FLAG (tmp, FLAG_ALIVE))
678 { 673 {
679 if (tmp->head) 674 if (tmp->head)
680 tmp = tmp->head; 675 tmp = tmp->head;
681 tmp->remove (); 676 tmp->remove ();
… …
684 if (tmp == NULL) 679 if (tmp == NULL)
685 break; 680 break;
686 }; 681 };
687} 682}
688 683
689
690/* surrounds the point x,y by doors, so as to enclose something, like 684/* surrounds the point x,y by doors, so as to enclose something, like
691 a chest. It only goes as far as the 8 squares surrounding, and 685 a chest. It only goes as far as the 8 squares surrounding, and
692 it'll remove any monsters it finds.*/ 686 it'll remove any monsters it finds.*/
693
694object ** 687object **
695surround_by_doors (maptile *map, char **layout, int x, int y, int opts) 688surround_by_doors (maptile *map, char **layout, int x, int y, int opts)
696{ 689{
697 int i; 690 int i;
698 char *doors[2]; 691 char *doors[2];
… …
715 /* place doors in all the 8 adjacent unblocked squares. */ 708 /* place doors in all the 8 adjacent unblocked squares. */
716 for (i = 1; i < 9; i++) 709 for (i = 1; i < 9; i++)
717 { 710 {
718 int x1 = x + freearr_x[i], y1 = y + freearr_y[i]; 711 int x1 = x + freearr_x[i], y1 = y + freearr_y[i];
719 712
720 if (!wall_blocked (map, x1, y1) || layout[x1][y1] == '>') 713 if (!wall_blocked (map, x1, y1) && layout[x1][y1] == '>')
721 { /* place a door */ 714 { /* place a door */
715 remove_monsters (x1, y1, map);
716
722 object *new_door = get_archetype ((freearr_x[i] == 0) ? doors[1] : doors[0]); 717 object *new_door = get_archetype (freearr_x[i] == 0 ? doors[1] : doors[0]);
723 718 map->insert (new_door, x1, y1);
724 new_door->x = x + freearr_x[i];
725 new_door->y = y + freearr_y[i];
726 remove_monsters (new_door->x, new_door->y, map);
727 insert_ob_in_map (new_door, map, NULL, 0);
728 doorlist[ndoors_made] = new_door; 719 doorlist[ndoors_made] = new_door;
729 ndoors_made++; 720 ndoors_made++;
730 } 721 }
731 } 722 }
723
732 return doorlist; 724 return doorlist;
733} 725}
734 726
735 727
736/* returns the first door in this square, or NULL if there isn't a door. */ 728/* returns the first door in this square, or NULL if there isn't a door. */
… …
780 } 772 }
781 else 773 else
782 { 774 {
783 layout[x][y] = 1; 775 layout[x][y] = 1;
784 /* now search all the 8 squares around recursively for free spots,in random order */ 776 /* now search all the 8 squares around recursively for free spots,in random order */
785 for (i = RANDOM () % 8, j = 0; j < 8 && theMonsterToFind == NULL; i++, j++) 777 for (i = rndm (8), j = 0; j < 8 && theMonsterToFind == NULL; i++, j++)
786 find_doors_in_room_recursive (layout, map, x + freearr_x[i % 8 + 1], y + freearr_y[i % 8 + 1], doorlist, ndoors, RP); 778 find_doors_in_room_recursive (layout, map, x + freearr_x[i % 8 + 1], y + freearr_y[i % 8 + 1], doorlist, ndoors, RP);
787 } 779 }
788} 780}
789 781
790/* find a random non-blocked spot in this room to drop a key. */ 782/* find a random non-blocked spot in this room to drop a key. */

Diff Legend

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