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.41 by root, Thu Jul 24 20:35:37 2008 UTC vs.
Revision 1.46 by root, Fri Nov 6 12:49:19 2009 UTC

… …
3 * 3 *
4 * Copyright (©) 2005,2006,2007,2008 Marc Alexander Lehmann / Robin Redeker / the Deliantra team 4 * Copyright (©) 2005,2006,2007,2008 Marc Alexander Lehmann / Robin Redeker / the Deliantra team
5 * Copyright (©) 2001,2007 Mark Wedel & Crossfire Development Team 5 * Copyright (©) 2001,2007 Mark Wedel & Crossfire Development Team
6 * Copyright (©) 1992,2007 Frank Tore Johansen 6 * Copyright (©) 1992,2007 Frank Tore Johansen
7 * 7 *
8 * Deliantra is free software: you can redistribute it and/or modify 8 * Deliantra is free software: you can redistribute it and/or modify it under
9 * it under the terms of the GNU General Public License as published by 9 * the terms of the Affero GNU General Public License as published by the
10 * the Free Software Foundation, either version 3 of the License, or 10 * Free Software Foundation, either version 3 of the License, or (at your
11 * (at your option) any later version. 11 * option) any later version.
12 * 12 *
13 * 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,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of 14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details. 16 * GNU General Public License for more details.
17 * 17 *
18 * You should have received a copy of the GNU General Public License 18 * You should have received a copy of the Affero GNU General Public License
19 * along with this program. If not, see <http://www.gnu.org/licenses/>. 19 * and the GNU General Public License along with this program. If not, see
20 * <http://www.gnu.org/licenses/>.
20 * 21 *
21 * The authors can be reached via e-mail to <support@deliantra.net> 22 * The authors can be reached via e-mail to <support@deliantra.net>
22 */ 23 */
23 24
24/* placing treasure in maps, where appropriate. */ 25/* placing treasure in maps, where appropriate. */
… …
40#define LAST_OPTION 64 /* set this to the last real option, for random */ 41#define LAST_OPTION 64 /* set this to the last real option, for random */
41 42
42#define NO_PASS_DOORS 0 43#define NO_PASS_DOORS 0
43#define PASS_DOORS 1 44#define PASS_DOORS 1
44 45
46static object *find_closest_monster (maptile *map, int x, int y, random_map_params *RP);
47static object *find_monster_in_room (maptile *map, int x, int y, random_map_params *RP);
48static void find_spot_in_room_recursive (char **layout, int x, int y, random_map_params *RP);
49static void find_spot_in_room (maptile *map, int x, int y, int *kx, int *ky, random_map_params *RP);
50static object *place_chest (int treasureoptions, int x, int y, maptile *map, maptile *style_map, int n_treasures, random_map_params *RP);
51static object **find_doors_in_room (maptile *map, int x, int y, random_map_params *RP);
52static void lock_and_hide_doors (object **doorlist, maptile *map, int opts, random_map_params *RP);
53static void find_enclosed_spot (maptile *map, int *cx, int *cy, random_map_params *RP);
54static object **surround_by_doors (maptile *map, char **layout, int x, int y, int opts);
55
45/* a macro to get a strongly centered random distribution, 56/* a macro to get a strongly centered random distribution,
46 from 0 to x, centered at x/2 */ 57 from 0 to x, centered at x/2 */
47static int 58static int
48bc_random (int x) 59bc_random (int x)
49{ 60{
… …
148 the_key->destroy (); 159 the_key->destroy ();
149 return 1; 160 return 1;
150 } 161 }
151 } 162 }
152 163
153 LOG(llevError, "key %d,%d %p\n", the_keymaster ? the_keymaster->x : x, the_keymaster ? the_keymaster->y : y, the_keymaster+0);//D
154 if (the_keymaster) 164 if (the_keymaster)
155 the_keymaster->head_ ()->insert (the_key); 165 the_keymaster->head_ ()->insert (the_key);
156 else 166 else
157 { 167 {
158 the_key->x = kx; 168 the_key->x = kx;
… …
410 the_chest->y = yl; 420 the_chest->y = yl;
411 insert_ob_in_map (the_chest, map, NULL, 0); 421 insert_ob_in_map (the_chest, map, NULL, 0);
412 return the_chest; 422 return the_chest;
413} 423}
414 424
415
416/* finds the closest monster and returns him, regardless of doors 425/* finds the closest monster and returns him, regardless of doors or walls */
417 or walls */ 426static object *
418object *
419find_closest_monster (maptile *map, int x, int y, random_map_params *RP) 427find_closest_monster (maptile *map, int x, int y, random_map_params *RP)
420{ 428{
421 int i; 429 int i;
422 430
423 for (i = 0; i < SIZEOFFREE; i++) 431 for (i = 0; i < SIZEOFFREE; i++)
… …
441 return NULL; 449 return NULL;
442} 450}
443 451
444/* both find_monster_in_room routines need to have access to this. */ 452/* both find_monster_in_room routines need to have access to this. */
445 453
446object *theMonsterToFind; 454static object *theMonsterToFind;
447 455
448/* a recursive routine which will return a monster, eventually,if there is one. 456/* a recursive routine which will return a monster, eventually,if there is one.
449 it does a check-off on the layout, converting 0's to 1's */ 457 it does a check-off on the layout, converting 0's to 1's */
450 458static object *
451object *
452find_monster_in_room_recursive (char **layout, maptile *map, int x, int y, random_map_params *RP) 459find_monster_in_room_recursive (char **layout, maptile *map, int x, int y, random_map_params *RP)
453{ 460{
454 int i, j; 461 int i, j;
455 462
456 /* if we've found a monster already, leave */ 463 /* if we've found a monster already, leave */
… …
514 521
515 return theMonsterToFind; 522 return theMonsterToFind;
516} 523}
517 524
518/* a datastructure needed by find_spot_in_room and find_spot_in_room_recursive */ 525/* a datastructure needed by find_spot_in_room and find_spot_in_room_recursive */
519int *room_free_spots_x; 526static int *room_free_spots_x;
520int *room_free_spots_y; 527static int *room_free_spots_y;
521int number_of_free_spots_in_room; 528static int number_of_free_spots_in_room;
522 529
523/* the workhorse routine, which finds the free spots in a room: 530/* the workhorse routine, which finds the free spots in a room:
524a datastructure of free points is set up, and a position chosen from 531a datastructure of free points is set up, and a position chosen from
525that datastructure. */ 532that datastructure. */
526void 533static void
527find_spot_in_room_recursive (char **layout, int x, int y, random_map_params *RP) 534find_spot_in_room_recursive (char **layout, int x, int y, random_map_params *RP)
528{ 535{
529 int i, j; 536 int i, j;
530 537
531 /* bounds check x and y */ 538 /* bounds check x and y */
… …
549 find_spot_in_room_recursive (layout, x + freearr_x[i % 8 + 1], y + freearr_y[i % 8 + 1], RP); 556 find_spot_in_room_recursive (layout, x + freearr_x[i % 8 + 1], y + freearr_y[i % 8 + 1], RP);
550 557
551} 558}
552 559
553/* find a random non-blocked spot in this room to drop a key. */ 560/* find a random non-blocked spot in this room to drop a key. */
554void 561static void
555find_spot_in_room (maptile *map, int x, int y, int *kx, int *ky, random_map_params *RP) 562find_spot_in_room (maptile *map, int x, int y, int *kx, int *ky, random_map_params *RP)
556{ 563{
557 char **layout2; 564 char **layout2;
558 int i, j; 565 int i, j;
559 566
… …
592 599
593 600
594/* searches the map for a spot with walls around it. The more 601/* searches the map for a spot with walls around it. The more
595 walls the better, but it'll settle for 1 wall, or even 0, but 602 walls the better, but it'll settle for 1 wall, or even 0, but
596 it'll return 0 if no FREE spots are found.*/ 603 it'll return 0 if no FREE spots are found.*/
597void 604static void
598find_enclosed_spot (maptile *map, int *cx, int *cy, random_map_params *RP) 605find_enclosed_spot (maptile *map, int *cx, int *cy, random_map_params *RP)
599{ 606{
600 int x, y; 607 int x, y;
601 int i; 608 int i;
602 609
… …
670} 677}
671 678
672void 679void
673remove_monsters (int x, int y, maptile *map) 680remove_monsters (int x, int y, maptile *map)
674{ 681{
675 object *tmp;
676
677 for (tmp = GET_MAP_OB (map, x, y); tmp; tmp = tmp->above) 682 for (object *tmp = GET_MAP_OB (map, x, y); tmp; )
678 if (QUERY_FLAG (tmp, FLAG_ALIVE))
679 { 683 {
680 if (tmp->head) 684 object *next = tmp->above;
681 tmp = tmp->head; 685
682 tmp->remove (); 686 if (tmp->flag [FLAG_ALIVE])
683 tmp->destroy (); 687 tmp->head_ ()->destroy ();
684 tmp = GET_MAP_OB (map, x, y); 688
685 if (tmp == NULL) 689 tmp = next;
686 break;
687 }; 690 }
688} 691}
689 692
690/* surrounds the point x,y by doors, so as to enclose something, like 693/* 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 694 a chest. It only goes as far as the 8 squares surrounding, and
692 it'll remove any monsters it finds.*/ 695 it'll remove any monsters it finds.*/
693object ** 696static object **
694surround_by_doors (maptile *map, char **layout, int x, int y, int opts) 697surround_by_doors (maptile *map, char **layout, int x, int y, int opts)
695{ 698{
696 int i; 699 int i;
697 const char *doors[2]; 700 const char *doors[2];
698 object **doorlist; 701 object **doorlist;
… …
728 } 731 }
729 732
730 return doorlist; 733 return doorlist;
731} 734}
732 735
733
734/* returns the first door in this square, or NULL if there isn't a door. */ 736/* returns the first door in this square, or NULL if there isn't a door. */
735object * 737static object *
736door_in_square (maptile *map, int x, int y) 738door_in_square (maptile *map, int x, int y)
737{ 739{
738 object *tmp;
739
740 for (tmp = GET_MAP_OB (map, x, y); tmp != NULL; tmp = tmp->above) 740 for (object *tmp = GET_MAP_OB (map, x, y); tmp; tmp = tmp->above)
741 if (tmp->type == DOOR || tmp->type == LOCKED_DOOR) 741 if (tmp->type == DOOR || tmp->type == LOCKED_DOOR)
742 return tmp; 742 return tmp;
743
743 return NULL; 744 return NULL;
744} 745}
745 746
746/* the workhorse routine, which finds the doors in a room */ 747/* the workhorse routine, which finds the doors in a room */
747void 748static void
748find_doors_in_room_recursive (char **layout, maptile *map, int x, int y, object **doorlist, int *ndoors, random_map_params *RP) 749find_doors_in_room_recursive (char **layout, maptile *map, int x, int y, object **doorlist, int *ndoors, random_map_params *RP)
749{ 750{
750 int i, j; 751 int i, j;
751 object *door; 752 object *door;
752 753
… …
787 doorlist, ndoors, RP); 788 doorlist, ndoors, RP);
788 } 789 }
789} 790}
790 791
791/* find a random non-blocked spot in this room to drop a key. */ 792/* find a random non-blocked spot in this room to drop a key. */
792object ** 793static object **
793find_doors_in_room (maptile *map, int x, int y, random_map_params *RP) 794find_doors_in_room (maptile *map, int x, int y, random_map_params *RP)
794{ 795{
795 int i, j; 796 int i, j;
796 int ndoors = 0; 797 int ndoors = 0;
797 798
… …
811 return doorlist; 812 return doorlist;
812} 813}
813 814
814/* locks and/or hides all the doors in doorlist, or does nothing if 815/* locks and/or hides all the doors in doorlist, or does nothing if
815 opts doesn't say to lock/hide doors. */ 816 opts doesn't say to lock/hide doors. */
816void 817static void
817lock_and_hide_doors (object **doorlist, maptile *map, int opts, random_map_params *RP) 818lock_and_hide_doors (object **doorlist, maptile *map, int opts, random_map_params *RP)
818{ 819{
819 object *door; 820 object *door;
820 int i; 821 int i;
821 822
822 /* lock the doors and hide the keys. */ 823 /* lock the doors and hide the keys. */
823 824
824 if (opts & DOORED) 825 if (opts & DOORED)
825 { 826 {
826 for (i = 0, door = doorlist[0]; doorlist[i] != NULL; i++) 827 for (i = 0, door = doorlist[0]; doorlist[i]; i++)
827 { 828 {
828 object *new_door = get_archetype (shstr_locked_door1); 829 object *new_door = get_archetype (shstr_locked_door1);
829 830
830 door = doorlist[i]; 831 door = doorlist[i];
831 new_door->face = door->face; 832 new_door->face = door->face;
832 new_door->x = door->x; 833 new_door->x = door->x;
833 new_door->y = door->y; 834 new_door->y = door->y;
834 door->remove ();
835 door->destroy (); 835 door->destroy ();
836 doorlist[i] = new_door; 836 doorlist[i] = new_door;
837 insert_ob_in_map (new_door, map, NULL, 0); 837 insert_ob_in_map (new_door, map, NULL, 0);
838 new_door->slaying = format ("RMG-%d-%d", (int)rmg_rndm (1000000000), (int)rmg_rndm (1000000000)); 838 new_door->slaying = format ("RMG-%d-%d", (int)rmg_rndm (1000000000), (int)rmg_rndm (1000000000));
839 keyplace (map, new_door->x, new_door->y, new_door->slaying, NO_PASS_DOORS, 2, RP); 839 keyplace (map, new_door->x, new_door->y, new_door->slaying, NO_PASS_DOORS, 2, RP);
… …
856 retrofit_joined_wall (map, door->x, door->y - 1, 0, RP); 856 retrofit_joined_wall (map, door->x, door->y - 1, 0, RP);
857 retrofit_joined_wall (map, door->x, door->y + 1, 0, RP); 857 retrofit_joined_wall (map, door->x, door->y + 1, 0, RP);
858 858
859 door->face = wallface->face; 859 door->face = wallface->face;
860 860
861 if (!QUERY_FLAG (wallface, FLAG_REMOVED))
862 wallface->remove ();
863
864 wallface->destroy (); 861 wallface->destroy ();
865 } 862 }
866 } 863 }
867 } 864 }
868} 865}

Diff Legend

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