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.15 by root, Sun Sep 10 13:20:12 2006 UTC vs.
Revision 1.34 by pippijn, Wed Jan 3 00:10:04 2007 UTC

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

Diff Legend

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