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

Comparing deliantra/server/common/arch.C (file contents):
Revision 1.16 by root, Sun Sep 10 16:00:23 2006 UTC vs.
Revision 1.25 by root, Tue Nov 7 16:30:54 2006 UTC

1
2/*
3 * static char *rcsid_arch_c =
4 * "$Id: arch.C,v 1.16 2006/09/10 16:00:23 root Exp $";
5 */
6
7/* 1/*
8 CrossFire, A Multiplayer game for X-windows 2 CrossFire, A Multiplayer game for X-windows
9 3
10 Copyright (C) 2002 Mark Wedel & Crossfire Development Team 4 Copyright (C) 2002 Mark Wedel & Crossfire Development Team
11 Copyright (C) 1992 Frank Tore Johansen 5 Copyright (C) 1992 Frank Tore Johansen
… …
22 16
23 You should have received a copy of the GNU General Public License 17 You should have received a copy of the GNU General Public License
24 along with this program; if not, write to the Free Software 18 along with this program; if not, write to the Free Software
25 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 19 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
26 20
27 The authors can be reached via e-mail at crossfire-devel@real-time.com 21 The authors can be reached via e-mail at <crossfire@schmorp.de>
28*/ 22*/
29 23
30#include <cassert> 24#include <cassert>
31 25
32#include <tr1/unordered_map> 26#include <tr1/unordered_map>
… …
54 * MSW 2003-04-29 48 * MSW 2003-04-29
55 */ 49 */
56 50
57#if USE_UNORDERED_MAP 51#if USE_UNORDERED_MAP
58// the hashtable 52// the hashtable
59typedef
60 std::tr1::unordered_map < 53typedef std::tr1::unordered_map
61size_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,
62 HT; 61 > HT;
63 62
64static 63static HT ht;
65 HT
66 ht;
67#endif 64#endif
68 65
69/** 66/**
70 * GROS - This function retrieves an archetype given the name that appears 67 * GROS - This function retrieves an archetype given the name that appears
71 * during the game (for example, "writing pen" instead of "stylus"). 68 * during the game (for example, "writing pen" instead of "stylus").
… …
78 * - the archetype found or null if nothing was found. 75 * - the archetype found or null if nothing was found.
79 */ 76 */
80archetype * 77archetype *
81find_archetype_by_object_name (const char *name) 78find_archetype_by_object_name (const char *name)
82{ 79{
83 archetype * 80 archetype *at;
84 at;
85 81
86 if (name == NULL) 82 if (name == NULL)
87 return (archetype *) NULL; 83 return (archetype *) NULL;
88 84
89 for (at = first_archetype; at != NULL; at = at->next) 85 for (at = first_archetype; at != NULL; at = at->next)
… …
100 * except that it considers only items of the given type. 96 * except that it considers only items of the given type.
101 */ 97 */
102archetype * 98archetype *
103find_archetype_by_object_type_name (int type, const char *name) 99find_archetype_by_object_type_name (int type, const char *name)
104{ 100{
105 archetype * 101 archetype *at;
106 at;
107 102
108 if (name == NULL) 103 if (name == NULL)
109 return NULL; 104 return NULL;
110 105
111 for (at = first_archetype; at != NULL; at = at->next) 106 for (at = first_archetype; at != NULL; at = at->next)
… …
173 * but it otherwise had a big memory leak. 168 * but it otherwise had a big memory leak.
174 */ 169 */
175object * 170object *
176get_archetype_by_object_name (const char *name) 171get_archetype_by_object_name (const char *name)
177{ 172{
178 archetype * 173 archetype *at;
179 at;
180 char
181 tmpname[MAX_BUF]; 174 char tmpname[MAX_BUF];
182 int 175 int i;
183 i;
184 176
185 strncpy (tmpname, name, MAX_BUF - 1); 177 assign (tmpname, name);
186 tmpname[MAX_BUF - 1] = 0; 178
187 for (i = strlen (tmpname); i > 0; i--) 179 for (i = strlen (tmpname); i > 0; i--)
188 { 180 {
189 tmpname[i] = 0; 181 tmpname[i] = 0;
190 at = find_archetype_by_object_name (tmpname); 182 at = find_archetype_by_object_name (tmpname);
183
191 if (at != NULL) 184 if (at != NULL)
192 {
193 return arch_to_object (at); 185 return arch_to_object (at);
194 }
195 } 186 }
187
196 return create_singularity (name); 188 return create_singularity (name);
197} 189}
198 190
199 /* This is a subset of the parse_id command. Basically, name can be 191 /* This is a subset of the parse_id command. Basically, name can be
200 * a string seperated lists of things to match, with certain keywords. 192 * a string seperated lists of things to match, with certain keywords.
… …
214 * Last, make a check on the full name. 206 * Last, make a check on the full name.
215 */ 207 */
216int 208int
217item_matched_string (object *pl, object *op, const char *name) 209item_matched_string (object *pl, object *op, const char *name)
218{ 210{
219 char *
220 cp,
221 local_name[MAX_BUF]; 211 char *cp, local_name[MAX_BUF];
222 int 212 int count, retval = 0;
223 count,
224 retval = 0;
225 213
226 strcpy (local_name, name); /* strtok is destructive to name */ 214 strcpy (local_name, name); /* strtok is destructive to name */
227 215
228 for (cp = strtok (local_name, ","); cp; cp = strtok (NULL, ",")) 216 for (cp = strtok (local_name, ","); cp; cp = strtok (NULL, ","))
229 { 217 {
… …
281 retval = 15; 269 retval = 15;
282 else if (!strncasecmp (cp, query_base_name (op, 0), strlen (cp))) 270 else if (!strncasecmp (cp, query_base_name (op, 0), strlen (cp)))
283 retval = 14; 271 retval = 14;
284 else if (!strncasecmp (cp, query_base_name (op, 1), strlen (cp))) 272 else if (!strncasecmp (cp, query_base_name (op, 1), strlen (cp)))
285 retval = 14; 273 retval = 14;
286
287 /* Do substring checks, so things like 'Str+1' will match. 274 /* Do substring checks, so things like 'Str+1' will match.
288 * retval of these should perhaps be lower - they are lower 275 * retval of these should perhaps be lower - they are lower
289 * then the specific strcasecmp aboves, but still higher than 276 * then the specific strcasecmp aboves, but still higher than
290 * some other match criteria. 277 * some other match criteria.
291 */ 278 */
… …
293 retval = 12; 280 retval = 12;
294 else if (strstr (query_base_name (op, 0), cp)) 281 else if (strstr (query_base_name (op, 0), cp))
295 retval = 12; 282 retval = 12;
296 else if (strstr (query_short_name (op), cp)) 283 else if (strstr (query_short_name (op), cp))
297 retval = 12; 284 retval = 12;
298
299 /* Check against plural/non plural based on count. */ 285 /* Check against plural/non plural based on count. */
300 else if (count > 1 && !strcasecmp (cp, op->name_pl)) 286 else if (count > 1 && !strcasecmp (cp, op->name_pl))
301 {
302 retval = 6; 287 retval = 6;
303 }
304 else if (count == 1 && !strcasecmp (op->name, cp)) 288 else if (count == 1 && !strcasecmp (op->name, cp))
305 {
306 retval = 6; 289 retval = 6;
307 }
308 /* base name matched - not bad */ 290 /* base name matched - not bad */
309 else if (strcasecmp (cp, op->name) == 0 && !count) 291 else if (strcasecmp (cp, op->name) == 0 && !count)
310 retval = 4; 292 retval = 4;
311 /* Check for partial custom name, but give a real low priority */ 293 /* Check for partial custom name, but give a real low priority */
312 else if (op->custom_name && strstr (op->custom_name, cp)) 294 else if (op->custom_name && strstr (op->custom_name, cp))
… …
314 296
315 if (retval) 297 if (retval)
316 { 298 {
317 if (pl->type == PLAYER) 299 if (pl->type == PLAYER)
318 pl->contr->count = count; 300 pl->contr->count = count;
301
319 return retval; 302 return retval;
320 } 303 }
321 } 304 }
305
322 return 0; 306 return 0;
323} 307}
324 308
325/* 309/*
326 * Initialises the internal linked list of archetypes (read from file). 310 * Initialises the internal linked list of archetypes (read from file).
… …
331void 315void
332init_archetypes (void) 316init_archetypes (void)
333{ /* called from add_player() and edit() */ 317{ /* called from add_player() and edit() */
334 if (first_archetype != NULL) /* Only do this once */ 318 if (first_archetype != NULL) /* Only do this once */
335 return; 319 return;
320
336 arch_init = 1; 321 arch_init = 1;
337 load_archetypes (); 322 load_archetypes ();
338 arch_init = 0; 323 arch_init = 0;
339 empty_archetype = find_archetype ("empty_archetype"); 324 empty_archetype = archetype::find ("empty_archetype");
340 325
341/* init_blocksview();*/ 326/* init_blocksview();*/
342} 327}
343 328
344/* 329/*
… …
368 */ 353 */
369 354
370void 355void
371init_archetable (void) 356init_archetable (void)
372{ 357{
373 archetype * 358 archetype *at;
374 at;
375 359
376 LOG (llevDebug, " Setting up archetable...\n"); 360 LOG (llevDebug, " Setting up archetable...\n");
377 361
378 for (at = first_archetype; at != NULL; at = (at->more == NULL) ? at->next : at->more) 362 for (at = first_archetype; at != NULL; at = (at->more == NULL) ? at->next : at->more)
379 add_arch (at); 363 add_arch (at);
380 364
381 LOG (llevDebug, "done\n"); 365 LOG (llevDebug, "done\n");
382} 366}
383 367
384/*
385 * Dumps an archetype to debug-level output.
386 */
387
388void
389dump_arch (archetype *at)
390{
391 dump_object (&at->clone);
392}
393
394/*
395 * Dumps _all_ archetypes to debug-level output.
396 * If you run crossfire with debug, and enter DM-mode, you can trigger
397 * this with the O key.
398 */
399
400void
401dump_all_archetypes (void)
402{
403 archetype *
404 at;
405
406 for (at = first_archetype; at != NULL; at = (at->more == NULL) ? at->next : at->more)
407 {
408 dump_arch (at);
409 fprintf (logfile, "%s\n", errmsg);
410 }
411}
412
413void 368void
414free_all_archs (void) 369free_all_archs (void)
415{ 370{
416 archetype * 371 archetype *at, *next;
417 at, *
418 next;
419 int
420 i = 0, f = 0; 372 int i = 0, f = 0;
421 373
422 for (at = first_archetype; at != NULL; at = next) 374 for (at = first_archetype; at != NULL; at = next)
423 { 375 {
424 if (at->more) 376 if (at->more)
425 next = at->more; 377 next = at->more;
… …
450 * of archetype-structures. 402 * of archetype-structures.
451 */ 403 */
452void 404void
453first_arch_pass (object_thawer & fp) 405first_arch_pass (object_thawer & fp)
454{ 406{
455 archetype *
456 at, *
457 head = NULL, *last_more = NULL; 407 archetype *at, *head = NULL, *last_more = NULL;
458 408
459 at->clone.arch = first_archetype = at = new archetype; 409 at->clone.arch = first_archetype = at = new archetype;
460 410
461 while (int i = load_object (fp, &at->clone, 0)) 411 while (int i = load_object (fp, &at->clone, 0))
462 { 412 {
… …
531 */ 481 */
532 482
533void 483void
534second_arch_pass (object_thawer & thawer) 484second_arch_pass (object_thawer & thawer)
535{ 485{
536 char
537 buf[MAX_BUF], *
538 variable = buf, *argument, *cp; 486 char buf[MAX_BUF], *variable = buf, *argument, *cp;
539 archetype *
540 at = NULL, *other; 487 archetype *at = NULL, *other;
541 488
542 while (fgets (buf, MAX_BUF, thawer) != NULL) 489 while (fgets (buf, MAX_BUF, thawer) != NULL)
543 { 490 {
544 if (*buf == '#') 491 if (*buf == '#')
545 continue; 492 continue;
… …
553 cp--; 500 cp--;
554 } 501 }
555 } 502 }
556 if (!strcmp ("Object", variable)) 503 if (!strcmp ("Object", variable))
557 { 504 {
558 if ((at = find_archetype (argument)) == NULL) 505 if ((at = archetype::find (argument)) == NULL)
559 LOG (llevError, "Warning: failed to find arch %s\n", argument); 506 LOG (llevError, "Warning: failed to find arch %s\n", argument);
560 } 507 }
561 else if (!strcmp ("other_arch", variable)) 508 else if (!strcmp ("other_arch", variable))
562 { 509 {
563 if (at != NULL && at->clone.other_arch == NULL) 510 if (at != NULL && at->clone.other_arch == NULL)
564 { 511 {
565 if ((other = find_archetype (argument)) == NULL) 512 if ((other = archetype::find (argument)) == NULL)
566 LOG (llevError, "Warning: failed to find other_arch %s\n", argument); 513 LOG (llevError, "Warning: failed to find other_arch %s\n", argument);
567 else if (at != NULL) 514 else if (at != NULL)
568 at->clone.other_arch = other; 515 at->clone.other_arch = other;
569 } 516 }
570 } 517 }
571 else if (!strcmp ("randomitems", variable)) 518 else if (!strcmp ("randomitems", variable))
572 { 519 {
573 if (at != NULL) 520 if (at != NULL)
574 { 521 {
575 treasurelist *
576 tl = find_treasurelist (argument); 522 treasurelist *tl = find_treasurelist (argument);
577 523
578 if (tl == NULL) 524 if (tl == NULL)
579 LOG (llevError, "Failed to link treasure to arch (%s): %s\n", &at->name, argument); 525 LOG (llevError, "Failed to link treasure to arch (%s): %s\n", &at->name, argument);
580 else 526 else
581 at->clone.randomitems = tl; 527 at->clone.randomitems = tl;
… …
586 532
587#ifdef DEBUG 533#ifdef DEBUG
588void 534void
589check_generators (void) 535check_generators (void)
590{ 536{
591 archetype * 537 archetype *at;
592 at;
593 538
594 for (at = first_archetype; at != NULL; at = at->next) 539 for (at = first_archetype; at != NULL; at = at->next)
595 if (QUERY_FLAG (&at->clone, FLAG_GENERATOR) && at->clone.other_arch == NULL) 540 if (QUERY_FLAG (&at->clone, FLAG_GENERATOR) && at->clone.other_arch == NULL)
596 LOG (llevError, "Warning: %s is generator but lacks other_arch.\n", &at->name); 541 LOG (llevError, "Warning: %s is generator but lacks other_arch.\n", &at->name);
597} 542}
… …
605 */ 550 */
606 551
607void 552void
608load_archetypes (void) 553load_archetypes (void)
609{ 554{
610 char
611 filename[MAX_BUF]; 555 char filename[MAX_BUF];
612 556
613#if TIME_ARCH_LOAD 557#if TIME_ARCH_LOAD
614 struct timeval 558 struct timeval
615 tv1, 559 tv1,
616 tv2; 560 tv2;
… …
654 */ 598 */
655 599
656object * 600object *
657arch_to_object (archetype *at) 601arch_to_object (archetype *at)
658{ 602{
659 object * 603 object *op;
660 op;
661 604
662 if (at == NULL) 605 if (at == NULL)
663 { 606 {
664 if (warn_archetypes) 607 if (warn_archetypes)
665 LOG (llevError, "Couldn't find archetype.\n"); 608 LOG (llevError, "Couldn't find archetype.\n");
… …
682 */ 625 */
683 626
684object * 627object *
685create_singularity (const char *name) 628create_singularity (const char *name)
686{ 629{
687 object * 630 object *op;
688 op;
689 char
690 buf[MAX_BUF]; 631 char buf[MAX_BUF];
691 632
692 sprintf (buf, "%s (%s)", ARCH_SINGULARITY, name); 633 sprintf (buf, "%s (%s)", ARCH_SINGULARITY, name);
693 op = get_object (); 634 op = get_object ();
694 op->name = op->name_pl = buf; 635 op->name = op->name_pl = buf;
695 SET_FLAG (op, FLAG_NO_PICK); 636 SET_FLAG (op, FLAG_NO_PICK);
… …
702 */ 643 */
703 644
704object * 645object *
705get_archetype (const char *name) 646get_archetype (const char *name)
706{ 647{
707 archetype * 648 archetype *at = archetype::find (name);
708 at;
709 649
710 at = find_archetype (name); 650 if (!at)
711 if (at == NULL)
712 return create_singularity (name); 651 return create_singularity (name);
713 652
714 return arch_to_object (at); 653 return arch_to_object (at);
715} 654}
716 655
… …
719 */ 658 */
720 659
721unsigned long 660unsigned long
722hasharch (const char *str, int tablesize) 661hasharch (const char *str, int tablesize)
723{ 662{
724 unsigned long 663 unsigned long hash = 0;
725 hash = 0;
726 unsigned int 664 unsigned int i = 0;
727 i = 0;
728 const char * 665 const char *p;
729 p;
730 666
731 /* use the one-at-a-time hash function, which supposedly is 667 /* use the one-at-a-time hash function, which supposedly is
732 * better than the djb2-like one used by perl5.005, but 668 * better than the djb2-like one used by perl5.005, but
733 * certainly is better then the bug used here before. 669 * certainly is better then the bug used here before.
734 * see http://burtleburtle.net/bob/hash/doobs.html 670 * see http://burtleburtle.net/bob/hash/doobs.html
… …
751 * Finds, using the hashtable, which archetype matches the given name. 687 * Finds, using the hashtable, which archetype matches the given name.
752 * returns a pointer to the found archetype, otherwise NULL. 688 * returns a pointer to the found archetype, otherwise NULL.
753 */ 689 */
754 690
755archetype * 691archetype *
756find_archetype (const char *name) 692archetype::find (const char *name)
757{ 693{
758#if USE_UNORDERED_MAP
759 name = shstr::find (name);
760
761 if (!name) 694 if (!name)
762 return 0; 695 return 0;
763 696
764 HT::const_iterator i = ht.find ((size_t) name); 697#if USE_UNORDERED_MAP
698 AUTODECL (i, ht.find ((size_t) name));
765 699
766 if (i == ht.end ()) 700 if (i == ht.end ())
767 return 0; 701 return 0;
768 else 702 else
769 return i->second; 703 return i->second;
770#endif 704#endif
771 705
772 archetype * 706 archetype *at;
773 at;
774 unsigned long 707 unsigned long index;
775 index;
776
777 if (name == NULL)
778 return (archetype *) NULL;
779 708
780 index = hasharch (name, ARCHTABLE); 709 index = hasharch (name, ARCHTABLE);
781 arch_search++; 710 arch_search++;
782 for (;;) 711 for (;;)
783 { 712 {
784 at = arch_table[index]; 713 at = arch_table[index];
714
785 if (at == NULL) 715 if (at == NULL)
786 { 716 {
787 if (warn_archetypes) 717 if (warn_archetypes)
788 LOG (llevError, "Couldn't find archetype %s\n", name); 718 LOG (llevError, "Couldn't find archetype %s\n", name);
719
789 return NULL; 720 return NULL;
790 } 721 }
722
791 arch_cmp++; 723 arch_cmp++;
724
792 if (!strcmp ((const char *) at->name, name)) 725 if (!strcmp ((const char *) at->name, name))
793 return at; 726 return at;
727
794 if (++index >= ARCHTABLE) 728 if (++index >= ARCHTABLE)
795 index = 0; 729 index = 0;
796 } 730 }
797} 731}
798 732
… …
805{ 739{
806#if USE_UNORDERED_MAP 740#if USE_UNORDERED_MAP
807 ht.insert (std::make_pair ((size_t) (const char *) at->name, at)); 741 ht.insert (std::make_pair ((size_t) (const char *) at->name, at));
808#endif 742#endif
809 743
810 int
811 index = hasharch ((const char *) at->name, ARCHTABLE), org_index = index; 744 int index = hasharch ((const char *) at->name, ARCHTABLE), org_index = index;
812 745
813 for (;;) 746 for (;;)
814 { 747 {
815 if (arch_table[index] == NULL) 748 if (arch_table[index] == NULL)
816 { 749 {
… …
832 */ 765 */
833 766
834archetype * 767archetype *
835type_to_archetype (int type) 768type_to_archetype (int type)
836{ 769{
837 archetype * 770 archetype *at;
838 at;
839 771
840 for (at = first_archetype; at != NULL; at = (at->more == NULL) ? at->next : at->more) 772 for (at = first_archetype; at; at = at->more == 0 ? at->next : at->more)
841 if (at->clone.type == type) 773 if (at->clone.type == type)
842 return at; 774 return at;
775
843 return NULL; 776 return 0;
844} 777}
845 778
846/* 779/*
847 * Returns a new object copied from the first archetype matching 780 * Returns a new object copied from the first archetype matching
848 * the given type. 781 * the given type.
… …
850 */ 783 */
851 784
852object * 785object *
853clone_arch (int type) 786clone_arch (int type)
854{ 787{
855 archetype * 788 archetype *at;
856 at;
857 object *
858 op = get_object (); 789 object *op = get_object ();
859 790
860 if ((at = type_to_archetype (type)) == NULL) 791 if ((at = type_to_archetype (type)) == NULL)
861 { 792 {
862 LOG (llevError, "Can't clone archetype %d\n", type); 793 LOG (llevError, "Can't clone archetype %d\n", type);
863 free_object (op); 794 free_object (op);
864 return NULL; 795 return NULL;
865 } 796 }
797
866 copy_object (&at->clone, op); 798 copy_object (&at->clone, op);
867 op->instantiate (); 799 op->instantiate ();
868 return op; 800 return op;
869} 801}
870 802
… …
873 */ 805 */
874 806
875object * 807object *
876object_create_arch (archetype *at) 808object_create_arch (archetype *at)
877{ 809{
878 object * 810 object *op, *prev = 0, *head = 0;
879 op, *
880 prev = NULL, *head = NULL;
881 811
882 while (at) 812 while (at)
883 { 813 {
884 op = arch_to_object (at); 814 op = arch_to_object (at);
885 op->x = at->clone.x; 815 op->x = at->clone.x;
886 op->y = at->clone.y; 816 op->y = at->clone.y;
817
887 if (head) 818 if (head)
888 op->head = head, prev->more = op; 819 op->head = head, prev->more = op;
820
889 if (!head) 821 if (!head)
890 head = op; 822 head = op;
823
891 prev = op; 824 prev = op;
892 at = at->more; 825 at = at->more;
893 } 826 }
827
894 return (head); 828 return (head);
895} 829}
896 830
897/*** end of arch.c ***/

Diff Legend

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