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.16 by root, Sun Sep 10 16:00:23 2006 UTC vs.
Revision 1.26 by root, Fri Nov 17 19:40:53 2006 UTC

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

Diff Legend

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