ViewVC Help

View File | Revision Log | Show Annotations | Download File

/cvs/deliantra/server/common/loader.C

Comparing deliantra/server/common/loader.C (file contents):
Revision 1.14 by root, Tue Sep 12 19:20:06 2006 UTC vs.
Revision 1.17 by root, Thu Sep 14 22:33:59 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. */
…		…
500	{	499	{
501	keyword kw = thawer.get_kv ();	500	keyword kw = thawer.get_kv ();
502		501
503	switch (kw)	502	switch (kw)
504	{	503	{
505	case KW_Object: // uppercase alias	504	case KW_Object: // uppercase alias
506	case KW_object:	505	case KW_object:
507	thawer.get (op->name);	506	thawer.get (op->name);
508		507
509	if (op->arch != NULL)	508	if (op->arch != NULL)
510	op->arch->name = op->name;	509	op->arch->name = op->name;
511		510
512	break;	511	break;
513		512
514	case KW_oid:	513	case KW_uuid:
515	thawer.get (op, thawer.get_sint32 ());	514	if (const char *s = thawer.get_str ())
516	break;
517
518	case KW_name:
519	thawer.get (op->name);
520	break;
521	case KW_name_pl:
522	thawer.get (op->name_pl);
523	break;
524	case KW_title:
525	thawer.get (op->title);
526	break;
527	case KW_custom_name:
528	thawer.get (op->custom_name);
529	break;
530	case KW_attach:
531	thawer.get_ornull (op->attach);
532	break;
533	case KW_skill:
534	thawer.get_ornull (op->skill);
535	break;
536	case KW_race:
537	thawer.get_ornull (op->race);
538	break;
539	case KW_slaying:
540	thawer.get_ornull (op->slaying);
541	break;
542
543	case KW_arch:
544	{	515	{
545	const char *str = thawer.get_str ();	516	unsigned int version;
		517	unsigned long long seq;
546		518
547	if (op->arch)	519	if (2 == sscanf (s, "<%d.%llx>", &version, &seq) && version == 1)
548	{	520	{
549	/* If op->arch has been set, then this new object	521	op->uuid.seq = seq;
550	* must be part of the inventory. So process
551	* appropriately.
552	*/
553	archetype *arch = find_archetype (str);
554
555	object *tmp;
556
557	if (arch != NULL)
558	tmp = arch_to_object (arch);
559	else	522	break;
560	{
561	tmp = get_object ();
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	}
595	else
596	{
597	LOG (llevDebug, "Discarding object without arch: %s\n", tmp->name ? (const char *) tmp->name : "(null)");
598	free_object (tmp);
599	}
600	}
601	else
602	{
603	/* This is the actual archetype definition then */
604	op->arch = find_archetype (str);
605
606	if (op->arch != NULL)
607	copy_object (&op->arch->clone, op);
608	else if (!arch_init)
609	/* record the name of the broken object */
610	op->name = str;
611	}	523	}
612	}	524	}
		525
		526	op->uuid = gen_uuid ();
613	break;	527	break;
614		528
615	case KW_other_arch:	529	case KW_oid:
616	op->other_arch = find_archetype (thawer.get_str ());	530	thawer.get (op, thawer.get_sint32 ());
617	break;	531	break;
618		532
619	case KW_animation:	533	case KW_name:
		534	thawer.get (op->name);
		535	break;
		536	case KW_name_pl:
		537	thawer.get (op->name_pl);
		538	break;
		539	case KW_title:
		540	thawer.get (op->title);
		541	break;
		542	case KW_custom_name:
		543	thawer.get (op->custom_name);
		544	break;
		545	case KW_attach:
		546	thawer.get_ornull (op->attach);
		547	break;
		548	case KW_skill:
		549	thawer.get_ornull (op->skill);
		550	break;
		551	case KW_race:
		552	thawer.get_ornull (op->race);
		553	break;
		554	case KW_slaying:
		555	thawer.get_ornull (op->slaying);
		556	break;
		557
		558	case KW_arch:
620	{	559	{
621	const char *str = thawer.get_str ();	560	const char *str = thawer.get_str ();
622		561
623	if (!str)	562	if (op->arch)
624	{
625	op->animation_id = 0;
626	CLEAR_FLAG (op, FLAG_ANIMATE);
627	}
628	else
629	{
630	op->animation_id = find_animation (str);
631	SET_FLAG (op, FLAG_ANIMATE);
632	}
633	}
634
635	break;
636
637	case KW_last_heal:
638	thawer.get (op->last_heal);
639	break;
640	case KW_last_sp:
641	thawer.get (op->last_sp);
642	break;
643	case KW_last_grace:
644	thawer.get (op->last_grace);
645	break;
646	case KW_last_eat:
647	thawer.get (op->last_eat);
648	break;
649	case KW_speed_left:
650	thawer.get (op->speed_left);
651	break;
652
653	case KW_speed:
654	thawer.get (op->speed);
655
656	//TODO: maybe do in check_object
657	if (!(map_flags & MAP_STYLE))
658	{	563	{
659	if (op->speed < 0)	564	/* If op->arch has been set, then this new object
660	op->speed_left = op->speed_left - RANDOM () % 100 / 100.0;	565	* must be part of the inventory. So process
661		566	* appropriately.
662	update_ob_speed (op);
663	}	567	*/
		568	archetype *arch = archetype::find (str);
664		569
665	break;	570	object *tmp;
666		571
667	case KW_slow_move:	572	if (arch != NULL)
668	op->move_slow |= MOVE_WALK;	573	tmp = arch_to_object (arch);
669	thawer.get (op->move_slow_penalty);
670	break;
671
672	case KW_face:
673	op->face = &new_faces[FindFace (thawer.get_str (), 0)];
674	break;
675
676	case KW_x:
677	thawer.get (op->x);
678	break;
679	case KW_y:
680	thawer.get (op->y);
681	break;
682	case KW_Str: // uppercase alias
683	case KW_str:
684	thawer.get (op->stats.Str);
685	break;
686	case KW_Dex: // uppercase alias
687	case KW_dex:
688	thawer.get (op->stats.Dex);
689	break;
690	case KW_Con: // uppercase alias
691	case KW_con:
692	thawer.get (op->stats.Con);
693	break;
694	case KW_Wis: // uppercase alias
695	case KW_wis:
696	thawer.get (op->stats.Wis);
697	break;
698	case KW_Cha: // uppercase alias
699	case KW_cha:
700	thawer.get (op->stats.Cha);
701	break;
702	case KW_Int: // uppercase alias
703	case KW_int:
704	thawer.get (op->stats.Int);
705	break;
706	case KW_Pow: // uppercase alias
707	case KW_pow:
708	thawer.get (op->stats.Pow);
709	break;
710	case KW_hp:
711	thawer.get (op->stats.hp);
712	break;
713	case KW_maxhp:
714	thawer.get (op->stats.maxhp);
715	break;
716	case KW_sp:
717	thawer.get (op->stats.sp);
718	break;
719	case KW_maxsp:
720	thawer.get (op->stats.maxsp);
721	break;
722	case KW_grace:
723	thawer.get (op->stats.grace);
724	break;
725	case KW_maxgrace:
726	thawer.get (op->stats.maxgrace);
727	break;
728
729	case KW_exp:
730	thawer.get (op->stats.exp);
731	break;
732	case KW_perm_exp:
733	thawer.get (op->perm_exp);
734	break;
735	case KW_food:
736	thawer.get (op->stats.food);
737	break;
738	case KW_dam:
739	thawer.get (op->stats.dam);
740	break;
741	case KW_wc:
742	thawer.get (op->stats.wc);
743	break;
744	case KW_ac:
745	thawer.get (op->stats.ac);
746	break;
747	case KW_nrof:
748	thawer.get (op->nrof);
749	break;
750	case KW_level:
751	thawer.get (op->level);
752	break;
753	case KW_direction:
754	thawer.get (op->direction);
755	break;
756	case KW_type:
757	thawer.get (op->type);
758	break;
759	case KW_subtype:
760	thawer.get (op->subtype);
761	break;
762	case KW_value:
763	thawer.get (op->value);
764	break;
765	case KW_weight:
766	thawer.get (op->weight);
767	break;
768	case KW_carrying:
769	thawer.get (op->carrying);
770	break;
771	case KW_attacktype:
772	thawer.get (op->attacktype);
773	break;
774	case KW_path_attuned:
775	thawer.get (op->path_attuned);
776	break;
777	case KW_path_repelled:
778	thawer.get (op->path_repelled);
779	break;
780	case KW_path_denied:
781	thawer.get (op->path_denied);
782	break;
783	case KW_invisible:
784	thawer.get (op->invisible);
785	break;
786	case KW_magic:
787	thawer.get (op->magic);
788	break;
789	case KW_state:
790	thawer.get (op->state);
791	break;
792	case KW_move_slow_penalty:
793	thawer.get (op->move_slow_penalty);
794	break;
795	case KW_material:
796	thawer.get (op->material);
797	break;
798	case KW_materialname:
799	thawer.get (op->materialname);
800	break;
801
802	/* These are the new values */
803	case KW_move_block:
804	set_move (op->move_block, thawer.get_str ());
805	break;
806	case KW_move_allow:
807	set_move (op->move_allow, thawer.get_str ());
808	break;
809	case KW_move_type:
810	set_move (op->move_type, thawer.get_str ());
811	break;
812	case KW_move_on:
813	set_move (op->move_on, thawer.get_str ());
814	break;
815	case KW_move_off:
816	set_move (op->move_off, thawer.get_str ());
817	break;
818	case KW_move_slow:
819	set_move (op->move_slow, thawer.get_str ());
820	break;
821
822	/* These are all legacy - any new objects should use the move_ .. values */
823	case KW_no_pass:
824	{
825	if (thawer.get_sint32 ())
826	op->move_block = MOVE_ALL;
827	else	574	else
828	op->move_block = 0;
829	}
830
831	break;
832
833	/* These are all legacy - any new objects should use the move_ .. values */
834	case KW_walk_on:
835	{	575	{
836	if (thawer.get_sint32 ())	576	tmp = get_object ();
837	op->move_on |= MOVE_WALK;	577	/* record the name of the broken object */
		578	tmp->name = str;
		579	}
		580
		581	parse_object (tmp, thawer, map_flags);
		582
		583	if (tmp->arch)
		584	{
		585	// was: insert_ob_in_ob (tmp, op);
		586	// but manually adding it can improve map loading times a lot
		587	// also, appending instead of prepending keeps the
		588	// save ordering the same between repeated load/saves.
		589	CLEAR_FLAG (tmp, FLAG_OBJ_ORIGINAL);
		590	CLEAR_FLAG (tmp, FLAG_REMOVED);
		591
		592	if (!op_inv)
		593	{
		594	op->inv = tmp;
		595	tmp->above = 0;
		596	}
		597	else
		598	{
		599	while (op_inv->below)
		600	op_inv = op_inv->below;
		601
		602	op_inv->below = tmp;
		603	tmp->above = op_inv;
		604	}
		605
		606	tmp->below = 0;
		607	tmp->env = op;
		608	op_inv = tmp;
		609	}
838	else	610	else
839	op->move_on &= ~MOVE_WALK;
840	}
841
842	break;
843
844	/* These are all legacy - any new objects should use the move_ .. values */
845	case KW_walk_off:
846	{
847	if (thawer.get_sint32 ())
848	op->move_off |= MOVE_WALK;
849	else
850	op->move_off &= ~MOVE_WALK;
851	}
852	break;
853
854	/* These are all legacy - any new objects should use the move_ .. values */
855	case KW_fly_on:
856	{
857	if (thawer.get_sint32 ())
858	op->move_on |= MOVE_FLY_LOW;
859	else
860	op->move_on &= ~MOVE_FLY_LOW;
861	}
862	break;
863
864	/* These are all legacy - any new objects should use the move_ .. values */
865	case KW_fly_off:
866	{
867	if (thawer.get_sint32 ())
868	op->move_off |= MOVE_FLY_LOW;
869	else
870	op->move_off &= ~MOVE_FLY_LOW;
871	}
872	break;
873
874	//TODO: remove these after convertign archetypes
875	case KW_can_use_wand:
876	GET_FLAG (op, FLAG_USE_RANGE);
877	break;
878
879	/* These are all legacy - any new objects should use the move_ .. values */
880	case KW_flying:
881	{
882	if (thawer.get_sint32 ())
883	op->move_type |= MOVE_FLY_LOW;
884	else
885	op->move_type &= ~MOVE_FLY_LOW;
886	}
887	break;
888
889
890	case KW_identified:
891	GET_FLAG (op, FLAG_IDENTIFIED);
892	//TODO: move to check_object or so
893	if (QUERY_FLAG (op, FLAG_IDENTIFIED))
894	CLEAR_FLAG (op, FLAG_KNOWN_MAGICAL);
895
896	break;
897
898	case KW_wiz:
899	GET_FLAG (op, FLAG_WIZ);
900	//TODO: move to check_object
901	if (QUERY_FLAG (op, FLAG_WIZ))
902	{	611	{
903	SET_FLAG (op, FLAG_WAS_WIZ);	612	LOG (llevDebug, "Discarding object without arch: %s\n", tmp->name ? (const char *) tmp->name : "(null)");
904	SET_FLAG (op, FLAG_WIZPASS);	613	free_object (tmp);
905	SET_FLAG (op, FLAG_WIZCAST);	614	}
906	}	615	}
907	else	616	else
908	{	617	{
909	CLEAR_FLAG (op, FLAG_WIZPASS);	618	/* This is the actual archetype definition then */
910	CLEAR_FLAG (op, FLAG_WIZCAST);	619	op->arch = archetype::find (str);
		620
		621	if (op->arch != NULL)
		622	copy_object (&op->arch->clone, op);
		623	else if (!arch_init)
		624	/* record the name of the broken object */
		625	op->name = str;
911	}	626	}
		627	}
912	break;	628	break;
913		629
914	case KW_friendly:	630	case KW_other_arch:
915	GET_FLAG (op, FLAG_FRIENDLY);	631	op->other_arch = archetype::find (thawer.get_str ());
916	//TODO: move to check_object or so
917	if (op->type != PLAYER && QUERY_FLAG (op, FLAG_FRIENDLY))
918	add_friendly_object (op);
919	break;	632	break;
920		633
921	case KW_monster:	634	case KW_animation:
		635	{
		636	const char *str = thawer.get_str ();
		637
		638	if (!str)
		639	{
		640	op->animation_id = 0;
		641	CLEAR_FLAG (op, FLAG_ANIMATE);
		642	}
		643	else
		644	{
		645	op->animation_id = find_animation (str);
922	GET_FLAG (op, FLAG_MONSTER);	646	SET_FLAG (op, FLAG_ANIMATE);
		647	}
		648	}
		649
923	break;	650	break;
		651
924	case KW_neutral:	652	case KW_last_heal:
925	GET_FLAG (op, FLAG_NEUTRAL);	653	thawer.get (op->last_heal);
926	break;	654	break;
927	case KW_no_attack:	655	case KW_last_sp:
928	GET_FLAG (op, FLAG_NO_ATTACK);	656	thawer.get (op->last_sp);
929	break;	657	break;
930	case KW_no_damage:	658	case KW_last_grace:
931	GET_FLAG (op, FLAG_NO_DAMAGE);	659	thawer.get (op->last_grace);
932	break;	660	break;
933	case KW_generator:	661	case KW_last_eat:
934	GET_FLAG (op, FLAG_GENERATOR);	662	thawer.get (op->last_eat);
935	break;	663	break;
936	case KW_use_content_on_gen:	664	case KW_speed_left:
937	GET_FLAG (op, FLAG_CONTENT_ON_GEN);	665	thawer.get (op->speed_left);
938	break;	666	break;
939	case KW_is_thrown:	667
940	GET_FLAG (op, FLAG_IS_THROWN);
941	break;
942	case KW_auto_apply:
943	GET_FLAG (op, FLAG_AUTO_APPLY);
944	break;
945	case KW_treasure:
946	GET_FLAG (op, FLAG_TREASURE);
947	break;
948	case KW_see_invisible:
949	GET_FLAG (op, FLAG_SEE_INVISIBLE);
950	break;
951	case KW_can_roll:
952	GET_FLAG (op, FLAG_CAN_ROLL);
953	break;
954	case KW_overlay_floor:
955	GET_FLAG (op, FLAG_OVERLAY_FLOOR);
956	break;
957	case KW_is_turnable:
958	GET_FLAG (op, FLAG_IS_TURNABLE);
959	break;
960	case KW_is_used_up:
961	GET_FLAG (op, FLAG_IS_USED_UP);
962	break;
963	case KW_alive:
964	GET_FLAG (op, FLAG_ALIVE);
965	break;
966	case KW_applied:
967	GET_FLAG (op, FLAG_APPLIED);
968	break;
969	case KW_unpaid:
970	GET_FLAG (op, FLAG_UNPAID);
971	break;
972	case KW_is_animated:
973	GET_FLAG (op, FLAG_ANIMATE);
974	break;
975	case KW_no_pick:
976	GET_FLAG (op, FLAG_NO_PICK);
977	break;
978	case KW_reflecting:
979	GET_FLAG (op, FLAG_REFLECTING);
980	break;
981	case KW_changing:
982	GET_FLAG (op, FLAG_CHANGING);
983	break;
984	case KW_splitting:
985	GET_FLAG (op, FLAG_SPLITTING);
986	break;
987	case KW_hitback:
988	GET_FLAG (op, FLAG_HITBACK);
989	break;
990	case KW_startequip:
991	GET_FLAG (op, FLAG_STARTEQUIP);
992	break;
993	case KW_blocksview:
994	GET_FLAG (op, FLAG_BLOCKSVIEW);
995	break;
996	case KW_undead:
997	GET_FLAG (op, FLAG_UNDEAD);
998	break;
999	case KW_scared:
1000	GET_FLAG (op, FLAG_SCARED);
1001	break;
1002	case KW_unaggressive:
1003	GET_FLAG (op, FLAG_UNAGGRESSIVE);
1004	break;
1005	case KW_reflect_missile:
1006	GET_FLAG (op, FLAG_REFL_MISSILE);
1007	break;
1008	case KW_reflect_spell:
1009	GET_FLAG (op, FLAG_REFL_SPELL);
1010	break;
1011	case KW_no_magic:
1012	GET_FLAG (op, FLAG_NO_MAGIC);
1013	break;
1014	case KW_no_drop:
1015	GET_FLAG (op, FLAG_NO_DROP);
1016	break;
1017	case KW_random_movement:
1018	GET_FLAG (op, FLAG_RANDOM_MOVE);
1019	break;
1020	case KW_was_wiz:
1021	GET_FLAG (op, FLAG_WAS_WIZ);
1022	break;
1023	case KW_no_fix_player:
1024	GET_FLAG (op, FLAG_NO_FIX_PLAYER);
1025	break;
1026	case KW_is_lightable:
1027	GET_FLAG (op, FLAG_IS_LIGHTABLE);
1028	break;
1029	case KW_tear_down:
1030	GET_FLAG (op, FLAG_TEAR_DOWN);
1031	break;
1032	case KW_can_use_shield:
1033	GET_FLAG (op, FLAG_USE_SHIELD);
1034	break;
1035	case KW_can_cast_spell:
1036	GET_FLAG (op, FLAG_CAST_SPELL);
1037	break;
1038	case KW_can_use_scroll:
1039	GET_FLAG (op, FLAG_USE_SCROLL);
1040	break;
1041	case KW_can_use_range:
1042	GET_FLAG (op, FLAG_USE_RANGE);
1043	break;
1044	case KW_can_use_bow:
1045	GET_FLAG (op, FLAG_USE_BOW);
1046	break;
1047	case KW_can_use_armour:
1048	GET_FLAG (op, FLAG_USE_ARMOUR);
1049	break;
1050	case KW_can_use_weapon:
1051	GET_FLAG (op, FLAG_USE_WEAPON);
1052	break;
1053	case KW_can_use_ring:
1054	GET_FLAG (op, FLAG_USE_RING);
1055	break;
1056	case KW_has_ready_bow:
1057	GET_FLAG (op, FLAG_READY_BOW);
1058	break;
1059	case KW_xrays:
1060	GET_FLAG (op, FLAG_XRAYS);
1061	break;
1062	case KW_is_floor:
1063	GET_FLAG (op, FLAG_IS_FLOOR);
1064	break;
1065	case KW_lifesave:
1066	GET_FLAG (op, FLAG_LIFESAVE);
1067	break;
1068	case KW_no_strength:
1069	GET_FLAG (op, FLAG_NO_STRENGTH);
1070	break;
1071	case KW_sleep:	668	case KW_speed:
1072	GET_FLAG (op, FLAG_SLEEP);
1073	break;
1074	case KW_stand_still:
1075	GET_FLAG (op, FLAG_STAND_STILL);
1076	break;
1077	case KW_random_move:
1078	GET_FLAG (op, FLAG_RANDOM_MOVE);
1079	break;
1080	case KW_only_attack:
1081	GET_FLAG (op, FLAG_ONLY_ATTACK);
1082	break;
1083	case KW_activate_on_push:
1084	GET_FLAG (op, FLAG_ACTIVATE_ON_PUSH);
1085	break;
1086	case KW_activate_on_release:
1087	GET_FLAG (op, FLAG_ACTIVATE_ON_RELEASE);
1088	break;
1089	case KW_confused:
1090	GET_FLAG (op, FLAG_CONFUSED);
1091	break;
1092	case KW_stealth:
1093	GET_FLAG (op, FLAG_STEALTH);
1094	break;
1095	case KW_cursed:
1096	GET_FLAG (op, FLAG_CURSED);
1097	break;
1098	case KW_damned:
1099	GET_FLAG (op, FLAG_DAMNED);
1100	break;
1101	case KW_see_anywhere:
1102	GET_FLAG (op, FLAG_SEE_ANYWHERE);
1103	break;
1104	case KW_known_magical:
1105	GET_FLAG (op, FLAG_KNOWN_MAGICAL);
1106	break;
1107	case KW_known_cursed:
1108	GET_FLAG (op, FLAG_KNOWN_CURSED);
1109	break;
1110	case KW_can_use_skill:
1111	GET_FLAG (op, FLAG_CAN_USE_SKILL);
1112	break;
1113	case KW_been_applied:
1114	GET_FLAG (op, FLAG_BEEN_APPLIED);
1115	break;
1116	case KW_has_ready_scroll:
1117	GET_FLAG (op, FLAG_READY_SCROLL);
1118	break;
1119	case KW_can_use_rod:
1120	GET_FLAG (op, FLAG_USE_ROD);
1121	break;
1122	case KW_can_use_horn:
1123	GET_FLAG (op, FLAG_USE_HORN);
1124	break;
1125	case KW_unique:
1126	GET_FLAG (op, FLAG_UNIQUE);
1127	break;
1128	case KW_make_invisible:
1129	GET_FLAG (op, FLAG_MAKE_INVIS);
1130	break;
1131	case KW_inv_locked:
1132	GET_FLAG (op, FLAG_INV_LOCKED);
1133	break;
1134	case KW_is_wooded:
1135	GET_FLAG (op, FLAG_IS_WOODED);
1136	break;
1137	case KW_is_hilly:
1138	GET_FLAG (op, FLAG_IS_HILLY);
1139	break;
1140	case KW_is_water:
1141	GET_FLAG (op, FLAG_IS_WATER);
1142	break;
1143	case KW_has_ready_skill:
1144	GET_FLAG (op, FLAG_READY_SKILL);
1145	break;
1146	case KW_has_ready_weapon:
1147	GET_FLAG (op, FLAG_READY_WEAPON);
1148	break;
1149	case KW_no_skill_ident:
1150	GET_FLAG (op, FLAG_NO_SKILL_IDENT);
1151	break;
1152	case KW_is_blind:
1153	GET_FLAG (op, FLAG_BLIND);
1154	break;
1155	case KW_can_see_in_dark:
1156	GET_FLAG (op, FLAG_SEE_IN_DARK);
1157	break;
1158	case KW_is_cauldron:
1159	GET_FLAG (op, FLAG_IS_CAULDRON);
1160	break;
1161	case KW_no_steal:
1162	GET_FLAG (op, FLAG_NO_STEAL);
1163	break;
1164	case KW_one_hit:
1165	GET_FLAG (op, FLAG_ONE_HIT);
1166	break;
1167	case KW_berserk:
1168	GET_FLAG (op, FLAG_BERSERK);
1169	break;
1170	case KW_is_buildable:
1171	GET_FLAG (op, FLAG_IS_BUILDABLE);
1172	break;
1173
1174	case KW_armour:
1175	thawer.get (op->resist[ATNR_PHYSICAL]);
1176	break;
1177	case KW_resist_physical:
1178	thawer.get (op->resist[ATNR_PHYSICAL]);
1179	break;
1180	case KW_resist_magic:
1181	thawer.get (op->resist[ATNR_MAGIC]);
1182	break;
1183	case KW_resist_fire:
1184	thawer.get (op->resist[ATNR_FIRE]);
1185	break;
1186	case KW_resist_electricity:
1187	thawer.get (op->resist[ATNR_ELECTRICITY]);
1188	break;
1189	case KW_resist_cold:
1190	thawer.get (op->resist[ATNR_COLD]);
1191	break;
1192	case KW_resist_confusion:
1193	thawer.get (op->resist[ATNR_CONFUSION]);
1194	break;
1195	case KW_resist_acid:
1196	thawer.get (op->resist[ATNR_ACID]);
1197	break;
1198	case KW_resist_drain:
1199	thawer.get (op->resist[ATNR_DRAIN]);
1200	break;
1201	case KW_resist_weaponmagic:
1202	thawer.get (op->resist[ATNR_WEAPONMAGIC]);
1203	break;
1204	case KW_resist_ghosthit:
1205	thawer.get (op->resist[ATNR_GHOSTHIT]);
1206	break;
1207	case KW_resist_poison:
1208	thawer.get (op->resist[ATNR_POISON]);
1209	break;
1210	case KW_resist_slow:
1211	thawer.get (op->resist[ATNR_SLOW]);
1212	break;
1213	case KW_resist_paralyze:
1214	thawer.get (op->resist[ATNR_PARALYZE]);
1215	break;
1216	case KW_resist_turn_undead:
1217	thawer.get (op->resist[ATNR_TURN_UNDEAD]);
1218	break;
1219	case KW_resist_fear:
1220	thawer.get (op->resist[ATNR_FEAR]);
1221	break;
1222	case KW_resist_cancellation:
1223	thawer.get (op->resist[ATNR_CANCELLATION]);
1224	break;
1225	case KW_resist_deplete:
1226	thawer.get (op->resist[ATNR_DEPLETE]);
1227	break;
1228	case KW_resist_death:
1229	thawer.get (op->resist[ATNR_DEATH]);
1230	break;
1231	case KW_resist_chaos:
1232	thawer.get (op->resist[ATNR_CHAOS]);
1233	break;
1234	case KW_resist_counterspell:
1235	thawer.get (op->resist[ATNR_COUNTERSPELL]);
1236	break;
1237	case KW_resist_godpower:
1238	thawer.get (op->resist[ATNR_GODPOWER]);
1239	break;
1240	case KW_resist_holyword:
1241	thawer.get (op->resist[ATNR_HOLYWORD]);
1242	break;
1243	case KW_resist_blind:
1244	thawer.get (op->resist[ATNR_BLIND]);
1245	break;
1246	case KW_resist_internal:
1247	thawer.get (op->resist[ATNR_INTERNAL]);
1248	break;
1249	case KW_resist_life_stealing:
1250	thawer.get (op->resist[ATNR_LIFE_STEALING]);
1251	break;
1252	case KW_resist_disease:
1253	thawer.get (op->resist[ATNR_DISEASE]);
1254	break;
1255
1256	case KW_luck:
1257	thawer.get (op->stats.luck);
1258	break;
1259	case KW_run_away:
1260	thawer.get (op->run_away);
1261	break;
1262	case KW_pick_up:
1263	thawer.get (op->pick_up);
1264	break;
1265	case KW_item_power:
1266	thawer.get (op->item_power);
1267	break;
1268	case KW_gen_sp_armour:
1269	thawer.get (op->gen_sp_armour);
1270	break;
1271	case KW_anim_speed:
1272	thawer.get (op->anim_speed);	669	thawer.get (op->speed);
1273	break;
1274	case KW_container:
1275	thawer.get (op->weight_limit);
1276	break;
1277	case KW_will_apply:
1278	thawer.get (op->will_apply);
1279	break;
1280	case KW_attack_movement:
1281	thawer.get (op->attack_movement);
1282	break;
1283	case KW_move_state:
1284	thawer.get (op->move_status);
1285	break;
1286	case KW_expmul:
1287	thawer.get (op->expmul);
1288	break;
1289	case KW_glow_radius:
1290	thawer.get (op->glow_radius);
1291	break;
1292	case KW_weapontype:
1293	thawer.get (op->weapontype);
1294	break;
1295	case KW_tooltype:
1296	thawer.get (op->tooltype);
1297	break;
1298	case KW_casting_time:
1299	thawer.get (op->casting_time);
1300	break;
1301	case KW_elevation:
1302	thawer.get (op->elevation);
1303	break;
1304	case KW_smoothlevel:
1305	thawer.get (op->smoothlevel);
1306	break;
1307	case KW_client_type:
1308	thawer.get (op->client_type);
1309	break;
1310	case KW_duration:
1311	thawer.get (op->duration);
1312	break;
1313	case KW_range:
1314	thawer.get (op->range);
1315	break;
1316	case KW_range_modifier:
1317	thawer.get (op->range_modifier);
1318	break;
1319	case KW_dam_modifier:
1320	thawer.get (op->dam_modifier);
1321	break;
1322	case KW_duration_modifier:
1323	thawer.get (op->duration_modifier);
1324	break;
1325		670
1326	//TODO: mechanism to ensure that KW_xxx is consecutive needed from include/preprocess	671	//TODO: maybe do in check_object
1327	//TODO: parse from other include files	672	if (!(map_flags & MAP_STYLE))
1328	case KW_body_range:
1329	thawer.get (op->body_info[0]);
1330	break;
1331	case KW_body_arm:
1332	thawer.get (op->body_info[1]);
1333	break;
1334	case KW_body_torso:
1335	thawer.get (op->body_info[2]);
1336	break;
1337	case KW_body_head:
1338	thawer.get (op->body_info[3]);
1339	break;
1340	case KW_body_neck:
1341	thawer.get (op->body_info[4]);
1342	break;
1343	case KW_body_skill:
1344	thawer.get (op->body_info[5]);
1345	break;
1346	case KW_body_finger:
1347	thawer.get (op->body_info[6]);
1348	break;
1349	case KW_body_shoulder:
1350	thawer.get (op->body_info[7]);
1351	break;
1352	case KW_body_foot:
1353	thawer.get (op->body_info[8]);
1354	break;
1355	case KW_body_hand:
1356	thawer.get (op->body_info[9]);
1357	break;
1358	case KW_body_wrist:
1359	thawer.get (op->body_info[10]);
1360	break;
1361	case KW_body_waist:
1362	thawer.get (op->body_info[11]);
1363	break;
1364	case KW_can_apply:
1365	break;
1366
1367	case KW_connected:
1368	add_button_link (op, op->map, thawer.get_sint32 ());
1369	break;
1370
1371	case KW_randomitems:
1372	op->randomitems = find_treasurelist (thawer.get_str ());
1373	break;
1374
1375	case KW_msg:
1376	{	673	{
1377	thawer.get_ml (KW_endmsg, op->msg);	674	if (op->speed < 0)
1378	//TODO: allow longer messages	675	op->speed_left = op->speed_left - RANDOM () % 100 / 100.0;
1379	if (strlen (op->msg) >= HUGE_BUF)	676
1380	{	677	update_ob_speed (op);
1381	LOG (llevDebug, "\n\tError message length >= %d: %d\n>%.80s<\n", HUGE_BUF, strlen (op->msg), &op->msg);
1382	op->msg = "ERROR, please report: string too long, winged.\n";
1383	}
1384	}	678	}
		679
1385	break;	680	break;
1386		681
		682	case KW_slow_move:
		683	op->move_slow |= MOVE_WALK;
		684	thawer.get (op->move_slow_penalty);
		685	break;
		686
		687	case KW_face:
		688	op->face = &new_faces[FindFace (thawer.get_str (), 0)];
		689	break;
		690
		691	case KW_x:
		692	thawer.get (op->x);
		693	break;
		694	case KW_y:
		695	thawer.get (op->y);
		696	break;
		697	case KW_Str: // uppercase alias
		698	case KW_str:
		699	thawer.get (op->stats.Str);
		700	break;
		701	case KW_Dex: // uppercase alias
		702	case KW_dex:
		703	thawer.get (op->stats.Dex);
		704	break;
		705	case KW_Con: // uppercase alias
		706	case KW_con:
		707	thawer.get (op->stats.Con);
		708	break;
		709	case KW_Wis: // uppercase alias
		710	case KW_wis:
		711	thawer.get (op->stats.Wis);
		712	break;
		713	case KW_Cha: // uppercase alias
		714	case KW_cha:
		715	thawer.get (op->stats.Cha);
		716	break;
		717	case KW_Int: // uppercase alias
		718	case KW_int:
		719	thawer.get (op->stats.Int);
		720	break;
		721	case KW_Pow: // uppercase alias
		722	case KW_pow:
		723	thawer.get (op->stats.Pow);
		724	break;
		725	case KW_hp:
		726	thawer.get (op->stats.hp);
		727	break;
		728	case KW_maxhp:
		729	thawer.get (op->stats.maxhp);
		730	break;
		731	case KW_sp:
		732	thawer.get (op->stats.sp);
		733	break;
		734	case KW_maxsp:
		735	thawer.get (op->stats.maxsp);
		736	break;
1387	case KW_lore:	737	case KW_grace:
		738	thawer.get (op->stats.grace);
		739	break;
		740	case KW_maxgrace:
		741	thawer.get (op->stats.maxgrace);
		742	break;
		743
		744	case KW_exp:
		745	thawer.get (op->stats.exp);
		746	break;
		747	case KW_perm_exp:
		748	thawer.get (op->perm_exp);
		749	break;
		750	case KW_food:
		751	thawer.get (op->stats.food);
		752	break;
		753	case KW_dam:
		754	thawer.get (op->stats.dam);
		755	break;
		756	case KW_wc:
		757	thawer.get (op->stats.wc);
		758	break;
		759	case KW_ac:
		760	thawer.get (op->stats.ac);
		761	break;
		762	case KW_nrof:
		763	thawer.get (op->nrof);
		764	break;
		765	case KW_level:
		766	thawer.get (op->level);
		767	break;
		768	case KW_direction:
		769	thawer.get (op->direction);
		770	break;
		771	case KW_type:
		772	thawer.get (op->type);
		773	break;
		774	case KW_subtype:
		775	thawer.get (op->subtype);
		776	break;
		777	case KW_value:
		778	thawer.get (op->value);
		779	break;
		780	case KW_weight:
		781	thawer.get (op->weight);
		782	break;
		783	case KW_carrying:
		784	thawer.get (op->carrying);
		785	break;
		786	case KW_attacktype:
		787	thawer.get (op->attacktype);
		788	break;
		789	case KW_path_attuned:
		790	thawer.get (op->path_attuned);
		791	break;
		792	case KW_path_repelled:
		793	thawer.get (op->path_repelled);
		794	break;
		795	case KW_path_denied:
		796	thawer.get (op->path_denied);
		797	break;
		798	case KW_invisible:
		799	thawer.get (op->invisible);
		800	break;
		801	case KW_magic:
		802	thawer.get (op->magic);
		803	break;
		804	case KW_state:
		805	thawer.get (op->state);
		806	break;
		807	case KW_move_slow_penalty:
		808	thawer.get (op->move_slow_penalty);
		809	break;
		810	case KW_material:
		811	thawer.get (op->material);
		812	break;
		813	case KW_materialname:
		814	thawer.get (op->materialname);
		815	break;
		816
		817	/* These are the new values */
		818	case KW_move_block:
		819	set_move (op->move_block, thawer.get_str ());
		820	break;
		821	case KW_move_allow:
		822	set_move (op->move_allow, thawer.get_str ());
		823	break;
		824	case KW_move_type:
		825	set_move (op->move_type, thawer.get_str ());
		826	break;
		827	case KW_move_on:
		828	set_move (op->move_on, thawer.get_str ());
		829	break;
		830	case KW_move_off:
		831	set_move (op->move_off, thawer.get_str ());
		832	break;
		833	case KW_move_slow:
		834	set_move (op->move_slow, thawer.get_str ());
		835	break;
		836
		837	/* These are all legacy - any new objects should use the move_ .. values */
		838	case KW_no_pass:
		839	{
		840	if (thawer.get_sint32 ())
		841	op->move_block = MOVE_ALL;
		842	else
		843	op->move_block = 0;
		844	}
		845
		846	break;
		847
		848	/* These are all legacy - any new objects should use the move_ .. values */
		849	case KW_walk_on:
		850	{
		851	if (thawer.get_sint32 ())
		852	op->move_on |= MOVE_WALK;
		853	else
		854	op->move_on &= ~MOVE_WALK;
		855	}
		856
		857	break;
		858
		859	/* These are all legacy - any new objects should use the move_ .. values */
		860	case KW_walk_off:
		861	{
		862	if (thawer.get_sint32 ())
		863	op->move_off |= MOVE_WALK;
		864	else
		865	op->move_off &= ~MOVE_WALK;
		866	}
		867	break;
		868
		869	/* These are all legacy - any new objects should use the move_ .. values */
		870	case KW_fly_on:
		871	{
		872	if (thawer.get_sint32 ())
		873	op->move_on |= MOVE_FLY_LOW;
		874	else
		875	op->move_on &= ~MOVE_FLY_LOW;
		876	}
		877	break;
		878
		879	/* These are all legacy - any new objects should use the move_ .. values */
		880	case KW_fly_off:
		881	{
		882	if (thawer.get_sint32 ())
		883	op->move_off |= MOVE_FLY_LOW;
		884	else
		885	op->move_off &= ~MOVE_FLY_LOW;
		886	}
		887	break;
		888
		889	//TODO: remove these after converting archetypes
		890	case KW_can_use_wand:
		891	GET_FLAG (op, FLAG_USE_RANGE);
		892	break;
		893
		894	/* These are all legacy - any new objects should use the move_ .. values */
		895	case KW_flying:
		896	{
		897	if (thawer.get_sint32 ())
		898	op->move_type |= MOVE_FLY_LOW;
		899	else
		900	op->move_type &= ~MOVE_FLY_LOW;
		901	}
		902	break;
		903
		904
		905	case KW_identified:
		906	GET_FLAG (op, FLAG_IDENTIFIED);
		907	//TODO: move to check_object or so
		908	if (QUERY_FLAG (op, FLAG_IDENTIFIED))
		909	CLEAR_FLAG (op, FLAG_KNOWN_MAGICAL);
		910
		911	break;
		912
		913	case KW_wiz:
		914	GET_FLAG (op, FLAG_WIZ);
		915	//TODO: move to check_object
		916	if (QUERY_FLAG (op, FLAG_WIZ))
1388	{	917	{
1389	shstr msgbuf;	918	SET_FLAG (op, FLAG_WAS_WIZ);
1390		919	SET_FLAG (op, FLAG_WIZPASS);
1391	thawer.get_ml (KW_endlore, op->lore);	920	SET_FLAG (op, FLAG_WIZCAST);
1392	//TODO: allow longer messages
1393	/* Just print a warning so we can be reasonably safe
1394	* about not overflowing the buffer.
1395	*/
1396	if (strlen (op->lore) > (HUGE_BUF / 2))
1397	LOG (llevDebug, "\n\tWarning lore length > %d (max allowed=%d): %d\n>%.80s<\n",
1398	HUGE_BUF / 2, HUGE_BUF, strlen (op->lore), &op->lore);
1399	}	921	}
		922	else
		923	{
		924	CLEAR_FLAG (op, FLAG_WIZPASS);
		925	CLEAR_FLAG (op, FLAG_WIZCAST);
		926	}
1400	break;	927	break;
1401		928
1402	case KW_editable:	929	case KW_friendly:
1403	case KW_editor_folder:	930	GET_FLAG (op, FLAG_FRIENDLY);
		931	//TODO: move to check_object or so
		932	if (op->type != PLAYER && QUERY_FLAG (op, FLAG_FRIENDLY))
		933	add_friendly_object (op);
1404	break;	934	break;
1405		935
1406	case KW_More: // uppercase alias	936	case KW_monster:
		937	GET_FLAG (op, FLAG_MONSTER);
		938	break;
		939	case KW_neutral:
		940	GET_FLAG (op, FLAG_NEUTRAL);
		941	break;
		942	case KW_no_attack:
		943	GET_FLAG (op, FLAG_NO_ATTACK);
		944	break;
		945	case KW_no_damage:
		946	GET_FLAG (op, FLAG_NO_DAMAGE);
		947	break;
		948	case KW_generator:
		949	GET_FLAG (op, FLAG_GENERATOR);
		950	break;
		951	case KW_use_content_on_gen:
		952	GET_FLAG (op, FLAG_CONTENT_ON_GEN);
		953	break;
		954	case KW_is_thrown:
		955	GET_FLAG (op, FLAG_IS_THROWN);
		956	break;
		957	case KW_auto_apply:
		958	GET_FLAG (op, FLAG_AUTO_APPLY);
		959	break;
		960	case KW_treasure:
		961	GET_FLAG (op, FLAG_TREASURE);
		962	break;
		963	case KW_see_invisible:
		964	GET_FLAG (op, FLAG_SEE_INVISIBLE);
		965	break;
		966	case KW_can_roll:
		967	GET_FLAG (op, FLAG_CAN_ROLL);
		968	break;
		969	case KW_overlay_floor:
		970	GET_FLAG (op, FLAG_OVERLAY_FLOOR);
		971	break;
		972	case KW_is_turnable:
		973	GET_FLAG (op, FLAG_IS_TURNABLE);
		974	break;
		975	case KW_is_used_up:
		976	GET_FLAG (op, FLAG_IS_USED_UP);
		977	break;
		978	case KW_alive:
		979	GET_FLAG (op, FLAG_ALIVE);
		980	break;
		981	case KW_applied:
		982	GET_FLAG (op, FLAG_APPLIED);
		983	break;
		984	case KW_unpaid:
		985	GET_FLAG (op, FLAG_UNPAID);
		986	break;
		987	case KW_is_animated:
		988	GET_FLAG (op, FLAG_ANIMATE);
		989	break;
		990	case KW_no_pick:
		991	GET_FLAG (op, FLAG_NO_PICK);
		992	break;
		993	case KW_reflecting:
		994	GET_FLAG (op, FLAG_REFLECTING);
		995	break;
		996	case KW_changing:
		997	GET_FLAG (op, FLAG_CHANGING);
		998	break;
		999	case KW_splitting:
		1000	GET_FLAG (op, FLAG_SPLITTING);
		1001	break;
		1002	case KW_hitback:
		1003	GET_FLAG (op, FLAG_HITBACK);
		1004	break;
		1005	case KW_startequip:
		1006	GET_FLAG (op, FLAG_STARTEQUIP);
		1007	break;
		1008	case KW_blocksview:
		1009	GET_FLAG (op, FLAG_BLOCKSVIEW);
		1010	break;
		1011	case KW_undead:
		1012	GET_FLAG (op, FLAG_UNDEAD);
		1013	break;
		1014	case KW_scared:
		1015	GET_FLAG (op, FLAG_SCARED);
		1016	break;
		1017	case KW_unaggressive:
		1018	GET_FLAG (op, FLAG_UNAGGRESSIVE);
		1019	break;
		1020	case KW_reflect_missile:
		1021	GET_FLAG (op, FLAG_REFL_MISSILE);
		1022	break;
		1023	case KW_reflect_spell:
		1024	GET_FLAG (op, FLAG_REFL_SPELL);
		1025	break;
		1026	case KW_no_magic:
		1027	GET_FLAG (op, FLAG_NO_MAGIC);
		1028	break;
		1029	case KW_no_drop:
		1030	GET_FLAG (op, FLAG_NO_DROP);
		1031	break;
		1032	case KW_random_movement:
		1033	GET_FLAG (op, FLAG_RANDOM_MOVE);
		1034	break;
		1035	case KW_was_wiz:
		1036	GET_FLAG (op, FLAG_WAS_WIZ);
		1037	break;
		1038	case KW_no_fix_player:
		1039	GET_FLAG (op, FLAG_NO_FIX_PLAYER);
		1040	break;
		1041	case KW_is_lightable:
		1042	GET_FLAG (op, FLAG_IS_LIGHTABLE);
		1043	break;
		1044	case KW_tear_down:
		1045	GET_FLAG (op, FLAG_TEAR_DOWN);
		1046	break;
		1047	case KW_can_use_shield:
		1048	GET_FLAG (op, FLAG_USE_SHIELD);
		1049	break;
		1050	case KW_can_cast_spell:
		1051	GET_FLAG (op, FLAG_CAST_SPELL);
		1052	break;
		1053	case KW_can_use_scroll:
		1054	GET_FLAG (op, FLAG_USE_SCROLL);
		1055	break;
		1056	case KW_can_use_range:
		1057	GET_FLAG (op, FLAG_USE_RANGE);
		1058	break;
		1059	case KW_can_use_bow:
		1060	GET_FLAG (op, FLAG_USE_BOW);
		1061	break;
		1062	case KW_can_use_armour:
		1063	GET_FLAG (op, FLAG_USE_ARMOUR);
		1064	break;
		1065	case KW_can_use_weapon:
		1066	GET_FLAG (op, FLAG_USE_WEAPON);
		1067	break;
		1068	case KW_can_use_ring:
		1069	GET_FLAG (op, FLAG_USE_RING);
		1070	break;
		1071	case KW_has_ready_bow:
		1072	GET_FLAG (op, FLAG_READY_BOW);
		1073	break;
		1074	case KW_xrays:
		1075	GET_FLAG (op, FLAG_XRAYS);
		1076	break;
		1077	case KW_is_floor:
		1078	GET_FLAG (op, FLAG_IS_FLOOR);
		1079	break;
		1080	case KW_lifesave:
		1081	GET_FLAG (op, FLAG_LIFESAVE);
		1082	break;
		1083	case KW_no_strength:
		1084	GET_FLAG (op, FLAG_NO_STRENGTH);
		1085	break;
		1086	case KW_sleep:
		1087	GET_FLAG (op, FLAG_SLEEP);
		1088	break;
		1089	case KW_stand_still:
		1090	GET_FLAG (op, FLAG_STAND_STILL);
		1091	break;
		1092	case KW_random_move:
		1093	GET_FLAG (op, FLAG_RANDOM_MOVE);
		1094	break;
		1095	case KW_only_attack:
		1096	GET_FLAG (op, FLAG_ONLY_ATTACK);
		1097	break;
		1098	case KW_activate_on_push:
		1099	GET_FLAG (op, FLAG_ACTIVATE_ON_PUSH);
		1100	break;
		1101	case KW_activate_on_release:
		1102	GET_FLAG (op, FLAG_ACTIVATE_ON_RELEASE);
		1103	break;
		1104	case KW_confused:
		1105	GET_FLAG (op, FLAG_CONFUSED);
		1106	break;
		1107	case KW_stealth:
		1108	GET_FLAG (op, FLAG_STEALTH);
		1109	break;
		1110	case KW_cursed:
		1111	GET_FLAG (op, FLAG_CURSED);
		1112	break;
		1113	case KW_damned:
		1114	GET_FLAG (op, FLAG_DAMNED);
		1115	break;
		1116	case KW_see_anywhere:
		1117	GET_FLAG (op, FLAG_SEE_ANYWHERE);
		1118	break;
		1119	case KW_known_magical:
		1120	GET_FLAG (op, FLAG_KNOWN_MAGICAL);
		1121	break;
		1122	case KW_known_cursed:
		1123	GET_FLAG (op, FLAG_KNOWN_CURSED);
		1124	break;
		1125	case KW_can_use_skill:
		1126	GET_FLAG (op, FLAG_CAN_USE_SKILL);
		1127	break;
		1128	case KW_been_applied:
		1129	GET_FLAG (op, FLAG_BEEN_APPLIED);
		1130	break;
		1131	case KW_has_ready_scroll:
		1132	GET_FLAG (op, FLAG_READY_SCROLL);
		1133	break;
		1134	case KW_can_use_rod:
		1135	GET_FLAG (op, FLAG_USE_ROD);
		1136	break;
		1137	case KW_can_use_horn:
		1138	GET_FLAG (op, FLAG_USE_HORN);
		1139	break;
		1140	case KW_unique:
		1141	GET_FLAG (op, FLAG_UNIQUE);
		1142	break;
		1143	case KW_make_invisible:
		1144	GET_FLAG (op, FLAG_MAKE_INVIS);
		1145	break;
		1146	case KW_inv_locked:
		1147	GET_FLAG (op, FLAG_INV_LOCKED);
		1148	break;
		1149	case KW_is_wooded:
		1150	GET_FLAG (op, FLAG_IS_WOODED);
		1151	break;
		1152	case KW_is_hilly:
		1153	GET_FLAG (op, FLAG_IS_HILLY);
		1154	break;
		1155	case KW_is_water:
		1156	GET_FLAG (op, FLAG_IS_WATER);
		1157	break;
		1158	case KW_has_ready_skill:
		1159	GET_FLAG (op, FLAG_READY_SKILL);
		1160	break;
		1161	case KW_has_ready_weapon:
		1162	GET_FLAG (op, FLAG_READY_WEAPON);
		1163	break;
		1164	case KW_no_skill_ident:
		1165	GET_FLAG (op, FLAG_NO_SKILL_IDENT);
		1166	break;
		1167	case KW_is_blind:
		1168	GET_FLAG (op, FLAG_BLIND);
		1169	break;
		1170	case KW_can_see_in_dark:
		1171	GET_FLAG (op, FLAG_SEE_IN_DARK);
		1172	break;
		1173	case KW_is_cauldron:
		1174	GET_FLAG (op, FLAG_IS_CAULDRON);
		1175	break;
		1176	case KW_no_steal:
		1177	GET_FLAG (op, FLAG_NO_STEAL);
		1178	break;
		1179	case KW_one_hit:
		1180	GET_FLAG (op, FLAG_ONE_HIT);
		1181	break;
		1182	case KW_berserk:
		1183	GET_FLAG (op, FLAG_BERSERK);
		1184	break;
		1185	case KW_is_buildable:
		1186	GET_FLAG (op, FLAG_IS_BUILDABLE);
		1187	break;
		1188
		1189	case KW_armour:
		1190	thawer.get (op->resist[ATNR_PHYSICAL]);
		1191	break;
		1192	case KW_resist_physical:
		1193	thawer.get (op->resist[ATNR_PHYSICAL]);
		1194	break;
		1195	case KW_resist_magic:
		1196	thawer.get (op->resist[ATNR_MAGIC]);
		1197	break;
		1198	case KW_resist_fire:
		1199	thawer.get (op->resist[ATNR_FIRE]);
		1200	break;
		1201	case KW_resist_electricity:
		1202	thawer.get (op->resist[ATNR_ELECTRICITY]);
		1203	break;
		1204	case KW_resist_cold:
		1205	thawer.get (op->resist[ATNR_COLD]);
		1206	break;
		1207	case KW_resist_confusion:
		1208	thawer.get (op->resist[ATNR_CONFUSION]);
		1209	break;
		1210	case KW_resist_acid:
		1211	thawer.get (op->resist[ATNR_ACID]);
		1212	break;
		1213	case KW_resist_drain:
		1214	thawer.get (op->resist[ATNR_DRAIN]);
		1215	break;
		1216	case KW_resist_weaponmagic:
		1217	thawer.get (op->resist[ATNR_WEAPONMAGIC]);
		1218	break;
		1219	case KW_resist_ghosthit:
		1220	thawer.get (op->resist[ATNR_GHOSTHIT]);
		1221	break;
		1222	case KW_resist_poison:
		1223	thawer.get (op->resist[ATNR_POISON]);
		1224	break;
		1225	case KW_resist_slow:
		1226	thawer.get (op->resist[ATNR_SLOW]);
		1227	break;
		1228	case KW_resist_paralyze:
		1229	thawer.get (op->resist[ATNR_PARALYZE]);
		1230	break;
		1231	case KW_resist_turn_undead:
		1232	thawer.get (op->resist[ATNR_TURN_UNDEAD]);
		1233	break;
		1234	case KW_resist_fear:
		1235	thawer.get (op->resist[ATNR_FEAR]);
		1236	break;
		1237	case KW_resist_cancellation:
		1238	thawer.get (op->resist[ATNR_CANCELLATION]);
		1239	break;
		1240	case KW_resist_deplete:
		1241	thawer.get (op->resist[ATNR_DEPLETE]);
		1242	break;
		1243	case KW_resist_death:
		1244	thawer.get (op->resist[ATNR_DEATH]);
		1245	break;
		1246	case KW_resist_chaos:
		1247	thawer.get (op->resist[ATNR_CHAOS]);
		1248	break;
		1249	case KW_resist_counterspell:
		1250	thawer.get (op->resist[ATNR_COUNTERSPELL]);
		1251	break;
		1252	case KW_resist_godpower:
		1253	thawer.get (op->resist[ATNR_GODPOWER]);
		1254	break;
		1255	case KW_resist_holyword:
		1256	thawer.get (op->resist[ATNR_HOLYWORD]);
		1257	break;
		1258	case KW_resist_blind:
		1259	thawer.get (op->resist[ATNR_BLIND]);
		1260	break;
		1261	case KW_resist_internal:
		1262	thawer.get (op->resist[ATNR_INTERNAL]);
		1263	break;
		1264	case KW_resist_life_stealing:
		1265	thawer.get (op->resist[ATNR_LIFE_STEALING]);
		1266	break;
		1267	case KW_resist_disease:
		1268	thawer.get (op->resist[ATNR_DISEASE]);
		1269	break;
		1270
		1271	case KW_luck:
		1272	thawer.get (op->stats.luck);
		1273	break;
		1274	case KW_run_away:
		1275	thawer.get (op->run_away);
		1276	break;
		1277	case KW_pick_up:
		1278	thawer.get (op->pick_up);
		1279	break;
		1280	case KW_item_power:
		1281	thawer.get (op->item_power);
		1282	break;
		1283	case KW_gen_sp_armour:
		1284	thawer.get (op->gen_sp_armour);
		1285	break;
		1286	case KW_anim_speed:
		1287	thawer.get (op->anim_speed);
		1288	break;
		1289	case KW_container:
		1290	thawer.get (op->weight_limit);
		1291	break;
		1292	case KW_will_apply:
		1293	thawer.get (op->will_apply);
		1294	break;
		1295	case KW_attack_movement:
		1296	thawer.get (op->attack_movement);
		1297	break;
		1298	case KW_move_state:
		1299	thawer.get (op->move_status);
		1300	break;
		1301	case KW_expmul:
		1302	thawer.get (op->expmul);
		1303	break;
		1304	case KW_glow_radius:
		1305	thawer.get (op->glow_radius);
		1306	break;
		1307	case KW_weapontype:
		1308	thawer.get (op->weapontype);
		1309	break;
		1310	case KW_tooltype:
		1311	thawer.get (op->tooltype);
		1312	break;
		1313	case KW_casting_time:
		1314	thawer.get (op->casting_time);
		1315	break;
		1316	case KW_elevation:
		1317	thawer.get (op->elevation);
		1318	break;
		1319	case KW_smoothlevel:
		1320	thawer.get (op->smoothlevel);
		1321	break;
		1322	case KW_client_type:
		1323	thawer.get (op->client_type);
		1324	break;
		1325	case KW_duration:
		1326	thawer.get (op->duration);
		1327	break;
		1328	case KW_range:
		1329	thawer.get (op->range);
		1330	break;
		1331	case KW_range_modifier:
		1332	thawer.get (op->range_modifier);
		1333	break;
		1334	case KW_dam_modifier:
		1335	thawer.get (op->dam_modifier);
		1336	break;
		1337	case KW_duration_modifier:
		1338	thawer.get (op->duration_modifier);
		1339	break;
		1340
		1341	//TODO: mechanism to ensure that KW_xxx is consecutive needed from include/preprocess
		1342	//TODO: parse from other include files
		1343	case KW_body_range:
		1344	thawer.get (op->body_info[0]);
		1345	break;
		1346	case KW_body_arm:
		1347	thawer.get (op->body_info[1]);
		1348	break;
		1349	case KW_body_torso:
		1350	thawer.get (op->body_info[2]);
		1351	break;
		1352	case KW_body_head:
		1353	thawer.get (op->body_info[3]);
		1354	break;
		1355	case KW_body_neck:
		1356	thawer.get (op->body_info[4]);
		1357	break;
		1358	case KW_body_skill:
		1359	thawer.get (op->body_info[5]);
		1360	break;
		1361	case KW_body_finger:
		1362	thawer.get (op->body_info[6]);
		1363	break;
		1364	case KW_body_shoulder:
		1365	thawer.get (op->body_info[7]);
		1366	break;
		1367	case KW_body_foot:
		1368	thawer.get (op->body_info[8]);
		1369	break;
		1370	case KW_body_hand:
		1371	thawer.get (op->body_info[9]);
		1372	break;
		1373	case KW_body_wrist:
		1374	thawer.get (op->body_info[10]);
		1375	break;
		1376	case KW_body_waist:
		1377	thawer.get (op->body_info[11]);
		1378	break;
		1379	case KW_can_apply:
		1380	break;
		1381
		1382	case KW_connected:
		1383	add_button_link (op, op->map, thawer.get_sint32 ());
		1384	break;
		1385
		1386	case KW_randomitems:
		1387	op->randomitems = find_treasurelist (thawer.get_str ());
		1388	break;
		1389
		1390	case KW_msg:
		1391	{
		1392	thawer.get_ml (KW_endmsg, op->msg);
		1393	//TODO: allow longer messages
		1394	if (strlen (op->msg) >= HUGE_BUF)
		1395	{
		1396	LOG (llevDebug, "\n\tError message length >= %d: %d\n>%.80s<\n", HUGE_BUF, strlen (op->msg), &op->msg);
		1397	op->msg = "ERROR, please report: string too long, winged.\n";
		1398	}
		1399	}
		1400	break;
		1401
1407	case KW_more:	1402	case KW_lore:
1408	/* We need to record that this is a multipart object,	1403	{
1409	* so the calling function can glue things back together	1404	shstr msgbuf;
		1405
		1406	thawer.get_ml (KW_endlore, op->lore);
		1407	//TODO: allow longer messages
		1408	/* Just print a warning so we can be reasonably safe
		1409	* about not overflowing the buffer.
1410	*/	1410	*/
		1411	if (strlen (op->lore) > (HUGE_BUF / 2))
		1412	LOG (llevDebug, "\n\tWarning lore length > %d (max allowed=%d): %d\n>%.80s<\n",
		1413	HUGE_BUF / 2, HUGE_BUF, strlen (op->lore), &op->lore);
		1414	}
		1415	break;
		1416
		1417	case KW_editable:
		1418	case KW_editor_folder:
		1419	break;
		1420
		1421	case KW_More: // uppercase alias
		1422	case KW_more:
		1423	/* We need to record that this is a multipart object,
		1424	* so the calling function can glue things back together
		1425	*/
1411	ismore = 1;	1426	ismore = 1;
1412	break;	1427	break;
1413		1428
1414	case KW_end:	1429	case KW_end:
1415	check_loaded_object (op);	1430	check_loaded_object (op);
1416		1431
1417	if (!arch_init)	1432	if (!arch_init)
1418	op->instantiate ();	1433	op->instantiate ();
1419		1434
1420	return ismore ? LL_MORE : LL_NORMAL;	1435	return ismore ? LL_MORE : LL_NORMAL;
1421		1436
1422	case KW_EOF:	1437	case KW_EOF:
1423	return LL_EOF;	1438	return LL_EOF;
1424		1439
1425	case KW_ERROR:	1440	case KW_ERROR:
1426	set_ob_key_value (op, thawer.line, thawer.last_value, true);	1441	set_ob_key_value (op, thawer.line, thawer.last_value, true);
1427	//printf ("addkv(%s,%s)\n", thawer.line, thawer.get_str());//D	1442	//printf ("addkv(%s,%s)\n", thawer.line, thawer.get_str());//D
1428		1443
1429	//TODO: skip line, ugly, factor parsing better	1444	//TODO: skip line, ugly, factor parsing better
1430	if (thawer.last_value)	1445	if (thawer.last_value)
1431	thawer.line = thawer.last_value;	1446	thawer.line = thawer.last_value;
1432		1447
1433	thawer.line += strlen (thawer.line) + 1;	1448	thawer.line += strlen (thawer.line) + 1;
1434		1449
1435	break;	1450	break;
1436		1451
1437	default:	1452	default:
1438	LOG (llevError, "UNSUPPORTED KEYWORD IN MAP: \"%s\", bug in normaliser. skipping.\n", keyword_str[kw]);	1453	LOG (llevError, "UNSUPPORTED KEYWORD IN MAP: \"%s\", bug in normaliser. skipping.\n", keyword_str[kw]);
1439	break;	1454	break;
1440	}	1455	}
1441	}	1456	}
1442	}	1457	}
1443		1458
1444	/*	1459	/*
…		…
1592	}	1607	}
1593	#endif	1608	#endif
1594		1609
1595	// compare *op against *tmp and output differences	1610	// compare *op against *tmp and output differences
1596	void	1611	void
1597	put (object_freezer & f, object *op, object *tmp)	1612	put (object_freezer &f, object *op, object *tmp)
1598	{	1613	{
1599	int i;	1614	int i;
1600		1615
1601	/* This saves the key/value lists. We do it first so that any	1616	/* This saves the key/value lists. We do it first so that any
1602	* keys that match field names will be overwritten by the loader.	1617	* keys that match field names will be overwritten by the loader.
…		…
1612	}	1627	}
1613		1628
1614	/* We don't need to worry about the arch's extra fields - they	1629	/* We don't need to worry about the arch's extra fields - they
1615	* will get taken care of the copy_object function.	1630	* will get taken care of the copy_object function.
1616	*/	1631	*/
		1632
		1633	{
		1634	char uids[64];
		1635	snprintf (uids, sizeof (uids), "<1.%llx>", (unsigned long long)op->uuid.seq);
		1636	f.put (KW_uuid, (const char *)uids);
		1637	}
1617		1638
1618	#define CMP_OUT(v) if (op->v != tmp->v) f.put (KW_ ## v, op->v)	1639	#define CMP_OUT(v) if (op->v != tmp->v) f.put (KW_ ## v, op->v)
1619	#define CMP_OUT2(k,v) if (op->v != tmp->v) f.put (KW_ ## k, op->v)	1640	#define CMP_OUT2(k,v) if (op->v != tmp->v) f.put (KW_ ## k, op->v)
1620		1641
1621	CMP_OUT (name);	1642	CMP_OUT (name);
…		…
1810	}	1831	}
1811		1832
1812	fp.put (op);	1833	fp.put (op);
1813	fprintf (fp, "end\n");	1834	fprintf (fp, "end\n");
1814	}	1835	}
		1836

Diff Legend

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