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.14 by root, Fri Sep 8 17:14:07 2006 UTC vs.
Revision 1.23 by root, Thu Sep 14 23:13:48 2006 UTC

1/*
2 * static char *rcsid_arch_c =
3 * "$Id: arch.C,v 1.14 2006/09/08 17:14:07 root Exp $";
4 */
5
6/* 1/*
7 CrossFire, A Multiplayer game for X-windows 2 CrossFire, A Multiplayer game for X-windows
8 3
9 Copyright (C) 2002 Mark Wedel & Crossfire Development Team 4 Copyright (C) 2002 Mark Wedel & Crossfire Development Team
10 Copyright (C) 1992 Frank Tore Johansen 5 Copyright (C) 1992 Frank Tore Johansen
… …
21 16
22 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
23 along with this program; if not, write to the Free Software 18 along with this program; if not, write to the Free Software
24 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 19 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
25 20
26 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>
27*/ 22*/
28 23
29#include <cassert> 24#include <cassert>
30 25
31#include <tr1/unordered_map> 26#include <tr1/unordered_map>
… …
36#include <loader.h> 31#include <loader.h>
37 32
38/* IF set, does a little timing on the archetype load. */ 33/* IF set, does a little timing on the archetype load. */
39#define TIME_ARCH_LOAD 0 34#define TIME_ARCH_LOAD 0
40 35
41static void add_arch (archetype * at); 36static void add_arch (archetype *at);
42 37
43static archetype *arch_table[ARCHTABLE]; 38static archetype *arch_table[ARCHTABLE];
44int arch_cmp = 0; /* How many strcmp's */ 39int arch_cmp = 0; /* How many strcmp's */
45int arch_search = 0; /* How many searches */ 40int arch_search = 0; /* How many searches */
46int arch_init; /* True if doing arch initialization */ 41int arch_init; /* True if doing arch initialization */
… …
53 * MSW 2003-04-29 48 * MSW 2003-04-29
54 */ 49 */
55 50
56#if USE_UNORDERED_MAP 51#if USE_UNORDERED_MAP
57// the hashtable 52// the hashtable
58typedef std::tr1::unordered_map<size_t, archetype *> HT; 53typedef std::tr1::unordered_map
54 <
55 std::size_t,
56 archetype *,
57 std::hash<size_t>,
58 std::equal_to<size_t>,
59 slice_allocator< std::pair<const std::size_t, archetype *> >
60 true,
61 > HT;
59 62
60static HT ht; 63static HT ht;
61#endif 64#endif
62 65
63/** 66/**
… …
165 * but it otherwise had a big memory leak. 168 * but it otherwise had a big memory leak.
166 */ 169 */
167object * 170object *
168get_archetype_by_object_name (const char *name) 171get_archetype_by_object_name (const char *name)
169{ 172{
170 archetype * 173 archetype *at;
171 at;
172 char
173 tmpname[MAX_BUF]; 174 char tmpname[MAX_BUF];
174 int 175 int i;
175 i;
176 176
177 strncpy (tmpname, name, MAX_BUF - 1); 177 assign (tmpname, name);
178 tmpname[MAX_BUF - 1] = 0; 178
179 for (i = strlen (tmpname); i > 0; i--) 179 for (i = strlen (tmpname); i > 0; i--)
180 { 180 {
181 tmpname[i] = 0; 181 tmpname[i] = 0;
182 at = find_archetype_by_object_name (tmpname); 182 at = find_archetype_by_object_name (tmpname);
183
183 if (at != NULL) 184 if (at != NULL)
184 {
185 return arch_to_object (at); 185 return arch_to_object (at);
186 }
187 } 186 }
187
188 return create_singularity (name); 188 return create_singularity (name);
189} 189}
190 190
191 /* 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
192 * a string seperated lists of things to match, with certain keywords. 192 * a string seperated lists of things to match, with certain keywords.
… …
204 * If count is 1, make a quick check on the name. 204 * If count is 1, make a quick check on the name.
205 * IF count is >1, we need to make plural name. Return if match. 205 * IF count is >1, we need to make plural name. Return if match.
206 * Last, make a check on the full name. 206 * Last, make a check on the full name.
207 */ 207 */
208int 208int
209item_matched_string (object * pl, object * op, const char *name) 209item_matched_string (object *pl, object *op, const char *name)
210{ 210{
211 char *
212 cp,
213 local_name[MAX_BUF]; 211 char *cp, local_name[MAX_BUF];
214 int 212 int count, retval = 0;
215 count, 213
216 retval = 0;
217 strcpy (local_name, name); /* strtok is destructive to name */ 214 strcpy (local_name, name); /* strtok is destructive to name */
218 215
219 for (cp = strtok (local_name, ","); cp; cp = strtok (NULL, ",")) 216 for (cp = strtok (local_name, ","); cp; cp = strtok (NULL, ","))
220 { 217 {
221 while (cp[0] == ' ') 218 while (cp[0] == ' ')
… …
272 retval = 15; 269 retval = 15;
273 else if (!strncasecmp (cp, query_base_name (op, 0), strlen (cp))) 270 else if (!strncasecmp (cp, query_base_name (op, 0), strlen (cp)))
274 retval = 14; 271 retval = 14;
275 else if (!strncasecmp (cp, query_base_name (op, 1), strlen (cp))) 272 else if (!strncasecmp (cp, query_base_name (op, 1), strlen (cp)))
276 retval = 14; 273 retval = 14;
277
278 /* Do substring checks, so things like 'Str+1' will match. 274 /* Do substring checks, so things like 'Str+1' will match.
279 * retval of these should perhaps be lower - they are lower 275 * retval of these should perhaps be lower - they are lower
280 * then the specific strcasecmp aboves, but still higher than 276 * then the specific strcasecmp aboves, but still higher than
281 * some other match criteria. 277 * some other match criteria.
282 */ 278 */
… …
284 retval = 12; 280 retval = 12;
285 else if (strstr (query_base_name (op, 0), cp)) 281 else if (strstr (query_base_name (op, 0), cp))
286 retval = 12; 282 retval = 12;
287 else if (strstr (query_short_name (op), cp)) 283 else if (strstr (query_short_name (op), cp))
288 retval = 12; 284 retval = 12;
289
290 /* Check against plural/non plural based on count. */ 285 /* Check against plural/non plural based on count. */
291 else if (count > 1 && !strcasecmp (cp, op->name_pl)) 286 else if (count > 1 && !strcasecmp (cp, op->name_pl))
292 {
293 retval = 6; 287 retval = 6;
294 }
295 else if (count == 1 && !strcasecmp (op->name, cp)) 288 else if (count == 1 && !strcasecmp (op->name, cp))
296 {
297 retval = 6; 289 retval = 6;
298 }
299 /* base name matched - not bad */ 290 /* base name matched - not bad */
300 else if (strcasecmp (cp, op->name) == 0 && !count) 291 else if (strcasecmp (cp, op->name) == 0 && !count)
301 retval = 4; 292 retval = 4;
302 /* Check for partial custom name, but give a real low priority */ 293 /* Check for partial custom name, but give a real low priority */
303 else if (op->custom_name && strstr (op->custom_name, cp)) 294 else if (op->custom_name && strstr (op->custom_name, cp))
… …
305 296
306 if (retval) 297 if (retval)
307 { 298 {
308 if (pl->type == PLAYER) 299 if (pl->type == PLAYER)
309 pl->contr->count = count; 300 pl->contr->count = count;
301
310 return retval; 302 return retval;
311 } 303 }
312 } 304 }
305
313 return 0; 306 return 0;
314} 307}
315 308
316/* 309/*
317 * Initialises the internal linked list of archetypes (read from file). 310 * Initialises the internal linked list of archetypes (read from file).
… …
322void 315void
323init_archetypes (void) 316init_archetypes (void)
324{ /* called from add_player() and edit() */ 317{ /* called from add_player() and edit() */
325 if (first_archetype != NULL) /* Only do this once */ 318 if (first_archetype != NULL) /* Only do this once */
326 return; 319 return;
320
327 arch_init = 1; 321 arch_init = 1;
328 load_archetypes (); 322 load_archetypes ();
329 arch_init = 0; 323 arch_init = 0;
330 empty_archetype = find_archetype ("empty_archetype"); 324 empty_archetype = archetype::find ("empty_archetype");
325
331/* init_blocksview();*/ 326/* init_blocksview();*/
332} 327}
333 328
334/* 329/*
335 * Stores debug-information about how efficient the hashtable 330 * Stores debug-information about how efficient the hashtable
336 * used for archetypes has been in the static errmsg array. 331 * used for archetypes has been in the static errmsg array.
337 */ 332 */
338 333
339void 334void
340arch_info (object * op) 335arch_info (object *op)
341{ 336{
342 sprintf (errmsg, "%d searches and %d strcmp()'s", arch_search, arch_cmp); 337 sprintf (errmsg, "%d searches and %d strcmp()'s", arch_search, arch_cmp);
343 new_draw_info (NDI_BLACK, 0, op, errmsg); 338 new_draw_info (NDI_BLACK, 0, op, errmsg);
344} 339}
345 340
… …
373/* 368/*
374 * Dumps an archetype to debug-level output. 369 * Dumps an archetype to debug-level output.
375 */ 370 */
376 371
377void 372void
378dump_arch (archetype * at) 373dump_arch (archetype *at)
379{ 374{
380 dump_object (&at->clone); 375 dump_object (&at->clone);
381} 376}
382 377
383/* 378/*
… …
387 */ 382 */
388 383
389void 384void
390dump_all_archetypes (void) 385dump_all_archetypes (void)
391{ 386{
392 archetype * 387 archetype *at;
393 at; 388
394 for (at = first_archetype; at != NULL; at = (at->more == NULL) ? at->next : at->more) 389 for (at = first_archetype; at != NULL; at = (at->more == NULL) ? at->next : at->more)
395 { 390 {
396 dump_arch (at); 391 dump_arch (at);
397 fprintf (logfile, "%s\n", errmsg); 392 fprintf (logfile, "%s\n", errmsg);
398 } 393 }
399} 394}
400 395
401void 396void
402free_all_archs (void) 397free_all_archs (void)
403{ 398{
404 archetype * 399 archetype *at, *next;
405 at, *
406 next;
407 int
408 i = 0, f = 0; 400 int i = 0, f = 0;
409 401
410 for (at = first_archetype; at != NULL; at = next) 402 for (at = first_archetype; at != NULL; at = next)
411 { 403 {
412 if (at->more) 404 if (at->more)
413 next = at->more; 405 next = at->more;
414 else 406 else
415 next = at->next; 407 next = at->next;
416 408
417 delete 409 delete
418 at; 410 at;
411
419 i++; 412 i++;
420 } 413 }
421 LOG (llevDebug, "Freed %d archetypes, %d faces\n", i, f); 414 LOG (llevDebug, "Freed %d archetypes, %d faces\n", i, f);
422} 415}
423 416
424archetype::archetype () 417archetype::archetype ()
425{ 418{
426 clear_object (&clone); /* to initial state other also */ 419 clear_object (&clone); /* to initial state other also */
427 CLEAR_FLAG (&clone, FLAG_FREED); /* This shouldn't matter, since copy_object() */ 420 CLEAR_FLAG (&clone, FLAG_FREED); /* This shouldn't matter, since copy_object() */
428 SET_FLAG (&clone, FLAG_REMOVED); /* doesn't copy these flags... */ 421 SET_FLAG (&clone, FLAG_REMOVED); /* doesn't copy these flags... */
429} 422}
430 423
431archetype::~archetype () 424archetype::~archetype ()
432{ 425{
433} 426}
… …
454 */ 447 */
455 memcpy (&at->clone.body_used, &at->clone.body_info, sizeof (at->clone.body_info)); 448 memcpy (&at->clone.body_used, &at->clone.body_info, sizeof (at->clone.body_info));
456 449
457 switch (i) 450 switch (i)
458 { 451 {
459 case LL_NORMAL: /* A new archetype, just link it with the previous */ 452 case LL_NORMAL: /* A new archetype, just link it with the previous */
460 if (last_more != NULL) 453 if (last_more != NULL)
461 last_more->next = at; 454 last_more->next = at;
462 if (head != NULL) 455 if (head != NULL)
463 head->next = at; 456 head->next = at;
464 head = last_more = at; 457 head = last_more = at;
465#if 0 458#if 0
466 if (!op->type) 459 if (!op->type)
467 LOG (llevDebug, " WARNING: Archetype %s has no type info!\n", op->arch->name); 460 LOG (llevDebug, " WARNING: Archetype %s has no type info!\n", op->arch->name);
468#endif 461#endif
469 at->tail_x = 0; 462 at->tail_x = 0;
470 at->tail_y = 0; 463 at->tail_y = 0;
471 break; 464 break;
472 465
473 case LL_MORE: /* Another part of the previous archetype, link it correctly */ 466 case LL_MORE: /* Another part of the previous archetype, link it correctly */
474 467
475 at->head = head; 468 at->head = head;
476 at->clone.head = &head->clone; 469 at->clone.head = &head->clone;
477 if (last_more != NULL) 470 if (last_more != NULL)
478 { 471 {
479 last_more->more = at; 472 last_more->more = at;
480 last_more->clone.more = &at->clone; 473 last_more->clone.more = &at->clone;
481 } 474 }
482 last_more = at; 475 last_more = at;
483 476
484 /* If this multipart image is still composed of individual small 477 /* If this multipart image is still composed of individual small
485 * images, don't set the tail_.. values. We can't use them anyways, 478 * images, don't set the tail_.. values. We can't use them anyways,
486 * and setting these to zero makes the map sending to the client much 479 * and setting these to zero makes the map sending to the client much
487 * easier as just looking at the head, we know what to do. 480 * easier as just looking at the head, we know what to do.
488 */ 481 */
489 if (at->clone.face != head->clone.face) 482 if (at->clone.face != head->clone.face)
490 { 483 {
491 head->tail_x = 0; 484 head->tail_x = 0;
492 head->tail_y = 0; 485 head->tail_y = 0;
493 } 486 }
494 else 487 else
495 { 488 {
496 if (at->clone.x > head->tail_x) 489 if (at->clone.x > head->tail_x)
497 head->tail_x = at->clone.x; 490 head->tail_x = at->clone.x;
498 if (at->clone.y > head->tail_y) 491 if (at->clone.y > head->tail_y)
499 head->tail_y = at->clone.y; 492 head->tail_y = at->clone.y;
500 } 493 }
501 break; 494 break;
502 495
503 } 496 }
504 497
505 at = new archetype; 498 at = new archetype;
499
506 at->clone.arch = at; 500 at->clone.arch = at;
507 } 501 }
508 502
509 delete at; 503 delete at;
510} 504}
… …
534 cp--; 528 cp--;
535 } 529 }
536 } 530 }
537 if (!strcmp ("Object", variable)) 531 if (!strcmp ("Object", variable))
538 { 532 {
539 if ((at = find_archetype (argument)) == NULL) 533 if ((at = archetype::find (argument)) == NULL)
540 LOG (llevError, "Warning: failed to find arch %s\n", argument); 534 LOG (llevError, "Warning: failed to find arch %s\n", argument);
541 } 535 }
542 else if (!strcmp ("other_arch", variable)) 536 else if (!strcmp ("other_arch", variable))
543 { 537 {
544 if (at != NULL && at->clone.other_arch == NULL) 538 if (at != NULL && at->clone.other_arch == NULL)
545 { 539 {
546 if ((other = find_archetype (argument)) == NULL) 540 if ((other = archetype::find (argument)) == NULL)
547 LOG (llevError, "Warning: failed to find other_arch %s\n", argument); 541 LOG (llevError, "Warning: failed to find other_arch %s\n", argument);
548 else if (at != NULL) 542 else if (at != NULL)
549 at->clone.other_arch = other; 543 at->clone.other_arch = other;
550 } 544 }
551 } 545 }
… …
553 { 547 {
554 if (at != NULL) 548 if (at != NULL)
555 { 549 {
556 treasurelist * 550 treasurelist *
557 tl = find_treasurelist (argument); 551 tl = find_treasurelist (argument);
552
558 if (tl == NULL) 553 if (tl == NULL)
559 LOG (llevError, "Failed to link treasure to arch (%s): %s\n", &at->name, argument); 554 LOG (llevError, "Failed to link treasure to arch (%s): %s\n", &at->name, argument);
560 else 555 else
561 at->clone.randomitems = tl; 556 at->clone.randomitems = tl;
562 } 557 }
… …
566 561
567#ifdef DEBUG 562#ifdef DEBUG
568void 563void
569check_generators (void) 564check_generators (void)
570{ 565{
571 archetype * 566 archetype *at;
572 at; 567
573 for (at = first_archetype; at != NULL; at = at->next) 568 for (at = first_archetype; at != NULL; at = at->next)
574 if (QUERY_FLAG (&at->clone, FLAG_GENERATOR) && at->clone.other_arch == NULL) 569 if (QUERY_FLAG (&at->clone, FLAG_GENERATOR) && at->clone.other_arch == NULL)
575 LOG (llevError, "Warning: %s is generator but lacks other_arch.\n", &at->name); 570 LOG (llevError, "Warning: %s is generator but lacks other_arch.\n", &at->name);
576} 571}
577#endif 572#endif
… …
584 */ 579 */
585 580
586void 581void
587load_archetypes (void) 582load_archetypes (void)
588{ 583{
589 char
590 filename[MAX_BUF]; 584 char filename[MAX_BUF];
585
591#if TIME_ARCH_LOAD 586#if TIME_ARCH_LOAD
592 struct timeval 587 struct timeval
593 tv1, 588 tv1,
594 tv2; 589 tv2;
595#endif 590#endif
… …
630 * Creates and returns a new object which is a copy of the given archetype. 625 * Creates and returns a new object which is a copy of the given archetype.
631 * This function returns NULL on failure. 626 * This function returns NULL on failure.
632 */ 627 */
633 628
634object * 629object *
635arch_to_object (archetype * at) 630arch_to_object (archetype *at)
636{ 631{
637 object * 632 object *op;
638 op; 633
639 if (at == NULL) 634 if (at == NULL)
640 { 635 {
641 if (warn_archetypes) 636 if (warn_archetypes)
642 LOG (llevError, "Couldn't find archetype.\n"); 637 LOG (llevError, "Couldn't find archetype.\n");
638
643 return NULL; 639 return NULL;
644 } 640 }
641
645 op = get_object (); 642 op = get_object ();
646 copy_object (&at->clone, op); 643 copy_object (&at->clone, op);
644 op->arch = at;
647 op->instantiate (); 645 op->instantiate ();
648 op->arch = at;
649 return op; 646 return op;
650} 647}
651 648
652/* 649/*
653 * Creates an object. This function is called by get_archetype() 650 * Creates an object. This function is called by get_archetype()
… …
659object * 656object *
660create_singularity (const char *name) 657create_singularity (const char *name)
661{ 658{
662 object *op; 659 object *op;
663 char buf[MAX_BUF]; 660 char buf[MAX_BUF];
661
664 sprintf (buf, "%s (%s)", ARCH_SINGULARITY, name); 662 sprintf (buf, "%s (%s)", ARCH_SINGULARITY, name);
665 op = get_object (); 663 op = get_object ();
666 op->name = op->name_pl = buf; 664 op->name = op->name_pl = buf;
667 SET_FLAG (op, FLAG_NO_PICK); 665 SET_FLAG (op, FLAG_NO_PICK);
668 return op; 666 return op;
… …
674 */ 672 */
675 673
676object * 674object *
677get_archetype (const char *name) 675get_archetype (const char *name)
678{ 676{
679 archetype *at; 677 archetype *at = archetype::find (name);
680 at = find_archetype (name); 678
681 if (at == NULL) 679 if (!at)
682 return create_singularity (name); 680 return create_singularity (name);
681
683 return arch_to_object (at); 682 return arch_to_object (at);
684} 683}
685 684
686/* 685/*
687 * Hash-function used by the arch-hashtable. 686 * Hash-function used by the arch-hashtable.
… …
717 * Finds, using the hashtable, which archetype matches the given name. 716 * Finds, using the hashtable, which archetype matches the given name.
718 * returns a pointer to the found archetype, otherwise NULL. 717 * returns a pointer to the found archetype, otherwise NULL.
719 */ 718 */
720 719
721archetype * 720archetype *
722find_archetype (const char *name) 721archetype::find (const char *name)
723{ 722{
724#if USE_UNORDERED_MAP
725 name = shstr::find (name);
726
727 if (!name) 723 if (!name)
728 return 0; 724 return 0;
729 725
730 HT::const_iterator i = ht.find ((size_t)name); 726#if USE_UNORDERED_MAP
727 AUTODECL (i, ht.find ((size_t) name));
731 728
732 if (i == ht.end ()) 729 if (i == ht.end ())
733 return 0; 730 return 0;
734 else 731 else
735 return i->second; 732 return i->second;
736#endif 733#endif
737 734
738 archetype *at; 735 archetype *at;
739 unsigned long index; 736 unsigned long index;
740 737
741 if (name == NULL)
742 return (archetype *) NULL;
743
744 index = hasharch (name, ARCHTABLE); 738 index = hasharch (name, ARCHTABLE);
745 arch_search++; 739 arch_search++;
746 for (;;) 740 for (;;)
747 { 741 {
748 at = arch_table[index]; 742 at = arch_table[index];
743
749 if (at == NULL) 744 if (at == NULL)
750 { 745 {
751 if (warn_archetypes) 746 if (warn_archetypes)
752 LOG (llevError, "Couldn't find archetype %s\n", name); 747 LOG (llevError, "Couldn't find archetype %s\n", name);
748
753 return NULL; 749 return NULL;
754 } 750 }
751
755 arch_cmp++; 752 arch_cmp++;
753
756 if (!strcmp ((const char *) at->name, name)) 754 if (!strcmp ((const char *) at->name, name))
757 return at; 755 return at;
756
758 if (++index >= ARCHTABLE) 757 if (++index >= ARCHTABLE)
759 index = 0; 758 index = 0;
760 } 759 }
761} 760}
762 761
… …
766 765
767static void 766static void
768add_arch (archetype *at) 767add_arch (archetype *at)
769{ 768{
770#if USE_UNORDERED_MAP 769#if USE_UNORDERED_MAP
771 ht.insert (std::make_pair ((size_t)(const char *)at->name, at)); 770 ht.insert (std::make_pair ((size_t) (const char *) at->name, at));
772#endif 771#endif
773 772
774 int index = hasharch ((const char *) at->name, ARCHTABLE), org_index = index; 773 int index = hasharch ((const char *) at->name, ARCHTABLE), org_index = index;
775 774
776 for (;;) 775 for (;;)
… …
795 */ 794 */
796 795
797archetype * 796archetype *
798type_to_archetype (int type) 797type_to_archetype (int type)
799{ 798{
800 archetype * 799 archetype *at;
801 at;
802 800
803 for (at = first_archetype; at != NULL; at = (at->more == NULL) ? at->next : at->more) 801 for (at = first_archetype; at; at = at->more == 0 ? at->next : at->more)
804 if (at->clone.type == type) 802 if (at->clone.type == type)
805 return at; 803 return at;
804
806 return NULL; 805 return 0;
807} 806}
808 807
809/* 808/*
810 * Returns a new object copied from the first archetype matching 809 * Returns a new object copied from the first archetype matching
811 * the given type. 810 * the given type.
… …
813 */ 812 */
814 813
815object * 814object *
816clone_arch (int type) 815clone_arch (int type)
817{ 816{
818 archetype * 817 archetype *at;
819 at;
820 object *
821 op = get_object (); 818 object *op = get_object ();
822 819
823 if ((at = type_to_archetype (type)) == NULL) 820 if ((at = type_to_archetype (type)) == NULL)
824 { 821 {
825 LOG (llevError, "Can't clone archetype %d\n", type); 822 LOG (llevError, "Can't clone archetype %d\n", type);
826 free_object (op); 823 free_object (op);
827 return NULL; 824 return NULL;
828 } 825 }
826
829 copy_object (&at->clone, op); 827 copy_object (&at->clone, op);
830 op->instantiate (); 828 op->instantiate ();
831 return op; 829 return op;
832} 830}
833 831
834/* 832/*
835 * member: make instance from class 833 * member: make instance from class
836 */ 834 */
837 835
838object * 836object *
839object_create_arch (archetype * at) 837object_create_arch (archetype *at)
840{ 838{
841 object * 839 object *op, *prev = 0, *head = 0;
842 op, *
843 prev = NULL, *head = NULL;
844 840
845 while (at) 841 while (at)
846 { 842 {
847 op = arch_to_object (at); 843 op = arch_to_object (at);
848 op->x = at->clone.x; 844 op->x = at->clone.x;
849 op->y = at->clone.y; 845 op->y = at->clone.y;
846
850 if (head) 847 if (head)
851 op->head = head, prev->more = op; 848 op->head = head, prev->more = op;
849
852 if (!head) 850 if (!head)
853 head = op; 851 head = op;
852
854 prev = op; 853 prev = op;
855 at = at->more; 854 at = at->more;
856 } 855 }
856
857 return (head); 857 return (head);
858} 858}
859 859
860/*** end of arch.c ***/

Diff Legend

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