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.24 by root, Sat Sep 16 22:24:12 2006 UTC vs.
Revision 1.34 by pippijn, Wed Jan 3 00:10:04 2007 UTC

… …
21 The authors can be reached via e-mail at <crossfire@schmorp.de> 21 The authors can be reached via e-mail at <crossfire@schmorp.de>
22*/ 22*/
23 23
24#include <cassert> 24#include <cassert>
25 25
26#include <tr1/unordered_map>
27
28#include <global.h> 26#include <global.h>
29#include <arch.h>
30#include <funcpoint.h> 27#include <funcpoint.h>
31#include <loader.h> 28#include <loader.h>
32 29
33/* IF set, does a little timing on the archetype load. */ 30#define USE_UNORDERED_MAP 0
34#define TIME_ARCH_LOAD 0
35 31
36static void add_arch (archetype *at); 32#if USE_UNORDERED_MAP
33# include <tr1/functional>
34# include <tr1/unordered_map>
35#endif
37 36
38static archetype *arch_table[ARCHTABLE];
39int arch_cmp = 0; /* How many strcmp's */ 37int arch_cmp = 0; /* How many strcmp's */
40int arch_search = 0; /* How many searches */ 38int arch_search = 0; /* How many searches */
41int arch_init; /* True if doing arch initialization */ 39int arch_init; /* True if doing arch initialization */
42 40
43/* The naming of these functions is really poor - they are all 41/* The naming of these functions is really poor - they are all
… …
51#if USE_UNORDERED_MAP 49#if USE_UNORDERED_MAP
52// the hashtable 50// the hashtable
53typedef std::tr1::unordered_map 51typedef std::tr1::unordered_map
54 < 52 <
55 std::size_t, 53 std::size_t,
56 archetype *, 54 arch_ptr,
57 std::hash<size_t>, 55 std::tr1::hash<size_t>,
58 std::equal_to<size_t>, 56 std::equal_to<size_t>,
59 slice_allocator< std::pair<const std::size_t, archetype *> > 57 slice_allocator< std::pair<const std::size_t, archetype *> >
60 true, 58 true,
61 > HT; 59 > HT;
62 60
63static HT ht; 61static HT ht;
62#else
63static arch_ptr arch_table[ARCHTABLE];
64#endif 64#endif
65 65
66/** 66/**
67 * GROS - This function retrieves an archetype given the name that appears 67 * GROS - This function retrieves an archetype given the name that appears
68 * during the game (for example, "writing pen" instead of "stylus"). 68 * during the game (for example, "writing pen" instead of "stylus").
… …
358 archetype *at; 358 archetype *at;
359 359
360 LOG (llevDebug, " Setting up archetable...\n"); 360 LOG (llevDebug, " Setting up archetable...\n");
361 361
362 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)
363 add_arch (at); 363 at->hash_add ();
364 364
365 LOG (llevDebug, "done\n"); 365 LOG (llevDebug, "done\n");
366}
367
368/*
369 * Dumps an archetype to debug-level output.
370 */
371
372void
373dump_arch (archetype *at)
374{
375 dump_object (&at->clone);
376}
377
378/*
379 * Dumps _all_ archetypes to debug-level output.
380 * If you run crossfire with debug, and enter DM-mode, you can trigger
381 * this with the O key.
382 */
383
384void
385dump_all_archetypes (void)
386{
387 archetype *at;
388
389 for (at = first_archetype; at != NULL; at = (at->more == NULL) ? at->next : at->more)
390 {
391 dump_arch (at);
392 fprintf (logfile, "%s\n", errmsg);
393 }
394} 366}
395 367
396void 368void
397free_all_archs (void) 369free_all_archs (void)
398{ 370{
… …
409 delete 381 delete
410 at; 382 at;
411 383
412 i++; 384 i++;
413 } 385 }
386
414 LOG (llevDebug, "Freed %d archetypes, %d faces\n", i, f); 387 LOG (llevDebug, "Freed %d archetypes, %d faces\n", i, f);
415} 388}
416 389
417archetype::archetype () 390archetype::archetype ()
418{ 391{
419 clear_object (&clone); /* to initial state other also */
420 CLEAR_FLAG (&clone, FLAG_FREED); /* This shouldn't matter, since copy_object() */ 392 CLEAR_FLAG (&clone, FLAG_FREED); /* This shouldn't matter, since copy_to */
421 SET_FLAG (&clone, FLAG_REMOVED); /* doesn't copy these flags... */ 393 SET_FLAG (&clone, FLAG_REMOVED); /* doesn't copy these flags... */
422} 394}
423 395
424archetype::~archetype () 396archetype::~archetype ()
425{ 397{
… …
430 * of archetype-structures. 402 * of archetype-structures.
431 */ 403 */
432void 404void
433first_arch_pass (object_thawer & fp) 405first_arch_pass (object_thawer & fp)
434{ 406{
435 archetype *at, *head = NULL, *last_more = NULL; 407 archetype *head = 0, *last_more = 0;
436 408
409 archetype *at = new archetype;
437 at->clone.arch = first_archetype = at = new archetype; 410 at->clone.arch = first_archetype = at;
438 411
439 while (int i = load_object (fp, &at->clone, 0)) 412 while (int i = load_object (fp, &at->clone, 0))
440 { 413 {
441 at->clone.speed_left = (float) (-0.1); 414 at->clone.speed_left = (float) (-0.1);
442 /* copy the body_info to the body_used - this is only really 415 /* copy the body_info to the body_used - this is only really
… …
580void 553void
581load_archetypes (void) 554load_archetypes (void)
582{ 555{
583 char filename[MAX_BUF]; 556 char filename[MAX_BUF];
584 557
585#if TIME_ARCH_LOAD
586 struct timeval
587 tv1,
588 tv2;
589#endif
590
591 sprintf (filename, "%s/%s", settings.datadir, settings.archetypes); 558 sprintf (filename, "%s/%s", settings.datadir, settings.archetypes);
592 LOG (llevDebug, "Reading archetypes from %s:\n", filename); 559 LOG (llevDebug, "Reading archetypes from %s:\n", filename);
593 560
594 { 561 {
595 object_thawer 562 object_thawer
… …
608 object_thawer 575 object_thawer
609 thawer (filename); 576 thawer (filename);
610 577
611 LOG (llevDebug, " loading treasure...\n"); 578 LOG (llevDebug, " loading treasure...\n");
612 load_treasures (); 579 load_treasures ();
580 LOG (llevDebug, " done\n");
613 LOG (llevDebug, " done\n arch-pass 2...\n"); 581 LOG (llevDebug, " arch-pass 2...\n");
614 second_arch_pass (thawer); 582 second_arch_pass (thawer);
615 LOG (llevDebug, " done\n"); 583 LOG (llevDebug, " done\n");
616#ifdef DEBUG 584#ifdef DEBUG
617 check_generators (); 585 check_generators ();
618#endif 586#endif
… …
622 590
623/* 591/*
624 * Creates and returns a new object which is a copy of the given archetype. 592 * Creates and returns a new object which is a copy of the given archetype.
625 * This function returns NULL on failure. 593 * This function returns NULL on failure.
626 */ 594 */
627
628object * 595object *
629arch_to_object (archetype *at) 596arch_to_object (archetype *at)
630{ 597{
631 object *op; 598 object *op;
632 599
… …
636 LOG (llevError, "Couldn't find archetype.\n"); 603 LOG (llevError, "Couldn't find archetype.\n");
637 604
638 return NULL; 605 return NULL;
639 } 606 }
640 607
641 op = get_object (); 608 op = at->clone.clone ();
642 copy_object (&at->clone, op);
643 op->arch = at; 609 op->arch = at;
644 op->instantiate (); 610 op->instantiate ();
645 return op; 611 return op;
646} 612}
647 613
… …
649 * Creates an object. This function is called by get_archetype() 615 * Creates an object. This function is called by get_archetype()
650 * if it fails to find the appropriate archetype. 616 * if it fails to find the appropriate archetype.
651 * Thus get_archetype() will be guaranteed to always return 617 * Thus get_archetype() will be guaranteed to always return
652 * an object, and never NULL. 618 * an object, and never NULL.
653 */ 619 */
654
655object * 620object *
656create_singularity (const char *name) 621create_singularity (const char *name)
657{ 622{
658 object *op; 623 object *op;
659 char buf[MAX_BUF]; 624 char buf[MAX_BUF];
660 625
661 sprintf (buf, "%s (%s)", ARCH_SINGULARITY, name); 626 sprintf (buf, "%s (%s)", ARCH_SINGULARITY, name);
662 op = get_object (); 627 op = object::create ();
663 op->name = op->name_pl = buf; 628 op->name = op->name_pl = buf;
664 SET_FLAG (op, FLAG_NO_PICK); 629 SET_FLAG (op, FLAG_NO_PICK);
665 return op; 630 return op;
666} 631}
667 632
668/* 633/*
669 * Finds which archetype matches the given name, and returns a new 634 * Finds which archetype matches the given name, and returns a new
670 * object containing a copy of the archetype. 635 * object containing a copy of the archetype.
671 */ 636 */
672
673object * 637object *
674get_archetype (const char *name) 638get_archetype (const char *name)
675{ 639{
676 archetype *at = archetype::find (name); 640 archetype *at = archetype::find (name);
677 641
… …
759} 723}
760 724
761/* 725/*
762 * Adds an archetype to the hashtable. 726 * Adds an archetype to the hashtable.
763 */ 727 */
764 728void
765static void 729archetype::hash_add ()
766add_arch (archetype *at)
767{ 730{
768#if USE_UNORDERED_MAP 731#if USE_UNORDERED_MAP
769 ht.insert (std::make_pair ((size_t) (const char *) at->name, at)); 732 ht.insert (std::make_pair ((size_t) (const char *) name, this));
770#endif 733#else
771 734
772 int index = hasharch ((const char *) at->name, ARCHTABLE), org_index = index; 735 int index = hasharch ((const char *) name, ARCHTABLE), org_index = index;
773 736
774 for (;;) 737 for (;;)
775 { 738 {
776 if (arch_table[index] == NULL) 739 if (!arch_table[index])
777 { 740 {
778 arch_table[index] = at; 741 arch_table[index] = this;
779 return; 742 break;
780 } 743 }
781 744
782 if (++index == ARCHTABLE) 745 if (++index == ARCHTABLE)
783 index = 0; 746 index = 0;
784 747
785 if (index == org_index) 748 if (index == org_index)
786 fatal (ARCHTABLE_TOO_SMALL); 749 fatal (ARCHTABLE_TOO_SMALL);
787 } 750 }
751#endif
752}
753
754void
755archetype::hash_del ()
756{
757#if USE_UNORDERED_MAP
758# error remove this from HT
759#else
760
761 int index = hasharch ((const char *) name, ARCHTABLE), org_index = index;
762
763 for (;;)
764 {
765 if (arch_table[index] == this)
766 {
767 arch_table[index] = 0;
768 break;
769 }
770
771 if (++index == ARCHTABLE)
772 index = 0;
773
774 if (index == org_index)
775 break;
776 }
777#endif
788} 778}
789 779
790/* 780/*
791 * Returns the first archetype using the given type. 781 * Returns the first archetype using the given type.
792 * Used in treasure-generation. 782 * Used in treasure-generation.
… …
812 802
813object * 803object *
814clone_arch (int type) 804clone_arch (int type)
815{ 805{
816 archetype *at; 806 archetype *at;
817 object *op = get_object ();
818 807
819 if ((at = type_to_archetype (type)) == NULL) 808 if ((at = type_to_archetype (type)) == NULL)
820 { 809 {
821 LOG (llevError, "Can't clone archetype %d\n", type); 810 LOG (llevError, "Can't clone archetype %d\n", type);
822 free_object (op);
823 return NULL; 811 return 0;
824 } 812 }
825 813
826 copy_object (&at->clone, op); 814 object *op = at->clone.clone ();
827 op->instantiate (); 815 op->instantiate ();
828 return op; 816 return op;
829} 817}
830 818
831/* 819/*

Diff Legend

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