ViewVC Help
View File | Revision Log | Show Annotations | Download File
/cvs/cf.schmorp.de/server/common/arch.C
(Generate patch)

Comparing cf.schmorp.de/server/common/arch.C (file contents):
Revision 1.17 by root, Tue Sep 12 19:20:06 2006 UTC vs.
Revision 1.20 by root, Thu Sep 14 21:16:11 2006 UTC

… …
48 * MSW 2003-04-29 48 * MSW 2003-04-29
49 */ 49 */
50 50
51#if USE_UNORDERED_MAP 51#if USE_UNORDERED_MAP
52// the hashtable 52// the hashtable
53typedef
54 std::tr1::unordered_map < 53typedef std::tr1::unordered_map
55size_t, archetype *> 54 <
55 std::size_t,
56 archetype *,
57 std::hash<size_t>,
58 std::equal_to<size_t>,
59 slice_allocator< std::pair<const std::size_t, archetype *> >
60 true,
56 HT; 61 > HT;
57 62
58static 63static HT ht;
59 HT
60 ht;
61#endif 64#endif
62 65
63/** 66/**
64 * GROS - This function retrieves an archetype given the name that appears 67 * GROS - This function retrieves an archetype given the name that appears
65 * during the game (for example, "writing pen" instead of "stylus"). 68 * during the game (for example, "writing pen" instead of "stylus").
… …
72 * - the archetype found or null if nothing was found. 75 * - the archetype found or null if nothing was found.
73 */ 76 */
74archetype * 77archetype *
75find_archetype_by_object_name (const char *name) 78find_archetype_by_object_name (const char *name)
76{ 79{
77 archetype * 80 archetype *at;
78 at;
79 81
80 if (name == NULL) 82 if (name == NULL)
81 return (archetype *) NULL; 83 return (archetype *) NULL;
82 84
83 for (at = first_archetype; at != NULL; at = at->next) 85 for (at = first_archetype; at != NULL; at = at->next)
… …
94 * except that it considers only items of the given type. 96 * except that it considers only items of the given type.
95 */ 97 */
96archetype * 98archetype *
97find_archetype_by_object_type_name (int type, const char *name) 99find_archetype_by_object_type_name (int type, const char *name)
98{ 100{
99 archetype * 101 archetype *at;
100 at;
101 102
102 if (name == NULL) 103 if (name == NULL)
103 return NULL; 104 return NULL;
104 105
105 for (at = first_archetype; at != NULL; at = at->next) 106 for (at = first_archetype; at != NULL; at = at->next)
… …
179 { 180 {
180 tmpname[i] = 0; 181 tmpname[i] = 0;
181 at = find_archetype_by_object_name (tmpname); 182 at = find_archetype_by_object_name (tmpname);
182 183
183 if (at != NULL) 184 if (at != NULL)
184 {
185 return arch_to_object (at); 185 return arch_to_object (at);
186 }
187 } 186 }
188 187
189 return create_singularity (name); 188 return create_singularity (name);
190} 189}
191 190
… …
324void 323void
325init_archetypes (void) 324init_archetypes (void)
326{ /* called from add_player() and edit() */ 325{ /* called from add_player() and edit() */
327 if (first_archetype != NULL) /* Only do this once */ 326 if (first_archetype != NULL) /* Only do this once */
328 return; 327 return;
328
329 arch_init = 1; 329 arch_init = 1;
330 load_archetypes (); 330 load_archetypes ();
331 arch_init = 0; 331 arch_init = 0;
332 empty_archetype = find_archetype ("empty_archetype"); 332 empty_archetype = archetype::find ("empty_archetype");
333 333
334/* init_blocksview();*/ 334/* init_blocksview();*/
335} 335}
336 336
337/* 337/*
… …
546 cp--; 546 cp--;
547 } 547 }
548 } 548 }
549 if (!strcmp ("Object", variable)) 549 if (!strcmp ("Object", variable))
550 { 550 {
551 if ((at = find_archetype (argument)) == NULL) 551 if ((at = archetype::find (argument)) == NULL)
552 LOG (llevError, "Warning: failed to find arch %s\n", argument); 552 LOG (llevError, "Warning: failed to find arch %s\n", argument);
553 } 553 }
554 else if (!strcmp ("other_arch", variable)) 554 else if (!strcmp ("other_arch", variable))
555 { 555 {
556 if (at != NULL && at->clone.other_arch == NULL) 556 if (at != NULL && at->clone.other_arch == NULL)
557 { 557 {
558 if ((other = find_archetype (argument)) == NULL) 558 if ((other = archetype::find (argument)) == NULL)
559 LOG (llevError, "Warning: failed to find other_arch %s\n", argument); 559 LOG (llevError, "Warning: failed to find other_arch %s\n", argument);
560 else if (at != NULL) 560 else if (at != NULL)
561 at->clone.other_arch = other; 561 at->clone.other_arch = other;
562 } 562 }
563 } 563 }
… …
675 */ 675 */
676 676
677object * 677object *
678create_singularity (const char *name) 678create_singularity (const char *name)
679{ 679{
680 object * 680 object * op;
681 op;
682 char
683 buf[MAX_BUF]; 681 char buf[MAX_BUF];
684 682
685 sprintf (buf, "%s (%s)", ARCH_SINGULARITY, name); 683 sprintf (buf, "%s (%s)", ARCH_SINGULARITY, name);
686 op = get_object (); 684 op = get_object ();
687 op->name = op->name_pl = buf; 685 op->name = op->name_pl = buf;
688 SET_FLAG (op, FLAG_NO_PICK); 686 SET_FLAG (op, FLAG_NO_PICK);
… …
695 */ 693 */
696 694
697object * 695object *
698get_archetype (const char *name) 696get_archetype (const char *name)
699{ 697{
700 archetype * 698 archetype *at = archetype::find (name);
701 at;
702 699
703 at = find_archetype (name); 700 if (!at)
704 if (at == NULL)
705 return create_singularity (name); 701 return create_singularity (name);
706 702
707 return arch_to_object (at); 703 return arch_to_object (at);
708} 704}
709 705
… …
712 */ 708 */
713 709
714unsigned long 710unsigned long
715hasharch (const char *str, int tablesize) 711hasharch (const char *str, int tablesize)
716{ 712{
717 unsigned long 713 unsigned long hash = 0;
718 hash = 0;
719 unsigned int 714 unsigned int i = 0;
720 i = 0;
721 const char * 715 const char *p;
722 p;
723 716
724 /* use the one-at-a-time hash function, which supposedly is 717 /* use the one-at-a-time hash function, which supposedly is
725 * better than the djb2-like one used by perl5.005, but 718 * better than the djb2-like one used by perl5.005, but
726 * certainly is better then the bug used here before. 719 * certainly is better then the bug used here before.
727 * see http://burtleburtle.net/bob/hash/doobs.html 720 * see http://burtleburtle.net/bob/hash/doobs.html
… …
744 * Finds, using the hashtable, which archetype matches the given name. 737 * Finds, using the hashtable, which archetype matches the given name.
745 * returns a pointer to the found archetype, otherwise NULL. 738 * returns a pointer to the found archetype, otherwise NULL.
746 */ 739 */
747 740
748archetype * 741archetype *
749find_archetype (const char *name) 742archetype::find (const char *name)
750{ 743{
751#if USE_UNORDERED_MAP
752 name = shstr::find (name);
753
754 if (!name) 744 if (!name)
755 return 0; 745 return 0;
756 746
757 HT::const_iterator i = ht.find ((size_t) name); 747#if USE_UNORDERED_MAP
748 AUTODECL (i, ht.find ((size_t) name));
758 749
759 if (i == ht.end ()) 750 if (i == ht.end ())
760 return 0; 751 return 0;
761 else 752 else
762 return i->second; 753 return i->second;
763#endif 754#endif
764 755
765 archetype * 756 archetype *at;
766 at;
767 unsigned long 757 unsigned long index;
768 index;
769
770 if (name == NULL)
771 return (archetype *) NULL;
772 758
773 index = hasharch (name, ARCHTABLE); 759 index = hasharch (name, ARCHTABLE);
774 arch_search++; 760 arch_search++;
775 for (;;) 761 for (;;)
776 { 762 {
777 at = arch_table[index]; 763 at = arch_table[index];
764
778 if (at == NULL) 765 if (at == NULL)
779 { 766 {
780 if (warn_archetypes) 767 if (warn_archetypes)
781 LOG (llevError, "Couldn't find archetype %s\n", name); 768 LOG (llevError, "Couldn't find archetype %s\n", name);
769
782 return NULL; 770 return NULL;
783 } 771 }
772
784 arch_cmp++; 773 arch_cmp++;
774
785 if (!strcmp ((const char *) at->name, name)) 775 if (!strcmp ((const char *) at->name, name))
786 return at; 776 return at;
777
787 if (++index >= ARCHTABLE) 778 if (++index >= ARCHTABLE)
788 index = 0; 779 index = 0;
789 } 780 }
790} 781}
791 782
… …
798{ 789{
799#if USE_UNORDERED_MAP 790#if USE_UNORDERED_MAP
800 ht.insert (std::make_pair ((size_t) (const char *) at->name, at)); 791 ht.insert (std::make_pair ((size_t) (const char *) at->name, at));
801#endif 792#endif
802 793
803 int
804 index = hasharch ((const char *) at->name, ARCHTABLE), org_index = index; 794 int index = hasharch ((const char *) at->name, ARCHTABLE), org_index = index;
805 795
806 for (;;) 796 for (;;)
807 { 797 {
808 if (arch_table[index] == NULL) 798 if (arch_table[index] == NULL)
809 { 799 {
… …
825 */ 815 */
826 816
827archetype * 817archetype *
828type_to_archetype (int type) 818type_to_archetype (int type)
829{ 819{
830 archetype * 820 archetype *at;
831 at;
832 821
833 for (at = first_archetype; at != NULL; at = (at->more == NULL) ? at->next : at->more) 822 for (at = first_archetype; at; at = at->more == 0 ? at->next : at->more)
834 if (at->clone.type == type) 823 if (at->clone.type == type)
835 return at; 824 return at;
825
836 return NULL; 826 return 0;
837} 827}
838 828
839/* 829/*
840 * Returns a new object copied from the first archetype matching 830 * Returns a new object copied from the first archetype matching
841 * the given type. 831 * the given type.
… …
843 */ 833 */
844 834
845object * 835object *
846clone_arch (int type) 836clone_arch (int type)
847{ 837{
848 archetype * 838 archetype *at;
849 at;
850 object *
851 op = get_object (); 839 object *op = get_object ();
852 840
853 if ((at = type_to_archetype (type)) == NULL) 841 if ((at = type_to_archetype (type)) == NULL)
854 { 842 {
855 LOG (llevError, "Can't clone archetype %d\n", type); 843 LOG (llevError, "Can't clone archetype %d\n", type);
856 free_object (op); 844 free_object (op);
857 return NULL; 845 return NULL;
858 } 846 }
847
859 copy_object (&at->clone, op); 848 copy_object (&at->clone, op);
860 op->instantiate (); 849 op->instantiate ();
861 return op; 850 return op;
862} 851}
863 852
… …
866 */ 855 */
867 856
868object * 857object *
869object_create_arch (archetype *at) 858object_create_arch (archetype *at)
870{ 859{
871 object * 860 object *op, *prev = 0, *head = 0;
872 op, *
873 prev = NULL, *head = NULL;
874 861
875 while (at) 862 while (at)
876 { 863 {
877 op = arch_to_object (at); 864 op = arch_to_object (at);
878 op->x = at->clone.x; 865 op->x = at->clone.x;
879 op->y = at->clone.y; 866 op->y = at->clone.y;
867
880 if (head) 868 if (head)
881 op->head = head, prev->more = op; 869 op->head = head, prev->more = op;
870
882 if (!head) 871 if (!head)
883 head = op; 872 head = op;
873
884 prev = op; 874 prev = op;
885 at = at->more; 875 at = at->more;
886 } 876 }
877
887 return (head); 878 return (head);
888} 879}
889 880
890/*** end of arch.c ***/

Diff Legend

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