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.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
… …
48 * MSW 2003-04-29 47 * MSW 2003-04-29
49 */ 48 */
50 49
51#if USE_UNORDERED_MAP 50#if USE_UNORDERED_MAP
52// the hashtable 51// the hashtable
53typedef
54 std::tr1::unordered_map < 52typedef std::tr1::unordered_map
55size_t, archetype *> 53 <
54 std::size_t,
55 arch_ptr,
56 std::tr1::hash<size_t>,
57 std::equal_to<size_t>,
58 slice_allocator< std::pair<const std::size_t, archetype *> >
59 true,
56 HT; 60 > HT;
57 61
58static 62static HT ht;
59 HT 63#else
60 ht; 64static arch_ptr arch_table[ARCHTABLE];
61#endif 65#endif
62 66
63/** 67/**
64 * GROS - This function retrieves an archetype given the name that appears 68 * GROS - This function retrieves an archetype given the name that appears
65 * during the game (for example, "writing pen" instead of "stylus"). 69 * during the game (for example, "writing pen" instead of "stylus").
… …
72 * - the archetype found or null if nothing was found. 76 * - the archetype found or null if nothing was found.
73 */ 77 */
74archetype * 78archetype *
75find_archetype_by_object_name (const char *name) 79find_archetype_by_object_name (const char *name)
76{ 80{
77 archetype * 81 archetype *at;
78 at;
79 82
80 if (name == NULL) 83 if (name == NULL)
81 return (archetype *) NULL; 84 return (archetype *) NULL;
82 85
83 for (at = first_archetype; at != NULL; at = at->next) 86 for (at = first_archetype; at != NULL; at = at->next)
… …
94 * except that it considers only items of the given type. 97 * except that it considers only items of the given type.
95 */ 98 */
96archetype * 99archetype *
97find_archetype_by_object_type_name (int type, const char *name) 100find_archetype_by_object_type_name (int type, const char *name)
98{ 101{
99 archetype * 102 archetype *at;
100 at;
101 103
102 if (name == NULL) 104 if (name == NULL)
103 return NULL; 105 return NULL;
104 106
105 for (at = first_archetype; at != NULL; at = at->next) 107 for (at = first_archetype; at != NULL; at = at->next)
… …
117 * If type is -1, ew don't match on type. 119 * If type is -1, ew don't match on type.
118 */ 120 */
119object * 121object *
120get_archetype_by_skill_name (const char *skill, int type) 122get_archetype_by_skill_name (const char *skill, int type)
121{ 123{
122 archetype * 124 archetype *at;
123 at;
124 125
125 if (skill == NULL) 126 if (skill)
126 return NULL;
127
128 for (at = first_archetype; at != NULL; at = at->next) 127 for (at = first_archetype; at; at = at->next)
129 {
130 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)))
131 return arch_to_object (at); 129 return arch_to_object (at);
132 } 130
133 return NULL; 131 return 0;
134} 132}
135 133
136/* similiar to above - this returns the first archetype 134/* similiar to above - this returns the first archetype
137 * that matches both the type and subtype. type and subtype 135 * 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 136 * can be -1 to say ignore, but in this case, the match it does
… …
178 for (i = strlen (tmpname); i > 0; i--) 176 for (i = strlen (tmpname); i > 0; i--)
179 { 177 {
180 tmpname[i] = 0; 178 tmpname[i] = 0;
181 at = find_archetype_by_object_name (tmpname); 179 at = find_archetype_by_object_name (tmpname);
182 180
183 if (at != NULL) 181 if (at)
184 {
185 return arch_to_object (at); 182 return arch_to_object (at);
186 }
187 } 183 }
188 184
189 return create_singularity (name); 185 return create_singularity (name);
190} 186}
191 187
… …
207 * Last, make a check on the full name. 203 * Last, make a check on the full name.
208 */ 204 */
209int 205int
210item_matched_string (object *pl, object *op, const char *name) 206item_matched_string (object *pl, object *op, const char *name)
211{ 207{
212 char *
213 cp,
214 local_name[MAX_BUF]; 208 char *cp, local_name[MAX_BUF];
215 int 209 int count, retval = 0;
216 count,
217 retval = 0;
218 210
219 strcpy (local_name, name); /* strtok is destructive to name */ 211 strcpy (local_name, name); /* strtok is destructive to name */
220 212
221 for (cp = strtok (local_name, ","); cp; cp = strtok (NULL, ",")) 213 for (cp = strtok (local_name, ","); cp; cp = strtok (NULL, ","))
222 { 214 {
… …
274 retval = 15; 266 retval = 15;
275 else if (!strncasecmp (cp, query_base_name (op, 0), strlen (cp))) 267 else if (!strncasecmp (cp, query_base_name (op, 0), strlen (cp)))
276 retval = 14; 268 retval = 14;
277 else if (!strncasecmp (cp, query_base_name (op, 1), strlen (cp))) 269 else if (!strncasecmp (cp, query_base_name (op, 1), strlen (cp)))
278 retval = 14; 270 retval = 14;
279
280 /* Do substring checks, so things like 'Str+1' will match. 271 /* Do substring checks, so things like 'Str+1' will match.
281 * retval of these should perhaps be lower - they are lower 272 * retval of these should perhaps be lower - they are lower
282 * then the specific strcasecmp aboves, but still higher than 273 * then the specific strcasecmp aboves, but still higher than
283 * some other match criteria. 274 * some other match criteria.
284 */ 275 */
… …
286 retval = 12; 277 retval = 12;
287 else if (strstr (query_base_name (op, 0), cp)) 278 else if (strstr (query_base_name (op, 0), cp))
288 retval = 12; 279 retval = 12;
289 else if (strstr (query_short_name (op), cp)) 280 else if (strstr (query_short_name (op), cp))
290 retval = 12; 281 retval = 12;
291
292 /* Check against plural/non plural based on count. */ 282 /* Check against plural/non plural based on count. */
293 else if (count > 1 && !strcasecmp (cp, op->name_pl)) 283 else if (count > 1 && !strcasecmp (cp, op->name_pl))
294 {
295 retval = 6; 284 retval = 6;
296 }
297 else if (count == 1 && !strcasecmp (op->name, cp)) 285 else if (count == 1 && !strcasecmp (op->name, cp))
298 {
299 retval = 6; 286 retval = 6;
300 }
301 /* base name matched - not bad */ 287 /* base name matched - not bad */
302 else if (strcasecmp (cp, op->name) == 0 && !count) 288 else if (strcasecmp (cp, op->name) == 0 && !count)
303 retval = 4; 289 retval = 4;
304 /* Check for partial custom name, but give a real low priority */ 290 /* Check for partial custom name, but give a real low priority */
305 else if (op->custom_name && strstr (op->custom_name, cp)) 291 else if (op->custom_name && strstr (op->custom_name, cp))
… …
307 293
308 if (retval) 294 if (retval)
309 { 295 {
310 if (pl->type == PLAYER) 296 if (pl->type == PLAYER)
311 pl->contr->count = count; 297 pl->contr->count = count;
298
312 return retval; 299 return retval;
313 } 300 }
314 } 301 }
302
315 return 0; 303 return 0;
316} 304}
317 305
318/* 306/*
319 * Initialises the internal linked list of archetypes (read from file). 307 * Initialises the internal linked list of archetypes (read from file).
… …
324void 312void
325init_archetypes (void) 313init_archetypes (void)
326{ /* called from add_player() and edit() */ 314{ /* called from add_player() and edit() */
327 if (first_archetype != NULL) /* Only do this once */ 315 if (first_archetype != NULL) /* Only do this once */
328 return; 316 return;
317
329 arch_init = 1; 318 arch_init = 1;
330 load_archetypes (); 319 load_archetypes ();
331 arch_init = 0; 320 arch_init = 0;
332 empty_archetype = find_archetype ("empty_archetype"); 321 empty_archetype = archetype::find ("empty_archetype");
333 322
334/* init_blocksview();*/ 323/* init_blocksview();*/
335} 324}
336 325
337/* 326/*
… …
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;
… …
546 cp--; 498 cp--;
547 } 499 }
548 } 500 }
549 if (!strcmp ("Object", variable)) 501 if (!strcmp ("Object", variable))
550 { 502 {
551 if ((at = find_archetype (argument)) == NULL) 503 if ((at = archetype::find (argument)) == NULL)
552 LOG (llevError, "Warning: failed to find arch %s\n", argument); 504 LOG (llevError, "Warning: failed to find arch %s\n", argument);
553 } 505 }
554 else if (!strcmp ("other_arch", variable)) 506 else if (!strcmp ("other_arch", variable))
555 { 507 {
556 if (at != NULL && at->clone.other_arch == NULL) 508 if (at != NULL && at->clone.other_arch == NULL)
557 { 509 {
558 if ((other = find_archetype (argument)) == NULL) 510 if ((other = archetype::find (argument)) == NULL)
559 LOG (llevError, "Warning: failed to find other_arch %s\n", argument); 511 LOG (llevError, "Warning: failed to find other_arch %s\n", argument);
560 else if (at != NULL) 512 else if (at != NULL)
561 at->clone.other_arch = other; 513 at->clone.other_arch = other;
562 } 514 }
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 * 620 object *op;
681 op;
682 char
683 buf[MAX_BUF]; 621 char buf[MAX_BUF];
684 622
685 sprintf (buf, "%s (%s)", ARCH_SINGULARITY, name); 623 sprintf (buf, "%s (%s)", ARCH_SINGULARITY, name);
686 op = get_object (); 624 op = object::create ();
687 op->name = op->name_pl = buf; 625 op->name = op->name_pl = buf;
688 SET_FLAG (op, FLAG_NO_PICK); 626 SET_FLAG (op, FLAG_NO_PICK);
689 return op; 627 return op;
690} 628}
691 629
692/* 630/*
693 * Finds which archetype matches the given name, and returns a new 631 * Finds which archetype matches the given name, and returns a new
694 * object containing a copy of the archetype. 632 * object containing a copy of the archetype.
695 */ 633 */
696
697object * 634object *
698get_archetype (const char *name) 635get_archetype (const char *name)
699{ 636{
700 archetype * 637 archetype *at = archetype::find (name);
701 at;
702 638
703 at = find_archetype (name); 639 if (!at)
704 if (at == NULL)
705 return create_singularity (name); 640 return create_singularity (name);
706 641
707 return arch_to_object (at); 642 return arch_to_object (at);
708} 643}
709 644
… …
712 */ 647 */
713 648
714unsigned long 649unsigned long
715hasharch (const char *str, int tablesize) 650hasharch (const char *str, int tablesize)
716{ 651{
717 unsigned long 652 unsigned long hash = 0;
718 hash = 0;
719 unsigned int 653 unsigned int i = 0;
720 i = 0;
721 const char * 654 const char *p;
722 p;
723 655
724 /* use the one-at-a-time hash function, which supposedly is 656 /* use the one-at-a-time hash function, which supposedly is
725 * better than the djb2-like one used by perl5.005, but 657 * better than the djb2-like one used by perl5.005, but
726 * certainly is better then the bug used here before. 658 * certainly is better then the bug used here before.
727 * see http://burtleburtle.net/bob/hash/doobs.html 659 * see http://burtleburtle.net/bob/hash/doobs.html
… …
744 * Finds, using the hashtable, which archetype matches the given name. 676 * Finds, using the hashtable, which archetype matches the given name.
745 * returns a pointer to the found archetype, otherwise NULL. 677 * returns a pointer to the found archetype, otherwise NULL.
746 */ 678 */
747 679
748archetype * 680archetype *
749find_archetype (const char *name) 681archetype::find (const char *name)
750{ 682{
751#if USE_UNORDERED_MAP
752 name = shstr::find (name);
753
754 if (!name) 683 if (!name)
755 return 0; 684 return 0;
756 685
757 HT::const_iterator i = ht.find ((size_t) name); 686#if USE_UNORDERED_MAP
687 AUTODECL (i, ht.find ((size_t) name));
758 688
759 if (i == ht.end ()) 689 if (i == ht.end ())
760 return 0; 690 return 0;
761 else 691 else
762 return i->second; 692 return i->second;
763#endif 693#endif
764 694
765 archetype * 695 archetype *at;
766 at;
767 unsigned long 696 unsigned long index;
768 index;
769
770 if (name == NULL)
771 return (archetype *) NULL;
772 697
773 index = hasharch (name, ARCHTABLE); 698 index = hasharch (name, ARCHTABLE);
774 arch_search++; 699 arch_search++;
775 for (;;) 700 for (;;)
776 { 701 {
777 at = arch_table[index]; 702 at = arch_table[index];
703
778 if (at == NULL) 704 if (at == NULL)
779 { 705 {
780 if (warn_archetypes) 706 if (warn_archetypes)
781 LOG (llevError, "Couldn't find archetype %s\n", name); 707 LOG (llevError, "Couldn't find archetype %s\n", name);
708
782 return NULL; 709 return NULL;
783 } 710 }
711
784 arch_cmp++; 712 arch_cmp++;
713
785 if (!strcmp ((const char *) at->name, name)) 714 if (!strcmp ((const char *) at->name, name))
786 return at; 715 return at;
716
787 if (++index >= ARCHTABLE) 717 if (++index >= ARCHTABLE)
788 index = 0; 718 index = 0;
789 } 719 }
790} 720}
791 721
792/* 722/*
793 * Adds an archetype to the hashtable. 723 * Adds an archetype to the hashtable.
794 */ 724 */
795 725void
796static void 726archetype::hash_add ()
797add_arch (archetype *at)
798{ 727{
799#if USE_UNORDERED_MAP 728#if USE_UNORDERED_MAP
800 ht.insert (std::make_pair ((size_t) (const char *) at->name, at)); 729 ht.insert (std::make_pair ((size_t) (const char *) name, this));
801#endif 730#else
802 731
803 int
804 index = hasharch ((const char *) at->name, ARCHTABLE), org_index = index; 732 int index = hasharch ((const char *) name, ARCHTABLE), org_index = index;
805 733
806 for (;;) 734 for (;;)
807 { 735 {
808 if (arch_table[index] == NULL) 736 if (!arch_table[index])
809 { 737 {
810 arch_table[index] = at; 738 arch_table[index] = this;
811 return; 739 break;
812 } 740 }
813 741
814 if (++index == ARCHTABLE) 742 if (++index == ARCHTABLE)
815 index = 0; 743 index = 0;
816 744
817 if (index == org_index) 745 if (index == org_index)
818 fatal (ARCHTABLE_TOO_SMALL); 746 fatal (ARCHTABLE_TOO_SMALL);
819 } 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
820} 775}
821 776
822/* 777/*
823 * Returns the first archetype using the given type. 778 * Returns the first archetype using the given type.
824 * Used in treasure-generation. 779 * Used in treasure-generation.
825 */ 780 */
826 781
827archetype * 782archetype *
828type_to_archetype (int type) 783type_to_archetype (int type)
829{ 784{
830 archetype * 785 archetype *at;
831 at;
832 786
833 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)
834 if (at->clone.type == type) 788 if (at->clone.type == type)
835 return at; 789 return at;
790
836 return NULL; 791 return 0;
837} 792}
838 793
839/* 794/*
840 * Returns a new object copied from the first archetype matching 795 * Returns a new object copied from the first archetype matching
841 * the given type. 796 * the given type.
… …
843 */ 798 */
844 799
845object * 800object *
846clone_arch (int type) 801clone_arch (int type)
847{ 802{
848 archetype * 803 archetype *at;
849 at;
850 object *
851 op = get_object ();
852 804
853 if ((at = type_to_archetype (type)) == NULL) 805 if ((at = type_to_archetype (type)) == NULL)
854 { 806 {
855 LOG (llevError, "Can't clone archetype %d\n", type); 807 LOG (llevError, "Can't clone archetype %d\n", type);
856 free_object (op);
857 return NULL; 808 return 0;
858 } 809 }
859 copy_object (&at->clone, op); 810
811 object *op = at->clone.clone ();
860 op->instantiate (); 812 op->instantiate ();
861 return op; 813 return op;
862} 814}
863 815
864/* 816/*
… …
866 */ 818 */
867 819
868object * 820object *
869object_create_arch (archetype *at) 821object_create_arch (archetype *at)
870{ 822{
871 object * 823 object *op, *prev = 0, *head = 0;
872 op, *
873 prev = NULL, *head = NULL;
874 824
875 while (at) 825 while (at)
876 { 826 {
877 op = arch_to_object (at); 827 op = arch_to_object (at);
878 op->x = at->clone.x; 828 op->x = at->clone.x;
879 op->y = at->clone.y; 829 op->y = at->clone.y;
830
880 if (head) 831 if (head)
881 op->head = head, prev->more = op; 832 op->head = head, prev->more = op;
833
882 if (!head) 834 if (!head)
883 head = op; 835 head = op;
836
884 prev = op; 837 prev = op;
885 at = at->more; 838 at = at->more;
886 } 839 }
840
887 return (head); 841 return (head);
888} 842}
889 843
890/*** end of arch.c ***/

Diff Legend

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