ViewVC Help
View File | Revision Log | Show Annotations | Download File
/cvs/deliantra/server/common/loader.C
(Generate patch)

Comparing deliantra/server/common/loader.C (file contents):
Revision 1.13 by root, Mon Sep 11 20:28:37 2006 UTC vs.
Revision 1.22 by root, Tue Dec 12 21:39:56 2006 UTC

1
2/* 1/*
3 CrossFire, A Multiplayer game for X-windows 2 CrossFire, A Multiplayer game for X-windows
4 3
5 Copyright (C) 2002 Mark Wedel & Crossfire Development Team 4 Copyright (C) 2002 Mark Wedel & Crossfire Development Team
6 Copyright (C) 1992 Frank Tore Johansen 5 Copyright (C) 1992 Frank Tore Johansen
… …
17 16
18 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
19 along with this program; if not, write to the Free Software 18 along with this program; if not, write to the Free Software
20 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 19 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
21 20
22 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>
23*/ 22*/
24 23
25/* Eneq(@csd.uu.se): Added weight-modifiers in environment of objects. 24/* Eneq(@csd.uu.se): Added weight-modifiers in environment of objects.
26 sub/add_weight will transcend the environment updating the carrying 25 sub/add_weight will transcend the environment updating the carrying
27 variable. */ 26 variable. */
… …
255 NULL 254 NULL
256}; 255};
257 256
258extern int arch_init; 257extern int arch_init;
259 258
260// return a suitable strign describign an objetc in enough detail to find it
261// used only in check_loaded_object: TODO remove static, move it elsewhere and
262// use it in more log messages.
263static char *
264op_debug_info_ (object *op, char *info)
265{
266 char info2[256 * 3];
267 char *p = info;
268
269 p += snprintf (p, 256, "%d=\"%s%s%s\"",
270 op->count, op->name ? (const char *) op->name : "(anon)", op->title ? " " : "", op->title ? (const char *) op->title : "");
271
272 if (op->env)
273 p += snprintf (p, 256, "(in %s)", op_debug_info_ (op->env, info2));
274
275 if (op->map)
276 p += snprintf (p, 256, "(on %s@%d+%d)", op->map->path, op->x, op->y);
277
278 return info;
279}
280
281static char *
282op_debug_info (object *op)
283{
284 static char info[256 * 3];
285
286 return op_debug_info_ (op, info);
287}
288
289/* This function checks the object after it has been loaded (when we 259/* This function checks the object after it has been loaded (when we
290 * get the 'end' in the input stream). This function can be used to 260 * get the 'end' in the input stream). This function can be used to
291 * deal with legacy objects where fields may have changed. It can also be used 261 * deal with legacy objects where fields may have changed. It can also be used
292 * to check for objects to make sure there are no common errors. 262 * to check for objects to make sure there are no common errors.
293 */ 263 */
… …
326 */ 296 */
327 if ((op->type == WEAPON || op->type == BOW) && arch_init) 297 if ((op->type == WEAPON || op->type == BOW) && arch_init)
328 { 298 {
329 if (!op->skill) 299 if (!op->skill)
330 { 300 {
331 LOG (llevError, "Weapon %s lacks a skill.\n", op_debug_info (op)); 301 LOG (llevError, "Weapon %s lacks a skill.\n", op->debug_desc ());
332 } 302 }
333 else if ((!strcmp (op->skill, "one handed weapons") && op->body_info[1] != -1) || 303 else if ((!strcmp (op->skill, "one handed weapons") && op->body_info[1] != -1) ||
334 (!strcmp (op->skill, "two handed weapons") && op->body_info[1] != -2)) 304 (!strcmp (op->skill, "two handed weapons") && op->body_info[1] != -2))
335 { 305 {
336 LOG (llevError, "weapon %s arm usage does not match skill: %d, %s\n", op_debug_info (op), op->body_info[1], &op->skill); 306 LOG (llevError, "weapon %s arm usage does not match skill: %d, %s\n", op->debug_desc (), op->body_info[1], &op->skill);
337 } 307 }
338 } 308 }
339 309
340 /* We changed last_heal to gen_sp_armour, which is what it 310 /* We changed last_heal to gen_sp_armour, which is what it
341 * really does for many objects. Need to catch any in maps 311 * really does for many objects. Need to catch any in maps
… …
347 (op->type == BOOTS) || (op->type == GLOVES) || 317 (op->type == BOOTS) || (op->type == GLOVES) ||
348 (op->type == AMULET) || (op->type == GIRDLE) || (op->type == BRACERS) || (op->type == CLOAK)) 318 (op->type == AMULET) || (op->type == GIRDLE) || (op->type == BRACERS) || (op->type == CLOAK))
349 { 319 {
350 if (op->last_heal) 320 if (op->last_heal)
351 { 321 {
352 LOG (llevDebug, "Object %s still has last_heal set, not gen_sp_armour\n", op_debug_info (op)); 322 LOG (llevDebug, "Object %s still has last_heal set, not gen_sp_armour\n", op->debug_desc ());
353 op->gen_sp_armour = op->last_heal; 323 op->gen_sp_armour = op->last_heal;
354 op->last_heal = 0; 324 op->last_heal = 0;
355 } 325 }
356 if (editor) 326 if (editor)
357 ip = 0; 327 ip = 0;
… …
360 /* Legacy objects from before item power was in the game */ 330 /* Legacy objects from before item power was in the game */
361 if (!op->item_power && ip) 331 if (!op->item_power && ip)
362 { 332 {
363 if (ip > 3) 333 if (ip > 3)
364 { 334 {
365 LOG (llevDebug, "Object %s had no item power, using %d\n", op_debug_info (op), ip); 335 LOG (llevDebug, "Object %s had no item power, using %d\n", op->debug_desc (), ip);
366 } 336 }
367 op->item_power = ip; 337 op->item_power = ip;
368 } 338 }
369 /* Check for possibly bogus values. Has to meet both these criteria - 339 /* Check for possibly bogus values. Has to meet both these criteria -
370 * something that has item_power 1 is probably just fine if our calculated 340 * something that has item_power 1 is probably just fine if our calculated
… …
372 * similarly, it item_power is 0, the first check will always pass, 342 * similarly, it item_power is 0, the first check will always pass,
373 * but not the second one. 343 * but not the second one.
374 */ 344 */
375 if (ip > 2 * op->item_power && ip > (op->item_power + 3)) 345 if (ip > 2 * op->item_power && ip > (op->item_power + 3))
376 { 346 {
377 LOG (llevDebug, "Object %s seems to have too low item power? %d > %d\n", op_debug_info (op), ip, op->item_power); 347 LOG (llevDebug, "Object %s seems to have too low item power? %d > %d\n", op->debug_desc (), ip, op->item_power);
378 } 348 }
379 349
380 } 350 }
381 /* Old spellcasting object - need to load in the appropiate object */ 351 /* Old spellcasting object - need to load in the appropiate object */
382 if ((op->type == ROD || op->type == WAND || op->type == SCROLL || op->type == HORN || op->type == FIREWALL || 352 if ((op->type == ROD || op->type == WAND || op->type == SCROLL || op->type == HORN || op->type == FIREWALL ||
… …
406 } 376 }
407 377
408 if (QUERY_FLAG (op, FLAG_MONSTER)) 378 if (QUERY_FLAG (op, FLAG_MONSTER))
409 { 379 {
410 if (op->stats.hp > op->stats.maxhp) 380 if (op->stats.hp > op->stats.maxhp)
411 LOG (llevDebug, "Monster %s has hp set higher than maxhp (%d>%d)\n", op_debug_info (op), op->stats.hp, op->stats.maxhp); 381 LOG (llevDebug, "Monster %s has hp set higher than maxhp (%d>%d)\n", op->debug_desc (), op->stats.hp, op->stats.maxhp);
412 382
413 /* The archs just need to be updated for this */ 383 /* The archs just need to be updated for this */
414 if (op->move_type == 0) 384 if (op->move_type == 0)
415 op->move_type = MOVE_WALK; 385 op->move_type = MOVE_WALK;
416 } 386 }
387
417 if ((QUERY_FLAG (op, FLAG_GENERATOR) && QUERY_FLAG (op, FLAG_CONTENT_ON_GEN)) || op->type == CREATOR || op->type == CONVERTER) 388 if ((QUERY_FLAG (op, FLAG_GENERATOR) && QUERY_FLAG (op, FLAG_CONTENT_ON_GEN)) || op->type == CREATOR || op->type == CONVERTER)
418 { 389 {
419 /* Object will duplicate it's content as part of the 390 /* Object will duplicate it's content as part of the
420 * generation process. To do this, we must flag inventory 391 * generation process. To do this, we must flag inventory
421 * so it remains unevaluated concerning the randomitems and 392 * so it remains unevaluated concerning the randomitems and
… …
528 { 499 {
529 keyword kw = thawer.get_kv (); 500 keyword kw = thawer.get_kv ();
530 501
531 switch (kw) 502 switch (kw)
532 { 503 {
533 case KW_Object: // uppercase alias 504 case KW_Object: // uppercase alias
534 case KW_object: 505 case KW_object:
535 thawer.get (op->name); 506 thawer.get (op->name);
536 507
537 if (op->arch != NULL) 508 if (op->arch != NULL)
538 op->arch->name = op->name; 509 op->arch->name = op->name;
539 510
540 break; 511 break;
541 512
542 case KW_oid: 513 case KW_uuid:
543 thawer.get (op, thawer.get_sint32 ()); 514 if (const char *s = thawer.get_str ())
544 break;
545
546 case KW_name:
547 thawer.get (op->name);
548 break;
549 case KW_name_pl:
550 thawer.get (op->name_pl);
551 break;
552 case KW_title:
553 thawer.get (op->title);
554 break;
555 case KW_custom_name:
556 thawer.get (op->custom_name);
557 break;
558 case KW_attach:
559 thawer.get_ornull (op->attach);
560 break;
561 case KW_skill:
562 thawer.get_ornull (op->skill);
563 break;
564 case KW_race:
565 thawer.get_ornull (op->race);
566 break;
567 case KW_slaying:
568 thawer.get_ornull (op->slaying);
569 break;
570
571 case KW_arch:
572 { 515 {
573 const char *str = thawer.get_str (); 516 unsigned int version;
517 unsigned long long seq;
574 518
575 if (op->arch) 519 if (2 == sscanf (s, "<%d.%llx>", &version, &seq) && version == 1)
576 { 520 {
577 /* If op->arch has been set, then this new object 521 op->uuid.seq = seq;
578 * must be part of the inventory. So process
579 * appropriately.
580 */
581 archetype *arch = find_archetype (str);
582
583 object *tmp;
584
585 if (arch != NULL)
586 tmp = arch_to_object (arch);
587 else 522 break;
588 {
589 tmp = get_object ();
590 /* record the name of the broken object */
591 tmp->name = str;
592 }
593
594 parse_object (tmp, thawer, map_flags);
595
596 if (tmp->arch)
597 {
598 // was: insert_ob_in_ob (tmp, op);
599 // but manually adding it can improve map loading times a lot
600 // also, appending instead of prepending keeps the
601 // save ordering the same between repeated load/saves.
602 CLEAR_FLAG (tmp, FLAG_OBJ_ORIGINAL);
603 CLEAR_FLAG (tmp, FLAG_REMOVED);
604
605 if (!op_inv)
606 {
607 op->inv = tmp;
608 tmp->above = 0;
609 }
610 else
611 {
612 while (op_inv->below)
613 op_inv = op_inv->below;
614
615 op_inv->below = tmp;
616 tmp->above = op_inv;
617 }
618
619 tmp->below = 0;
620 tmp->env = op;
621 op_inv = tmp;
622 }
623 else
624 {
625 LOG (llevDebug, "Discarding object without arch: %s\n", tmp->name ? (const char *) tmp->name : "(null)");
626 free_object (tmp);
627 }
628 }
629 else
630 {
631 /* This is the actual archetype definition then */
632 op->arch = find_archetype (str);
633
634 if (op->arch != NULL)
635 copy_object (&op->arch->clone, op);
636 else if (!arch_init)
637 /* record the name of the broken object */
638 op->name = str;
639 } 523 }
640 } 524 }
525
526 op->uuid = gen_uuid ();
641 break; 527 break;
642 528
643 case KW_other_arch: 529 case KW_oid:
644 op->other_arch = find_archetype (thawer.get_str ()); 530 thawer.get (op, thawer.get_sint32 ());
645 break; 531 break;
646 532
533 case KW_name: thawer.get (op->name); break;
534 case KW_name_pl: thawer.get (op->name_pl); break;
535 case KW_title: thawer.get (op->title); break;
536 case KW_custom_name: thawer.get (op->custom_name); break;
537
538 case KW_attach: thawer.get_ornull (op->attach); break;
539 case KW_skill: thawer.get_ornull (op->skill); break;
540 case KW_race: thawer.get_ornull (op->race); break;
541 case KW_slaying: thawer.get_ornull (op->slaying); break;
542
647 case KW_animation: 543 case KW_arch:
648 { 544 {
649 const char *str = thawer.get_str (); 545 const char *str = thawer.get_str ();
650 546
651 if (!str) 547 if (op->arch)
652 {
653 op->animation_id = 0;
654 CLEAR_FLAG (op, FLAG_ANIMATE);
655 }
656 else
657 {
658 op->animation_id = find_animation (str);
659 SET_FLAG (op, FLAG_ANIMATE);
660 }
661 }
662
663 break;
664
665 case KW_last_heal:
666 thawer.get (op->last_heal);
667 break;
668 case KW_last_sp:
669 thawer.get (op->last_sp);
670 break;
671 case KW_last_grace:
672 thawer.get (op->last_grace);
673 break;
674 case KW_last_eat:
675 thawer.get (op->last_eat);
676 break;
677 case KW_speed_left:
678 thawer.get (op->speed_left);
679 break;
680
681 case KW_speed:
682 thawer.get (op->speed);
683
684 //TODO: maybe do in check_object
685 if (!(map_flags & MAP_STYLE))
686 { 548 {
687 if (op->speed < 0) 549 /* If op->arch has been set, then this new object
688 op->speed_left = op->speed_left - RANDOM () % 100 / 100.0; 550 * must be part of the inventory. So process
689 551 * appropriately.
690 update_ob_speed (op);
691 } 552 */
553 archetype *arch = archetype::find (str);
692 554
693 break; 555 object *tmp;
694 556
695 case KW_slow_move: 557 if (arch != NULL)
696 op->move_slow |= MOVE_WALK; 558 tmp = arch_to_object (arch);
697 thawer.get (op->move_slow_penalty);
698 break;
699
700 case KW_face:
701 op->face = &new_faces[FindFace (thawer.get_str (), 0)];
702 break;
703
704 case KW_x:
705 thawer.get (op->x);
706 break;
707 case KW_y:
708 thawer.get (op->y);
709 break;
710 case KW_Str: // uppercase alias
711 case KW_str:
712 thawer.get (op->stats.Str);
713 break;
714 case KW_Dex: // uppercase alias
715 case KW_dex:
716 thawer.get (op->stats.Dex);
717 break;
718 case KW_Con: // uppercase alias
719 case KW_con:
720 thawer.get (op->stats.Con);
721 break;
722 case KW_Wis: // uppercase alias
723 case KW_wis:
724 thawer.get (op->stats.Wis);
725 break;
726 case KW_Cha: // uppercase alias
727 case KW_cha:
728 thawer.get (op->stats.Cha);
729 break;
730 case KW_Int: // uppercase alias
731 case KW_int:
732 thawer.get (op->stats.Int);
733 break;
734 case KW_Pow: // uppercase alias
735 case KW_pow:
736 thawer.get (op->stats.Pow);
737 break;
738 case KW_hp:
739 thawer.get (op->stats.hp);
740 break;
741 case KW_maxhp:
742 thawer.get (op->stats.maxhp);
743 break;
744 case KW_sp:
745 thawer.get (op->stats.sp);
746 break;
747 case KW_maxsp:
748 thawer.get (op->stats.maxsp);
749 break;
750 case KW_grace:
751 thawer.get (op->stats.grace);
752 break;
753 case KW_maxgrace:
754 thawer.get (op->stats.maxgrace);
755 break;
756
757 case KW_exp:
758 thawer.get (op->stats.exp);
759 break;
760 case KW_perm_exp:
761 thawer.get (op->perm_exp);
762 break;
763 case KW_food:
764 thawer.get (op->stats.food);
765 break;
766 case KW_dam:
767 thawer.get (op->stats.dam);
768 break;
769 case KW_wc:
770 thawer.get (op->stats.wc);
771 break;
772 case KW_ac:
773 thawer.get (op->stats.ac);
774 break;
775 case KW_nrof:
776 thawer.get (op->nrof);
777 break;
778 case KW_level:
779 thawer.get (op->level);
780 break;
781 case KW_direction:
782 thawer.get (op->direction);
783 break;
784 case KW_type:
785 thawer.get (op->type);
786 break;
787 case KW_subtype:
788 thawer.get (op->subtype);
789 break;
790 case KW_value:
791 thawer.get (op->value);
792 break;
793 case KW_weight:
794 thawer.get (op->weight);
795 break;
796 case KW_carrying:
797 thawer.get (op->carrying);
798 break;
799 case KW_attacktype:
800 thawer.get (op->attacktype);
801 break;
802 case KW_path_attuned:
803 thawer.get (op->path_attuned);
804 break;
805 case KW_path_repelled:
806 thawer.get (op->path_repelled);
807 break;
808 case KW_path_denied:
809 thawer.get (op->path_denied);
810 break;
811 case KW_invisible:
812 thawer.get (op->invisible);
813 break;
814 case KW_magic:
815 thawer.get (op->magic);
816 break;
817 case KW_state:
818 thawer.get (op->state);
819 break;
820 case KW_move_slow_penalty:
821 thawer.get (op->move_slow_penalty);
822 break;
823 case KW_material:
824 thawer.get (op->material);
825 break;
826 case KW_materialname:
827 thawer.get (op->materialname);
828 break;
829
830 /* These are the new values */
831 case KW_move_block:
832 set_move (op->move_block, thawer.get_str ());
833 break;
834 case KW_move_allow:
835 set_move (op->move_allow, thawer.get_str ());
836 break;
837 case KW_move_type:
838 set_move (op->move_type, thawer.get_str ());
839 break;
840 case KW_move_on:
841 set_move (op->move_on, thawer.get_str ());
842 break;
843 case KW_move_off:
844 set_move (op->move_off, thawer.get_str ());
845 break;
846 case KW_move_slow:
847 set_move (op->move_slow, thawer.get_str ());
848 break;
849
850 /* These are all legacy - any new objects should use the move_ .. values */
851 case KW_no_pass:
852 {
853 if (thawer.get_sint32 ())
854 op->move_block = MOVE_ALL;
855 else 559 else
856 op->move_block = 0;
857 }
858
859 break;
860
861 /* These are all legacy - any new objects should use the move_ .. values */
862 case KW_walk_on:
863 { 560 {
864 if (thawer.get_sint32 ()) 561 tmp = object::create ();
865 op->move_on |= MOVE_WALK; 562 /* record the name of the broken object */
563 tmp->name = str;
564 }
565
566 parse_object (tmp, thawer, map_flags);
567
568 if (tmp->arch)
569 {
570 // was: insert_ob_in_ob (tmp, op);
571 // but manually adding it can improve map loading times a lot
572 // also, appending instead of prepending keeps the
573 // save ordering the same between repeated load/saves.
574 CLEAR_FLAG (tmp, FLAG_OBJ_ORIGINAL);
575 CLEAR_FLAG (tmp, FLAG_REMOVED);
576
577 if (!op_inv)
578 {
579 op->inv = tmp;
580 tmp->above = 0;
581 }
582 else
583 {
584 while (op_inv->below)
585 op_inv = op_inv->below;
586
587 op_inv->below = tmp;
588 tmp->above = op_inv;
589 }
590
591 tmp->below = 0;
592 tmp->env = op;
593 op_inv = tmp;
594 }
866 else 595 else
867 op->move_on &= ~MOVE_WALK;
868 }
869
870 break;
871
872 /* These are all legacy - any new objects should use the move_ .. values */
873 case KW_walk_off:
874 {
875 if (thawer.get_sint32 ())
876 op->move_off |= MOVE_WALK;
877 else
878 op->move_off &= ~MOVE_WALK;
879 }
880 break;
881
882 /* These are all legacy - any new objects should use the move_ .. values */
883 case KW_fly_on:
884 {
885 if (thawer.get_sint32 ())
886 op->move_on |= MOVE_FLY_LOW;
887 else
888 op->move_on &= ~MOVE_FLY_LOW;
889 }
890 break;
891
892 /* These are all legacy - any new objects should use the move_ .. values */
893 case KW_fly_off:
894 {
895 if (thawer.get_sint32 ())
896 op->move_off |= MOVE_FLY_LOW;
897 else
898 op->move_off &= ~MOVE_FLY_LOW;
899 }
900 break;
901
902 //TODO: remove these after convertign archetypes
903 case KW_can_use_wand:
904 GET_FLAG (op, FLAG_USE_RANGE);
905 break;
906
907 /* These are all legacy - any new objects should use the move_ .. values */
908 case KW_flying:
909 {
910 if (thawer.get_sint32 ())
911 op->move_type |= MOVE_FLY_LOW;
912 else
913 op->move_type &= ~MOVE_FLY_LOW;
914 }
915 break;
916
917
918 case KW_identified:
919 GET_FLAG (op, FLAG_IDENTIFIED);
920 //TODO: move to check_object or so
921 if (QUERY_FLAG (op, FLAG_IDENTIFIED))
922 CLEAR_FLAG (op, FLAG_KNOWN_MAGICAL);
923
924 break;
925
926 case KW_wiz:
927 GET_FLAG (op, FLAG_WIZ);
928 //TODO: move to check_object
929 if (QUERY_FLAG (op, FLAG_WIZ))
930 { 596 {
931 SET_FLAG (op, FLAG_WAS_WIZ); 597 LOG (llevDebug, "Discarding object without arch: %s\n", tmp->name ? (const char *) tmp->name : "(null)");
932 SET_FLAG (op, FLAG_WIZPASS); 598 tmp->destroy ();
933 SET_FLAG (op, FLAG_WIZCAST); 599 }
934 } 600 }
935 else 601 else
936 { 602 {
937 CLEAR_FLAG (op, FLAG_WIZPASS); 603 /* This is the actual archetype definition then */
938 CLEAR_FLAG (op, FLAG_WIZCAST); 604 op->arch = archetype::find (str);
605
606 if (op->arch)
607 op->arch->clone.copy_to (op);
608 else if (!arch_init)
609 /* record the name of the broken object */
610 op->name = str;
939 } 611 }
612 }
940 break; 613 break;
941 614
942 case KW_friendly: 615 case KW_other_arch:
943 GET_FLAG (op, FLAG_FRIENDLY); 616 op->other_arch = archetype::find (thawer.get_str ());
944 //TODO: move to check_object or so
945 if (op->type != PLAYER && QUERY_FLAG (op, FLAG_FRIENDLY))
946 add_friendly_object (op);
947 break; 617 break;
948 618
949 case KW_monster: 619 case KW_animation:
620 {
621 const char *str = thawer.get_str ();
622
623 if (!str)
624 {
625 op->animation_id = 0;
626 CLEAR_FLAG (op, FLAG_ANIMATE);
627 }
628 else
629 {
630 op->animation_id = find_animation (str);
950 GET_FLAG (op, FLAG_MONSTER); 631 SET_FLAG (op, FLAG_ANIMATE);
632 }
633 }
634
951 break; 635 break;
952 case KW_neutral: 636
953 GET_FLAG (op, FLAG_NEUTRAL); 637 case KW_last_heal: thawer.get (op->last_heal); break;
954 break; 638 case KW_last_sp: thawer.get (op->last_sp); break;
955 case KW_no_attack: 639 case KW_last_grace: thawer.get (op->last_grace); break;
956 GET_FLAG (op, FLAG_NO_ATTACK); 640 case KW_last_eat: thawer.get (op->last_eat); break;
957 break; 641 case KW_speed_left: thawer.get (op->speed_left); break;
958 case KW_no_damage: 642
959 GET_FLAG (op, FLAG_NO_DAMAGE);
960 break;
961 case KW_generator:
962 GET_FLAG (op, FLAG_GENERATOR);
963 break;
964 case KW_use_content_on_gen:
965 GET_FLAG (op, FLAG_CONTENT_ON_GEN);
966 break;
967 case KW_is_thrown:
968 GET_FLAG (op, FLAG_IS_THROWN);
969 break;
970 case KW_auto_apply:
971 GET_FLAG (op, FLAG_AUTO_APPLY);
972 break;
973 case KW_treasure:
974 GET_FLAG (op, FLAG_TREASURE);
975 break;
976 case KW_see_invisible:
977 GET_FLAG (op, FLAG_SEE_INVISIBLE);
978 break;
979 case KW_can_roll:
980 GET_FLAG (op, FLAG_CAN_ROLL);
981 break;
982 case KW_overlay_floor:
983 GET_FLAG (op, FLAG_OVERLAY_FLOOR);
984 break;
985 case KW_is_turnable:
986 GET_FLAG (op, FLAG_IS_TURNABLE);
987 break;
988 case KW_is_used_up:
989 GET_FLAG (op, FLAG_IS_USED_UP);
990 break;
991 case KW_alive:
992 GET_FLAG (op, FLAG_ALIVE);
993 break;
994 case KW_applied:
995 GET_FLAG (op, FLAG_APPLIED);
996 break;
997 case KW_unpaid:
998 GET_FLAG (op, FLAG_UNPAID);
999 break;
1000 case KW_is_animated:
1001 GET_FLAG (op, FLAG_ANIMATE);
1002 break;
1003 case KW_no_pick:
1004 GET_FLAG (op, FLAG_NO_PICK);
1005 break;
1006 case KW_reflecting:
1007 GET_FLAG (op, FLAG_REFLECTING);
1008 break;
1009 case KW_changing:
1010 GET_FLAG (op, FLAG_CHANGING);
1011 break;
1012 case KW_splitting:
1013 GET_FLAG (op, FLAG_SPLITTING);
1014 break;
1015 case KW_hitback:
1016 GET_FLAG (op, FLAG_HITBACK);
1017 break;
1018 case KW_startequip:
1019 GET_FLAG (op, FLAG_STARTEQUIP);
1020 break;
1021 case KW_blocksview:
1022 GET_FLAG (op, FLAG_BLOCKSVIEW);
1023 break;
1024 case KW_undead:
1025 GET_FLAG (op, FLAG_UNDEAD);
1026 break;
1027 case KW_scared:
1028 GET_FLAG (op, FLAG_SCARED);
1029 break;
1030 case KW_unaggressive:
1031 GET_FLAG (op, FLAG_UNAGGRESSIVE);
1032 break;
1033 case KW_reflect_missile:
1034 GET_FLAG (op, FLAG_REFL_MISSILE);
1035 break;
1036 case KW_reflect_spell:
1037 GET_FLAG (op, FLAG_REFL_SPELL);
1038 break;
1039 case KW_no_magic:
1040 GET_FLAG (op, FLAG_NO_MAGIC);
1041 break;
1042 case KW_no_drop:
1043 GET_FLAG (op, FLAG_NO_DROP);
1044 break;
1045 case KW_random_movement:
1046 GET_FLAG (op, FLAG_RANDOM_MOVE);
1047 break;
1048 case KW_was_wiz:
1049 GET_FLAG (op, FLAG_WAS_WIZ);
1050 break;
1051 case KW_no_fix_player:
1052 GET_FLAG (op, FLAG_NO_FIX_PLAYER);
1053 break;
1054 case KW_is_lightable:
1055 GET_FLAG (op, FLAG_IS_LIGHTABLE);
1056 break;
1057 case KW_tear_down:
1058 GET_FLAG (op, FLAG_TEAR_DOWN);
1059 break;
1060 case KW_can_use_shield:
1061 GET_FLAG (op, FLAG_USE_SHIELD);
1062 break;
1063 case KW_can_cast_spell:
1064 GET_FLAG (op, FLAG_CAST_SPELL);
1065 break;
1066 case KW_can_use_scroll:
1067 GET_FLAG (op, FLAG_USE_SCROLL);
1068 break;
1069 case KW_can_use_range:
1070 GET_FLAG (op, FLAG_USE_RANGE);
1071 break;
1072 case KW_can_use_bow:
1073 GET_FLAG (op, FLAG_USE_BOW);
1074 break;
1075 case KW_can_use_armour:
1076 GET_FLAG (op, FLAG_USE_ARMOUR);
1077 break;
1078 case KW_can_use_weapon:
1079 GET_FLAG (op, FLAG_USE_WEAPON);
1080 break;
1081 case KW_can_use_ring:
1082 GET_FLAG (op, FLAG_USE_RING);
1083 break;
1084 case KW_has_ready_bow:
1085 GET_FLAG (op, FLAG_READY_BOW);
1086 break;
1087 case KW_xrays:
1088 GET_FLAG (op, FLAG_XRAYS);
1089 break;
1090 case KW_is_floor:
1091 GET_FLAG (op, FLAG_IS_FLOOR);
1092 break;
1093 case KW_lifesave:
1094 GET_FLAG (op, FLAG_LIFESAVE);
1095 break;
1096 case KW_no_strength:
1097 GET_FLAG (op, FLAG_NO_STRENGTH);
1098 break;
1099 case KW_sleep: 643 case KW_speed:
1100 GET_FLAG (op, FLAG_SLEEP);
1101 break;
1102 case KW_stand_still:
1103 GET_FLAG (op, FLAG_STAND_STILL);
1104 break;
1105 case KW_random_move:
1106 GET_FLAG (op, FLAG_RANDOM_MOVE);
1107 break;
1108 case KW_only_attack:
1109 GET_FLAG (op, FLAG_ONLY_ATTACK);
1110 break;
1111 case KW_activate_on_push:
1112 GET_FLAG (op, FLAG_ACTIVATE_ON_PUSH);
1113 break;
1114 case KW_activate_on_release:
1115 GET_FLAG (op, FLAG_ACTIVATE_ON_RELEASE);
1116 break;
1117 case KW_confused:
1118 GET_FLAG (op, FLAG_CONFUSED);
1119 break;
1120 case KW_stealth:
1121 GET_FLAG (op, FLAG_STEALTH);
1122 break;
1123 case KW_cursed:
1124 GET_FLAG (op, FLAG_CURSED);
1125 break;
1126 case KW_damned:
1127 GET_FLAG (op, FLAG_DAMNED);
1128 break;
1129 case KW_see_anywhere:
1130 GET_FLAG (op, FLAG_SEE_ANYWHERE);
1131 break;
1132 case KW_known_magical:
1133 GET_FLAG (op, FLAG_KNOWN_MAGICAL);
1134 break;
1135 case KW_known_cursed:
1136 GET_FLAG (op, FLAG_KNOWN_CURSED);
1137 break;
1138 case KW_can_use_skill:
1139 GET_FLAG (op, FLAG_CAN_USE_SKILL);
1140 break;
1141 case KW_been_applied:
1142 GET_FLAG (op, FLAG_BEEN_APPLIED);
1143 break;
1144 case KW_has_ready_scroll:
1145 GET_FLAG (op, FLAG_READY_SCROLL);
1146 break;
1147 case KW_can_use_rod:
1148 GET_FLAG (op, FLAG_USE_ROD);
1149 break;
1150 case KW_can_use_horn:
1151 GET_FLAG (op, FLAG_USE_HORN);
1152 break;
1153 case KW_unique:
1154 GET_FLAG (op, FLAG_UNIQUE);
1155 break;
1156 case KW_make_invisible:
1157 GET_FLAG (op, FLAG_MAKE_INVIS);
1158 break;
1159 case KW_inv_locked:
1160 GET_FLAG (op, FLAG_INV_LOCKED);
1161 break;
1162 case KW_is_wooded:
1163 GET_FLAG (op, FLAG_IS_WOODED);
1164 break;
1165 case KW_is_hilly:
1166 GET_FLAG (op, FLAG_IS_HILLY);
1167 break;
1168 case KW_is_water:
1169 GET_FLAG (op, FLAG_IS_WATER);
1170 break;
1171 case KW_has_ready_skill:
1172 GET_FLAG (op, FLAG_READY_SKILL);
1173 break;
1174 case KW_has_ready_weapon:
1175 GET_FLAG (op, FLAG_READY_WEAPON);
1176 break;
1177 case KW_no_skill_ident:
1178 GET_FLAG (op, FLAG_NO_SKILL_IDENT);
1179 break;
1180 case KW_is_blind:
1181 GET_FLAG (op, FLAG_BLIND);
1182 break;
1183 case KW_can_see_in_dark:
1184 GET_FLAG (op, FLAG_SEE_IN_DARK);
1185 break;
1186 case KW_is_cauldron:
1187 GET_FLAG (op, FLAG_IS_CAULDRON);
1188 break;
1189 case KW_no_steal:
1190 GET_FLAG (op, FLAG_NO_STEAL);
1191 break;
1192 case KW_one_hit:
1193 GET_FLAG (op, FLAG_ONE_HIT);
1194 break;
1195 case KW_berserk:
1196 GET_FLAG (op, FLAG_BERSERK);
1197 break;
1198 case KW_is_buildable:
1199 GET_FLAG (op, FLAG_IS_BUILDABLE);
1200 break;
1201
1202 case KW_armour:
1203 thawer.get (op->resist[ATNR_PHYSICAL]);
1204 break;
1205 case KW_resist_physical:
1206 thawer.get (op->resist[ATNR_PHYSICAL]);
1207 break;
1208 case KW_resist_magic:
1209 thawer.get (op->resist[ATNR_MAGIC]);
1210 break;
1211 case KW_resist_fire:
1212 thawer.get (op->resist[ATNR_FIRE]);
1213 break;
1214 case KW_resist_electricity:
1215 thawer.get (op->resist[ATNR_ELECTRICITY]);
1216 break;
1217 case KW_resist_cold:
1218 thawer.get (op->resist[ATNR_COLD]);
1219 break;
1220 case KW_resist_confusion:
1221 thawer.get (op->resist[ATNR_CONFUSION]);
1222 break;
1223 case KW_resist_acid:
1224 thawer.get (op->resist[ATNR_ACID]);
1225 break;
1226 case KW_resist_drain:
1227 thawer.get (op->resist[ATNR_DRAIN]);
1228 break;
1229 case KW_resist_weaponmagic:
1230 thawer.get (op->resist[ATNR_WEAPONMAGIC]);
1231 break;
1232 case KW_resist_ghosthit:
1233 thawer.get (op->resist[ATNR_GHOSTHIT]);
1234 break;
1235 case KW_resist_poison:
1236 thawer.get (op->resist[ATNR_POISON]);
1237 break;
1238 case KW_resist_slow:
1239 thawer.get (op->resist[ATNR_SLOW]);
1240 break;
1241 case KW_resist_paralyze:
1242 thawer.get (op->resist[ATNR_PARALYZE]);
1243 break;
1244 case KW_resist_turn_undead:
1245 thawer.get (op->resist[ATNR_TURN_UNDEAD]);
1246 break;
1247 case KW_resist_fear:
1248 thawer.get (op->resist[ATNR_FEAR]);
1249 break;
1250 case KW_resist_cancellation:
1251 thawer.get (op->resist[ATNR_CANCELLATION]);
1252 break;
1253 case KW_resist_deplete:
1254 thawer.get (op->resist[ATNR_DEPLETE]);
1255 break;
1256 case KW_resist_death:
1257 thawer.get (op->resist[ATNR_DEATH]);
1258 break;
1259 case KW_resist_chaos:
1260 thawer.get (op->resist[ATNR_CHAOS]);
1261 break;
1262 case KW_resist_counterspell:
1263 thawer.get (op->resist[ATNR_COUNTERSPELL]);
1264 break;
1265 case KW_resist_godpower:
1266 thawer.get (op->resist[ATNR_GODPOWER]);
1267 break;
1268 case KW_resist_holyword:
1269 thawer.get (op->resist[ATNR_HOLYWORD]);
1270 break;
1271 case KW_resist_blind:
1272 thawer.get (op->resist[ATNR_BLIND]);
1273 break;
1274 case KW_resist_internal:
1275 thawer.get (op->resist[ATNR_INTERNAL]);
1276 break;
1277 case KW_resist_life_stealing:
1278 thawer.get (op->resist[ATNR_LIFE_STEALING]);
1279 break;
1280 case KW_resist_disease:
1281 thawer.get (op->resist[ATNR_DISEASE]);
1282 break;
1283
1284 case KW_luck:
1285 thawer.get (op->stats.luck);
1286 break;
1287 case KW_run_away:
1288 thawer.get (op->run_away);
1289 break;
1290 case KW_pick_up:
1291 thawer.get (op->pick_up);
1292 break;
1293 case KW_item_power:
1294 thawer.get (op->item_power);
1295 break;
1296 case KW_gen_sp_armour:
1297 thawer.get (op->gen_sp_armour);
1298 break;
1299 case KW_anim_speed:
1300 thawer.get (op->anim_speed); 644 thawer.get (op->speed);
1301 break;
1302 case KW_container:
1303 thawer.get (op->weight_limit);
1304 break;
1305 case KW_will_apply:
1306 thawer.get (op->will_apply);
1307 break;
1308 case KW_attack_movement:
1309 thawer.get (op->attack_movement);
1310 break;
1311 case KW_move_state:
1312 thawer.get (op->move_status);
1313 break;
1314 case KW_expmul:
1315 thawer.get (op->expmul);
1316 break;
1317 case KW_glow_radius:
1318 thawer.get (op->glow_radius);
1319 break;
1320 case KW_weapontype:
1321 thawer.get (op->weapontype);
1322 break;
1323 case KW_tooltype:
1324 thawer.get (op->tooltype);
1325 break;
1326 case KW_casting_time:
1327 thawer.get (op->casting_time);
1328 break;
1329 case KW_elevation:
1330 thawer.get (op->elevation);
1331 break;
1332 case KW_smoothlevel:
1333 thawer.get (op->smoothlevel);
1334 break;
1335 case KW_client_type:
1336 thawer.get (op->client_type);
1337 break;
1338 case KW_duration:
1339 thawer.get (op->duration);
1340 break;
1341 case KW_range:
1342 thawer.get (op->range);
1343 break;
1344 case KW_range_modifier:
1345 thawer.get (op->range_modifier);
1346 break;
1347 case KW_dam_modifier:
1348 thawer.get (op->dam_modifier);
1349 break;
1350 case KW_duration_modifier:
1351 thawer.get (op->duration_modifier);
1352 break;
1353 645
1354 //TODO: mechanism to ensure that KW_xxx is consecutive needed from include/preprocess 646 //TODO: maybe do in check_object
1355 //TODO: parse from other include files 647 if (!(map_flags & MAP_STYLE))
1356 case KW_body_range:
1357 thawer.get (op->body_info[0]);
1358 break;
1359 case KW_body_arm:
1360 thawer.get (op->body_info[1]);
1361 break;
1362 case KW_body_torso:
1363 thawer.get (op->body_info[2]);
1364 break;
1365 case KW_body_head:
1366 thawer.get (op->body_info[3]);
1367 break;
1368 case KW_body_neck:
1369 thawer.get (op->body_info[4]);
1370 break;
1371 case KW_body_skill:
1372 thawer.get (op->body_info[5]);
1373 break;
1374 case KW_body_finger:
1375 thawer.get (op->body_info[6]);
1376 break;
1377 case KW_body_shoulder:
1378 thawer.get (op->body_info[7]);
1379 break;
1380 case KW_body_foot:
1381 thawer.get (op->body_info[8]);
1382 break;
1383 case KW_body_hand:
1384 thawer.get (op->body_info[9]);
1385 break;
1386 case KW_body_wrist:
1387 thawer.get (op->body_info[10]);
1388 break;
1389 case KW_body_waist:
1390 thawer.get (op->body_info[11]);
1391 break;
1392 case KW_can_apply:
1393 break;
1394
1395 case KW_connected:
1396 add_button_link (op, op->map, thawer.get_sint32 ());
1397 break;
1398
1399 case KW_randomitems:
1400 op->randomitems = find_treasurelist (thawer.get_str ());
1401 break;
1402
1403 case KW_msg:
1404 { 648 {
1405 thawer.get_ml (KW_endmsg, op->msg); 649 if (op->speed < 0)
1406 //TODO: allow longer messages 650 op->speed_left = op->speed_left - RANDOM () % 100 / 100.0;
1407 if (strlen (op->msg) >= HUGE_BUF) 651
1408 { 652 update_ob_speed (op);
1409 LOG (llevDebug, "\n\tError message length >= %d: %d\n>%.80s<\n", HUGE_BUF, strlen (op->msg), &op->msg);
1410 op->msg = "ERROR, please report: string too long, winged.\n";
1411 }
1412 } 653 }
654
1413 break; 655 break;
1414 656
657 case KW_slow_move:
658 op->move_slow |= MOVE_WALK;
659 thawer.get (op->move_slow_penalty);
660 break;
661
662 case KW_face:
663 op->face = &new_faces[FindFace (thawer.get_str (), 0)];
664 break;
665
666 case KW_x: thawer.get (op->x); break;
667 case KW_y: thawer.get (op->y); break;
668
669 case KW_Str: // uppercase alias
670 case KW_str: thawer.get (op->stats.Str); break;
671 case KW_Dex: // uppercase alias
672 case KW_dex: thawer.get (op->stats.Dex); break;
673 case KW_Con: // uppercase alias
674 case KW_con: thawer.get (op->stats.Con); break;
675 case KW_Wis: // uppercase alias
676 case KW_wis: thawer.get (op->stats.Wis); break;
677 case KW_Cha: // uppercase alias
678 case KW_cha: thawer.get (op->stats.Cha); break;
679 case KW_Int: // uppercase alias
680 case KW_int: thawer.get (op->stats.Int); break;
681 case KW_Pow: // uppercase alias
682 case KW_pow: thawer.get (op->stats.Pow); break;
683
684 case KW_hp: thawer.get (op->stats.hp); break;
685 case KW_maxhp: thawer.get (op->stats.maxhp); break;
686 case KW_sp: thawer.get (op->stats.sp); break;
687 case KW_maxsp: thawer.get (op->stats.maxsp); break;
688 case KW_grace: thawer.get (op->stats.grace); break;
689 case KW_maxgrace: thawer.get (op->stats.maxgrace); break;
690
691 case KW_exp: thawer.get (op->stats.exp); break;
692 case KW_perm_exp: thawer.get (op->perm_exp); break;
693 case KW_food: thawer.get (op->stats.food); break;
694 case KW_dam: thawer.get (op->stats.dam); break;
695 case KW_wc: thawer.get (op->stats.wc); break;
696 case KW_ac: thawer.get (op->stats.ac); break;
697 case KW_nrof: thawer.get (op->nrof); break;
698 case KW_level: thawer.get (op->level); break;
699 case KW_direction: thawer.get (op->direction); break;
700 case KW_type: thawer.get (op->type); break;
701 case KW_subtype: thawer.get (op->subtype); break;
702 case KW_value: thawer.get (op->value); break;
703 case KW_weight: thawer.get (op->weight); break;
704 case KW_carrying: thawer.get (op->carrying); break;
705 case KW_attacktype: thawer.get (op->attacktype); break;
706 case KW_path_attuned: thawer.get (op->path_attuned); break;
707 case KW_path_repelled: thawer.get (op->path_repelled); break;
708 case KW_path_denied: thawer.get (op->path_denied); break;
709 case KW_invisible: thawer.get (op->invisible); break;
710 case KW_magic: thawer.get (op->magic); break;
711 case KW_state: thawer.get (op->state); break;
712 case KW_move_slow_penalty: thawer.get (op->move_slow_penalty); break;
713 case KW_material: thawer.get (op->material); break;
714 case KW_materialname: thawer.get (op->materialname); break;
715
716 /* These are the new values */
717 case KW_move_block: set_move (op->move_block, thawer.get_str ()); break;
718 case KW_move_allow: set_move (op->move_allow, thawer.get_str ()); break;
719 case KW_move_type: set_move (op->move_type, thawer.get_str ()); break;
720 case KW_move_on: set_move (op->move_on, thawer.get_str ()); break;
721 case KW_move_off: set_move (op->move_off, thawer.get_str ()); break;
722 case KW_move_slow: set_move (op->move_slow, thawer.get_str ()); break;
723
724 /* These are all legacy - any new objects should use the move_ .. values */
725 case KW_no_pass:
726 {
727 if (thawer.get_sint32 ())
728 op->move_block = MOVE_ALL;
729 else
730 op->move_block = 0;
731 }
732
733 break;
734
735 /* These are all legacy - any new objects should use the move_ .. values */
736 case KW_walk_on:
737 {
738 if (thawer.get_sint32 ())
739 op->move_on |= MOVE_WALK;
740 else
741 op->move_on &= ~MOVE_WALK;
742 }
743
744 break;
745
746 /* These are all legacy - any new objects should use the move_ .. values */
747 case KW_walk_off:
748 {
749 if (thawer.get_sint32 ())
750 op->move_off |= MOVE_WALK;
751 else
752 op->move_off &= ~MOVE_WALK;
753 }
754 break;
755
756 /* These are all legacy - any new objects should use the move_ .. values */
1415 case KW_lore: 757 case KW_fly_on:
758 {
759 if (thawer.get_sint32 ())
760 op->move_on |= MOVE_FLY_LOW;
761 else
762 op->move_on &= ~MOVE_FLY_LOW;
763 }
764 break;
765
766 /* These are all legacy - any new objects should use the move_ .. values */
767 case KW_fly_off:
768 {
769 if (thawer.get_sint32 ())
770 op->move_off |= MOVE_FLY_LOW;
771 else
772 op->move_off &= ~MOVE_FLY_LOW;
773 }
774 break;
775
776 //TODO: remove these after converting archetypes
777 case KW_can_use_wand:
778 GET_FLAG (op, FLAG_USE_RANGE);
779 break;
780
781 /* These are all legacy - any new objects should use the move_ .. values */
782 case KW_flying:
783 {
784 if (thawer.get_sint32 ())
785 op->move_type |= MOVE_FLY_LOW;
786 else
787 op->move_type &= ~MOVE_FLY_LOW;
788 }
789 break;
790
791
792 case KW_identified:
793 GET_FLAG (op, FLAG_IDENTIFIED);
794 //TODO: move to check_object or so
795 if (QUERY_FLAG (op, FLAG_IDENTIFIED))
796 CLEAR_FLAG (op, FLAG_KNOWN_MAGICAL);
797
798 break;
799
800 case KW_wiz:
801 GET_FLAG (op, FLAG_WIZ);
802 //TODO: move to check_object
803 if (QUERY_FLAG (op, FLAG_WIZ))
1416 { 804 {
1417 shstr msgbuf; 805 SET_FLAG (op, FLAG_WAS_WIZ);
1418 806 SET_FLAG (op, FLAG_WIZPASS);
1419 thawer.get_ml (KW_endlore, op->lore); 807 SET_FLAG (op, FLAG_WIZCAST);
1420 //TODO: allow longer messages
1421 /* Just print a warning so we can be reasonably safe
1422 * about not overflowing the buffer.
1423 */
1424 if (strlen (op->lore) > (HUGE_BUF / 2))
1425 LOG (llevDebug, "\n\tWarning lore length > %d (max allowed=%d): %d\n>%.80s<\n",
1426 HUGE_BUF / 2, HUGE_BUF, strlen (op->lore), &op->lore);
1427 } 808 }
809 else
810 {
811 CLEAR_FLAG (op, FLAG_WIZPASS);
812 CLEAR_FLAG (op, FLAG_WIZCAST);
813 }
1428 break; 814 break;
1429 815
1430 case KW_editable: 816 case KW_friendly:
1431 case KW_editor_folder: 817 GET_FLAG (op, FLAG_FRIENDLY);
818 //TODO: move to check_object or so
819 if (op->type != PLAYER && QUERY_FLAG (op, FLAG_FRIENDLY))
820 add_friendly_object (op);
1432 break; 821 break;
1433 822
1434 case KW_More: // uppercase alias 823 case KW_monster: GET_FLAG (op, FLAG_MONSTER); break;
824 case KW_neutral: GET_FLAG (op, FLAG_NEUTRAL); break;
825 case KW_no_attack: GET_FLAG (op, FLAG_NO_ATTACK); break;
826 case KW_no_damage: GET_FLAG (op, FLAG_NO_DAMAGE); break;
827 case KW_generator: GET_FLAG (op, FLAG_GENERATOR); break;
828 case KW_use_content_on_gen: GET_FLAG (op, FLAG_CONTENT_ON_GEN); break;
829 case KW_is_thrown: GET_FLAG (op, FLAG_IS_THROWN); break;
830 case KW_auto_apply: GET_FLAG (op, FLAG_AUTO_APPLY); break;
831 case KW_treasure: GET_FLAG (op, FLAG_TREASURE); break;
832 case KW_see_invisible: GET_FLAG (op, FLAG_SEE_INVISIBLE); break;
833 case KW_can_roll: GET_FLAG (op, FLAG_CAN_ROLL); break;
834 case KW_overlay_floor: GET_FLAG (op, FLAG_OVERLAY_FLOOR); break;
835 case KW_is_turnable: GET_FLAG (op, FLAG_IS_TURNABLE); break;
836 case KW_is_used_up: GET_FLAG (op, FLAG_IS_USED_UP); break;
837 case KW_alive: GET_FLAG (op, FLAG_ALIVE); break;
838 case KW_applied: GET_FLAG (op, FLAG_APPLIED); break;
839 case KW_unpaid: GET_FLAG (op, FLAG_UNPAID); break;
840 case KW_is_animated: GET_FLAG (op, FLAG_ANIMATE); break;
841 case KW_no_pick: GET_FLAG (op, FLAG_NO_PICK); break;
842 case KW_reflecting: GET_FLAG (op, FLAG_REFLECTING); break;
843 case KW_changing: GET_FLAG (op, FLAG_CHANGING); break;
844 case KW_splitting: GET_FLAG (op, FLAG_SPLITTING); break;
845 case KW_hitback: GET_FLAG (op, FLAG_HITBACK); break;
846 case KW_startequip: GET_FLAG (op, FLAG_STARTEQUIP); break;
847 case KW_blocksview: GET_FLAG (op, FLAG_BLOCKSVIEW); break;
848 case KW_undead: GET_FLAG (op, FLAG_UNDEAD); break;
849 case KW_scared: GET_FLAG (op, FLAG_SCARED); break;
850 case KW_unaggressive: GET_FLAG (op, FLAG_UNAGGRESSIVE); break;
851 case KW_reflect_missile: GET_FLAG (op, FLAG_REFL_MISSILE); break;
852 case KW_reflect_spell: GET_FLAG (op, FLAG_REFL_SPELL); break;
853 case KW_no_magic: GET_FLAG (op, FLAG_NO_MAGIC); break;
854 case KW_no_drop: GET_FLAG (op, FLAG_NO_DROP); break;
855 case KW_random_movement: GET_FLAG (op, FLAG_RANDOM_MOVE); break;
856 case KW_was_wiz: GET_FLAG (op, FLAG_WAS_WIZ); break;
857 case KW_no_fix_player: GET_FLAG (op, FLAG_NO_FIX_PLAYER); break;
858 case KW_is_lightable: GET_FLAG (op, FLAG_IS_LIGHTABLE); break;
859 case KW_tear_down: GET_FLAG (op, FLAG_TEAR_DOWN); break;
860 case KW_can_use_shield: GET_FLAG (op, FLAG_USE_SHIELD); break;
861 case KW_can_cast_spell: GET_FLAG (op, FLAG_CAST_SPELL); break;
862 case KW_can_use_scroll: GET_FLAG (op, FLAG_USE_SCROLL); break;
863 case KW_can_use_range: GET_FLAG (op, FLAG_USE_RANGE); break;
864 case KW_can_use_bow: GET_FLAG (op, FLAG_USE_BOW); break;
865 case KW_can_use_armour: GET_FLAG (op, FLAG_USE_ARMOUR); break;
866 case KW_can_use_weapon: GET_FLAG (op, FLAG_USE_WEAPON); break;
867 case KW_can_use_ring: GET_FLAG (op, FLAG_USE_RING); break;
868 case KW_has_ready_bow: GET_FLAG (op, FLAG_READY_BOW); break;
869 case KW_has_ready_range: GET_FLAG (op, FLAG_READY_RANGE); break;
870 case KW_xrays: GET_FLAG (op, FLAG_XRAYS); break;
871 case KW_is_floor: GET_FLAG (op, FLAG_IS_FLOOR); break;
872 case KW_lifesave: GET_FLAG (op, FLAG_LIFESAVE); break;
873 case KW_no_strength: GET_FLAG (op, FLAG_NO_STRENGTH); break;
874 case KW_sleep: GET_FLAG (op, FLAG_SLEEP); break;
875 case KW_stand_still: GET_FLAG (op, FLAG_STAND_STILL); break;
876 case KW_random_move: GET_FLAG (op, FLAG_RANDOM_MOVE); break;
877 case KW_only_attack: GET_FLAG (op, FLAG_ONLY_ATTACK); break;
878 case KW_activate_on_push: GET_FLAG (op, FLAG_ACTIVATE_ON_PUSH); break;
879 case KW_activate_on_release: GET_FLAG (op, FLAG_ACTIVATE_ON_RELEASE); break;
880 case KW_confused: GET_FLAG (op, FLAG_CONFUSED); break;
881 case KW_stealth: GET_FLAG (op, FLAG_STEALTH); break;
882 case KW_cursed: GET_FLAG (op, FLAG_CURSED); break;
883 case KW_damned: GET_FLAG (op, FLAG_DAMNED); break;
884 case KW_see_anywhere: GET_FLAG (op, FLAG_SEE_ANYWHERE); break;
885 case KW_known_magical: GET_FLAG (op, FLAG_KNOWN_MAGICAL); break;
886 case KW_known_cursed: GET_FLAG (op, FLAG_KNOWN_CURSED); break;
887 case KW_can_use_skill: GET_FLAG (op, FLAG_CAN_USE_SKILL); break;
888 case KW_been_applied: GET_FLAG (op, FLAG_BEEN_APPLIED); break;
889 case KW_has_ready_scroll: GET_FLAG (op, FLAG_READY_SCROLL); break;
890 case KW_can_use_rod: GET_FLAG (op, FLAG_USE_ROD); break;
891 case KW_can_use_horn: GET_FLAG (op, FLAG_USE_HORN); break;
892 case KW_unique: GET_FLAG (op, FLAG_UNIQUE); break;
893 case KW_make_invisible: GET_FLAG (op, FLAG_MAKE_INVIS); break;
894 case KW_inv_locked: GET_FLAG (op, FLAG_INV_LOCKED); break;
895 case KW_is_wooded: GET_FLAG (op, FLAG_IS_WOODED); break;
896 case KW_is_hilly: GET_FLAG (op, FLAG_IS_HILLY); break;
897 case KW_is_water: GET_FLAG (op, FLAG_IS_WATER); break;
898 case KW_has_ready_skill: GET_FLAG (op, FLAG_READY_SKILL); break;
899 case KW_has_ready_weapon: GET_FLAG (op, FLAG_READY_WEAPON); break;
900 case KW_no_skill_ident: GET_FLAG (op, FLAG_NO_SKILL_IDENT); break;
901 case KW_is_blind: GET_FLAG (op, FLAG_BLIND); break;
902 case KW_can_see_in_dark: GET_FLAG (op, FLAG_SEE_IN_DARK); break;
903 case KW_is_cauldron: GET_FLAG (op, FLAG_IS_CAULDRON); break;
904 case KW_no_steal: GET_FLAG (op, FLAG_NO_STEAL); break;
905 case KW_one_hit: GET_FLAG (op, FLAG_ONE_HIT); break;
906 case KW_berserk: GET_FLAG (op, FLAG_BERSERK); break;
907 case KW_is_buildable: GET_FLAG (op, FLAG_IS_BUILDABLE); break;
908
909 case KW_armour: thawer.get (op->resist[ATNR_PHYSICAL]); break;
910 case KW_resist_physical: thawer.get (op->resist[ATNR_PHYSICAL]); break;
911 case KW_resist_magic: thawer.get (op->resist[ATNR_MAGIC]); break;
912 case KW_resist_fire: thawer.get (op->resist[ATNR_FIRE]); break;
913 case KW_resist_electricity: thawer.get (op->resist[ATNR_ELECTRICITY]); break;
914 case KW_resist_cold: thawer.get (op->resist[ATNR_COLD]); break;
915 case KW_resist_confusion: thawer.get (op->resist[ATNR_CONFUSION]); break;
916 case KW_resist_acid: thawer.get (op->resist[ATNR_ACID]); break;
917 case KW_resist_drain: thawer.get (op->resist[ATNR_DRAIN]); break;
918 case KW_resist_weaponmagic: thawer.get (op->resist[ATNR_WEAPONMAGIC]); break;
919 case KW_resist_ghosthit: thawer.get (op->resist[ATNR_GHOSTHIT]); break;
920 case KW_resist_poison: thawer.get (op->resist[ATNR_POISON]); break;
921 case KW_resist_slow: thawer.get (op->resist[ATNR_SLOW]); break;
922 case KW_resist_paralyze: thawer.get (op->resist[ATNR_PARALYZE]); break;
923 case KW_resist_turn_undead: thawer.get (op->resist[ATNR_TURN_UNDEAD]); break;
924 case KW_resist_fear: thawer.get (op->resist[ATNR_FEAR]); break;
925 case KW_resist_cancellation: thawer.get (op->resist[ATNR_CANCELLATION]); break;
926 case KW_resist_deplete: thawer.get (op->resist[ATNR_DEPLETE]); break;
927 case KW_resist_death: thawer.get (op->resist[ATNR_DEATH]); break;
928 case KW_resist_chaos: thawer.get (op->resist[ATNR_CHAOS]); break;
929 case KW_resist_counterspell: thawer.get (op->resist[ATNR_COUNTERSPELL]); break;
930 case KW_resist_godpower: thawer.get (op->resist[ATNR_GODPOWER]); break;
931 case KW_resist_holyword: thawer.get (op->resist[ATNR_HOLYWORD]); break;
932 case KW_resist_blind: thawer.get (op->resist[ATNR_BLIND]); break;
933 case KW_resist_internal: thawer.get (op->resist[ATNR_INTERNAL]); break;
934 case KW_resist_life_stealing: thawer.get (op->resist[ATNR_LIFE_STEALING]); break;
935 case KW_resist_disease: thawer.get (op->resist[ATNR_DISEASE]); break;
936
937 case KW_luck: thawer.get (op->stats.luck); break;
938 case KW_run_away: thawer.get (op->run_away); break;
939 case KW_pick_up: thawer.get (op->pick_up); break;
940 case KW_item_power: thawer.get (op->item_power); break;
941 case KW_gen_sp_armour: thawer.get (op->gen_sp_armour); break;
942 case KW_anim_speed: thawer.get (op->anim_speed); break;
943 case KW_container: thawer.get (op->weight_limit); break;
944 case KW_will_apply: thawer.get (op->will_apply); break;
945 case KW_attack_movement: thawer.get (op->attack_movement); break;
946 case KW_move_state: thawer.get (op->move_status); break;
947 case KW_expmul: thawer.get (op->expmul); break;
948 case KW_glow_radius: thawer.get (op->glow_radius); break;
949 case KW_weapontype: thawer.get (op->weapontype); break;
950 case KW_tooltype: thawer.get (op->tooltype); break;
951 case KW_casting_time: thawer.get (op->casting_time); break;
952 case KW_elevation: thawer.get (op->elevation); break;
953 case KW_smoothlevel: thawer.get (op->smoothlevel); break;
954 case KW_client_type: thawer.get (op->client_type); break;
955 case KW_duration: thawer.get (op->duration); break;
956 case KW_range: thawer.get (op->range); break;
957 case KW_range_modifier: thawer.get (op->range_modifier); break;
958 case KW_dam_modifier: thawer.get (op->dam_modifier); break;
959 case KW_duration_modifier: thawer.get (op->duration_modifier); break;
960
961 //TODO: mechanism to ensure that KW_xxx is consecutive needed from include/preprocess
962 //TODO: parse from other include files
963 case KW_body_range: thawer.get (op->body_info[0]); break;
964 case KW_body_arm: thawer.get (op->body_info[1]); break;
965 case KW_body_torso: thawer.get (op->body_info[2]); break;
966 case KW_body_head: thawer.get (op->body_info[3]); break;
967 case KW_body_neck: thawer.get (op->body_info[4]); break;
968 case KW_body_skill: thawer.get (op->body_info[5]); break;
969 case KW_body_finger: thawer.get (op->body_info[6]); break;
970 case KW_body_shoulder: thawer.get (op->body_info[7]); break;
971 case KW_body_foot: thawer.get (op->body_info[8]); break;
972 case KW_body_hand: thawer.get (op->body_info[9]); break;
973 case KW_body_wrist: thawer.get (op->body_info[10]); break;
974 case KW_body_waist: thawer.get (op->body_info[11]); break;
975 case KW_can_apply:
976 break;
977
978 case KW_connected:
979 add_button_link (op, op->map, thawer.get_sint32 ());
980 break;
981
982 case KW_randomitems:
983 op->randomitems = find_treasurelist (thawer.get_str ());
984 break;
985
986 case KW_msg:
987 {
988 thawer.get_ml (KW_endmsg, op->msg);
989 //TODO: allow longer messages
990 if (strlen (op->msg) >= HUGE_BUF)
991 {
992 LOG (llevDebug, "\n\tError message length >= %d: %d\n>%.80s<\n", HUGE_BUF, strlen (op->msg), &op->msg);
993 op->msg = "ERROR, please report: string too long, winged.\n";
994 }
995 }
996 break;
997
1435 case KW_more: 998 case KW_lore:
1436 /* We need to record that this is a multipart object, 999 {
1437 * so the calling function can glue things back together 1000 shstr msgbuf;
1001
1002 thawer.get_ml (KW_endlore, op->lore);
1003 //TODO: allow longer messages
1004 /* Just print a warning so we can be reasonably safe
1005 * about not overflowing the buffer.
1438 */ 1006 */
1007 if (strlen (op->lore) > (HUGE_BUF / 2))
1008 LOG (llevDebug, "\n\tWarning lore length > %d (max allowed=%d): %d\n>%.80s<\n",
1009 HUGE_BUF / 2, HUGE_BUF, strlen (op->lore), &op->lore);
1010 }
1011 break;
1012
1013 case KW_editable:
1014 case KW_editor_folder:
1015 break;
1016
1017 case KW_More: // uppercase alias
1018 case KW_more:
1019 /* We need to record that this is a multipart object,
1020 * so the calling function can glue things back together
1021 */
1439 ismore = 1; 1022 ismore = 1;
1440 break; 1023 break;
1441 1024
1442 case KW_end: 1025 case KW_end:
1443 check_loaded_object (op); 1026 check_loaded_object (op);
1444 1027
1445 if (!arch_init) 1028 if (!arch_init)
1446 op->instantiate (); 1029 op->instantiate ();
1447 1030
1448 return ismore ? LL_MORE : LL_NORMAL; 1031 return ismore ? LL_MORE : LL_NORMAL;
1449 1032
1450 case KW_EOF: 1033 case KW_EOF:
1451 return LL_EOF; 1034 return LL_EOF;
1452 1035
1453 case KW_ERROR: 1036 case KW_ERROR:
1454 set_ob_key_value (op, thawer.line, thawer.last_value, true); 1037 set_ob_key_value (op, thawer.line, thawer.last_value, true);
1455 //printf ("addkv(%s,%s)\n", thawer.line, thawer.get_str());//D 1038 //printf ("addkv(%s,%s)\n", thawer.line, thawer.get_str());//D
1456 1039
1457 //TODO: skip line, ugly, factor parsing better 1040 //TODO: skip line, ugly, factor parsing better
1458 if (thawer.last_value) 1041 if (thawer.last_value)
1459 thawer.line = thawer.last_value; 1042 thawer.line = thawer.last_value;
1460 1043
1461 thawer.line += strlen (thawer.line) + 1; 1044 thawer.line += strlen (thawer.line) + 1;
1462 1045
1463 break; 1046 break;
1464 1047
1465 default: 1048 default:
1466 LOG (llevError, "UNSUPPORTED KEYWORD IN MAP: \"%s\", bug in normaliser. skipping.\n", keyword_str[kw]); 1049 LOG (llevError, "UNSUPPORTED KEYWORD IN MAP: \"%s\", bug in normaliser. skipping.\n", keyword_str[kw]);
1467 break; 1050 break;
1468 } 1051 }
1469 } 1052 }
1470} 1053}
1471 1054
1472/* 1055/*
… …
1498 * override values and in c_wiz to mutate values. 1081 * override values and in c_wiz to mutate values.
1499 */ 1082 */
1500int 1083int
1501set_variable (object *op, char *buf) 1084set_variable (object *op, char *buf)
1502{ 1085{
1503 return 0;
1504#if 0
1505 int retval;
1506 object_thawer thawer (0); 1086 object_thawer thawer (buf, (AV *)0);
1507 1087
1508 strcpy (msgbuf, "");
1509 strcpy (lorebuf, "");
1510 retval = parse_object (op, thawer, 0); 1088 return parse_object (op, thawer, 0);
1511 yy_switch_to_buffer (yycurbuf);
1512 yy_delete_buffer (yybufstate);
1513 yy_pop_state ();
1514 return retval;
1515#endif
1516} 1089}
1517
1518/* This array equates the FLAG_ values with the V_ values. Use -1 to
1519 * put gaps in the array that should not be processed.
1520 * The order matches the order of the define values in 'define.h'.
1521 */
1522
1523/* This is a list of pointers that correspond to the FLAG_.. values.
1524 * This is a simple 1:1 mapping - if FLAG_FRIENDLY is 15, then
1525 * the 15'th element of this array should match that name.
1526 * If an entry is NULL, that is a flag not to loaded/saved.
1527 */
1528static const char *const flag_names[NUM_FLAGS + 1] = {
1529 "alive", "wiz", NULL, NULL, "was_wiz", "applied", "unpaid",
1530 "can_use_shield", "no_pick", NULL /* walk_on */ , NULL /* no_pass */ , /* 10 */
1531 "is_animated", NULL /* slow_move */ ,
1532 NULL /* flying */ , "monster", "friendly", "generator",
1533 "is_thrown", "auto_apply", "treasure", "player sold", /* 20 */
1534 "see_invisible", "can_roll", "overlay_floor",
1535 "is_turnable", NULL /* walk_off */ , NULL /* fly_on */ ,
1536 NULL /*fly_off */ , "is_used_up", "identified", "reflecting", /* 30 */
1537 "changing", "splitting", "hitback", "startequip",
1538 "blocksview", "undead", "scared", "unaggressive",
1539 "reflect_missile", "reflect_spell", /* 40 */
1540 "no_magic", "no_fix_player", "is_lightable", "tear_down",
1541 "run_away", NULL /*pass_thru */ , NULL /*can_pass_thru */ ,
1542 "pick_up", "unique", "no_drop", /* 50 */
1543 NULL /* wizcast */ , "can_cast_spell", "can_use_scroll", "can_use_range",
1544 "can_use_bow", "can_use_armour", "can_use_weapon",
1545 "can_use_ring", "has_ready_range", "has_ready_bow", /* 60 */
1546 "xrays", NULL, "is_floor", "lifesave", "no_strength", "sleep",
1547 "stand_still", "random_move", "only_attack", "confused", /* 70 */
1548 "stealth", NULL, NULL, "cursed", "damned",
1549 "see_anywhere", "known_magical", "known_cursed",
1550 "can_use_skill", "been_applied", /* 80 */
1551 "has_ready_scroll", "can_use_rod", NULL,
1552 "can_use_horn", "make_invisible", "inv_locked", "is_wooded",
1553 "is_hilly", "has_ready_skill", "has_ready_weapon", /* 90 */
1554 "no_skill_ident", "is_blind", "can_see_in_dark", "is_cauldron",
1555 "is_dust", "no_steal", "one_hit", NULL, "berserk", "neutral", /* 100 */
1556 "no_attack", "no_damage", NULL, NULL, "activate_on_push",
1557 "activate_on_release", "is_water", "use_content_on_gen", NULL, "is_buildable", /* 110 */
1558 NULL
1559};
1560
1561 1090
1562/* 1091/*
1563 * Initialises the array of variable-names. Needed before any 1092 * Initialises the array of variable-names. Needed before any
1564 * objects can be loaded. Called by init_library(). 1093 * objects can be loaded. Called by init_library().
1565 */ 1094 */
… …
1620} 1149}
1621#endif 1150#endif
1622 1151
1623// compare *op against *tmp and output differences 1152// compare *op against *tmp and output differences
1624void 1153void
1625put (object_freezer & f, object *op, object *tmp) 1154put (object_freezer &f, object *op, object *tmp)
1626{ 1155{
1156 static const keyword resist_save[NROFATTACKS] = {
1157# define def(uc, lc, name, plus, change) KW_resist_ ## lc,
1158# include "attackinc.h"
1159# undef def
1160 };
1161
1162 /* This is a list of keywords that correspond to the FLAG_.. values.
1163 * This is a simple 1:1 mapping - if FLAG_FRIENDLY is 15, then
1164 * the 15'th element of this array should match that name.
1165 * If an entry is NULL, that is a flag not to loaded/saved.
1166 */
1167 static const keyword flag_names [NUM_FLAGS] = {
1168 KW_alive,
1169 KW_wiz,
1170 KW_NULL,
1171 KW_NULL,
1172 KW_was_wiz,
1173 KW_applied,
1174 KW_unpaid,
1175 KW_can_use_shield,
1176 KW_no_pick,
1177 KW_NULL, // walk_on
1178 KW_NULL, // no_pass
1179 /* 10 */
1180 KW_is_animated,
1181 KW_NULL, // slow_move
1182 KW_NULL, // flying
1183 KW_monster,
1184 KW_friendly,
1185 KW_generator,
1186 KW_is_thrown,
1187 KW_auto_apply,
1188 KW_treasure,
1189 KW_player_sold,
1190 /* 20 */
1191 KW_see_invisible,
1192 KW_can_roll,
1193 KW_overlay_floor,
1194 KW_is_turnable,
1195 KW_NULL, // walk_off
1196 KW_NULL, // fly_on
1197 KW_NULL, // fly_off
1198 KW_is_used_up,
1199 KW_identified,
1200 KW_reflecting,
1201 /* 30 */
1202 KW_changing,
1203 KW_splitting,
1204 KW_hitback,
1205 KW_startequip,
1206 KW_blocksview,
1207 KW_undead,
1208 KW_scared,
1209 KW_unaggressive,
1210 KW_reflect_missile,
1211 KW_reflect_spell,
1212 /* 40 */
1213 KW_no_magic,
1214 KW_no_fix_player,
1215 KW_is_lightable,
1216 KW_tear_down,
1217 KW_run_away,
1218 KW_NULL, // pass_thru
1219 KW_NULL, // an_pass_thru
1220 KW_pick_up,
1221 KW_unique,
1222 KW_no_drop,
1223 /* 50 */
1224 KW_NULL, // wizcast
1225 KW_can_cast_spell,
1226 KW_can_use_scroll,
1227 KW_can_use_range,
1228 KW_can_use_bow,
1229 KW_can_use_armour,
1230 KW_can_use_weapon,
1231 KW_can_use_ring,
1232 KW_has_ready_range,
1233 KW_has_ready_bow,
1234 /* 60 */
1235 KW_xrays,
1236 KW_NULL,
1237 KW_is_floor,
1238 KW_lifesave,
1239 KW_no_strength,
1240 KW_sleep,
1241 KW_stand_still,
1242 KW_random_move,
1243 KW_only_attack,
1244 KW_confused,
1245 /* 70 */
1246 KW_stealth,
1247 KW_NULL,
1248 KW_NULL,
1249 KW_cursed,
1250 KW_damned,
1251 KW_see_anywhere,
1252 KW_known_magical,
1253 KW_known_cursed,
1254 KW_can_use_skill,
1255 KW_been_applied,
1256 /* 80 */
1257 KW_has_ready_scroll,
1258 KW_can_use_rod,
1259 KW_NULL,
1260 KW_can_use_horn,
1261 KW_make_invisible,
1262 KW_inv_locked,
1263 KW_is_wooded,
1264 KW_is_hilly,
1265 KW_has_ready_skill,
1266 KW_has_ready_weapon,
1267 /* 90 */
1268 KW_no_skill_ident,
1269 KW_is_blind,
1270 KW_can_see_in_dark,
1271 KW_is_cauldron,
1272 KW_NULL,
1273 KW_no_steal,
1274 KW_one_hit,
1275 KW_NULL,
1276 KW_berserk,
1277 KW_neutral,
1278 /* 100 */
1279 KW_no_attack,
1280 KW_no_damage,
1281 KW_NULL,
1282 KW_NULL,
1283 KW_activate_on_push,
1284 KW_activate_on_release,
1285 KW_is_water,
1286 KW_use_content_on_gen,
1287 KW_NULL,
1288 KW_is_buildable,
1289 /* 110 */
1290 };
1291
1627 int i; 1292 int i;
1628 1293
1629 /* This saves the key/value lists. We do it first so that any 1294 /* This saves the key/value lists. We do it first so that any
1630 * keys that match field names will be overwritten by the loader. 1295 * keys that match field names will be overwritten by the loader.
1631 */ 1296 */
… …
1633 { 1298 {
1634 /* Find the field in the opposing member. */ 1299 /* Find the field in the opposing member. */
1635 key_value *arch_field = get_ob_key_link (tmp, my_field->key); 1300 key_value *arch_field = get_ob_key_link (tmp, my_field->key);
1636 1301
1637 /* If there's no partnering field, or it's got a different value, save our field. */ 1302 /* If there's no partnering field, or it's got a different value, save our field. */
1638 if (arch_field == NULL || my_field->value != arch_field->value) 1303 if (!arch_field || my_field->value != arch_field->value)
1639 f.put (my_field->key, my_field->value); 1304 f.put (my_field->key, my_field->value);
1640 } 1305 }
1641 1306
1642 /* We don't need to worry about the arch's extra fields - they 1307 /* We don't need to worry about the arch's extra fields - they
1643 * will get taken care of the copy_object function. 1308 * will get taken care of the copy_to method.
1644 */ 1309 */
1310
1311 {
1312 char uids[64];
1313 snprintf (uids, sizeof (uids), "<1.%llx>", (unsigned long long)op->uuid.seq);
1314 f.put (KW_uuid, (const char *)uids);
1315 }
1645 1316
1646#define CMP_OUT(v) if (op->v != tmp->v) f.put (KW_ ## v, op->v) 1317#define CMP_OUT(v) if (op->v != tmp->v) f.put (KW_ ## v, op->v)
1647#define CMP_OUT2(k,v) if (op->v != tmp->v) f.put (KW_ ## k, op->v) 1318#define CMP_OUT2(k,v) if (op->v != tmp->v) f.put (KW_ ## k, op->v)
1648 1319
1649 CMP_OUT (name); 1320 CMP_OUT (name);
… …
1658 if (op->lore != tmp->lore) 1329 if (op->lore != tmp->lore)
1659 f.put (KW_lore, KW_endlore, op->lore); 1330 f.put (KW_lore, KW_endlore, op->lore);
1660 1331
1661 CMP_OUT (other_arch); 1332 CMP_OUT (other_arch);
1662 CMP_OUT (face); 1333 CMP_OUT (face);
1663
1664 if (!op->face || !op->face->name)
1665 printf ("ERRFACE<%s,%s, face %p,%p, fname%s>\n", &tmp->name, &op->name, tmp->face, op->face, op->face ? &op->face->name : "<noface>"); //D
1666 1334
1667 if (op->animation_id != tmp->animation_id) 1335 if (op->animation_id != tmp->animation_id)
1668 if (op->animation_id) 1336 if (op->animation_id)
1669 { 1337 {
1670 f.put (KW_animation, animations[GET_ANIM_ID (op)].name); 1338 f.put (KW_animation, animations[GET_ANIM_ID (op)].name);
… …
1830 save_object (fp, tmp, flag); 1498 save_object (fp, tmp, flag);
1831 old = tmp; 1499 old = tmp;
1832 } 1500 }
1833 1501
1834 if (!(flag & 2)) 1502 if (!(flag & 2))
1835 { 1503 op->destroy ();
1836 remove_ob (op);
1837 free_object (op);
1838 }
1839 1504
1840 fp.put (op); 1505 fp.put (op);
1841 fprintf (fp, "end\n"); 1506 fprintf (fp, "end\n");
1842} 1507}
1508

Diff Legend

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