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.16 by root, Thu Sep 14 21:16:11 2006 UTC vs.
Revision 1.40 by pippijn, Sat Jan 6 14:42:29 2007 UTC

1
2/* 1/*
3 CrossFire, A Multiplayer game for X-windows 2 CrossFire, A Multiplayer game for X-windows
4 3
4 Copyright (C) 2005, 2006, 2007 Marc Lehmann & Crossfire+ Development Team
5 Copyright (C) 2002 Mark Wedel & Crossfire Development Team 5 Copyright (C) 2002 Mark Wedel & Crossfire Development Team
6 Copyright (C) 1992 Frank Tore Johansen 6 Copyright (C) 1992 Frank Tore Johansen
7 7
8 This program is free software; you can redistribute it and/or modify 8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by 9 it under the terms of the GNU General Public License as published by
… …
17 17
18 You should have received a copy of the GNU General Public License 18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software 19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 20 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
21 21
22 The authors can be reached via e-mail at crossfire-devel@real-time.com 22 The authors can be reached via e-mail at <crossfire@schmorp.de>
23*/ 23*/
24 24
25/* Eneq(@csd.uu.se): Added weight-modifiers in environment of objects. 25/* Eneq(@csd.uu.se): Added weight-modifiers in environment of objects.
26 sub/add_weight will transcend the environment updating the carrying 26 sub/add_weight will transcend the environment updating the carrying
27 variable. */ 27 variable. */
28 28
29 29
30#include <global.h> 30#include <global.h>
31#include <loader.h> 31#include <loader.h>
32#include <newserver.h>
33#include <sproto.h> 32#include <sproto.h>
34 33
35/* Maps the MOVE_* values to names */ 34/* Maps the MOVE_* values to names */
36static const char *const move_name[] = { "walk", "fly_low", "fly_high", "swim", "boat", NULL }; 35static const char *const move_name[] = { "walk", "fly_low", "fly_high", "swim", "boat", NULL };
37 36
… …
265static void 264static void
266check_loaded_object (object *op) 265check_loaded_object (object *op)
267{ 266{
268 int ip; 267 int ip;
269 268
270 /* We do some specialized handling to handle legacy cases of name_pl. 269 /* We do some specialised handling to handle legacy cases of name_pl.
271 * If the object doesn't have a name_pl, we just use the object name - 270 * If the object doesn't have a name_pl, we just use the object name -
272 * this isn't perfect (things won't be properly pluralized), but works to 271 * this isn't perfect (things won't be properly pluralised), but works to
273 * that degree (5 heart is still quite understandable). But the case we 272 * that degree (5 heart is still quite understandable). But the case we
274 * also have to catch is if this object is not using the normal name for 273 * also have to catch is if this object is not using the normal name for
275 * the object. In that case, we also want to use the loaded name. 274 * the object. In that case, we also want to use the loaded name.
276 * Otherwise, what happens is that the the plural name will lose 275 * Otherwise, what happens is that the the plural name will lose
277 * information (appear as just 'hearts' and not 'goblins heart') 276 * information (appear as just 'hearts' and not 'goblins heart')
… …
281 280
282 if (!op->name_pl) 281 if (!op->name_pl)
283 op->name_pl = op->name; 282 op->name_pl = op->name;
284 283
285 /* objects now have a materialname. try to patch it in */ 284 /* objects now have a materialname. try to patch it in */
286 if (!(IS_WEAPON (op) && op->level > 0)) 285 if (!(op->is_weapon () && op->level > 0))
287 { 286 {
288 if (op->map != NULL) 287 if (op->map != NULL)
289 set_materialname (op, op->map->difficulty, NULL); 288 set_materialname (op, op->map->difficulty, NULL);
290 else 289 else
291 set_materialname (op, 5, NULL); 290 set_materialname (op, 5, NULL);
… …
322 { 321 {
323 LOG (llevDebug, "Object %s still has last_heal set, not gen_sp_armour\n", op->debug_desc ()); 322 LOG (llevDebug, "Object %s still has last_heal set, not gen_sp_armour\n", op->debug_desc ());
324 op->gen_sp_armour = op->last_heal; 323 op->gen_sp_armour = op->last_heal;
325 op->last_heal = 0; 324 op->last_heal = 0;
326 } 325 }
327 if (editor) 326
328 ip = 0;
329 else
330 ip = calc_item_power (op, 0); 327 ip = calc_item_power (op, 0);
331 /* Legacy objects from before item power was in the game */ 328 /* Legacy objects from before item power was in the game */
332 if (!op->item_power && ip) 329 if (!op->item_power && ip)
333 { 330 {
334 if (ip > 3) 331 if (ip > 3)
335 { 332 {
… …
489 SET_FLAG (op, flag); \ 486 SET_FLAG (op, flag); \
490 else \ 487 else \
491 CLEAR_FLAG (op, flag) \ 488 CLEAR_FLAG (op, flag) \
492 489
493int 490int
494parse_object (object *op, object_thawer & thawer, int map_flags) 491parse_object (object *op, object_thawer &thawer, int map_flags)
495{ 492{
496 bool ismore = 0; 493 bool ismore = 0;
497 object *op_inv = op->inv; 494 object *op_inv = op->inv;
498 495
499 for (;;) 496 for (;;)
… …
504 { 501 {
505 case KW_Object: // uppercase alias 502 case KW_Object: // uppercase alias
506 case KW_object: 503 case KW_object:
507 thawer.get (op->name); 504 thawer.get (op->name);
508 505
509 if (op->arch != NULL) 506 if (op->arch)
510 op->arch->name = op->name; 507 op->arch->name = op->name;
511 508
512 break; 509 break;
513 510
514 case KW_uuid: 511 case KW_uuid:
… …
529 526
530 case KW_oid: 527 case KW_oid:
531 thawer.get (op, thawer.get_sint32 ()); 528 thawer.get (op, thawer.get_sint32 ());
532 break; 529 break;
533 530
534 case KW_name: 531 case KW_name: thawer.get (op->name); break;
535 thawer.get (op->name); 532 case KW_name_pl: thawer.get (op->name_pl); break;
536 break; 533 case KW_title: thawer.get (op->title); break;
537 case KW_name_pl:
538 thawer.get (op->name_pl);
539 break;
540 case KW_title:
541 thawer.get (op->title);
542 break;
543 case KW_custom_name:
544 thawer.get (op->custom_name); 534 case KW_custom_name: thawer.get (op->custom_name); break;
545 break; 535
546 case KW_attach:
547 thawer.get_ornull (op->attach); 536 case KW_attach: thawer.get_ornull (op->attach); break;
548 break;
549 case KW_skill:
550 thawer.get_ornull (op->skill); 537 case KW_skill: thawer.get_ornull (op->skill); break;
551 break;
552 case KW_race:
553 thawer.get_ornull (op->race); 538 case KW_race: thawer.get_ornull (op->race); break;
554 break;
555 case KW_slaying:
556 thawer.get_ornull (op->slaying); 539 case KW_slaying: thawer.get_ornull (op->slaying); break;
557 break;
558 540
559 case KW_arch: 541 case KW_arch:
560 { 542 {
561 const char *str = thawer.get_str (); 543 const char *str = thawer.get_str ();
562 544
… …
568 */ 550 */
569 archetype *arch = archetype::find (str); 551 archetype *arch = archetype::find (str);
570 552
571 object *tmp; 553 object *tmp;
572 554
573 if (arch != NULL) 555 if (arch)
574 tmp = arch_to_object (arch); 556 tmp = arch_to_object (arch);
575 else 557 else
576 { 558 {
577 tmp = get_object (); 559 tmp = object::create ();
578 /* record the name of the broken object */ 560 /* record the name of the broken object */
579 tmp->name = str; 561 tmp->name = str;
580 } 562 }
563
564 // decativate the object we, as we are still going
565 // to read the speed value. Objects should be activated
566 // when the map, object or player is completly loaded.
567 tmp->deactivate ();
581 568
582 parse_object (tmp, thawer, map_flags); 569 parse_object (tmp, thawer, map_flags);
583 570
584 if (tmp->arch) 571 if (tmp->arch)
585 { 572 {
… …
609 op_inv = tmp; 596 op_inv = tmp;
610 } 597 }
611 else 598 else
612 { 599 {
613 LOG (llevDebug, "Discarding object without arch: %s\n", tmp->name ? (const char *) tmp->name : "(null)"); 600 LOG (llevDebug, "Discarding object without arch: %s\n", tmp->name ? (const char *) tmp->name : "(null)");
614 free_object (tmp); 601 tmp->destroy ();
615 } 602 }
616 } 603 }
617 else 604 else
618 { 605 {
619 /* This is the actual archetype definition then */ 606 /* This is the actual archetype definition then */
620 op->arch = archetype::find (str); 607 op->arch = archetype::find (str);
621 608
622 if (op->arch != NULL) 609 if (op->arch)
623 copy_object (&op->arch->clone, op); 610 {
611 op->arch->clone.copy_to (op);
612 // copy_to activates, this should be fixed properly
613 op->deactivate ();
614 }
624 else if (!arch_init) 615 else if (!arch_init)
625 /* record the name of the broken object */ 616 /* record the name of the broken object */
626 op->name = str; 617 op->name = str;
627 } 618 }
628 } 619 }
… …
648 } 639 }
649 } 640 }
650 641
651 break; 642 break;
652 643
653 case KW_last_heal:
654 thawer.get (op->last_heal); 644 case KW_last_heal: thawer.get (op->last_heal); break;
655 break; 645 case KW_last_sp: thawer.get (op->last_sp); break;
656 case KW_last_sp: 646 case KW_last_grace: thawer.get (op->last_grace); break;
657 thawer.get (op->last_sp); 647 case KW_last_eat: thawer.get (op->last_eat); break;
658 break; 648 case KW_speed_left: thawer.get (op->speed_left); break;
659 case KW_last_grace:
660 thawer.get (op->last_grace);
661 break;
662 case KW_last_eat:
663 thawer.get (op->last_eat);
664 break;
665 case KW_speed_left:
666 thawer.get (op->speed_left);
667 break;
668 649
669 case KW_speed: 650 case KW_speed:
670 thawer.get (op->speed); 651 thawer.get (op->speed);
671 652
672 //TODO: maybe do in check_object 653 //TODO: maybe do in check_object
673 if (!(map_flags & MAP_STYLE)) 654 // removed check for style maps
674 {
675 if (op->speed < 0) 655 if (op->speed < 0)
676 op->speed_left = op->speed_left - RANDOM () % 100 / 100.0; 656 op->speed_left = op->speed_left - RANDOM () % 100 / 100.0;
677
678 update_ob_speed (op);
679 }
680 657
681 break; 658 break;
682 659
683 case KW_slow_move: 660 case KW_slow_move:
684 op->move_slow |= MOVE_WALK; 661 op->move_slow |= MOVE_WALK;
… …
687 664
688 case KW_face: 665 case KW_face:
689 op->face = &new_faces[FindFace (thawer.get_str (), 0)]; 666 op->face = &new_faces[FindFace (thawer.get_str (), 0)];
690 break; 667 break;
691 668
692 case KW_x:
693 thawer.get (op->x); 669 case KW_x: thawer.get (op->x); break;
694 break;
695 case KW_y:
696 thawer.get (op->y); 670 case KW_y: thawer.get (op->y); break;
697 break; 671
698 case KW_Str: // uppercase alias 672 case KW_Str: // uppercase alias
699 case KW_str:
700 thawer.get (op->stats.Str); 673 case KW_str: thawer.get (op->stats.Str); break;
701 break;
702 case KW_Dex: // uppercase alias 674 case KW_Dex: // uppercase alias
703 case KW_dex:
704 thawer.get (op->stats.Dex); 675 case KW_dex: thawer.get (op->stats.Dex); break;
705 break;
706 case KW_Con: // uppercase alias 676 case KW_Con: // uppercase alias
707 case KW_con:
708 thawer.get (op->stats.Con); 677 case KW_con: thawer.get (op->stats.Con); break;
709 break;
710 case KW_Wis: // uppercase alias 678 case KW_Wis: // uppercase alias
711 case KW_wis:
712 thawer.get (op->stats.Wis); 679 case KW_wis: thawer.get (op->stats.Wis); break;
713 break;
714 case KW_Cha: // uppercase alias 680 case KW_Cha: // uppercase alias
715 case KW_cha:
716 thawer.get (op->stats.Cha); 681 case KW_cha: thawer.get (op->stats.Cha); break;
717 break;
718 case KW_Int: // uppercase alias 682 case KW_Int: // uppercase alias
719 case KW_int:
720 thawer.get (op->stats.Int); 683 case KW_int: thawer.get (op->stats.Int); break;
721 break;
722 case KW_Pow: // uppercase alias 684 case KW_Pow: // uppercase alias
723 case KW_pow:
724 thawer.get (op->stats.Pow); 685 case KW_pow: thawer.get (op->stats.Pow); break;
725 break;
726 case KW_hp:
727 thawer.get (op->stats.hp);
728 break;
729 case KW_maxhp:
730 thawer.get (op->stats.maxhp);
731 break;
732 case KW_sp:
733 thawer.get (op->stats.sp);
734 break;
735 case KW_maxsp:
736 thawer.get (op->stats.maxsp);
737 break;
738 case KW_grace:
739 thawer.get (op->stats.grace);
740 break;
741 case KW_maxgrace:
742 thawer.get (op->stats.maxgrace);
743 break;
744 686
745 case KW_exp: 687 case KW_hp: thawer.get (op->stats.hp); break;
746 thawer.get (op->stats.exp); 688 case KW_maxhp: thawer.get (op->stats.maxhp); break;
747 break; 689 case KW_sp: thawer.get (op->stats.sp); break;
748 case KW_perm_exp: 690 case KW_maxsp: thawer.get (op->stats.maxsp); break;
749 thawer.get (op->perm_exp); 691 case KW_grace: thawer.get (op->stats.grace); break;
750 break; 692 case KW_maxgrace: thawer.get (op->stats.maxgrace); break;
751 case KW_food: 693
752 thawer.get (op->stats.food); 694 case KW_exp: thawer.get (op->stats.exp); break;
753 break; 695 case KW_perm_exp: thawer.get (op->perm_exp); break;
754 case KW_dam: 696 case KW_food: thawer.get (op->stats.food); break;
755 thawer.get (op->stats.dam); 697 case KW_dam: thawer.get (op->stats.dam); break;
756 break; 698 case KW_wc: thawer.get (op->stats.wc); break;
757 case KW_wc: 699 case KW_ac: thawer.get (op->stats.ac); break;
758 thawer.get (op->stats.wc); 700 case KW_nrof: thawer.get (op->nrof); break;
759 break; 701 case KW_level: thawer.get (op->level); break;
760 case KW_ac: 702 case KW_direction: thawer.get (op->direction); break;
761 thawer.get (op->stats.ac); 703 case KW_type: thawer.get (op->type); break;
762 break; 704 case KW_subtype: thawer.get (op->subtype); break;
763 case KW_nrof: 705 case KW_value: thawer.get (op->value); break;
764 thawer.get (op->nrof); 706 case KW_weight: thawer.get (op->weight); break;
765 break; 707 case KW_carrying: thawer.get (op->carrying); break;
766 case KW_level: 708 case KW_attacktype: thawer.get (op->attacktype); break;
767 thawer.get (op->level); 709 case KW_path_attuned: thawer.get (op->path_attuned); break;
768 break; 710 case KW_path_repelled: thawer.get (op->path_repelled); break;
769 case KW_direction: 711 case KW_path_denied: thawer.get (op->path_denied); break;
770 thawer.get (op->direction); 712 case KW_invisible: thawer.get (op->invisible); break;
771 break; 713 case KW_magic: thawer.get (op->magic); break;
772 case KW_type: 714 case KW_state: thawer.get (op->state); break;
773 thawer.get (op->type); 715 case KW_move_slow_penalty: thawer.get (op->move_slow_penalty); break;
774 break; 716 case KW_material: thawer.get (op->material); break;
775 case KW_subtype: 717 case KW_materialname: thawer.get (op->materialname); break;
776 thawer.get (op->subtype);
777 break;
778 case KW_value:
779 thawer.get (op->value);
780 break;
781 case KW_weight:
782 thawer.get (op->weight);
783 break;
784 case KW_carrying:
785 thawer.get (op->carrying);
786 break;
787 case KW_attacktype:
788 thawer.get (op->attacktype);
789 break;
790 case KW_path_attuned:
791 thawer.get (op->path_attuned);
792 break;
793 case KW_path_repelled:
794 thawer.get (op->path_repelled);
795 break;
796 case KW_path_denied:
797 thawer.get (op->path_denied);
798 break;
799 case KW_invisible:
800 thawer.get (op->invisible);
801 break;
802 case KW_magic:
803 thawer.get (op->magic);
804 break;
805 case KW_state:
806 thawer.get (op->state);
807 break;
808 case KW_move_slow_penalty:
809 thawer.get (op->move_slow_penalty);
810 break;
811 case KW_material:
812 thawer.get (op->material);
813 break;
814 case KW_materialname:
815 thawer.get (op->materialname);
816 break;
817 718
818 /* These are the new values */ 719 /* These are the new values */
819 case KW_move_block:
820 set_move (op->move_block, thawer.get_str ()); 720 case KW_move_block: set_move (op->move_block, thawer.get_str ()); break;
821 break;
822 case KW_move_allow:
823 set_move (op->move_allow, thawer.get_str ()); 721 case KW_move_allow: set_move (op->move_allow, thawer.get_str ()); break;
824 break;
825 case KW_move_type:
826 set_move (op->move_type, thawer.get_str ()); 722 case KW_move_type: set_move (op->move_type, thawer.get_str ()); break;
827 break;
828 case KW_move_on:
829 set_move (op->move_on, thawer.get_str ()); 723 case KW_move_on: set_move (op->move_on, thawer.get_str ()); break;
830 break;
831 case KW_move_off:
832 set_move (op->move_off, thawer.get_str ()); 724 case KW_move_off: set_move (op->move_off, thawer.get_str ()); break;
833 break;
834 case KW_move_slow:
835 set_move (op->move_slow, thawer.get_str ()); 725 case KW_move_slow: set_move (op->move_slow, thawer.get_str ()); break;
836 break;
837 726
838 /* These are all legacy - any new objects should use the move_ .. values */ 727 /* These are all legacy - any new objects should use the move_ .. values */
839 case KW_no_pass: 728 case KW_no_pass:
840 { 729 {
841 if (thawer.get_sint32 ()) 730 if (thawer.get_sint32 ())
… …
885 else 774 else
886 op->move_off &= ~MOVE_FLY_LOW; 775 op->move_off &= ~MOVE_FLY_LOW;
887 } 776 }
888 break; 777 break;
889 778
890 //TODO: remove these after convertign archetypes 779 //TODO: remove these after converting archetypes
891 case KW_can_use_wand: 780 case KW_can_use_wand:
892 GET_FLAG (op, FLAG_USE_RANGE); 781 GET_FLAG (op, FLAG_USE_RANGE);
893 break; 782 break;
894 783
895 /* These are all legacy - any new objects should use the move_ .. values */ 784 /* These are all legacy - any new objects should use the move_ .. values */
… …
932 //TODO: move to check_object or so 821 //TODO: move to check_object or so
933 if (op->type != PLAYER && QUERY_FLAG (op, FLAG_FRIENDLY)) 822 if (op->type != PLAYER && QUERY_FLAG (op, FLAG_FRIENDLY))
934 add_friendly_object (op); 823 add_friendly_object (op);
935 break; 824 break;
936 825
937 case KW_monster: 826 case KW_monster: GET_FLAG (op, FLAG_MONSTER); break;
938 GET_FLAG (op, FLAG_MONSTER); 827 case KW_neutral: GET_FLAG (op, FLAG_NEUTRAL); break;
939 break; 828 case KW_no_attack: GET_FLAG (op, FLAG_NO_ATTACK); break;
940 case KW_neutral: 829 case KW_no_damage: GET_FLAG (op, FLAG_NO_DAMAGE); break;
941 GET_FLAG (op, FLAG_NEUTRAL); 830 case KW_generator: GET_FLAG (op, FLAG_GENERATOR); break;
942 break; 831 case KW_use_content_on_gen: GET_FLAG (op, FLAG_CONTENT_ON_GEN); break;
943 case KW_no_attack: 832 case KW_is_thrown: GET_FLAG (op, FLAG_IS_THROWN); break;
944 GET_FLAG (op, FLAG_NO_ATTACK); 833 case KW_auto_apply: GET_FLAG (op, FLAG_AUTO_APPLY); break;
945 break; 834 case KW_see_invisible: GET_FLAG (op, FLAG_SEE_INVISIBLE); break;
946 case KW_no_damage: 835 case KW_can_roll: GET_FLAG (op, FLAG_CAN_ROLL); break;
947 GET_FLAG (op, FLAG_NO_DAMAGE); 836 case KW_overlay_floor: GET_FLAG (op, FLAG_OVERLAY_FLOOR); break;
948 break; 837 case KW_is_turnable: GET_FLAG (op, FLAG_IS_TURNABLE); break;
949 case KW_generator: 838 case KW_is_used_up: GET_FLAG (op, FLAG_IS_USED_UP); break;
950 GET_FLAG (op, FLAG_GENERATOR); 839 case KW_alive: GET_FLAG (op, FLAG_ALIVE); break;
951 break; 840 case KW_applied: GET_FLAG (op, FLAG_APPLIED); break;
952 case KW_use_content_on_gen: 841 case KW_unpaid: GET_FLAG (op, FLAG_UNPAID); break;
953 GET_FLAG (op, FLAG_CONTENT_ON_GEN); 842 case KW_is_animated: GET_FLAG (op, FLAG_ANIMATE); break;
954 break; 843 case KW_no_pick: GET_FLAG (op, FLAG_NO_PICK); break;
955 case KW_is_thrown: 844 case KW_reflecting: GET_FLAG (op, FLAG_REFLECTING); break;
956 GET_FLAG (op, FLAG_IS_THROWN); 845 case KW_changing: GET_FLAG (op, FLAG_CHANGING); break;
957 break; 846 case KW_splitting: GET_FLAG (op, FLAG_SPLITTING); break;
958 case KW_auto_apply: 847 case KW_hitback: GET_FLAG (op, FLAG_HITBACK); break;
959 GET_FLAG (op, FLAG_AUTO_APPLY); 848 case KW_startequip: GET_FLAG (op, FLAG_STARTEQUIP); break;
960 break; 849 case KW_blocksview: GET_FLAG (op, FLAG_BLOCKSVIEW); break;
961 case KW_treasure: 850 case KW_undead: GET_FLAG (op, FLAG_UNDEAD); break;
962 GET_FLAG (op, FLAG_TREASURE); 851 case KW_scared: GET_FLAG (op, FLAG_SCARED); break;
963 break; 852 case KW_unaggressive: GET_FLAG (op, FLAG_UNAGGRESSIVE); break;
964 case KW_see_invisible: 853 case KW_reflect_missile: GET_FLAG (op, FLAG_REFL_MISSILE); break;
965 GET_FLAG (op, FLAG_SEE_INVISIBLE); 854 case KW_reflect_spell: GET_FLAG (op, FLAG_REFL_SPELL); break;
966 break; 855 case KW_no_magic: GET_FLAG (op, FLAG_NO_MAGIC); break;
967 case KW_can_roll: 856 case KW_no_drop: GET_FLAG (op, FLAG_NO_DROP); break;
968 GET_FLAG (op, FLAG_CAN_ROLL); 857 case KW_random_movement: GET_FLAG (op, FLAG_RANDOM_MOVE); break;
969 break; 858 case KW_was_wiz: GET_FLAG (op, FLAG_WAS_WIZ); break;
970 case KW_overlay_floor: 859 case KW_no_fix_player: GET_FLAG (op, FLAG_NO_FIX_PLAYER); break;
971 GET_FLAG (op, FLAG_OVERLAY_FLOOR); 860 case KW_is_lightable: GET_FLAG (op, FLAG_IS_LIGHTABLE); break;
972 break; 861 case KW_tear_down: GET_FLAG (op, FLAG_TEAR_DOWN); break;
973 case KW_is_turnable: 862 case KW_can_use_shield: GET_FLAG (op, FLAG_USE_SHIELD); break;
974 GET_FLAG (op, FLAG_IS_TURNABLE); 863 case KW_can_cast_spell: GET_FLAG (op, FLAG_CAST_SPELL); break;
975 break; 864 case KW_can_use_scroll: GET_FLAG (op, FLAG_USE_SCROLL); break;
976 case KW_is_used_up: 865 case KW_can_use_range: GET_FLAG (op, FLAG_USE_RANGE); break;
977 GET_FLAG (op, FLAG_IS_USED_UP); 866 case KW_can_use_bow: GET_FLAG (op, FLAG_USE_BOW); break;
978 break; 867 case KW_can_use_armour: GET_FLAG (op, FLAG_USE_ARMOUR); break;
979 case KW_alive: 868 case KW_can_use_weapon: GET_FLAG (op, FLAG_USE_WEAPON); break;
980 GET_FLAG (op, FLAG_ALIVE); 869 case KW_can_use_ring: GET_FLAG (op, FLAG_USE_RING); break;
981 break; 870 case KW_has_ready_bow: GET_FLAG (op, FLAG_READY_BOW); break;
982 case KW_applied: 871 case KW_has_ready_range: GET_FLAG (op, FLAG_READY_RANGE); break;
983 GET_FLAG (op, FLAG_APPLIED); 872 case KW_xrays: GET_FLAG (op, FLAG_XRAYS); break;
984 break; 873 case KW_is_floor: GET_FLAG (op, FLAG_IS_FLOOR); break;
985 case KW_unpaid: 874 case KW_lifesave: GET_FLAG (op, FLAG_LIFESAVE); break;
986 GET_FLAG (op, FLAG_UNPAID); 875 case KW_no_strength: GET_FLAG (op, FLAG_NO_STRENGTH); break;
987 break; 876 case KW_sleep: GET_FLAG (op, FLAG_SLEEP); break;
988 case KW_is_animated: 877 case KW_stand_still: GET_FLAG (op, FLAG_STAND_STILL); break;
989 GET_FLAG (op, FLAG_ANIMATE); 878 case KW_random_move: GET_FLAG (op, FLAG_RANDOM_MOVE); break;
990 break; 879 case KW_only_attack: GET_FLAG (op, FLAG_ONLY_ATTACK); break;
991 case KW_no_pick: 880 case KW_activate_on_push: GET_FLAG (op, FLAG_ACTIVATE_ON_PUSH); break;
992 GET_FLAG (op, FLAG_NO_PICK); 881 case KW_activate_on_release: GET_FLAG (op, FLAG_ACTIVATE_ON_RELEASE); break;
993 break; 882 case KW_confused: GET_FLAG (op, FLAG_CONFUSED); break;
994 case KW_reflecting: 883 case KW_stealth: GET_FLAG (op, FLAG_STEALTH); break;
995 GET_FLAG (op, FLAG_REFLECTING); 884 case KW_cursed: GET_FLAG (op, FLAG_CURSED); break;
996 break; 885 case KW_damned: GET_FLAG (op, FLAG_DAMNED); break;
997 case KW_changing: 886 case KW_see_anywhere: GET_FLAG (op, FLAG_SEE_ANYWHERE); break;
998 GET_FLAG (op, FLAG_CHANGING); 887 case KW_known_magical: GET_FLAG (op, FLAG_KNOWN_MAGICAL); break;
999 break; 888 case KW_known_cursed: GET_FLAG (op, FLAG_KNOWN_CURSED); break;
1000 case KW_splitting: 889 case KW_can_use_skill: GET_FLAG (op, FLAG_CAN_USE_SKILL); break;
1001 GET_FLAG (op, FLAG_SPLITTING); 890 case KW_been_applied: GET_FLAG (op, FLAG_BEEN_APPLIED); break;
1002 break; 891 case KW_has_ready_scroll: GET_FLAG (op, FLAG_READY_SCROLL); break;
1003 case KW_hitback: 892 case KW_can_use_rod: GET_FLAG (op, FLAG_USE_ROD); break;
1004 GET_FLAG (op, FLAG_HITBACK); 893 case KW_can_use_horn: GET_FLAG (op, FLAG_USE_HORN); break;
1005 break; 894 case KW_unique: GET_FLAG (op, FLAG_UNIQUE); break;
1006 case KW_startequip: 895 case KW_make_invisible: GET_FLAG (op, FLAG_MAKE_INVIS); break;
1007 GET_FLAG (op, FLAG_STARTEQUIP); 896 case KW_inv_locked: GET_FLAG (op, FLAG_INV_LOCKED); break;
1008 break; 897 case KW_is_wooded: GET_FLAG (op, FLAG_IS_WOODED); break;
1009 case KW_blocksview: 898 case KW_is_hilly: GET_FLAG (op, FLAG_IS_HILLY); break;
1010 GET_FLAG (op, FLAG_BLOCKSVIEW); 899 case KW_is_water: GET_FLAG (op, FLAG_IS_WATER); break;
1011 break; 900 case KW_has_ready_skill: GET_FLAG (op, FLAG_READY_SKILL); break;
1012 case KW_undead: 901 case KW_has_ready_weapon: GET_FLAG (op, FLAG_READY_WEAPON); break;
1013 GET_FLAG (op, FLAG_UNDEAD); 902 case KW_no_skill_ident: GET_FLAG (op, FLAG_NO_SKILL_IDENT); break;
1014 break; 903 case KW_is_blind: GET_FLAG (op, FLAG_BLIND); break;
1015 case KW_scared: 904 case KW_can_see_in_dark: GET_FLAG (op, FLAG_SEE_IN_DARK); break;
1016 GET_FLAG (op, FLAG_SCARED); 905 case KW_is_cauldron: GET_FLAG (op, FLAG_IS_CAULDRON); break;
1017 break; 906 case KW_no_steal: GET_FLAG (op, FLAG_NO_STEAL); break;
1018 case KW_unaggressive: 907 case KW_one_hit: GET_FLAG (op, FLAG_ONE_HIT); break;
1019 GET_FLAG (op, FLAG_UNAGGRESSIVE); 908 case KW_berserk: GET_FLAG (op, FLAG_BERSERK); break;
1020 break; 909 case KW_is_buildable: GET_FLAG (op, FLAG_IS_BUILDABLE); break;
1021 case KW_reflect_missile:
1022 GET_FLAG (op, FLAG_REFL_MISSILE);
1023 break;
1024 case KW_reflect_spell:
1025 GET_FLAG (op, FLAG_REFL_SPELL);
1026 break;
1027 case KW_no_magic:
1028 GET_FLAG (op, FLAG_NO_MAGIC);
1029 break;
1030 case KW_no_drop:
1031 GET_FLAG (op, FLAG_NO_DROP);
1032 break;
1033 case KW_random_movement:
1034 GET_FLAG (op, FLAG_RANDOM_MOVE);
1035 break;
1036 case KW_was_wiz:
1037 GET_FLAG (op, FLAG_WAS_WIZ);
1038 break;
1039 case KW_no_fix_player:
1040 GET_FLAG (op, FLAG_NO_FIX_PLAYER);
1041 break;
1042 case KW_is_lightable:
1043 GET_FLAG (op, FLAG_IS_LIGHTABLE);
1044 break;
1045 case KW_tear_down:
1046 GET_FLAG (op, FLAG_TEAR_DOWN);
1047 break;
1048 case KW_can_use_shield:
1049 GET_FLAG (op, FLAG_USE_SHIELD);
1050 break;
1051 case KW_can_cast_spell:
1052 GET_FLAG (op, FLAG_CAST_SPELL);
1053 break;
1054 case KW_can_use_scroll:
1055 GET_FLAG (op, FLAG_USE_SCROLL);
1056 break;
1057 case KW_can_use_range:
1058 GET_FLAG (op, FLAG_USE_RANGE);
1059 break;
1060 case KW_can_use_bow:
1061 GET_FLAG (op, FLAG_USE_BOW);
1062 break;
1063 case KW_can_use_armour:
1064 GET_FLAG (op, FLAG_USE_ARMOUR);
1065 break;
1066 case KW_can_use_weapon:
1067 GET_FLAG (op, FLAG_USE_WEAPON);
1068 break;
1069 case KW_can_use_ring:
1070 GET_FLAG (op, FLAG_USE_RING);
1071 break;
1072 case KW_has_ready_bow:
1073 GET_FLAG (op, FLAG_READY_BOW);
1074 break;
1075 case KW_xrays:
1076 GET_FLAG (op, FLAG_XRAYS);
1077 break;
1078 case KW_is_floor:
1079 GET_FLAG (op, FLAG_IS_FLOOR);
1080 break;
1081 case KW_lifesave:
1082 GET_FLAG (op, FLAG_LIFESAVE);
1083 break;
1084 case KW_no_strength:
1085 GET_FLAG (op, FLAG_NO_STRENGTH);
1086 break;
1087 case KW_sleep:
1088 GET_FLAG (op, FLAG_SLEEP);
1089 break;
1090 case KW_stand_still:
1091 GET_FLAG (op, FLAG_STAND_STILL);
1092 break;
1093 case KW_random_move:
1094 GET_FLAG (op, FLAG_RANDOM_MOVE);
1095 break;
1096 case KW_only_attack:
1097 GET_FLAG (op, FLAG_ONLY_ATTACK);
1098 break;
1099 case KW_activate_on_push:
1100 GET_FLAG (op, FLAG_ACTIVATE_ON_PUSH);
1101 break;
1102 case KW_activate_on_release:
1103 GET_FLAG (op, FLAG_ACTIVATE_ON_RELEASE);
1104 break;
1105 case KW_confused:
1106 GET_FLAG (op, FLAG_CONFUSED);
1107 break;
1108 case KW_stealth:
1109 GET_FLAG (op, FLAG_STEALTH);
1110 break;
1111 case KW_cursed:
1112 GET_FLAG (op, FLAG_CURSED);
1113 break;
1114 case KW_damned:
1115 GET_FLAG (op, FLAG_DAMNED);
1116 break;
1117 case KW_see_anywhere:
1118 GET_FLAG (op, FLAG_SEE_ANYWHERE);
1119 break;
1120 case KW_known_magical:
1121 GET_FLAG (op, FLAG_KNOWN_MAGICAL);
1122 break;
1123 case KW_known_cursed:
1124 GET_FLAG (op, FLAG_KNOWN_CURSED);
1125 break;
1126 case KW_can_use_skill:
1127 GET_FLAG (op, FLAG_CAN_USE_SKILL);
1128 break;
1129 case KW_been_applied:
1130 GET_FLAG (op, FLAG_BEEN_APPLIED);
1131 break;
1132 case KW_has_ready_scroll:
1133 GET_FLAG (op, FLAG_READY_SCROLL);
1134 break;
1135 case KW_can_use_rod:
1136 GET_FLAG (op, FLAG_USE_ROD);
1137 break;
1138 case KW_can_use_horn:
1139 GET_FLAG (op, FLAG_USE_HORN);
1140 break;
1141 case KW_unique:
1142 GET_FLAG (op, FLAG_UNIQUE);
1143 break;
1144 case KW_make_invisible:
1145 GET_FLAG (op, FLAG_MAKE_INVIS);
1146 break;
1147 case KW_inv_locked:
1148 GET_FLAG (op, FLAG_INV_LOCKED);
1149 break;
1150 case KW_is_wooded:
1151 GET_FLAG (op, FLAG_IS_WOODED);
1152 break;
1153 case KW_is_hilly:
1154 GET_FLAG (op, FLAG_IS_HILLY);
1155 break;
1156 case KW_is_water:
1157 GET_FLAG (op, FLAG_IS_WATER);
1158 break;
1159 case KW_has_ready_skill:
1160 GET_FLAG (op, FLAG_READY_SKILL);
1161 break;
1162 case KW_has_ready_weapon:
1163 GET_FLAG (op, FLAG_READY_WEAPON);
1164 break;
1165 case KW_no_skill_ident:
1166 GET_FLAG (op, FLAG_NO_SKILL_IDENT);
1167 break;
1168 case KW_is_blind:
1169 GET_FLAG (op, FLAG_BLIND);
1170 break;
1171 case KW_can_see_in_dark:
1172 GET_FLAG (op, FLAG_SEE_IN_DARK);
1173 break;
1174 case KW_is_cauldron:
1175 GET_FLAG (op, FLAG_IS_CAULDRON);
1176 break;
1177 case KW_no_steal:
1178 GET_FLAG (op, FLAG_NO_STEAL);
1179 break;
1180 case KW_one_hit:
1181 GET_FLAG (op, FLAG_ONE_HIT);
1182 break;
1183 case KW_berserk:
1184 GET_FLAG (op, FLAG_BERSERK);
1185 break;
1186 case KW_is_buildable:
1187 GET_FLAG (op, FLAG_IS_BUILDABLE);
1188 break;
1189 910
1190 case KW_armour: 911 case KW_armour: thawer.get (op->resist[ATNR_PHYSICAL]); break;
1191 thawer.get (op->resist[ATNR_PHYSICAL]); 912 case KW_resist_physical: thawer.get (op->resist[ATNR_PHYSICAL]); break;
1192 break; 913 case KW_resist_magic: thawer.get (op->resist[ATNR_MAGIC]); break;
1193 case KW_resist_physical: 914 case KW_resist_fire: thawer.get (op->resist[ATNR_FIRE]); break;
1194 thawer.get (op->resist[ATNR_PHYSICAL]);
1195 break;
1196 case KW_resist_magic:
1197 thawer.get (op->resist[ATNR_MAGIC]);
1198 break;
1199 case KW_resist_fire:
1200 thawer.get (op->resist[ATNR_FIRE]);
1201 break;
1202 case KW_resist_electricity:
1203 thawer.get (op->resist[ATNR_ELECTRICITY]); 915 case KW_resist_electricity: thawer.get (op->resist[ATNR_ELECTRICITY]); break;
1204 break; 916 case KW_resist_cold: thawer.get (op->resist[ATNR_COLD]); break;
1205 case KW_resist_cold: 917 case KW_resist_confusion: thawer.get (op->resist[ATNR_CONFUSION]); break;
1206 thawer.get (op->resist[ATNR_COLD]); 918 case KW_resist_acid: thawer.get (op->resist[ATNR_ACID]); break;
1207 break; 919 case KW_resist_drain: thawer.get (op->resist[ATNR_DRAIN]); break;
1208 case KW_resist_confusion:
1209 thawer.get (op->resist[ATNR_CONFUSION]);
1210 break;
1211 case KW_resist_acid:
1212 thawer.get (op->resist[ATNR_ACID]);
1213 break;
1214 case KW_resist_drain:
1215 thawer.get (op->resist[ATNR_DRAIN]);
1216 break;
1217 case KW_resist_weaponmagic:
1218 thawer.get (op->resist[ATNR_WEAPONMAGIC]); 920 case KW_resist_weaponmagic: thawer.get (op->resist[ATNR_WEAPONMAGIC]); break;
1219 break; 921 case KW_resist_ghosthit: thawer.get (op->resist[ATNR_GHOSTHIT]); break;
1220 case KW_resist_ghosthit: 922 case KW_resist_poison: thawer.get (op->resist[ATNR_POISON]); break;
1221 thawer.get (op->resist[ATNR_GHOSTHIT]); 923 case KW_resist_slow: thawer.get (op->resist[ATNR_SLOW]); break;
1222 break; 924 case KW_resist_paralyze: thawer.get (op->resist[ATNR_PARALYZE]); break;
1223 case KW_resist_poison:
1224 thawer.get (op->resist[ATNR_POISON]);
1225 break;
1226 case KW_resist_slow:
1227 thawer.get (op->resist[ATNR_SLOW]);
1228 break;
1229 case KW_resist_paralyze:
1230 thawer.get (op->resist[ATNR_PARALYZE]);
1231 break;
1232 case KW_resist_turn_undead:
1233 thawer.get (op->resist[ATNR_TURN_UNDEAD]); 925 case KW_resist_turn_undead: thawer.get (op->resist[ATNR_TURN_UNDEAD]); break;
1234 break; 926 case KW_resist_fear: thawer.get (op->resist[ATNR_FEAR]); break;
1235 case KW_resist_fear:
1236 thawer.get (op->resist[ATNR_FEAR]);
1237 break;
1238 case KW_resist_cancellation:
1239 thawer.get (op->resist[ATNR_CANCELLATION]); 927 case KW_resist_cancellation: thawer.get (op->resist[ATNR_CANCELLATION]); break;
1240 break; 928 case KW_resist_deplete: thawer.get (op->resist[ATNR_DEPLETE]); break;
1241 case KW_resist_deplete: 929 case KW_resist_death: thawer.get (op->resist[ATNR_DEATH]); break;
1242 thawer.get (op->resist[ATNR_DEPLETE]); 930 case KW_resist_chaos: thawer.get (op->resist[ATNR_CHAOS]); break;
1243 break;
1244 case KW_resist_death:
1245 thawer.get (op->resist[ATNR_DEATH]);
1246 break;
1247 case KW_resist_chaos:
1248 thawer.get (op->resist[ATNR_CHAOS]);
1249 break;
1250 case KW_resist_counterspell:
1251 thawer.get (op->resist[ATNR_COUNTERSPELL]); 931 case KW_resist_counterspell: thawer.get (op->resist[ATNR_COUNTERSPELL]); break;
1252 break; 932 case KW_resist_godpower: thawer.get (op->resist[ATNR_GODPOWER]); break;
1253 case KW_resist_godpower: 933 case KW_resist_holyword: thawer.get (op->resist[ATNR_HOLYWORD]); break;
1254 thawer.get (op->resist[ATNR_GODPOWER]); 934 case KW_resist_blind: thawer.get (op->resist[ATNR_BLIND]); break;
1255 break; 935 case KW_resist_internal: thawer.get (op->resist[ATNR_INTERNAL]); break;
1256 case KW_resist_holyword: 936 case KW_resist_life_stealing: thawer.get (op->resist[ATNR_LIFE_STEALING]); break;
1257 thawer.get (op->resist[ATNR_HOLYWORD]); 937 case KW_resist_disease: thawer.get (op->resist[ATNR_DISEASE]); break;
1258 break;
1259 case KW_resist_blind:
1260 thawer.get (op->resist[ATNR_BLIND]);
1261 break;
1262 case KW_resist_internal:
1263 thawer.get (op->resist[ATNR_INTERNAL]);
1264 break;
1265 case KW_resist_life_stealing:
1266 thawer.get (op->resist[ATNR_LIFE_STEALING]);
1267 break;
1268 case KW_resist_disease:
1269 thawer.get (op->resist[ATNR_DISEASE]);
1270 break;
1271 938
1272 case KW_luck: 939 case KW_luck: thawer.get (op->stats.luck); break;
1273 thawer.get (op->stats.luck); 940 case KW_run_away: thawer.get (op->run_away); break;
1274 break; 941 case KW_pick_up: thawer.get (op->pick_up); break;
1275 case KW_run_away: 942 case KW_item_power: thawer.get (op->item_power); break;
1276 thawer.get (op->run_away); 943 case KW_gen_sp_armour: thawer.get (op->gen_sp_armour); break;
1277 break; 944 case KW_anim_speed: thawer.get (op->anim_speed); break;
1278 case KW_pick_up: 945 case KW_container: thawer.get (op->weight_limit); break;
1279 thawer.get (op->pick_up); 946 case KW_will_apply: thawer.get (op->will_apply); break;
1280 break; 947 case KW_attack_movement: thawer.get (op->attack_movement); break;
1281 case KW_item_power: 948 case KW_move_state: thawer.get (op->move_status); break;
1282 thawer.get (op->item_power); 949 case KW_expmul: thawer.get (op->expmul); break;
1283 break; 950 case KW_glow_radius: thawer.get (op->glow_radius); break;
1284 case KW_gen_sp_armour: 951 case KW_weapontype: thawer.get (op->weapontype); break;
1285 thawer.get (op->gen_sp_armour); 952 case KW_tooltype: thawer.get (op->tooltype); break;
1286 break; 953 case KW_casting_time: thawer.get (op->casting_time); break;
1287 case KW_anim_speed: 954 case KW_elevation: thawer.get (op->elevation); break;
1288 thawer.get (op->anim_speed); 955 case KW_smoothlevel: thawer.get (op->smoothlevel); break;
1289 break; 956 case KW_client_type: thawer.get (op->client_type); break;
1290 case KW_container: 957 case KW_duration: thawer.get (op->duration); break;
1291 thawer.get (op->weight_limit); 958 case KW_range: thawer.get (op->range); break;
1292 break; 959 case KW_range_modifier: thawer.get (op->range_modifier); break;
1293 case KW_will_apply: 960 case KW_dam_modifier: thawer.get (op->dam_modifier); break;
1294 thawer.get (op->will_apply); 961 case KW_duration_modifier: thawer.get (op->duration_modifier); break;
1295 break;
1296 case KW_attack_movement:
1297 thawer.get (op->attack_movement);
1298 break;
1299 case KW_move_state:
1300 thawer.get (op->move_status);
1301 break;
1302 case KW_expmul:
1303 thawer.get (op->expmul);
1304 break;
1305 case KW_glow_radius:
1306 thawer.get (op->glow_radius);
1307 break;
1308 case KW_weapontype:
1309 thawer.get (op->weapontype);
1310 break;
1311 case KW_tooltype:
1312 thawer.get (op->tooltype);
1313 break;
1314 case KW_casting_time:
1315 thawer.get (op->casting_time);
1316 break;
1317 case KW_elevation:
1318 thawer.get (op->elevation);
1319 break;
1320 case KW_smoothlevel:
1321 thawer.get (op->smoothlevel);
1322 break;
1323 case KW_client_type:
1324 thawer.get (op->client_type);
1325 break;
1326 case KW_duration:
1327 thawer.get (op->duration);
1328 break;
1329 case KW_range:
1330 thawer.get (op->range);
1331 break;
1332 case KW_range_modifier:
1333 thawer.get (op->range_modifier);
1334 break;
1335 case KW_dam_modifier:
1336 thawer.get (op->dam_modifier);
1337 break;
1338 case KW_duration_modifier:
1339 thawer.get (op->duration_modifier);
1340 break;
1341 962
1342 //TODO: mechanism to ensure that KW_xxx is consecutive needed from include/preprocess 963 //TODO: mechanism to ensure that KW_xxx is consecutive needed from include/preprocess
1343 //TODO: parse from other include files 964 //TODO: parse from other include files
1344 case KW_body_range: 965 case KW_body_range: thawer.get (op->body_info[0]); break;
1345 thawer.get (op->body_info[0]); 966 case KW_body_arm: thawer.get (op->body_info[1]); break;
1346 break; 967 case KW_body_torso: thawer.get (op->body_info[2]); break;
1347 case KW_body_arm: 968 case KW_body_head: thawer.get (op->body_info[3]); break;
1348 thawer.get (op->body_info[1]); 969 case KW_body_neck: thawer.get (op->body_info[4]); break;
1349 break; 970 case KW_body_skill: thawer.get (op->body_info[5]); break;
1350 case KW_body_torso: 971 case KW_body_finger: thawer.get (op->body_info[6]); break;
1351 thawer.get (op->body_info[2]); 972 case KW_body_shoulder: thawer.get (op->body_info[7]); break;
1352 break; 973 case KW_body_foot: thawer.get (op->body_info[8]); break;
1353 case KW_body_head: 974 case KW_body_hand: thawer.get (op->body_info[9]); break;
1354 thawer.get (op->body_info[3]); 975 case KW_body_wrist: thawer.get (op->body_info[10]); break;
1355 break; 976 case KW_body_waist: thawer.get (op->body_info[11]); break;
1356 case KW_body_neck:
1357 thawer.get (op->body_info[4]);
1358 break;
1359 case KW_body_skill:
1360 thawer.get (op->body_info[5]);
1361 break;
1362 case KW_body_finger:
1363 thawer.get (op->body_info[6]);
1364 break;
1365 case KW_body_shoulder:
1366 thawer.get (op->body_info[7]);
1367 break;
1368 case KW_body_foot:
1369 thawer.get (op->body_info[8]);
1370 break;
1371 case KW_body_hand:
1372 thawer.get (op->body_info[9]);
1373 break;
1374 case KW_body_wrist:
1375 thawer.get (op->body_info[10]);
1376 break;
1377 case KW_body_waist:
1378 thawer.get (op->body_info[11]);
1379 break;
1380 case KW_can_apply: 977 case KW_can_apply:
1381 break; 978 break;
1382 979
1383 case KW_connected: 980 case KW_connected:
1384 add_button_link (op, op->map, thawer.get_sint32 ()); 981 add_button_link (op, op->map, thawer.get_sint32 ());
… …
1387 case KW_randomitems: 984 case KW_randomitems:
1388 op->randomitems = find_treasurelist (thawer.get_str ()); 985 op->randomitems = find_treasurelist (thawer.get_str ());
1389 break; 986 break;
1390 987
1391 case KW_msg: 988 case KW_msg:
1392 {
1393 thawer.get_ml (KW_endmsg, op->msg); 989 thawer.get_ml (KW_endmsg, op->msg);
1394 //TODO: allow longer messages 990 //TODO: allow longer messages
1395 if (strlen (op->msg) >= HUGE_BUF) 991 if (strlen (op->msg) >= HUGE_BUF)
1396 { 992 {
1397 LOG (llevDebug, "\n\tError message length >= %d: %d\n>%.80s<\n", HUGE_BUF, strlen (op->msg), &op->msg); 993 LOG (llevDebug, "\tError message length >= %d: %d\n>%.80s<\n", HUGE_BUF, strlen (op->msg), &op->msg);
1398 op->msg = "ERROR, please report: string too long, winged.\n"; 994 op->msg = "ERROR, please report: string too long, winged.\n";
1399 } 995 }
1400 }
1401 break; 996 break;
1402 997
1403 case KW_lore: 998 case KW_lore:
1404 {
1405 shstr msgbuf;
1406
1407 thawer.get_ml (KW_endlore, op->lore); 999 thawer.get_ml (KW_endlore, op->lore);
1408 //TODO: allow longer messages 1000 //TODO: allow longer messages
1409 /* Just print a warning so we can be reasonably safe 1001 /* Just print a warning so we can be reasonably safe
1410 * about not overflowing the buffer. 1002 * about not overflowing the buffer.
1411 */ 1003 */
1412 if (strlen (op->lore) > (HUGE_BUF / 2)) 1004 if (strlen (op->lore) > (HUGE_BUF / 2))
1413 LOG (llevDebug, "\n\tWarning lore length > %d (max allowed=%d): %d\n>%.80s<\n", 1005 LOG (llevDebug, "\tWarning lore length > %d (max allowed=%d): %d\n>%.80s<\n",
1414 HUGE_BUF / 2, HUGE_BUF, strlen (op->lore), &op->lore); 1006 HUGE_BUF / 2, HUGE_BUF, strlen (op->lore), &op->lore);
1415 }
1416 break; 1007 break;
1417 1008
1418 case KW_editable: 1009 case KW_editable:
1419 case KW_editor_folder: 1010 case KW_editor_folder:
1420 break; 1011 break;
… …
1437 1028
1438 case KW_EOF: 1029 case KW_EOF:
1439 return LL_EOF; 1030 return LL_EOF;
1440 1031
1441 case KW_ERROR: 1032 case KW_ERROR:
1442 set_ob_key_value (op, thawer.line, thawer.last_value, true); 1033 set_ob_key_value (op, thawer.last_keyword, thawer.last_value, true);
1443 //printf ("addkv(%s,%s)\n", thawer.line, thawer.get_str());//D 1034 //fprintf (stderr, "addkv(%s,%s)\n", thawer.last_keyword, thawer.last_value);//D
1444
1445 //TODO: skip line, ugly, factor parsing better
1446 if (thawer.last_value)
1447 thawer.line = thawer.last_value;
1448
1449 thawer.line += strlen (thawer.line) + 1;
1450
1451 break; 1035 break;
1452 1036
1453 default: 1037 default:
1454 LOG (llevError, "UNSUPPORTED KEYWORD IN MAP: \"%s\", bug in normaliser. skipping.\n", keyword_str[kw]); 1038 LOG (llevError, "UNSUPPORTED KEYWORD IN MAP: \"%s\", bug in normaliser. skipping.\n", keyword_str[kw]);
1455 break; 1039 break;
… …
1469 * LO_NEWFILE (2): This is the first read from a particular file, so the buffers should 1053 * LO_NEWFILE (2): This is the first read from a particular file, so the buffers should
1470 * be reset. 1054 * be reset.
1471 * LO_NOREAD (3): Reset the buffers, but don't read from it. (op can be null) 1055 * LO_NOREAD (3): Reset the buffers, but don't read from it. (op can be null)
1472 * 1056 *
1473 */ 1057 */
1474
1475int 1058int
1476load_object (object_thawer & fp, object *op, int map_flags) 1059load_object (object_thawer &fp, object *op, int map_flags)
1477{ 1060{
1061 coroapi::cede_every (1000); // cede once in a while
1062
1478 return parse_object (op, fp, map_flags); 1063 return parse_object (op, fp, map_flags);
1479} 1064}
1480
1481 1065
1482/* This takes a buffer, scans it for variables, and sets those variables 1066/* This takes a buffer, scans it for variables, and sets those variables
1483 * as appropriate in op. 1067 * as appropriate in op.
1484 * 1068 *
1485 * This function appears to be used in only 2 places - in crossedit to 1069 * This function appears to be used in only 2 places - in crossedit to
1486 * override values and in c_wiz to mutate values. 1070 * override values and in c_wiz to mutate values.
1487 */ 1071 */
1488int 1072int
1489set_variable (object *op, char *buf) 1073set_variable (object *op, char *buf)
1490{ 1074{
1491 return 0;
1492#if 0
1493 int retval;
1494 object_thawer thawer (0); 1075 object_thawer thawer (buf, (AV *)0);
1495 1076
1496 strcpy (msgbuf, "");
1497 strcpy (lorebuf, "");
1498 retval = parse_object (op, thawer, 0); 1077 return parse_object (op, thawer, 0);
1499 yy_switch_to_buffer (yycurbuf);
1500 yy_delete_buffer (yybufstate);
1501 yy_pop_state ();
1502 return retval;
1503#endif
1504} 1078}
1505
1506/* This array equates the FLAG_ values with the V_ values. Use -1 to
1507 * put gaps in the array that should not be processed.
1508 * The order matches the order of the define values in 'define.h'.
1509 */
1510
1511/* This is a list of pointers that correspond to the FLAG_.. values.
1512 * This is a simple 1:1 mapping - if FLAG_FRIENDLY is 15, then
1513 * the 15'th element of this array should match that name.
1514 * If an entry is NULL, that is a flag not to loaded/saved.
1515 */
1516static const char *const flag_names[NUM_FLAGS + 1] = {
1517 "alive", "wiz", NULL, NULL, "was_wiz", "applied", "unpaid",
1518 "can_use_shield", "no_pick", NULL /* walk_on */ , NULL /* no_pass */ , /* 10 */
1519 "is_animated", NULL /* slow_move */ ,
1520 NULL /* flying */ , "monster", "friendly", "generator",
1521 "is_thrown", "auto_apply", "treasure", "player sold", /* 20 */
1522 "see_invisible", "can_roll", "overlay_floor",
1523 "is_turnable", NULL /* walk_off */ , NULL /* fly_on */ ,
1524 NULL /*fly_off */ , "is_used_up", "identified", "reflecting", /* 30 */
1525 "changing", "splitting", "hitback", "startequip",
1526 "blocksview", "undead", "scared", "unaggressive",
1527 "reflect_missile", "reflect_spell", /* 40 */
1528 "no_magic", "no_fix_player", "is_lightable", "tear_down",
1529 "run_away", NULL /*pass_thru */ , NULL /*can_pass_thru */ ,
1530 "pick_up", "unique", "no_drop", /* 50 */
1531 NULL /* wizcast */ , "can_cast_spell", "can_use_scroll", "can_use_range",
1532 "can_use_bow", "can_use_armour", "can_use_weapon",
1533 "can_use_ring", "has_ready_range", "has_ready_bow", /* 60 */
1534 "xrays", NULL, "is_floor", "lifesave", "no_strength", "sleep",
1535 "stand_still", "random_move", "only_attack", "confused", /* 70 */
1536 "stealth", NULL, NULL, "cursed", "damned",
1537 "see_anywhere", "known_magical", "known_cursed",
1538 "can_use_skill", "been_applied", /* 80 */
1539 "has_ready_scroll", "can_use_rod", NULL,
1540 "can_use_horn", "make_invisible", "inv_locked", "is_wooded",
1541 "is_hilly", "has_ready_skill", "has_ready_weapon", /* 90 */
1542 "no_skill_ident", "is_blind", "can_see_in_dark", "is_cauldron",
1543 "is_dust", "no_steal", "one_hit", NULL, "berserk", "neutral", /* 100 */
1544 "no_attack", "no_damage", NULL, NULL, "activate_on_push",
1545 "activate_on_release", "is_water", "use_content_on_gen", NULL, "is_buildable", /* 110 */
1546 NULL
1547};
1548
1549 1079
1550/* 1080/*
1551 * Initialises the array of variable-names. Needed before any 1081 * Initialises the array of variable-names. Needed before any
1552 * objects can be loaded. Called by init_library(). 1082 * objects can be loaded. Called by init_library().
1553 */ 1083 */
… …
1610 1140
1611// compare *op against *tmp and output differences 1141// compare *op against *tmp and output differences
1612void 1142void
1613put (object_freezer &f, object *op, object *tmp) 1143put (object_freezer &f, object *op, object *tmp)
1614{ 1144{
1145 static const keyword resist_save[NROFATTACKS] = {
1146# define def(uc, lc, name, plus, change) KW_resist_ ## lc,
1147# include "attackinc.h"
1148# undef def
1149 };
1150
1151 /* This is a list of keywords that correspond to the FLAG_.. values.
1152 * This is a simple 1:1 mapping - if FLAG_FRIENDLY is 15, then
1153 * the 15'th element of this array should match that name.
1154 * If an entry is NULL, that is a flag not to loaded/saved.
1155 */
1156 static const keyword flag_names [NUM_FLAGS] = {
1157 KW_alive,
1158 KW_wiz,
1159 KW_NULL,
1160 KW_NULL,
1161 KW_was_wiz,
1162 KW_applied,
1163 KW_unpaid,
1164 KW_can_use_shield,
1165 KW_no_pick,
1166 KW_NULL, // walk_on
1167 KW_NULL, // no_pass
1168 /* 10 */
1169 KW_is_animated,
1170 KW_NULL, // slow_move
1171 KW_NULL, // flying
1172 KW_monster,
1173 KW_friendly,
1174 KW_generator,
1175 KW_is_thrown,
1176 KW_auto_apply,
1177 KW_NULL, // was KW_treasure
1178 KW_player_sold,
1179 /* 20 */
1180 KW_see_invisible,
1181 KW_can_roll,
1182 KW_overlay_floor,
1183 KW_is_turnable,
1184 KW_NULL, // walk_off
1185 KW_NULL, // fly_on
1186 KW_NULL, // fly_off
1187 KW_is_used_up,
1188 KW_identified,
1189 KW_reflecting,
1190 /* 30 */
1191 KW_changing,
1192 KW_splitting,
1193 KW_hitback,
1194 KW_startequip,
1195 KW_blocksview,
1196 KW_undead,
1197 KW_scared,
1198 KW_unaggressive,
1199 KW_reflect_missile,
1200 KW_reflect_spell,
1201 /* 40 */
1202 KW_no_magic,
1203 KW_no_fix_player,
1204 KW_is_lightable,
1205 KW_tear_down,
1206 KW_run_away,
1207 KW_NULL, // pass_thru
1208 KW_NULL, // an_pass_thru
1209 KW_pick_up,
1210 KW_unique,
1211 KW_no_drop,
1212 /* 50 */
1213 KW_NULL, // wizcast
1214 KW_can_cast_spell,
1215 KW_can_use_scroll,
1216 KW_can_use_range,
1217 KW_can_use_bow,
1218 KW_can_use_armour,
1219 KW_can_use_weapon,
1220 KW_can_use_ring,
1221 KW_has_ready_range,
1222 KW_has_ready_bow,
1223 /* 60 */
1224 KW_xrays,
1225 KW_NULL,
1226 KW_is_floor,
1227 KW_lifesave,
1228 KW_no_strength,
1229 KW_sleep,
1230 KW_stand_still,
1231 KW_random_move,
1232 KW_only_attack,
1233 KW_confused,
1234 /* 70 */
1235 KW_stealth,
1236 KW_NULL,
1237 KW_NULL,
1238 KW_cursed,
1239 KW_damned,
1240 KW_see_anywhere,
1241 KW_known_magical,
1242 KW_known_cursed,
1243 KW_can_use_skill,
1244 KW_been_applied,
1245 /* 80 */
1246 KW_has_ready_scroll,
1247 KW_can_use_rod,
1248 KW_NULL,
1249 KW_can_use_horn,
1250 KW_make_invisible,
1251 KW_inv_locked,
1252 KW_is_wooded,
1253 KW_is_hilly,
1254 KW_has_ready_skill,
1255 KW_has_ready_weapon,
1256 /* 90 */
1257 KW_no_skill_ident,
1258 KW_is_blind,
1259 KW_can_see_in_dark,
1260 KW_is_cauldron,
1261 KW_NULL,
1262 KW_no_steal,
1263 KW_one_hit,
1264 KW_NULL,
1265 KW_berserk,
1266 KW_neutral,
1267 /* 100 */
1268 KW_no_attack,
1269 KW_no_damage,
1270 KW_NULL,
1271 KW_NULL,
1272 KW_activate_on_push,
1273 KW_activate_on_release,
1274 KW_is_water,
1275 KW_use_content_on_gen,
1276 KW_NULL,
1277 KW_is_buildable,
1278 /* 110 */
1279 };
1280
1615 int i; 1281 int i;
1616 1282
1617 /* This saves the key/value lists. We do it first so that any 1283 /* This saves the key/value lists. We do it first so that any
1618 * keys that match field names will be overwritten by the loader. 1284 * keys that match field names will be overwritten by the loader.
1619 */ 1285 */
… …
1621 { 1287 {
1622 /* Find the field in the opposing member. */ 1288 /* Find the field in the opposing member. */
1623 key_value *arch_field = get_ob_key_link (tmp, my_field->key); 1289 key_value *arch_field = get_ob_key_link (tmp, my_field->key);
1624 1290
1625 /* If there's no partnering field, or it's got a different value, save our field. */ 1291 /* If there's no partnering field, or it's got a different value, save our field. */
1626 if (arch_field == NULL || my_field->value != arch_field->value) 1292 if (!arch_field || my_field->value != arch_field->value)
1627 f.put (my_field->key, my_field->value); 1293 f.put (my_field->key, my_field->value);
1628 } 1294 }
1629 1295
1630 /* We don't need to worry about the arch's extra fields - they 1296 /* We don't need to worry about the arch's extra fields - they
1631 * will get taken care of the copy_object function. 1297 * will get taken care of the copy_to method.
1632 */ 1298 */
1633 1299
1634 { 1300 {
1635 char uids[64]; 1301 char uids[64];
1636 snprintf (uids, sizeof (uids), "<1.%llx>", (unsigned long long)op->uuid.seq); 1302 snprintf (uids, sizeof (uids), "<1.%llx>", (unsigned long long)op->uuid.seq);
… …
1652 if (op->lore != tmp->lore) 1318 if (op->lore != tmp->lore)
1653 f.put (KW_lore, KW_endlore, op->lore); 1319 f.put (KW_lore, KW_endlore, op->lore);
1654 1320
1655 CMP_OUT (other_arch); 1321 CMP_OUT (other_arch);
1656 CMP_OUT (face); 1322 CMP_OUT (face);
1657
1658 if (!op->face || !op->face->name)
1659 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
1660 1323
1661 if (op->animation_id != tmp->animation_id) 1324 if (op->animation_id != tmp->animation_id)
1662 if (op->animation_id) 1325 if (op->animation_id)
1663 { 1326 {
1664 f.put (KW_animation, animations[GET_ANIM_ID (op)].name); 1327 f.put (KW_animation, animations[GET_ANIM_ID (op)].name);
… …
1756 CMP_OUT (move_on); 1419 CMP_OUT (move_on);
1757 CMP_OUT (move_off); 1420 CMP_OUT (move_off);
1758 CMP_OUT (move_slow); 1421 CMP_OUT (move_slow);
1759 CMP_OUT (move_slow_penalty); 1422 CMP_OUT (move_slow_penalty);
1760 1423
1761 if (!COMPARE_FLAGS (op, tmp)) 1424 if (op->flag != tmp->flag)
1762 for (i = 0; i <= NUM_FLAGS; i++) 1425 for (i = 0; i <= NUM_FLAGS; i++)
1763 if (flag_names[i] && (QUERY_FLAG (op, i) != QUERY_FLAG (tmp, i))) 1426 if (flag_names [i] && op->flag [i] != tmp->flag [i])
1764 f.put (flag_names[i], QUERY_FLAG (op, i) ? "1" : "0"); 1427 f.put (flag_names [i], op->flag [i] ? "1" : "0");
1765 1428
1766 /* Save body locations */ 1429 /* Save body locations */
1767 for (i = 0; i < NUM_BODY_LOCATIONS; i++) 1430 for (i = 0; i < NUM_BODY_LOCATIONS; i++)
1768 if (op->body_info[i] != tmp->body_info[i]) 1431 if (op->body_info[i] != tmp->body_info[i])
1769 f.put (body_locations[i].save_name, op->body_info[i]); 1432 f.put (body_locations[i].save_name, op->body_info[i]);
… …
1771 1434
1772/* 1435/*
1773 * Dumps all variables in an object to a file. 1436 * Dumps all variables in an object to a file.
1774 * If bit 0 of flag is set, unpaid objects will be saved. As of now, 1437 * If bit 0 of flag is set, unpaid objects will be saved. As of now,
1775 * the only place this is not set is when saving the player. 1438 * the only place this is not set is when saving the player.
1776 * If bit 1 of flag is set, don't remove the object after save. As of now,
1777 * all of the callers are setting this.
1778 */ 1439 */
1779
1780void 1440void
1781save_object (object_freezer & fp, object *op, int flag) 1441save_object (object_freezer &fp, object *op, int flag)
1782{ 1442{
1783 archetype *at;
1784 object *tmp, *old;
1785
1786 /* Even if the object does have an owner, it would seem that we should 1443 /* Even if the object does have an owner, it would seem that we should
1787 * still save it. 1444 * still save it.
1788 */ 1445 */
1789 if (op->owner) 1446 if (op->owner)
1790 return; 1447 return;
1791 1448
1792 /* If it is unpaid and we don't want to save those, just return. */ 1449 /* If it is unpaid and we don't want to save those, just return. */
1793 if (!(flag & 1) && (QUERY_FLAG (op, FLAG_UNPAID))) 1450 if (!(flag & 1) && op->flag [FLAG_UNPAID])
1794 return; 1451 return;
1795 1452
1796 if ((at = op->arch) == NULL) 1453 archetype *at = op->arch ? (archetype *)op->arch : empty_archetype;
1797 at = empty_archetype;
1798 1454
1799 fp.put (KW_arch, at->name); 1455 fp.put (KW_arch, at->name);
1800
1801 put (fp, op, &at->clone); 1456 put (fp, op, &at->clone);
1802 1457
1803 /* Eneq(@csd.uu.se): Added this to allow containers being saved with contents */ 1458 /* Eneq(@csd.uu.se): Added this to allow containers being saved with contents */
1804 1459
1805 old = NULL;
1806
1807 if (flag & 2)
1808 for (tmp = op->inv; tmp != NULL; tmp = tmp->below) 1460 for (object *tmp = op->inv; tmp; tmp = tmp->below)
1809 save_object (fp, tmp, flag); 1461 save_object (fp, tmp, flag);
1810 else
1811 /* Slightly different logic because tmp/op will be removed by
1812 * the save_object we call. So we just keep looking at op->inv
1813 * until there is nothing left. In theory, the variable old
1814 * should not be needed, as recursive loops shouldn't happen.
1815 */
1816 while ((tmp = op->inv) != NULL)
1817 {
1818 if (old == tmp)
1819 {
1820 LOG (llevError, " Recursive loop in inventory\n");
1821 break;
1822 }
1823
1824 save_object (fp, tmp, flag);
1825 old = tmp;
1826 }
1827
1828 if (!(flag & 2))
1829 {
1830 remove_ob (op);
1831 free_object (op);
1832 }
1833 1462
1834 fp.put (op); 1463 fp.put (op);
1835 fprintf (fp, "end\n"); 1464 fp.put (KW_end);
1836} 1465}
1837 1466

Diff Legend

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