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.22 by root, Thu Sep 14 22:35:53 2006 UTC vs.
Revision 1.36 by pippijn, Sat Jan 6 14:42:28 2007 UTC

1/* 1/*
2 CrossFire, A Multiplayer game for X-windows 2 CrossFire, A Multiplayer game for X-windows
3 3
4 Copyright (C) 2005, 2006, 2007 Marc Lehmann & Crossfire+ Development Team
4 Copyright (C) 2002 Mark Wedel & Crossfire Development Team 5 Copyright (C) 2002 Mark Wedel & Crossfire Development Team
5 Copyright (C) 1992 Frank Tore Johansen 6 Copyright (C) 1992 Frank Tore Johansen
6 7
7 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
8 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
… …
21 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>
22*/ 23*/
23 24
24#include <cassert> 25#include <cassert>
25 26
26#include <tr1/unordered_map>
27
28#include <global.h> 27#include <global.h>
29#include <arch.h>
30#include <funcpoint.h> 28#include <funcpoint.h>
31#include <loader.h> 29#include <loader.h>
32 30
33/* IF set, does a little timing on the archetype load. */ 31#define USE_UNORDERED_MAP 0
34#define TIME_ARCH_LOAD 0
35 32
36static void add_arch (archetype *at); 33#if USE_UNORDERED_MAP
34# include <tr1/functional>
35# include <tr1/unordered_map>
36#endif
37 37
38static archetype *arch_table[ARCHTABLE];
39int arch_cmp = 0; /* How many strcmp's */ 38int arch_cmp = 0; /* How many strcmp's */
40int arch_search = 0; /* How many searches */ 39int arch_search = 0; /* How many searches */
41int arch_init; /* True if doing arch initialization */ 40int arch_init; /* True if doing arch initialization */
42 41
43/* The naming of these functions is really poor - they are all 42/* The naming of these functions is really poor - they are all
… …
51#if USE_UNORDERED_MAP 50#if USE_UNORDERED_MAP
52// the hashtable 51// the hashtable
53typedef std::tr1::unordered_map 52typedef std::tr1::unordered_map
54 < 53 <
55 std::size_t, 54 std::size_t,
56 archetype *, 55 arch_ptr,
57 std::hash<size_t>, 56 std::tr1::hash<size_t>,
58 std::equal_to<size_t>, 57 std::equal_to<size_t>,
59 slice_allocator< std::pair<const std::size_t, archetype *> > 58 slice_allocator< std::pair<const std::size_t, archetype *> >
60 true, 59 true,
61 > HT; 60 > HT;
62 61
63static HT ht; 62static HT ht;
63#else
64static arch_ptr arch_table[ARCHTABLE];
64#endif 65#endif
65 66
66/** 67/**
67 * GROS - This function retrieves an archetype given the name that appears 68 * GROS - This function retrieves an archetype given the name that appears
68 * during the game (for example, "writing pen" instead of "stylus"). 69 * during the game (for example, "writing pen" instead of "stylus").
… …
118 * If type is -1, ew don't match on type. 119 * If type is -1, ew don't match on type.
119 */ 120 */
120object * 121object *
121get_archetype_by_skill_name (const char *skill, int type) 122get_archetype_by_skill_name (const char *skill, int type)
122{ 123{
123 archetype * 124 archetype *at;
124 at;
125 125
126 if (skill == NULL) 126 if (skill)
127 return NULL;
128
129 for (at = first_archetype; at != NULL; at = at->next) 127 for (at = first_archetype; at; at = at->next)
130 {
131 if (((type == -1) || (type == at->clone.type)) && (!strcmp (at->clone.skill, skill))) 128 if (((type == -1) || (type == at->clone.type)) && (!strcmp (at->clone.skill, skill)))
132 return arch_to_object (at); 129 return arch_to_object (at);
133 } 130
134 return NULL; 131 return 0;
135} 132}
136 133
137/* similiar to above - this returns the first archetype 134/* similiar to above - this returns the first archetype
138 * that matches both the type and subtype. type and subtype 135 * that matches both the type and subtype. type and subtype
139 * can be -1 to say ignore, but in this case, the match it does 136 * can be -1 to say ignore, but in this case, the match it does
… …
179 for (i = strlen (tmpname); i > 0; i--) 176 for (i = strlen (tmpname); i > 0; i--)
180 { 177 {
181 tmpname[i] = 0; 178 tmpname[i] = 0;
182 at = find_archetype_by_object_name (tmpname); 179 at = find_archetype_by_object_name (tmpname);
183 180
184 if (at != NULL) 181 if (at)
185 return arch_to_object (at); 182 return arch_to_object (at);
186 } 183 }
187 184
188 return create_singularity (name); 185 return create_singularity (name);
189} 186}
… …
269 retval = 15; 266 retval = 15;
270 else if (!strncasecmp (cp, query_base_name (op, 0), strlen (cp))) 267 else if (!strncasecmp (cp, query_base_name (op, 0), strlen (cp)))
271 retval = 14; 268 retval = 14;
272 else if (!strncasecmp (cp, query_base_name (op, 1), strlen (cp))) 269 else if (!strncasecmp (cp, query_base_name (op, 1), strlen (cp)))
273 retval = 14; 270 retval = 14;
274
275 /* Do substring checks, so things like 'Str+1' will match. 271 /* Do substring checks, so things like 'Str+1' will match.
276 * retval of these should perhaps be lower - they are lower 272 * retval of these should perhaps be lower - they are lower
277 * then the specific strcasecmp aboves, but still higher than 273 * then the specific strcasecmp aboves, but still higher than
278 * some other match criteria. 274 * some other match criteria.
279 */ 275 */
… …
281 retval = 12; 277 retval = 12;
282 else if (strstr (query_base_name (op, 0), cp)) 278 else if (strstr (query_base_name (op, 0), cp))
283 retval = 12; 279 retval = 12;
284 else if (strstr (query_short_name (op), cp)) 280 else if (strstr (query_short_name (op), cp))
285 retval = 12; 281 retval = 12;
286
287 /* Check against plural/non plural based on count. */ 282 /* Check against plural/non plural based on count. */
288 else if (count > 1 && !strcasecmp (cp, op->name_pl)) 283 else if (count > 1 && !strcasecmp (cp, op->name_pl))
289 {
290 retval = 6; 284 retval = 6;
291 }
292 else if (count == 1 && !strcasecmp (op->name, cp)) 285 else if (count == 1 && !strcasecmp (op->name, cp))
293 {
294 retval = 6; 286 retval = 6;
295 }
296 /* base name matched - not bad */ 287 /* base name matched - not bad */
297 else if (strcasecmp (cp, op->name) == 0 && !count) 288 else if (strcasecmp (cp, op->name) == 0 && !count)
298 retval = 4; 289 retval = 4;
299 /* Check for partial custom name, but give a real low priority */ 290 /* Check for partial custom name, but give a real low priority */
300 else if (op->custom_name && strstr (op->custom_name, cp)) 291 else if (op->custom_name && strstr (op->custom_name, cp))
… …
302 293
303 if (retval) 294 if (retval)
304 { 295 {
305 if (pl->type == PLAYER) 296 if (pl->type == PLAYER)
306 pl->contr->count = count; 297 pl->contr->count = count;
298
307 return retval; 299 return retval;
308 } 300 }
309 } 301 }
302
310 return 0; 303 return 0;
311} 304}
312 305
313/* 306/*
314 * Initialises the internal linked list of archetypes (read from file). 307 * Initialises the internal linked list of archetypes (read from file).
… …
362 archetype *at; 355 archetype *at;
363 356
364 LOG (llevDebug, " Setting up archetable...\n"); 357 LOG (llevDebug, " Setting up archetable...\n");
365 358
366 for (at = first_archetype; at != NULL; at = (at->more == NULL) ? at->next : at->more) 359 for (at = first_archetype; at != NULL; at = (at->more == NULL) ? at->next : at->more)
367 add_arch (at); 360 at->hash_add ();
368 361
369 LOG (llevDebug, "done\n"); 362 LOG (llevDebug, "done\n");
370}
371
372/*
373 * Dumps an archetype to debug-level output.
374 */
375
376void
377dump_arch (archetype *at)
378{
379 dump_object (&at->clone);
380}
381
382/*
383 * Dumps _all_ archetypes to debug-level output.
384 * If you run crossfire with debug, and enter DM-mode, you can trigger
385 * this with the O key.
386 */
387
388void
389dump_all_archetypes (void)
390{
391 archetype *at;
392
393 for (at = first_archetype; at != NULL; at = (at->more == NULL) ? at->next : at->more)
394 {
395 dump_arch (at);
396 fprintf (logfile, "%s\n", errmsg);
397 }
398} 363}
399 364
400void 365void
401free_all_archs (void) 366free_all_archs (void)
402{ 367{
… …
413 delete 378 delete
414 at; 379 at;
415 380
416 i++; 381 i++;
417 } 382 }
383
418 LOG (llevDebug, "Freed %d archetypes, %d faces\n", i, f); 384 LOG (llevDebug, "Freed %d archetypes, %d faces\n", i, f);
419} 385}
420 386
421archetype::archetype () 387archetype::archetype ()
422{ 388{
423 clear_object (&clone); /* to initial state other also */
424 CLEAR_FLAG (&clone, FLAG_FREED); /* This shouldn't matter, since copy_object() */ 389 CLEAR_FLAG (&clone, FLAG_FREED); /* This shouldn't matter, since copy_to */
425 SET_FLAG (&clone, FLAG_REMOVED); /* doesn't copy these flags... */ 390 SET_FLAG (&clone, FLAG_REMOVED); /* doesn't copy these flags... */
426} 391}
427 392
428archetype::~archetype () 393archetype::~archetype ()
429{ 394{
… …
434 * of archetype-structures. 399 * of archetype-structures.
435 */ 400 */
436void 401void
437first_arch_pass (object_thawer & fp) 402first_arch_pass (object_thawer & fp)
438{ 403{
439 archetype *at, *head = NULL, *last_more = NULL; 404 archetype *head = 0, *last_more = 0;
440 405
406 archetype *at = new archetype;
441 at->clone.arch = first_archetype = at = new archetype; 407 at->clone.arch = first_archetype = at;
442 408
443 while (int i = load_object (fp, &at->clone, 0)) 409 while (int i = load_object (fp, &at->clone, 0))
444 { 410 {
445 at->clone.speed_left = (float) (-0.1); 411 at->clone.speed_left = (float) (-0.1);
446 /* copy the body_info to the body_used - this is only really 412 /* copy the body_info to the body_used - this is only really
… …
549 } 515 }
550 else if (!strcmp ("randomitems", variable)) 516 else if (!strcmp ("randomitems", variable))
551 { 517 {
552 if (at != NULL) 518 if (at != NULL)
553 { 519 {
554 treasurelist *
555 tl = find_treasurelist (argument); 520 treasurelist *tl = find_treasurelist (argument);
556 521
557 if (tl == NULL) 522 if (tl == NULL)
558 LOG (llevError, "Failed to link treasure to arch (%s): %s\n", &at->name, argument); 523 LOG (llevError, "Failed to link treasure to arch (%s): %s\n", &at->name, argument);
559 else 524 else
560 at->clone.randomitems = tl; 525 at->clone.randomitems = tl;
… …
585void 550void
586load_archetypes (void) 551load_archetypes (void)
587{ 552{
588 char filename[MAX_BUF]; 553 char filename[MAX_BUF];
589 554
590#if TIME_ARCH_LOAD
591 struct timeval
592 tv1,
593 tv2;
594#endif
595
596 sprintf (filename, "%s/%s", settings.datadir, settings.archetypes); 555 sprintf (filename, "%s/%s", settings.datadir, settings.archetypes);
597 LOG (llevDebug, "Reading archetypes from %s:\n", filename); 556 LOG (llevDebug, "Reading archetypes from %s:\n", filename);
598 557
599 { 558 {
600 object_thawer 559 object_thawer
… …
613 object_thawer 572 object_thawer
614 thawer (filename); 573 thawer (filename);
615 574
616 LOG (llevDebug, " loading treasure...\n"); 575 LOG (llevDebug, " loading treasure...\n");
617 load_treasures (); 576 load_treasures ();
577 LOG (llevDebug, " done\n");
618 LOG (llevDebug, " done\n arch-pass 2...\n"); 578 LOG (llevDebug, " arch-pass 2...\n");
619 second_arch_pass (thawer); 579 second_arch_pass (thawer);
620 LOG (llevDebug, " done\n"); 580 LOG (llevDebug, " done\n");
621#ifdef DEBUG 581#ifdef DEBUG
622 check_generators (); 582 check_generators ();
623#endif 583#endif
… …
627 587
628/* 588/*
629 * Creates and returns a new object which is a copy of the given archetype. 589 * Creates and returns a new object which is a copy of the given archetype.
630 * This function returns NULL on failure. 590 * This function returns NULL on failure.
631 */ 591 */
632
633object * 592object *
634arch_to_object (archetype *at) 593arch_to_object (archetype *at)
635{ 594{
636 object *op; 595 object *op;
637 596
… …
641 LOG (llevError, "Couldn't find archetype.\n"); 600 LOG (llevError, "Couldn't find archetype.\n");
642 601
643 return NULL; 602 return NULL;
644 } 603 }
645 604
646 op = get_object (); 605 op = at->clone.clone ();
647 copy_object (&at->clone, op);
648 op->arch = at; 606 op->arch = at;
649 op->instantiate (); 607 op->instantiate ();
650 return op; 608 return op;
651} 609}
652 610
… …
654 * Creates an object. This function is called by get_archetype() 612 * Creates an object. This function is called by get_archetype()
655 * if it fails to find the appropriate archetype. 613 * if it fails to find the appropriate archetype.
656 * Thus get_archetype() will be guaranteed to always return 614 * Thus get_archetype() will be guaranteed to always return
657 * an object, and never NULL. 615 * an object, and never NULL.
658 */ 616 */
659
660object * 617object *
661create_singularity (const char *name) 618create_singularity (const char *name)
662{ 619{
663 object *op; 620 object *op;
664 char buf[MAX_BUF]; 621 char buf[MAX_BUF];
665 622
666 sprintf (buf, "%s (%s)", ARCH_SINGULARITY, name); 623 sprintf (buf, "%s (%s)", ARCH_SINGULARITY, name);
667 op = get_object (); 624 op = object::create ();
668 op->name = op->name_pl = buf; 625 op->name = op->name_pl = buf;
669 SET_FLAG (op, FLAG_NO_PICK); 626 SET_FLAG (op, FLAG_NO_PICK);
670 return op; 627 return op;
671} 628}
672 629
673/* 630/*
674 * Finds which archetype matches the given name, and returns a new 631 * Finds which archetype matches the given name, and returns a new
675 * object containing a copy of the archetype. 632 * object containing a copy of the archetype.
676 */ 633 */
677
678object * 634object *
679get_archetype (const char *name) 635get_archetype (const char *name)
680{ 636{
681 archetype *at = archetype::find (name); 637 archetype *at = archetype::find (name);
682 638
… …
764} 720}
765 721
766/* 722/*
767 * Adds an archetype to the hashtable. 723 * Adds an archetype to the hashtable.
768 */ 724 */
769 725void
770static void 726archetype::hash_add ()
771add_arch (archetype *at)
772{ 727{
773#if USE_UNORDERED_MAP 728#if USE_UNORDERED_MAP
774 ht.insert (std::make_pair ((size_t) (const char *) at->name, at)); 729 ht.insert (std::make_pair ((size_t) (const char *) name, this));
775#endif 730#else
776 731
777 int index = hasharch ((const char *) at->name, ARCHTABLE), org_index = index; 732 int index = hasharch ((const char *) name, ARCHTABLE), org_index = index;
778 733
779 for (;;) 734 for (;;)
780 { 735 {
781 if (arch_table[index] == NULL) 736 if (!arch_table[index])
782 { 737 {
783 arch_table[index] = at; 738 arch_table[index] = this;
784 return; 739 break;
785 } 740 }
786 741
787 if (++index == ARCHTABLE) 742 if (++index == ARCHTABLE)
788 index = 0; 743 index = 0;
789 744
790 if (index == org_index) 745 if (index == org_index)
791 fatal (ARCHTABLE_TOO_SMALL); 746 fatal (ARCHTABLE_TOO_SMALL);
792 } 747 }
748#endif
749}
750
751void
752archetype::hash_del ()
753{
754#if USE_UNORDERED_MAP
755# error remove this from HT
756#else
757
758 int index = hasharch ((const char *) name, ARCHTABLE), org_index = index;
759
760 for (;;)
761 {
762 if (arch_table[index] == this)
763 {
764 arch_table[index] = 0;
765 break;
766 }
767
768 if (++index == ARCHTABLE)
769 index = 0;
770
771 if (index == org_index)
772 break;
773 }
774#endif
793} 775}
794 776
795/* 777/*
796 * Returns the first archetype using the given type. 778 * Returns the first archetype using the given type.
797 * Used in treasure-generation. 779 * Used in treasure-generation.
… …
817 799
818object * 800object *
819clone_arch (int type) 801clone_arch (int type)
820{ 802{
821 archetype *at; 803 archetype *at;
822 object *op = get_object ();
823 804
824 if ((at = type_to_archetype (type)) == NULL) 805 if ((at = type_to_archetype (type)) == NULL)
825 { 806 {
826 LOG (llevError, "Can't clone archetype %d\n", type); 807 LOG (llevError, "Can't clone archetype %d\n", type);
827 free_object (op);
828 return NULL; 808 return 0;
829 } 809 }
830 810
831 copy_object (&at->clone, op); 811 object *op = at->clone.clone ();
832 op->instantiate (); 812 op->instantiate ();
833 return op; 813 return op;
834} 814}
835 815
836/* 816/*

Diff Legend

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