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.17 by root, Tue Sep 12 19:20:06 2006 UTC vs.
Revision 1.35 by root, Wed Jan 3 20:32:13 2007 UTC

… …
16 16
17 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
18 along with this program; if not, write to the Free Software 18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 19 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
20 20
21 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>
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
… …
48 * MSW 2003-04-29 46 * MSW 2003-04-29
49 */ 47 */
50 48
51#if USE_UNORDERED_MAP 49#if USE_UNORDERED_MAP
52// the hashtable 50// the hashtable
53typedef
54 std::tr1::unordered_map < 51typedef std::tr1::unordered_map
55size_t, archetype *> 52 <
53 std::size_t,
54 arch_ptr,
55 std::tr1::hash<size_t>,
56 std::equal_to<size_t>,
57 slice_allocator< std::pair<const std::size_t, archetype *> >
58 true,
56 HT; 59 > HT;
57 60
58static 61static HT ht;
59 HT 62#else
60 ht; 63static arch_ptr arch_table[ARCHTABLE];
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)
… …
117 * If type is -1, ew don't match on type. 118 * If type is -1, ew don't match on type.
118 */ 119 */
119object * 120object *
120get_archetype_by_skill_name (const char *skill, int type) 121get_archetype_by_skill_name (const char *skill, int type)
121{ 122{
122 archetype * 123 archetype *at;
123 at;
124 124
125 if (skill == NULL) 125 if (skill)
126 return NULL;
127
128 for (at = first_archetype; at != NULL; at = at->next) 126 for (at = first_archetype; at; at = at->next)
129 {
130 if (((type == -1) || (type == at->clone.type)) && (!strcmp (at->clone.skill, skill))) 127 if (((type == -1) || (type == at->clone.type)) && (!strcmp (at->clone.skill, skill)))
131 return arch_to_object (at); 128 return arch_to_object (at);
132 } 129
133 return NULL; 130 return 0;
134} 131}
135 132
136/* similiar to above - this returns the first archetype 133/* similiar to above - this returns the first archetype
137 * that matches both the type and subtype. type and subtype 134 * that matches both the type and subtype. type and subtype
138 * can be -1 to say ignore, but in this case, the match it does 135 * can be -1 to say ignore, but in this case, the match it does
… …
178 for (i = strlen (tmpname); i > 0; i--) 175 for (i = strlen (tmpname); i > 0; i--)
179 { 176 {
180 tmpname[i] = 0; 177 tmpname[i] = 0;
181 at = find_archetype_by_object_name (tmpname); 178 at = find_archetype_by_object_name (tmpname);
182 179
183 if (at != NULL) 180 if (at)
184 {
185 return arch_to_object (at); 181 return arch_to_object (at);
186 }
187 } 182 }
188 183
189 return create_singularity (name); 184 return create_singularity (name);
190} 185}
191 186
… …
207 * Last, make a check on the full name. 202 * Last, make a check on the full name.
208 */ 203 */
209int 204int
210item_matched_string (object *pl, object *op, const char *name) 205item_matched_string (object *pl, object *op, const char *name)
211{ 206{
212 char *
213 cp,
214 local_name[MAX_BUF]; 207 char *cp, local_name[MAX_BUF];
215 int 208 int count, retval = 0;
216 count,
217 retval = 0;
218 209
219 strcpy (local_name, name); /* strtok is destructive to name */ 210 strcpy (local_name, name); /* strtok is destructive to name */
220 211
221 for (cp = strtok (local_name, ","); cp; cp = strtok (NULL, ",")) 212 for (cp = strtok (local_name, ","); cp; cp = strtok (NULL, ","))
222 { 213 {
… …
274 retval = 15; 265 retval = 15;
275 else if (!strncasecmp (cp, query_base_name (op, 0), strlen (cp))) 266 else if (!strncasecmp (cp, query_base_name (op, 0), strlen (cp)))
276 retval = 14; 267 retval = 14;
277 else if (!strncasecmp (cp, query_base_name (op, 1), strlen (cp))) 268 else if (!strncasecmp (cp, query_base_name (op, 1), strlen (cp)))
278 retval = 14; 269 retval = 14;
279
280 /* Do substring checks, so things like 'Str+1' will match. 270 /* Do substring checks, so things like 'Str+1' will match.
281 * retval of these should perhaps be lower - they are lower 271 * retval of these should perhaps be lower - they are lower
282 * then the specific strcasecmp aboves, but still higher than 272 * then the specific strcasecmp aboves, but still higher than
283 * some other match criteria. 273 * some other match criteria.
284 */ 274 */
… …
286 retval = 12; 276 retval = 12;
287 else if (strstr (query_base_name (op, 0), cp)) 277 else if (strstr (query_base_name (op, 0), cp))
288 retval = 12; 278 retval = 12;
289 else if (strstr (query_short_name (op), cp)) 279 else if (strstr (query_short_name (op), cp))
290 retval = 12; 280 retval = 12;
291
292 /* Check against plural/non plural based on count. */ 281 /* Check against plural/non plural based on count. */
293 else if (count > 1 && !strcasecmp (cp, op->name_pl)) 282 else if (count > 1 && !strcasecmp (cp, op->name_pl))
294 {
295 retval = 6; 283 retval = 6;
296 }
297 else if (count == 1 && !strcasecmp (op->name, cp)) 284 else if (count == 1 && !strcasecmp (op->name, cp))
298 {
299 retval = 6; 285 retval = 6;
300 }
301 /* base name matched - not bad */ 286 /* base name matched - not bad */
302 else if (strcasecmp (cp, op->name) == 0 && !count) 287 else if (strcasecmp (cp, op->name) == 0 && !count)
303 retval = 4; 288 retval = 4;
304 /* Check for partial custom name, but give a real low priority */ 289 /* Check for partial custom name, but give a real low priority */
305 else if (op->custom_name && strstr (op->custom_name, cp)) 290 else if (op->custom_name && strstr (op->custom_name, cp))
… …
307 292
308 if (retval) 293 if (retval)
309 { 294 {
310 if (pl->type == PLAYER) 295 if (pl->type == PLAYER)
311 pl->contr->count = count; 296 pl->contr->count = count;
297
312 return retval; 298 return retval;
313 } 299 }
314 } 300 }
301
315 return 0; 302 return 0;
316} 303}
317 304
318/* 305/*
319 * Initialises the internal linked list of archetypes (read from file). 306 * Initialises the internal linked list of archetypes (read from file).
… …
324void 311void
325init_archetypes (void) 312init_archetypes (void)
326{ /* called from add_player() and edit() */ 313{ /* called from add_player() and edit() */
327 if (first_archetype != NULL) /* Only do this once */ 314 if (first_archetype != NULL) /* Only do this once */
328 return; 315 return;
316
329 arch_init = 1; 317 arch_init = 1;
330 load_archetypes (); 318 load_archetypes ();
331 arch_init = 0; 319 arch_init = 0;
332 empty_archetype = find_archetype ("empty_archetype"); 320 empty_archetype = archetype::find ("empty_archetype");
333 321
334/* init_blocksview();*/ 322/* init_blocksview();*/
335} 323}
336 324
337/* 325/*
… …
361 */ 349 */
362 350
363void 351void
364init_archetable (void) 352init_archetable (void)
365{ 353{
366 archetype * 354 archetype *at;
367 at;
368 355
369 LOG (llevDebug, " Setting up archetable...\n"); 356 LOG (llevDebug, " Setting up archetable...\n");
370 357
371 for (at = first_archetype; at != NULL; at = (at->more == NULL) ? at->next : at->more) 358 for (at = first_archetype; at != NULL; at = (at->more == NULL) ? at->next : at->more)
372 add_arch (at); 359 at->hash_add ();
373 360
374 LOG (llevDebug, "done\n"); 361 LOG (llevDebug, "done\n");
375} 362}
376 363
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 364void
407free_all_archs (void) 365free_all_archs (void)
408{ 366{
409 archetype * 367 archetype *at, *next;
410 at, *
411 next;
412 int
413 i = 0, f = 0; 368 int i = 0, f = 0;
414 369
415 for (at = first_archetype; at != NULL; at = next) 370 for (at = first_archetype; at != NULL; at = next)
416 { 371 {
417 if (at->more) 372 if (at->more)
418 next = at->more; 373 next = at->more;
… …
422 delete 377 delete
423 at; 378 at;
424 379
425 i++; 380 i++;
426 } 381 }
382
427 LOG (llevDebug, "Freed %d archetypes, %d faces\n", i, f); 383 LOG (llevDebug, "Freed %d archetypes, %d faces\n", i, f);
428} 384}
429 385
430archetype::archetype () 386archetype::archetype ()
431{ 387{
432 clear_object (&clone); /* to initial state other also */
433 CLEAR_FLAG (&clone, FLAG_FREED); /* This shouldn't matter, since copy_object() */ 388 CLEAR_FLAG (&clone, FLAG_FREED); /* This shouldn't matter, since copy_to */
434 SET_FLAG (&clone, FLAG_REMOVED); /* doesn't copy these flags... */ 389 SET_FLAG (&clone, FLAG_REMOVED); /* doesn't copy these flags... */
435} 390}
436 391
437archetype::~archetype () 392archetype::~archetype ()
438{ 393{
… …
443 * of archetype-structures. 398 * of archetype-structures.
444 */ 399 */
445void 400void
446first_arch_pass (object_thawer & fp) 401first_arch_pass (object_thawer & fp)
447{ 402{
448 archetype * 403 archetype *head = 0, *last_more = 0;
449 at, *
450 head = NULL, *last_more = NULL;
451 404
405 archetype *at = new archetype;
452 at->clone.arch = first_archetype = at = new archetype; 406 at->clone.arch = first_archetype = at;
453 407
454 while (int i = load_object (fp, &at->clone, 0)) 408 while (int i = load_object (fp, &at->clone, 0))
455 { 409 {
456 at->clone.speed_left = (float) (-0.1); 410 at->clone.speed_left = (float) (-0.1);
457 /* copy the body_info to the body_used - this is only really 411 /* copy the body_info to the body_used - this is only really
… …
524 */ 478 */
525 479
526void 480void
527second_arch_pass (object_thawer & thawer) 481second_arch_pass (object_thawer & thawer)
528{ 482{
529 char
530 buf[MAX_BUF], *
531 variable = buf, *argument, *cp; 483 char buf[MAX_BUF], *variable = buf, *argument, *cp;
532 archetype *
533 at = NULL, *other; 484 archetype *at = NULL, *other;
534 485
535 while (fgets (buf, MAX_BUF, thawer) != NULL) 486 while (fgets (buf, MAX_BUF, thawer) != NULL)
536 { 487 {
537 if (*buf == '#') 488 if (*buf == '#')
538 continue; 489 continue;
… …
546 cp--; 497 cp--;
547 } 498 }
548 } 499 }
549 if (!strcmp ("Object", variable)) 500 if (!strcmp ("Object", variable))
550 { 501 {
551 if ((at = find_archetype (argument)) == NULL) 502 if ((at = archetype::find (argument)) == NULL)
552 LOG (llevError, "Warning: failed to find arch %s\n", argument); 503 LOG (llevError, "Warning: failed to find arch %s\n", argument);
553 } 504 }
554 else if (!strcmp ("other_arch", variable)) 505 else if (!strcmp ("other_arch", variable))
555 { 506 {
556 if (at != NULL && at->clone.other_arch == NULL) 507 if (at != NULL && at->clone.other_arch == NULL)
557 { 508 {
558 if ((other = find_archetype (argument)) == NULL) 509 if ((other = archetype::find (argument)) == NULL)
559 LOG (llevError, "Warning: failed to find other_arch %s\n", argument); 510 LOG (llevError, "Warning: failed to find other_arch %s\n", argument);
560 else if (at != NULL) 511 else if (at != NULL)
561 at->clone.other_arch = other; 512 at->clone.other_arch = other;
562 } 513 }
563 } 514 }
564 else if (!strcmp ("randomitems", variable)) 515 else if (!strcmp ("randomitems", variable))
565 { 516 {
566 if (at != NULL) 517 if (at != NULL)
567 { 518 {
568 treasurelist *
569 tl = find_treasurelist (argument); 519 treasurelist *tl = find_treasurelist (argument);
570 520
571 if (tl == NULL) 521 if (tl == NULL)
572 LOG (llevError, "Failed to link treasure to arch (%s): %s\n", &at->name, argument); 522 LOG (llevError, "Failed to link treasure to arch (%s): %s\n", &at->name, argument);
573 else 523 else
574 at->clone.randomitems = tl; 524 at->clone.randomitems = tl;
… …
579 529
580#ifdef DEBUG 530#ifdef DEBUG
581void 531void
582check_generators (void) 532check_generators (void)
583{ 533{
584 archetype * 534 archetype *at;
585 at;
586 535
587 for (at = first_archetype; at != NULL; at = at->next) 536 for (at = first_archetype; at != NULL; at = at->next)
588 if (QUERY_FLAG (&at->clone, FLAG_GENERATOR) && at->clone.other_arch == NULL) 537 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); 538 LOG (llevError, "Warning: %s is generator but lacks other_arch.\n", &at->name);
590} 539}
… …
598 */ 547 */
599 548
600void 549void
601load_archetypes (void) 550load_archetypes (void)
602{ 551{
603 char
604 filename[MAX_BUF]; 552 char filename[MAX_BUF];
605
606#if TIME_ARCH_LOAD
607 struct timeval
608 tv1,
609 tv2;
610#endif
611 553
612 sprintf (filename, "%s/%s", settings.datadir, settings.archetypes); 554 sprintf (filename, "%s/%s", settings.datadir, settings.archetypes);
613 LOG (llevDebug, "Reading archetypes from %s:\n", filename); 555 LOG (llevDebug, "Reading archetypes from %s:\n", filename);
614 556
615 { 557 {
… …
629 object_thawer 571 object_thawer
630 thawer (filename); 572 thawer (filename);
631 573
632 LOG (llevDebug, " loading treasure...\n"); 574 LOG (llevDebug, " loading treasure...\n");
633 load_treasures (); 575 load_treasures ();
576 LOG (llevDebug, " done\n");
634 LOG (llevDebug, " done\n arch-pass 2...\n"); 577 LOG (llevDebug, " arch-pass 2...\n");
635 second_arch_pass (thawer); 578 second_arch_pass (thawer);
636 LOG (llevDebug, " done\n"); 579 LOG (llevDebug, " done\n");
637#ifdef DEBUG 580#ifdef DEBUG
638 check_generators (); 581 check_generators ();
639#endif 582#endif
… …
643 586
644/* 587/*
645 * Creates and returns a new object which is a copy of the given archetype. 588 * Creates and returns a new object which is a copy of the given archetype.
646 * This function returns NULL on failure. 589 * This function returns NULL on failure.
647 */ 590 */
648
649object * 591object *
650arch_to_object (archetype *at) 592arch_to_object (archetype *at)
651{ 593{
652 object * 594 object *op;
653 op;
654 595
655 if (at == NULL) 596 if (at == NULL)
656 { 597 {
657 if (warn_archetypes) 598 if (warn_archetypes)
658 LOG (llevError, "Couldn't find archetype.\n"); 599 LOG (llevError, "Couldn't find archetype.\n");
659 600
660 return NULL; 601 return NULL;
661 } 602 }
662 603
663 op = get_object (); 604 op = at->clone.clone ();
664 copy_object (&at->clone, op);
665 op->arch = at; 605 op->arch = at;
666 op->instantiate (); 606 op->instantiate ();
667 return op; 607 return op;
668} 608}
669 609
… …
671 * Creates an object. This function is called by get_archetype() 611 * Creates an object. This function is called by get_archetype()
672 * if it fails to find the appropriate archetype. 612 * if it fails to find the appropriate archetype.
673 * Thus get_archetype() will be guaranteed to always return 613 * Thus get_archetype() will be guaranteed to always return
674 * an object, and never NULL. 614 * an object, and never NULL.
675 */ 615 */
676
677object * 616object *
678create_singularity (const char *name) 617create_singularity (const char *name)
679{ 618{
680 object * 619 object *op;
681 op;
682 char
683 buf[MAX_BUF]; 620 char buf[MAX_BUF];
684 621
685 sprintf (buf, "%s (%s)", ARCH_SINGULARITY, name); 622 sprintf (buf, "%s (%s)", ARCH_SINGULARITY, name);
686 op = get_object (); 623 op = object::create ();
687 op->name = op->name_pl = buf; 624 op->name = op->name_pl = buf;
688 SET_FLAG (op, FLAG_NO_PICK); 625 SET_FLAG (op, FLAG_NO_PICK);
689 return op; 626 return op;
690} 627}
691 628
692/* 629/*
693 * Finds which archetype matches the given name, and returns a new 630 * Finds which archetype matches the given name, and returns a new
694 * object containing a copy of the archetype. 631 * object containing a copy of the archetype.
695 */ 632 */
696
697object * 633object *
698get_archetype (const char *name) 634get_archetype (const char *name)
699{ 635{
700 archetype * 636 archetype *at = archetype::find (name);
701 at;
702 637
703 at = find_archetype (name); 638 if (!at)
704 if (at == NULL)
705 return create_singularity (name); 639 return create_singularity (name);
706 640
707 return arch_to_object (at); 641 return arch_to_object (at);
708} 642}
709 643
… …
712 */ 646 */
713 647
714unsigned long 648unsigned long
715hasharch (const char *str, int tablesize) 649hasharch (const char *str, int tablesize)
716{ 650{
717 unsigned long 651 unsigned long hash = 0;
718 hash = 0;
719 unsigned int 652 unsigned int i = 0;
720 i = 0;
721 const char * 653 const char *p;
722 p;
723 654
724 /* use the one-at-a-time hash function, which supposedly is 655 /* use the one-at-a-time hash function, which supposedly is
725 * better than the djb2-like one used by perl5.005, but 656 * better than the djb2-like one used by perl5.005, but
726 * certainly is better then the bug used here before. 657 * certainly is better then the bug used here before.
727 * see http://burtleburtle.net/bob/hash/doobs.html 658 * see http://burtleburtle.net/bob/hash/doobs.html
… …
744 * Finds, using the hashtable, which archetype matches the given name. 675 * Finds, using the hashtable, which archetype matches the given name.
745 * returns a pointer to the found archetype, otherwise NULL. 676 * returns a pointer to the found archetype, otherwise NULL.
746 */ 677 */
747 678
748archetype * 679archetype *
749find_archetype (const char *name) 680archetype::find (const char *name)
750{ 681{
751#if USE_UNORDERED_MAP
752 name = shstr::find (name);
753
754 if (!name) 682 if (!name)
755 return 0; 683 return 0;
756 684
757 HT::const_iterator i = ht.find ((size_t) name); 685#if USE_UNORDERED_MAP
686 AUTODECL (i, ht.find ((size_t) name));
758 687
759 if (i == ht.end ()) 688 if (i == ht.end ())
760 return 0; 689 return 0;
761 else 690 else
762 return i->second; 691 return i->second;
763#endif 692#endif
764 693
765 archetype * 694 archetype *at;
766 at;
767 unsigned long 695 unsigned long index;
768 index;
769
770 if (name == NULL)
771 return (archetype *) NULL;
772 696
773 index = hasharch (name, ARCHTABLE); 697 index = hasharch (name, ARCHTABLE);
774 arch_search++; 698 arch_search++;
775 for (;;) 699 for (;;)
776 { 700 {
777 at = arch_table[index]; 701 at = arch_table[index];
702
778 if (at == NULL) 703 if (at == NULL)
779 { 704 {
780 if (warn_archetypes) 705 if (warn_archetypes)
781 LOG (llevError, "Couldn't find archetype %s\n", name); 706 LOG (llevError, "Couldn't find archetype %s\n", name);
707
782 return NULL; 708 return NULL;
783 } 709 }
710
784 arch_cmp++; 711 arch_cmp++;
712
785 if (!strcmp ((const char *) at->name, name)) 713 if (!strcmp ((const char *) at->name, name))
786 return at; 714 return at;
715
787 if (++index >= ARCHTABLE) 716 if (++index >= ARCHTABLE)
788 index = 0; 717 index = 0;
789 } 718 }
790} 719}
791 720
792/* 721/*
793 * Adds an archetype to the hashtable. 722 * Adds an archetype to the hashtable.
794 */ 723 */
795 724void
796static void 725archetype::hash_add ()
797add_arch (archetype *at)
798{ 726{
799#if USE_UNORDERED_MAP 727#if USE_UNORDERED_MAP
800 ht.insert (std::make_pair ((size_t) (const char *) at->name, at)); 728 ht.insert (std::make_pair ((size_t) (const char *) name, this));
801#endif 729#else
802 730
803 int
804 index = hasharch ((const char *) at->name, ARCHTABLE), org_index = index; 731 int index = hasharch ((const char *) name, ARCHTABLE), org_index = index;
805 732
806 for (;;) 733 for (;;)
807 { 734 {
808 if (arch_table[index] == NULL) 735 if (!arch_table[index])
809 { 736 {
810 arch_table[index] = at; 737 arch_table[index] = this;
811 return; 738 break;
812 } 739 }
813 740
814 if (++index == ARCHTABLE) 741 if (++index == ARCHTABLE)
815 index = 0; 742 index = 0;
816 743
817 if (index == org_index) 744 if (index == org_index)
818 fatal (ARCHTABLE_TOO_SMALL); 745 fatal (ARCHTABLE_TOO_SMALL);
819 } 746 }
747#endif
748}
749
750void
751archetype::hash_del ()
752{
753#if USE_UNORDERED_MAP
754# error remove this from HT
755#else
756
757 int index = hasharch ((const char *) name, ARCHTABLE), org_index = index;
758
759 for (;;)
760 {
761 if (arch_table[index] == this)
762 {
763 arch_table[index] = 0;
764 break;
765 }
766
767 if (++index == ARCHTABLE)
768 index = 0;
769
770 if (index == org_index)
771 break;
772 }
773#endif
820} 774}
821 775
822/* 776/*
823 * Returns the first archetype using the given type. 777 * Returns the first archetype using the given type.
824 * Used in treasure-generation. 778 * Used in treasure-generation.
825 */ 779 */
826 780
827archetype * 781archetype *
828type_to_archetype (int type) 782type_to_archetype (int type)
829{ 783{
830 archetype * 784 archetype *at;
831 at;
832 785
833 for (at = first_archetype; at != NULL; at = (at->more == NULL) ? at->next : at->more) 786 for (at = first_archetype; at; at = at->more == 0 ? at->next : at->more)
834 if (at->clone.type == type) 787 if (at->clone.type == type)
835 return at; 788 return at;
789
836 return NULL; 790 return 0;
837} 791}
838 792
839/* 793/*
840 * Returns a new object copied from the first archetype matching 794 * Returns a new object copied from the first archetype matching
841 * the given type. 795 * the given type.
… …
843 */ 797 */
844 798
845object * 799object *
846clone_arch (int type) 800clone_arch (int type)
847{ 801{
848 archetype * 802 archetype *at;
849 at;
850 object *
851 op = get_object ();
852 803
853 if ((at = type_to_archetype (type)) == NULL) 804 if ((at = type_to_archetype (type)) == NULL)
854 { 805 {
855 LOG (llevError, "Can't clone archetype %d\n", type); 806 LOG (llevError, "Can't clone archetype %d\n", type);
856 free_object (op);
857 return NULL; 807 return 0;
858 } 808 }
859 copy_object (&at->clone, op); 809
810 object *op = at->clone.clone ();
860 op->instantiate (); 811 op->instantiate ();
861 return op; 812 return op;
862} 813}
863 814
864/* 815/*
… …
866 */ 817 */
867 818
868object * 819object *
869object_create_arch (archetype *at) 820object_create_arch (archetype *at)
870{ 821{
871 object * 822 object *op, *prev = 0, *head = 0;
872 op, *
873 prev = NULL, *head = NULL;
874 823
875 while (at) 824 while (at)
876 { 825 {
877 op = arch_to_object (at); 826 op = arch_to_object (at);
878 op->x = at->clone.x; 827 op->x = at->clone.x;
879 op->y = at->clone.y; 828 op->y = at->clone.y;
829
880 if (head) 830 if (head)
881 op->head = head, prev->more = op; 831 op->head = head, prev->more = op;
832
882 if (!head) 833 if (!head)
883 head = op; 834 head = op;
835
884 prev = op; 836 prev = op;
885 at = at->more; 837 at = at->more;
886 } 838 }
839
887 return (head); 840 return (head);
888} 841}
889 842
890/*** end of arch.c ***/

Diff Legend

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