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.20 by root, Thu Sep 14 21:16:11 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
… …
16 17
17 You should have received a copy of the GNU General Public License 18 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software 19 along with this program; if not, write to the Free Software
19 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 20 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
20 21
21 The authors can be reached via e-mail at crossfire-devel@real-time.com 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}
… …
206 * Last, make a check on the full name. 203 * Last, make a check on the full name.
207 */ 204 */
208int 205int
209item_matched_string (object *pl, object *op, const char *name) 206item_matched_string (object *pl, object *op, const char *name)
210{ 207{
211 char *
212 cp,
213 local_name[MAX_BUF]; 208 char *cp, local_name[MAX_BUF];
214 int 209 int count, retval = 0;
215 count,
216 retval = 0;
217 210
218 strcpy (local_name, name); /* strtok is destructive to name */ 211 strcpy (local_name, name); /* strtok is destructive to name */
219 212
220 for (cp = strtok (local_name, ","); cp; cp = strtok (NULL, ",")) 213 for (cp = strtok (local_name, ","); cp; cp = strtok (NULL, ","))
221 { 214 {
… …
273 retval = 15; 266 retval = 15;
274 else if (!strncasecmp (cp, query_base_name (op, 0), strlen (cp))) 267 else if (!strncasecmp (cp, query_base_name (op, 0), strlen (cp)))
275 retval = 14; 268 retval = 14;
276 else if (!strncasecmp (cp, query_base_name (op, 1), strlen (cp))) 269 else if (!strncasecmp (cp, query_base_name (op, 1), strlen (cp)))
277 retval = 14; 270 retval = 14;
278
279 /* Do substring checks, so things like 'Str+1' will match. 271 /* Do substring checks, so things like 'Str+1' will match.
280 * retval of these should perhaps be lower - they are lower 272 * retval of these should perhaps be lower - they are lower
281 * then the specific strcasecmp aboves, but still higher than 273 * then the specific strcasecmp aboves, but still higher than
282 * some other match criteria. 274 * some other match criteria.
283 */ 275 */
… …
285 retval = 12; 277 retval = 12;
286 else if (strstr (query_base_name (op, 0), cp)) 278 else if (strstr (query_base_name (op, 0), cp))
287 retval = 12; 279 retval = 12;
288 else if (strstr (query_short_name (op), cp)) 280 else if (strstr (query_short_name (op), cp))
289 retval = 12; 281 retval = 12;
290
291 /* Check against plural/non plural based on count. */ 282 /* Check against plural/non plural based on count. */
292 else if (count > 1 && !strcasecmp (cp, op->name_pl)) 283 else if (count > 1 && !strcasecmp (cp, op->name_pl))
293 {
294 retval = 6; 284 retval = 6;
295 }
296 else if (count == 1 && !strcasecmp (op->name, cp)) 285 else if (count == 1 && !strcasecmp (op->name, cp))
297 {
298 retval = 6; 286 retval = 6;
299 }
300 /* base name matched - not bad */ 287 /* base name matched - not bad */
301 else if (strcasecmp (cp, op->name) == 0 && !count) 288 else if (strcasecmp (cp, op->name) == 0 && !count)
302 retval = 4; 289 retval = 4;
303 /* Check for partial custom name, but give a real low priority */ 290 /* Check for partial custom name, but give a real low priority */
304 else if (op->custom_name && strstr (op->custom_name, cp)) 291 else if (op->custom_name && strstr (op->custom_name, cp))
… …
306 293
307 if (retval) 294 if (retval)
308 { 295 {
309 if (pl->type == PLAYER) 296 if (pl->type == PLAYER)
310 pl->contr->count = count; 297 pl->contr->count = count;
298
311 return retval; 299 return retval;
312 } 300 }
313 } 301 }
302
314 return 0; 303 return 0;
315} 304}
316 305
317/* 306/*
318 * Initialises the internal linked list of archetypes (read from file). 307 * Initialises the internal linked list of archetypes (read from file).
… …
361 */ 350 */
362 351
363void 352void
364init_archetable (void) 353init_archetable (void)
365{ 354{
366 archetype * 355 archetype *at;
367 at;
368 356
369 LOG (llevDebug, " Setting up archetable...\n"); 357 LOG (llevDebug, " Setting up archetable...\n");
370 358
371 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)
372 add_arch (at); 360 at->hash_add ();
373 361
374 LOG (llevDebug, "done\n"); 362 LOG (llevDebug, "done\n");
375} 363}
376 364
377/*
378 * Dumps an archetype to debug-level output.
379 */
380
381void
382dump_arch (archetype *at)
383{
384 dump_object (&at->clone);
385}
386
387/*
388 * Dumps _all_ archetypes to debug-level output.
389 * If you run crossfire with debug, and enter DM-mode, you can trigger
390 * this with the O key.
391 */
392
393void
394dump_all_archetypes (void)
395{
396 archetype *
397 at;
398
399 for (at = first_archetype; at != NULL; at = (at->more == NULL) ? at->next : at->more)
400 {
401 dump_arch (at);
402 fprintf (logfile, "%s\n", errmsg);
403 }
404}
405
406void 365void
407free_all_archs (void) 366free_all_archs (void)
408{ 367{
409 archetype * 368 archetype *at, *next;
410 at, *
411 next;
412 int
413 i = 0, f = 0; 369 int i = 0, f = 0;
414 370
415 for (at = first_archetype; at != NULL; at = next) 371 for (at = first_archetype; at != NULL; at = next)
416 { 372 {
417 if (at->more) 373 if (at->more)
418 next = at->more; 374 next = at->more;
… …
422 delete 378 delete
423 at; 379 at;
424 380
425 i++; 381 i++;
426 } 382 }
383
427 LOG (llevDebug, "Freed %d archetypes, %d faces\n", i, f); 384 LOG (llevDebug, "Freed %d archetypes, %d faces\n", i, f);
428} 385}
429 386
430archetype::archetype () 387archetype::archetype ()
431{ 388{
432 clear_object (&clone); /* to initial state other also */
433 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 */
434 SET_FLAG (&clone, FLAG_REMOVED); /* doesn't copy these flags... */ 390 SET_FLAG (&clone, FLAG_REMOVED); /* doesn't copy these flags... */
435} 391}
436 392
437archetype::~archetype () 393archetype::~archetype ()
438{ 394{
… …
443 * of archetype-structures. 399 * of archetype-structures.
444 */ 400 */
445void 401void
446first_arch_pass (object_thawer & fp) 402first_arch_pass (object_thawer & fp)
447{ 403{
448 archetype * 404 archetype *head = 0, *last_more = 0;
449 at, *
450 head = NULL, *last_more = NULL;
451 405
406 archetype *at = new archetype;
452 at->clone.arch = first_archetype = at = new archetype; 407 at->clone.arch = first_archetype = at;
453 408
454 while (int i = load_object (fp, &at->clone, 0)) 409 while (int i = load_object (fp, &at->clone, 0))
455 { 410 {
456 at->clone.speed_left = (float) (-0.1); 411 at->clone.speed_left = (float) (-0.1);
457 /* 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
… …
524 */ 479 */
525 480
526void 481void
527second_arch_pass (object_thawer & thawer) 482second_arch_pass (object_thawer & thawer)
528{ 483{
529 char
530 buf[MAX_BUF], *
531 variable = buf, *argument, *cp; 484 char buf[MAX_BUF], *variable = buf, *argument, *cp;
532 archetype *
533 at = NULL, *other; 485 archetype *at = NULL, *other;
534 486
535 while (fgets (buf, MAX_BUF, thawer) != NULL) 487 while (fgets (buf, MAX_BUF, thawer) != NULL)
536 { 488 {
537 if (*buf == '#') 489 if (*buf == '#')
538 continue; 490 continue;
… …
563 } 515 }
564 else if (!strcmp ("randomitems", variable)) 516 else if (!strcmp ("randomitems", variable))
565 { 517 {
566 if (at != NULL) 518 if (at != NULL)
567 { 519 {
568 treasurelist *
569 tl = find_treasurelist (argument); 520 treasurelist *tl = find_treasurelist (argument);
570 521
571 if (tl == NULL) 522 if (tl == NULL)
572 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);
573 else 524 else
574 at->clone.randomitems = tl; 525 at->clone.randomitems = tl;
… …
579 530
580#ifdef DEBUG 531#ifdef DEBUG
581void 532void
582check_generators (void) 533check_generators (void)
583{ 534{
584 archetype * 535 archetype *at;
585 at;
586 536
587 for (at = first_archetype; at != NULL; at = at->next) 537 for (at = first_archetype; at != NULL; at = at->next)
588 if (QUERY_FLAG (&at->clone, FLAG_GENERATOR) && at->clone.other_arch == NULL) 538 if (QUERY_FLAG (&at->clone, FLAG_GENERATOR) && at->clone.other_arch == NULL)
589 LOG (llevError, "Warning: %s is generator but lacks other_arch.\n", &at->name); 539 LOG (llevError, "Warning: %s is generator but lacks other_arch.\n", &at->name);
590} 540}
… …
598 */ 548 */
599 549
600void 550void
601load_archetypes (void) 551load_archetypes (void)
602{ 552{
603 char
604 filename[MAX_BUF]; 553 char filename[MAX_BUF];
605
606#if TIME_ARCH_LOAD
607 struct timeval
608 tv1,
609 tv2;
610#endif
611 554
612 sprintf (filename, "%s/%s", settings.datadir, settings.archetypes); 555 sprintf (filename, "%s/%s", settings.datadir, settings.archetypes);
613 LOG (llevDebug, "Reading archetypes from %s:\n", filename); 556 LOG (llevDebug, "Reading archetypes from %s:\n", filename);
614 557
615 { 558 {
… …
629 object_thawer 572 object_thawer
630 thawer (filename); 573 thawer (filename);
631 574
632 LOG (llevDebug, " loading treasure...\n"); 575 LOG (llevDebug, " loading treasure...\n");
633 load_treasures (); 576 load_treasures ();
577 LOG (llevDebug, " done\n");
634 LOG (llevDebug, " done\n arch-pass 2...\n"); 578 LOG (llevDebug, " arch-pass 2...\n");
635 second_arch_pass (thawer); 579 second_arch_pass (thawer);
636 LOG (llevDebug, " done\n"); 580 LOG (llevDebug, " done\n");
637#ifdef DEBUG 581#ifdef DEBUG
638 check_generators (); 582 check_generators ();
639#endif 583#endif
… …
643 587
644/* 588/*
645 * 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.
646 * This function returns NULL on failure. 590 * This function returns NULL on failure.
647 */ 591 */
648
649object * 592object *
650arch_to_object (archetype *at) 593arch_to_object (archetype *at)
651{ 594{
652 object * 595 object *op;
653 op;
654 596
655 if (at == NULL) 597 if (at == NULL)
656 { 598 {
657 if (warn_archetypes) 599 if (warn_archetypes)
658 LOG (llevError, "Couldn't find archetype.\n"); 600 LOG (llevError, "Couldn't find archetype.\n");
659 601
660 return NULL; 602 return NULL;
661 } 603 }
662 604
663 op = get_object (); 605 op = at->clone.clone ();
664 copy_object (&at->clone, op);
665 op->arch = at; 606 op->arch = at;
666 op->instantiate (); 607 op->instantiate ();
667 return op; 608 return op;
668} 609}
669 610
… …
671 * Creates an object. This function is called by get_archetype() 612 * Creates an object. This function is called by get_archetype()
672 * if it fails to find the appropriate archetype. 613 * if it fails to find the appropriate archetype.
673 * Thus get_archetype() will be guaranteed to always return 614 * Thus get_archetype() will be guaranteed to always return
674 * an object, and never NULL. 615 * an object, and never NULL.
675 */ 616 */
676
677object * 617object *
678create_singularity (const char *name) 618create_singularity (const char *name)
679{ 619{
680 object * op; 620 object *op;
681 char buf[MAX_BUF]; 621 char buf[MAX_BUF];
682 622
683 sprintf (buf, "%s (%s)", ARCH_SINGULARITY, name); 623 sprintf (buf, "%s (%s)", ARCH_SINGULARITY, name);
684 op = get_object (); 624 op = object::create ();
685 op->name = op->name_pl = buf; 625 op->name = op->name_pl = buf;
686 SET_FLAG (op, FLAG_NO_PICK); 626 SET_FLAG (op, FLAG_NO_PICK);
687 return op; 627 return op;
688} 628}
689 629
690/* 630/*
691 * Finds which archetype matches the given name, and returns a new 631 * Finds which archetype matches the given name, and returns a new
692 * object containing a copy of the archetype. 632 * object containing a copy of the archetype.
693 */ 633 */
694
695object * 634object *
696get_archetype (const char *name) 635get_archetype (const char *name)
697{ 636{
698 archetype *at = archetype::find (name); 637 archetype *at = archetype::find (name);
699 638
… …
781} 720}
782 721
783/* 722/*
784 * Adds an archetype to the hashtable. 723 * Adds an archetype to the hashtable.
785 */ 724 */
786 725void
787static void 726archetype::hash_add ()
788add_arch (archetype *at)
789{ 727{
790#if USE_UNORDERED_MAP 728#if USE_UNORDERED_MAP
791 ht.insert (std::make_pair ((size_t) (const char *) at->name, at)); 729 ht.insert (std::make_pair ((size_t) (const char *) name, this));
792#endif 730#else
793 731
794 int index = hasharch ((const char *) at->name, ARCHTABLE), org_index = index; 732 int index = hasharch ((const char *) name, ARCHTABLE), org_index = index;
795 733
796 for (;;) 734 for (;;)
797 { 735 {
798 if (arch_table[index] == NULL) 736 if (!arch_table[index])
799 { 737 {
800 arch_table[index] = at; 738 arch_table[index] = this;
801 return; 739 break;
802 } 740 }
803 741
804 if (++index == ARCHTABLE) 742 if (++index == ARCHTABLE)
805 index = 0; 743 index = 0;
806 744
807 if (index == org_index) 745 if (index == org_index)
808 fatal (ARCHTABLE_TOO_SMALL); 746 fatal (ARCHTABLE_TOO_SMALL);
809 } 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
810} 775}
811 776
812/* 777/*
813 * Returns the first archetype using the given type. 778 * Returns the first archetype using the given type.
814 * Used in treasure-generation. 779 * Used in treasure-generation.
… …
834 799
835object * 800object *
836clone_arch (int type) 801clone_arch (int type)
837{ 802{
838 archetype *at; 803 archetype *at;
839 object *op = get_object ();
840 804
841 if ((at = type_to_archetype (type)) == NULL) 805 if ((at = type_to_archetype (type)) == NULL)
842 { 806 {
843 LOG (llevError, "Can't clone archetype %d\n", type); 807 LOG (llevError, "Can't clone archetype %d\n", type);
844 free_object (op);
845 return NULL; 808 return 0;
846 } 809 }
847 810
848 copy_object (&at->clone, op); 811 object *op = at->clone.clone ();
849 op->instantiate (); 812 op->instantiate ();
850 return op; 813 return op;
851} 814}
852 815
853/* 816/*

Diff Legend

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