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

Diff Legend

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