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

Diff Legend

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