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

Diff Legend

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

Comparing deliantra/server/common/loader.C (file contents): Revision 1.14 by root, Tue Sep 12 19:20:06 2006 UTC vs. Revision 1.44 by root, Thu Jan 11 01:10:01 2007 UTC

Diff Legend

Comparing deliantra/server/common/loader.C (file contents):
Revision 1.14 by root, Tue Sep 12 19:20:06 2006 UTC vs.
Revision 1.44 by root, Thu Jan 11 01:10:01 2007 UTC