ViewVC Help

View File | Revision Log | Show Annotations | Download File

/cvs/deliantra/server/common/loader.l

Comparing deliantra/server/common/loader.l (file contents):
Revision 1.2 by root, Thu May 11 18:37:20 2006 UTC vs.
Revision 1.18 by root, Thu Aug 31 17:54:14 2006 UTC

1	%{	1	%{
2	/*	2	/*
3	* static char *rcsid_object_c =	3	* static char *rcsid_object_c =
4	* "$Id: loader.l,v 1.2 2006/05/11 18:37:20 root Exp $";	4	* "$Id: loader.l,v 1.18 2006/08/31 17:54:14 root Exp $";
5	*/	5	*/
6		6
7	/*	7	/*
8	CrossFire, A Multiplayer game for X-windows	8	CrossFire, A Multiplayer game for X-windows
9		9
…		…
35	#include <global.h>	35	#include <global.h>
36	#include <loader.h>	36	#include <loader.h>
37	#include <newserver.h>	37	#include <newserver.h>
38	#include <sproto.h>	38	#include <sproto.h>
39		39
40	#define YY_DECL int lex_load(object *op, int map_flags)	40	#define YY_DECL int lex_load(object *op, object_thawer &thawer, int map_flags)
41		41
42	static char *yval();	42	static char *yval();
43		43
44	static int lex_error;	44	static int lex_error;
45	static char msgbuf[HUGE_BUF];	45	static char msgbuf[65536];
46	static char lorebuf[HUGE_BUF];	46	static char lorebuf[65536];
47		47
48	/* Maps the MOVE_* values to names */	48	/* Maps the MOVE_* values to names */
49	static const char *const move_name[] = {"walk", "fly_low", "fly_high", "swim", "boat",	49	static const char *const move_name[] = {"walk", "fly_low", "fly_high", "swim", "boat",
50	NULL};	50	NULL};
51		51
…		…
57	* If you are adding a new spell, you should not modify this - you	57	* If you are adding a new spell, you should not modify this - you
58	* new spell won't have been used, and thus won't have any legacy object.	58	* new spell won't have been used, and thus won't have any legacy object.
59	* NULL entries in this table are valid - to denote objects that should	59	* NULL entries in this table are valid - to denote objects that should
60	* not be updated for whatever reason.	60	* not be updated for whatever reason.
61	*/	61	*/
62	const char *const spell_mapping[] = {	62	const char *spell_mapping[] = {
63	"spell_magic_bullet", /* 0 */	63	"spell_magic_bullet", /* 0 */
64	"spell_small_fireball", /* 1 */	64	"spell_small_fireball", /* 1 */
65	"spell_medium_fireball", /* 2 */	65	"spell_medium_fireball", /* 2 */
66	"spell_large_fireball", /* 3 */	66	"spell_large_fireball", /* 3 */
67	"spell_burning_hands", /* 4 */	67	"spell_burning_hands", /* 4 */
68	"spell_sm_lightning", /* 5 */	68	"spell_sm_lightning", /* 5 */
69	"spell_large_lightning", /* 6 */	69	"spell_large_lightning", /* 6 */
70	"spell_magic_missile", /* 7 */	70	"spell_magic_missile", /* 7 */
71	"spell_create_bomb", /* 8 */	71	"spell_create_bomb", /* 8 */
72	"spell_summon_golem", /* 9 */	72	"spell_summon_golem", /* 9 */
73	"spell_summon_fire_elemental", /* 10 */	73	"spell_summon_fire_elemental", /* 10 */
74	"spell_summon_earth_elemental", /* 11 */	74	"spell_summon_earth_elemental", /* 11 */
75	"spell_summon_water_elemental", /* 12 */	75	"spell_summon_water_elemental", /* 12 */
76	"spell_summon_air_elemental", /* 13 */	76	"spell_summon_air_elemental", /* 13 */
77	"spell_dimension_door", /* 14 */	77	"spell_dimension_door", /* 14 */
78	"spell_create_earth_wall", /* 15 */	78	"spell_create_earth_wall", /* 15 */
79	"spell_paralyze", /* 16 */	79	"spell_paralyze", /* 16 */
80	"spell_icestorm", /* 17 */	80	"spell_icestorm", /* 17 */
81	"spell_magic_mapping", /* 18 */	81	"spell_magic_mapping", /* 18 */
82	"spell_turn_undead", /* 19 */	82	"spell_turn_undead", /* 19 */
83	"spell_fear", /* 20 */	83	"spell_fear", /* 20 */
84	"spell_poison_cloud", /* 21 */	84	"spell_poison_cloud", /* 21 */
85	"spell_wonder", /* 22 */	85	"spell_wonder", /* 22 */
86	"spell_destruction", /* 23 */	86	"spell_destruction", /* 23 */
87	"spell_perceive_self", /* 24 */	87	"spell_perceive_self", /* 24 */
88	"spell_word_of_recall", /* 25 */	88	"spell_word_of_recall", /* 25 */
89	"spell_invisible", /* 26 */	89	"spell_invisible", /* 26 */
90	"spell_invisible_to_undead", /* 27 */	90	"spell_invisible_to_undead", /* 27 */
91	"spell_probe", /* 28 */	91	"spell_probe", /* 28 */
92	"spell_lg_magic_bullet", /* 29 */	92	"spell_lg_magic_bullet", /* 29 */
93	"spell_improved_invisibility", /* 30 */	93	"spell_improved_invisibility", /* 30 */
94	"spell_holy_word", /* 31 */	94	"spell_holy_word", /* 31 */
95	"spell_minor_healing", /* 32 */	95	"spell_minor_healing", /* 32 */
96	"spell_medium_healing", /* 33 */	96	"spell_medium_healing", /* 33 */
97	"spell_major_healing", /* 34 */	97	"spell_major_healing", /* 34 */
98	"spell_heal", /* 35 */	98	"spell_heal", /* 35 */
99	"spell_create_food", /* 36 */	99	"spell_create_food", /* 36 */
100	"spell_earth_to_dust", /* 37 */	100	"spell_earth_to_dust", /* 37 */
101	"spell_armour", /* 38 */	101	"spell_armour", /* 38 */
102	"spell_strength", /* 39 */	102	"spell_strength", /* 39 */
103	"spell_dexterity", /* 40 */	103	"spell_dexterity", /* 40 */
104	"spell_constitution", /* 41 */	104	"spell_constitution", /* 41 */
105	"spell_charisma", /* 42 */	105	"spell_charisma", /* 42 */
106	"spell_create_fire_wall", /* 43 */	106	"spell_create_fire_wall", /* 43 */
107	"spell_create_frost_wall", /* 44 */	107	"spell_create_frost_wall", /* 44 */
108	"spell_protection_from_cold", /* 45 */	108	"spell_protection_from_cold", /* 45 */
109	"spell_protection_from_electricity", /* 46 */	109	"spell_protection_from_electricity", /* 46 */
110	"spell_protection_from_fire", /* 47 */	110	"spell_protection_from_fire", /* 47 */
111	"spell_protection_from_poison", /* 48 */	111	"spell_protection_from_poison", /* 48 */
112	"spell_protection_from_slow", /* 49 */	112	"spell_protection_from_slow", /* 49 */
113	"spell_protection_from_paralysis", /* 50 */	113	"spell_protection_from_paralysis", /* 50 */
114	"spell_protection_from_draining", /* 51 */	114	"spell_protection_from_draining", /* 51 */
115	"spell_protection_from_magic", /* 52 */	115	"spell_protection_from_magic", /* 52 */
116	"spell_protection_from_attack", /* 53 */	116	"spell_protection_from_attack", /* 53 */
117	"spell_levitate", /* 54 */	117	"spell_levitate", /* 54 */
118	"spell_small_speedball", /* 55 */	118	"spell_small_speedball", /* 55 */
119	"spell_large_speedball", /* 56 */	119	"spell_large_speedball", /* 56 */
120	"spell_hellfire", /* 57 */	120	"spell_hellfire", /* 57 */
121	"spell_dragonbreath", /* 58 */	121	"spell_dragonbreath", /* 58 */
122	"spell_large_icestorm", /* 59 */	122	"spell_large_icestorm", /* 59 */
123	"spell_charging", /* 60 */	123	"spell_charging", /* 60 */
124	"spell_polymorph", /* 61 */	124	"spell_polymorph", /* 61 */
125	"spell_cancellation", /* 62 */	125	"spell_cancellation", /* 62 */
126	"spell_confusion", /* 63 */	126	"spell_confusion", /* 63 */
127	"spell_mass_confusion", /* 64 */	127	"spell_mass_confusion", /* 64 */
128	"spell_summon_pet_monster", /* 65 */	128	"spell_summon_pet_monster", /* 65 */
129	"spell_slow", /* 66 */	129	"spell_slow", /* 66 */
130	"spell_regenerate_spellpoints", /* 67 */	130	"spell_regenerate_spellpoints", /* 67 */
131	"spell_cure_poison", /* 68 */	131	"spell_cure_poison", /* 68 */
132	"spell_protection_from_confusion", /* 69 */	132	"spell_protection_from_confusion", /* 69 */
133	"spell_protection_from_cancellation", /* 70 */	133	"spell_protection_from_cancellation", /* 70 */
134	"spell_protection_from_depletion", /* 71 */	134	"spell_protection_from_depletion", /* 71 */
135	"spell_alchemy", /* 72 */	135	"spell_alchemy", /* 72 */
136	"spell_remove_curse", /* 73 */	136	"spell_remove_curse", /* 73 */
137	"spell_remove_damnation", /* 74 */	137	"spell_remove_damnation", /* 74 */
138	"spell_identify", /* 75*/	138	"spell_identify", /* 75*/
139	"spell_detect_magic", /* 76 */	139	"spell_detect_magic", /* 76 */
140	"spell_detect_monster", /* 77 */	140	"spell_detect_monster", /* 77 */
141	"spell_detect_evil", /* 78 */	141	"spell_detect_evil", /* 78 */
142	"spell_detect_curse", /* 79 */	142	"spell_detect_curse", /* 79 */
143	"spell_heroism", /* 80 */	143	"spell_heroism", /* 80 */
144	"spell_aggravation", /* 81 */	144	"spell_aggravation", /* 81 */
145	"spell_firebolt", /* 82 */	145	"spell_firebolt", /* 82 */
146	"spell_frostbolt", /* 83 */	146	"spell_frostbolt", /* 83 */
147	"spell_shockwave", /* 84 */	147	"spell_shockwave", /* 84 */
148	"spell_color_spray", /* 85 */	148	"spell_color_spray", /* 85 */
149	"spell_haste", /* 86 */	149	"spell_haste", /* 86 */
150	"spell_face_of_death", /* 87 */	150	"spell_face_of_death", /* 87 */
151	"spell_ball_lightning", /* 88 */	151	"spell_ball_lightning", /* 88 */
152	"spell_meteor_swarm", /* 89 */	152	"spell_meteor_swarm", /* 89 */
153	"spell_comet", /* 90 */	153	"spell_comet", /* 90 */
154	"spell_mystic_fist", /* 91 */	154	"spell_mystic_fist", /* 91 */
155	"spell_raise_dead", /* 92 */	155	"spell_raise_dead", /* 92 */
156	"spell_resurrection", /* 93 */	156	"spell_resurrection", /* 93 */
157	"spell_reincarnation", /* 94 */	157	"spell_reincarnation", /* 94 */
158	"spell_immunity_to_cold", /* 95 */	158	"spell_immunity_to_cold", /* 95 */
159	"spell_immunity_to_electricity",/* 96 */	159	"spell_immunity_to_electricity",/* 96 */
160	"spell_immunity_to_fire", /* 97 */	160	"spell_immunity_to_fire", /* 97 */
161	"spell_immunity_to_poison", /* 98 */	161	"spell_immunity_to_poison", /* 98 */
162	"spell_immunity_to_slow", /* 99 */	162	"spell_immunity_to_slow", /* 99 */
163	"spell_immunity_to_paralysis", /* 100 */	163	"spell_immunity_to_paralysis", /* 100 */
164	"spell_immunity_to_draining", /* 101 */	164	"spell_immunity_to_draining", /* 101 */
165	"spell_immunity_to_magic", /* 102 */	165	"spell_immunity_to_magic", /* 102 */
166	"spell_immunity_to_attack", /* 103 */	166	"spell_immunity_to_attack", /* 103 */
167	"spell_invulnerability", /* 104 */	167	"spell_invulnerability", /* 104 */
168	"spell_defense", /* 105 */	168	"spell_defense", /* 105 */
169	"spell_rune_of_fire", /* 106 */	169	"spell_rune_of_fire", /* 106 */
170	"spell_rune_of_frost", /* 107 */	170	"spell_rune_of_frost", /* 107 */
171	"spell_rune_of_shocking", /* 108 */	171	"spell_rune_of_shocking", /* 108 */
172	"spell_rune_of_blasting", /* 109 */	172	"spell_rune_of_blasting", /* 109 */
173	"spell_rune_of_death", /* 110 */	173	"spell_rune_of_death", /* 110 */
174	"spell_marking_rune", /* 111 */	174	"spell_marking_rune", /* 111 */
175	"spell_build_director", /* 112 */	175	"spell_build_director", /* 112 */
176	"spell_create_pool_of_chaos", /* 113 */	176	"spell_create_pool_of_chaos", /* 113 */
177	"spell_build_bullet_wall", /* 114 */	177	"spell_build_bullet_wall", /* 114 */
178	"spell_build_lightning_wall", /* 115 */	178	"spell_build_lightning_wall", /* 115 */
179	"spell_build_fireball_wall", /* 116 */	179	"spell_build_fireball_wall", /* 116 */
180	"spell_magic_rune", /* 117 */	180	"spell_magic_rune", /* 117 */
181	"spell_rune_of_magic_drain", /* 118 */	181	"spell_rune_of_magic_drain", /* 118 */
182	"spell_antimagic_rune", /* 119 */	182	"spell_antimagic_rune", /* 119 */
183	"spell_rune_of_transference", /* 120 */	183	"spell_rune_of_transference", /* 120 */
184	"spell_transference", /* 121 */	184	"spell_transference", /* 121 */
185	"spell_magic_drain", /* 122 */	185	"spell_magic_drain", /* 122 */
186	"spell_counterspell", /* 123 */	186	"spell_counterspell", /* 123 */
187	"spell_disarm", /* 124 */	187	"spell_disarm", /* 124 */
188	"spell_cure_confusion", /* 125 */	188	"spell_cure_confusion", /* 125 */
189	"spell_restoration", /* 126 */	189	"spell_restoration", /* 126 */
190	"was summon evil monster", /* 127 */ /* Not implenented as nothing used it */	190	"was summon evil monster", /* 127 */ /* Not implenented as nothing used it */
191	"spell_counterwall", /* 128 */	191	"spell_counterwall", /* 128 */
192	"spell_cause_light_wounds", /* 129 */	192	"spell_cause_light_wounds", /* 129 */
193	"spell_cause_medium_wounds", /* 130 */	193	"spell_cause_medium_wounds", /* 130 */
194	"spell_cause_heavy_wounds", /* 131 */	194	"spell_cause_heavy_wounds", /* 131 */
195	"spell_charm_monsters", /* 132 */	195	"spell_charm_monsters", /* 132 */
196	"spell_banishment", /* 133 */	196	"spell_banishment", /* 133 */
197	"spell_create_missile", /* 134 */	197	"spell_create_missile", /* 134 */
198	"spell_show_invisible", /* 135 */	198	"spell_show_invisible", /* 135 */
199	"spell_xray", /* 136 */	199	"spell_xray", /* 136 */
200	"spell_pacify", /* 137 */	200	"spell_pacify", /* 137 */
201	"spell_summon_fog", /* 138 */	201	"spell_summon_fog", /* 138 */
202	"spell_steambolt", /* 139 */	202	"spell_steambolt", /* 139 */
203	"spell_command_undead", /* 140 */	203	"spell_command_undead", /* 140 */
204	"spell_holy_orb", /* 141 */	204	"spell_holy_orb", /* 141 */
205	"spell_summon_avatar", /* 142 */	205	"spell_summon_avatar", /* 142 */
206	"spell_holy_possession", /* 143 */	206	"spell_holy_possession", /* 143 */
207	"spell_bless", /* 144 */	207	"spell_bless", /* 144 */
208	"spell_curse", /* 145 */	208	"spell_curse", /* 145 */
209	"spell_regeneration", /* 146 */	209	"spell_regeneration", /* 146 */
210	"spell_consecrate", /* 147 */	210	"spell_consecrate", /* 147 */
211	"spell_summon_cult_monsters", /* 148 */	211	"spell_summon_cult_monsters", /* 148 */
212	"spell_cause_critical_wounds", /* 149 */	212	"spell_cause_critical_wounds", /* 149 */
213	"spell_holy_wrath", /* 150 */	213	"spell_holy_wrath", /* 150 */
214	"spell_retributive_strike", /* 151 */	214	"spell_retributive_strike", /* 151 */
215	"spell_finger_of_death", /* 152 */	215	"spell_finger_of_death", /* 152 */
216	"spell_insect_plague", /* 153 */	216	"spell_insect_plague", /* 153 */
217	"spell_call_holy_servant", /* 154 */	217	"spell_call_holy_servant", /* 154 */
218	"spell_wall_of_thorns", /* 155 */	218	"spell_wall_of_thorns", /* 155 */
219	"spell_staff_to_snake", /* 156 */	219	"spell_staff_to_snake", /* 156 */
220	"spell_light", /* 157 */	220	"spell_light", /* 157 */
221	"spell_darkness", /* 158 */	221	"spell_darkness", /* 158 */
222	"spell_nightfall", /* 159 */	222	"spell_nightfall", /* 159 */
223	"spell_daylight", /* 160 */	223	"spell_daylight", /* 160 */
224	"spell_sunspear", /* 161 */	224	"spell_sunspear", /* 161 */
225	"spell_faery_fire", /* 162 */	225	"spell_faery_fire", /* 162 */
226	"spell_cure_blindness", /* 163 */	226	"spell_cure_blindness", /* 163 */
227	"spell_dark_vision", /* 164 */	227	"spell_dark_vision", /* 164 */
228	"spell_bullet_swarm", /* 165 */	228	"spell_bullet_swarm", /* 165 */
229	"spell_bullet_storm", /* 166 */	229	"spell_bullet_storm", /* 166 */
230	"spell_cause_many_wounds", /* 167 */	230	"spell_cause_many_wounds", /* 167 */
231	"spell_small_snowstorm", /* 168 */	231	"spell_small_snowstorm", /* 168 */
232	"spell_medium_snowstorm", /* 169 */	232	"spell_medium_snowstorm", /* 169 */
233	"spell_large_snowstorm", /* 170 */	233	"spell_large_snowstorm", /* 170 */
234	"spell_cure_disease", /* 171 */	234	"spell_cure_disease", /* 171 */
235	"spell_cause_red_death", /* 172 */	235	"spell_cause_red_death", /* 172 */
236	"spell_cause_flu", /* 173 */	236	"spell_cause_flu", /* 173 */
237	"spell_cause_black_death", /* 174 */	237	"spell_cause_black_death", /* 174 */
238	"spell_cause_leprosy", /* 175 */	238	"spell_cause_leprosy", /* 175 */
239	"spell_cause_smallpox", /* 176 */	239	"spell_cause_smallpox", /* 176 */
240	"spell_cause_white_death", /* 177 */	240	"spell_cause_white_death", /* 177 */
241	"spell_cause_anthrax", /* 178 */	241	"spell_cause_anthrax", /* 178 */
242	"spell_cause_typhoid", /* 179 */	242	"spell_cause_typhoid", /* 179 */
243	"spell_mana_blast", /* 180 */	243	"spell_mana_blast", /* 180 */
244	"spell_small_manaball", /* 181 */	244	"spell_small_manaball", /* 181 */
245	"spell_medium_manaball", /* 182 */	245	"spell_medium_manaball", /* 182 */
246	"spell_large_manaball", /* 183 */	246	"spell_large_manaball", /* 183 */
247	"spell_manabolt", /* 184 */	247	"spell_manabolt", /* 184 */
248	"spell_dancing_sword", /* 185 */	248	"spell_dancing_sword", /* 185 */
249	"spell_animate_weapon", /* 186 */	249	"spell_animate_weapon", /* 186 */
250	"spell_cause_cold", /* 187 */	250	"spell_cause_cold", /* 187 */
251	"spell_divine_shock", /* 188 */	251	"spell_divine_shock", /* 188 */
252	"spell_windstorm", /* 189 */	252	"spell_windstorm", /* 189 */
253	"spell_sanctuary", /* 190 */	253	"spell_sanctuary", /* 190 */
254	"spell_peace", /* 191 */	254	"spell_peace", /* 191 */
255	"spell_spiderweb", /* 192 */	255	"spell_spiderweb", /* 192 */
256	"spell_conflict", /* 193 */	256	"spell_conflict", /* 193 */
257	"spell_rage", /* 194 */	257	"spell_rage", /* 194 */
258	"spell_forked_lightning", /* 195 */	258	"spell_forked_lightning", /* 195 */
259	"spell_poison_fog", /* 196 */	259	"spell_poison_fog", /* 196 */
260	"spell_flaming_aura", /* 197 */	260	"spell_flaming_aura", /* 197 */
261	"spell_vitriol", /* 198 */	261	"spell_vitriol", /* 198 */
262	"spell_vitriol_splash", /* 199 */	262	"spell_vitriol_splash", /* 199 */
263	"spell_iron_skin", /* 200 */	263	"spell_iron_skin", /* 200 */
264	"spell_wrathful_eye", /* 201 */	264	"spell_wrathful_eye", /* 201 */
265	"spell_town_portal", /* 202 */	265	"spell_town_portal", /* 202 */
266	"spell_missile_swarm", /* 203 */	266	"spell_missile_swarm", /* 203 */
267	"spell_cause_rabies", /* 204 */	267	"spell_cause_rabies", /* 204 */
268	"spell_glyph", /* 205 */	268	"spell_glyph", /* 205 */
269	NULL	269	NULL
270	};	270	};
271		271
272	#define SET_OR_CLEAR_FLAG(op, flag, val) \	272	#define SET_OR_CLEAR_FLAG(op, flag, val) \
273	{ if (val) SET_FLAG(op, flag); else CLEAR_FLAG(op, flag); }	273	{ if (val) SET_FLAG(op, flag); else CLEAR_FLAG(op, flag); }
274		274
275	/* SET_RESIST is really only really needed for transition code. We normally	275	/* SET_RESIST is really only really needed for transition code. We normally
276	* don't care about multiple values overwriting each other, but this is	276	* don't care about multiple values overwriting each other, but this is
277	* to catch items that have multiple protection/immune/vulnerable.	277	* to catch items that have multiple protection/immune/vulnerable.
278	* This can be simplified later on to just do the set after all the archs	278	* This can be simplified later on to just do the set after all the archs
…		…
280	* We always keep the last value because otherwise the value from the	280	* We always keep the last value because otherwise the value from the
281	* arch may take precedence.	281	* arch may take precedence.
282	* Unfortunately, we will report warnings here simply because an object has	282	* Unfortunately, we will report warnings here simply because an object has
283	* been modified from the arch.	283	* been modified from the arch.
284	*/	284	*/
285	#if 0 /* #if's don't work in #define macros */	285	#if 0 /* #if's don't work in #define macros */
286	#define SET_RESIST(op, type, val) \	286	#define SET_RESIST(op, type, val) \
287	{if (op->resist[type]!=0) { \	287	{if (op->resist[type]!=0) { \
288	LOG(llevInfo, "object %s having multiple resistances set, type=%s, old=%d, new=%d\n", \	288	LOG(llevInfo, "object %s having multiple resistances set, type=%s, old=%d, new=%d\n", \
289	op->name?op->name:(op->arch?op->arch->name:"unknown"), \	289	op->name?op->name:(op->arch?op->arch->name:"unknown"), \
290	resist_plus[type], op->resist[type], val); \	290	resist_plus[type], op->resist[type], val); \
291	} op->resist[type] = val; }	291	} op->resist[type] = val; }
292	#else	292	#else
293	#define SET_RESIST(op, type, val) op->resist[type] = val;	293	#define SET_RESIST(op, type, val) op->resist[type] = val;
294	#endif	294	#endif
295		295
296	#define IVAL atoi(yval())	296	#define IVAL atoi(yval())
297	#define FVAL atof(yval())	297	#define FVAL atof(yval())
298	extern int arch_init;	298	extern int arch_init;
299		299
300	/* Put this here since it is used below */	300	/* Put this here since it is used below */
301	static void set_protection(object *op, uint32 mask, uint16 pro_val)	301	static void set_protection(object *op, uint32 mask, uint16 pro_val)
302	{	302	{
303	int i;	303	int i;
304		304
305	if (!mask) return; /* Unlikely, but might as well check */	305	if (!mask) return; /* Unlikely, but might as well check */
306	for (i=0; i<NROFATTACKS; i++) {	306	for (i=0; i<NROFATTACKS; i++) {
307	if (mask & (1<<i)) SET_RESIST(op, i, pro_val);	307	if (mask & (1<<i)) SET_RESIST(op, i, pro_val);
308	}	308	}
309	}	309	}
310		310
311		311
312	static void set_body_info(object *op, char *params) {	312	static void set_body_info(object *op, char *params) {
…		…
314	char *cp;	314	char *cp;
315		315
316	/* go to first space character */	316	/* go to first space character */
317	for (cp=params; !isspace(*cp); cp++) ;	317	for (cp=params; !isspace(*cp); cp++) ;
318		318
319	*cp++ = 0; /* null it out */	319	*cp++ = 0; /* null it out */
320		320
321	for (i=0; i<NUM_BODY_LOCATIONS; i++) {	321	for (i=0; i<NUM_BODY_LOCATIONS; i++) {
322	if (!strcmp(params, body_locations[i].save_name)) {	322	if (!strcmp(params, body_locations[i].save_name)) {
323	op->body_info[i] = atoi(cp);	323	op->body_info[i] = atoi(cp);
324	return; /* Only one line passed in params */	324	return; /* Only one line passed in params */
325	}	325	}
326	}	326	}
327	LOG(llevError,"set_body_info called with bogus params: %s\n", params);	327	LOG(llevError,"set_body_info called with bogus params: %s\n", params);
328	}	328	}
329		329
		330	// return a suitable strign describign an objetc in enough detail to find it
		331	// used only in check_loaded_object: TODO remove static, move it elsewhere and
		332	// use it in more log messages.
		333	static char *op_debug_info_ (object *op, char *info)
		334	{
		335	char info2[256 * 3];
		336	char *p = info;
		337
		338	p += snprintf (p, 256, "%d=\"%s%s%s\"",
		339	op->count,
		340	op->name ? (const char *)op->name : "(anon)",
		341	op->title ? " " : "",
		342	op->title ? (const char *)op->title : "");
		343
		344	if (op->env)
		345	p += snprintf (p, 256, "(in %s)", op_debug_info_ (op->env, info2));
		346
		347	if (op->map)
		348	p += snprintf (p, 256, "(on %s@%d+%d)", op->map->path, op->x, op->y);
		349
		350	return info;
		351	}
		352
		353	static char *op_debug_info (object *op)
		354	{
		355	static char info[256 * 3];
		356
		357	return op_debug_info_ (op, info);
		358	}
330		359
331	/* This function checks the object after it has been loaded (when we	360	/* This function checks the object after it has been loaded (when we
332	* get the 'end' in the input stream). This function can be used to	361	* get the 'end' in the input stream). This function can be used to
333	* deal with legacy objects where fields may have changed. It can also be used	362	* deal with legacy objects where fields may have changed. It can also be used
334	* to check for objects to make sure there are no common errors.	363	* to check for objects to make sure there are no common errors.
…		…
344	* the object. In that case, we also want to use the loaded name.	373	* the object. In that case, we also want to use the loaded name.
345	* Otherwise, what happens is that the the plural name will lose	374	* Otherwise, what happens is that the the plural name will lose
346	* information (appear as just 'hearts' and not 'goblins heart')	375	* information (appear as just 'hearts' and not 'goblins heart')
347	*/	376	*/
348	if (op->arch && op->name != op->arch->clone.name && op->name_pl == op->arch->clone.name_pl) {	377	if (op->arch && op->name != op->arch->clone.name && op->name_pl == op->arch->clone.name_pl) {
349	if (op->name_pl) free_string(op->name_pl);	378	if (op->name_pl) free_string(op->name_pl);
350	op->name_pl = NULL;	379	op->name_pl = NULL;
351	}	380	}
352	if (!op->name_pl) op->name_pl = add_string(op->name);	381	if (!op->name_pl) op->name_pl = add_string(op->name);
353		382
354	/* objects now have a materialname. try to patch it in */	383	/* objects now have a materialname. try to patch it in */
355	if (!(IS_WEAPON(op) && op->level > 0)) {	384	if (!(IS_WEAPON(op) && op->level > 0)) {
…		…
362	* excessive to do this at every run - most of this is	391	* excessive to do this at every run - most of this is
363	* really just to catch any errors - program will still run, but	392	* really just to catch any errors - program will still run, but
364	* not in the ideal fashion.	393	* not in the ideal fashion.
365	*/	394	*/
366	if ((op->type == WEAPON || op->type==BOW) && arch_init) {	395	if ((op->type == WEAPON || op->type==BOW) && arch_init) {
367	if (!op->skill) {	396	if (!op->skill) {
368	LOG(llevError,"Weapon %s lacks a skill.\n", op->name);	397	LOG(llevError,"Weapon %s lacks a skill.\n", op_debug_info (op));
369	} else if ((!strcmp(op->skill,"one handed weapons") && op->body_info[1] != -1) ||	398	} else if ((!strcmp(op->skill,"one handed weapons") && op->body_info[1] != -1) ||
370	(!strcmp(op->skill,"two handed weapons") && op->body_info[1] != -2)) {	399	(!strcmp(op->skill,"two handed weapons") && op->body_info[1] != -2)) {
371	LOG(llevError,"weapon %s arm usage does not match skill: %d, %s\n",	400	LOG(llevError,"weapon %s arm usage does not match skill: %d, %s\n",
372	op->name, op->body_info[1], op->skill);	401	op_debug_info (op), op->body_info[1], op->skill);
373	}	402	}
374	}	403	}
375		404
376	/* We changed last_heal to gen_sp_armour, which is what it	405	/* We changed last_heal to gen_sp_armour, which is what it
377	* really does for many objects. Need to catch any in maps	406	* really does for many objects. Need to catch any in maps
378	* that may have an old value.	407	* that may have an old value.
…		…
381	(op->type == ARMOUR) || (op->type == HELMET) ||	410	(op->type == ARMOUR) || (op->type == HELMET) ||
382	(op->type == SHIELD) || (op->type == RING) ||	411	(op->type == SHIELD) || (op->type == RING) ||
383	(op->type == BOOTS) || (op->type == GLOVES) ||	412	(op->type == BOOTS) || (op->type == GLOVES) ||
384	(op->type == AMULET ) || (op->type == GIRDLE) ||	413	(op->type == AMULET ) || (op->type == GIRDLE) ||
385	(op->type == BRACERS ) || (op->type == CLOAK)) {	414	(op->type == BRACERS ) || (op->type == CLOAK)) {
386	if (op->last_heal) {	415	if (op->last_heal) {
387	LOG(llevDebug,"Object %s still has last_heal set, not gen_sp_armour\n",	416	LOG(llevDebug,"Object %s still has last_heal set, not gen_sp_armour\n", op_debug_info (op));
388	op->name?op->name:"NULL");
389	op->gen_sp_armour = op->last_heal;	417	op->gen_sp_armour = op->last_heal;
390	op->last_heal = 0;	418	op->last_heal = 0;
391	}	419	}
392	if (editor) ip =0;	420	if (editor) ip =0;
393	else ip = calc_item_power(op, 0);	421	else ip = calc_item_power(op, 0);
394	/* Legacy objects from before item power was in the game */	422	/* Legacy objects from before item power was in the game */
395	if (!op->item_power && ip) {	423	if (!op->item_power && ip) {
396	if (ip > 3) {	424	if (ip > 3) {
397	LOG(llevDebug,"Object %s had no item power, using %d\n",	425	LOG(llevDebug,"Object %s had no item power, using %d\n", op_debug_info (op), ip);
398	op->name?op->name:"NULL", ip);	426	}
399	}
400	op->item_power = ip;	427	op->item_power = ip;
401	}	428	}
402	/* Check for possibly bogus values. Has to meet both these criteria -	429	/* Check for possibly bogus values. Has to meet both these criteria -
403	* something that has item_power 1 is probably just fine if our calculated	430	* something that has item_power 1 is probably just fine if our calculated
404	* value is 1 or 2 - these values are small enough that hard to be precise.	431	* value is 1 or 2 - these values are small enough that hard to be precise.
405	* similarly, it item_power is 0, the first check will always pass,	432	* similarly, it item_power is 0, the first check will always pass,
406	* but not the second one.	433	* but not the second one.
407	*/	434	*/
408	if (ip > 2 *op->item_power && ip > (op->item_power + 3)) {	435	if (ip > 2 *op->item_power && ip > (op->item_power + 3)) {
409	LOG(llevDebug,"Object %s seems to have too low item power? %d > %d\n",	436	LOG(llevDebug,"Object %s seems to have too low item power? %d > %d\n",
410	op->name?op->name:"NULL", ip, op->item_power);	437	op_debug_info (op), ip, op->item_power);
411	}	438	}
412		439
413	}	440	}
414	/* Old spellcasting object - need to load in the appropiate object */	441	/* Old spellcasting object - need to load in the appropiate object */
415	if ((op->type == ROD || op->type == WAND || op->type == SCROLL || op->type == HORN	442	if ((op->type == ROD || op->type == WAND || op->type == SCROLL || op->type == HORN
416	|| op->type == FIREWALL ||	443	|| op->type == FIREWALL ||
417	/* POTIONS and ALTARS don't always cast spells, but if they do, update them */	444	/* POTIONS and ALTARS don't always cast spells, but if they do, update them */
418	((op->type == POTION || op->type == ALTAR) && op->stats.sp)) && !op->inv && !arch_init) {	445	((op->type == POTION || op->type == ALTAR) && op->stats.sp)) && !op->inv && !arch_init) {
419	object *tmp;	446	object *tmp;
420		447
421	/* Fireall is bizarre in that spell type was stored in dam. Rest are 'normal'	448	/* Fireall is bizarre in that spell type was stored in dam. Rest are 'normal'
422	* in that spell was stored in sp.	449	* in that spell was stored in sp.
423	*/	450	*/
424	tmp = get_archetype(spell_mapping[op->type == FIREWALL?op->stats.dam:op->stats.sp]);	451	tmp = get_archetype(spell_mapping[op->type == FIREWALL?op->stats.dam:op->stats.sp]);
425	insert_ob_in_ob(tmp, op);	452	insert_ob_in_ob(tmp, op);
426	op->randomitems = NULL; /* So another spell isn't created for this object */	453	op->randomitems = NULL; /* So another spell isn't created for this object */
427	}	454	}
428	/* spellbooks & runes use slaying. But not to arch name, but to spell name */	455	/* spellbooks & runes use slaying. But not to arch name, but to spell name */
429		456
430	if ((op->type == SPELLBOOK || op->type == RUNE) && op->slaying && !op->inv && !arch_init) {	457	if ((op->type == SPELLBOOK || op->type == RUNE) && op->slaying && !op->inv && !arch_init) {
431	object *tmp;	458	object *tmp;
432		459
433	tmp = get_archetype_by_object_name(op->slaying);	460	tmp = get_archetype_by_object_name(op->slaying);
434	insert_ob_in_ob(tmp, op);	461	insert_ob_in_ob(tmp, op);
435	op->randomitems = NULL; /* So another spell isn't created for this object */	462	op->randomitems = NULL; /* So another spell isn't created for this object */
436	/* without this, value is all screwed up */	463	/* without this, value is all screwed up */
437	op->value = op->arch->clone.value * op->inv->value;	464	op->value = op->arch->clone.value * op->inv->value;
438	}	465	}
439		466
440	if (QUERY_FLAG(op, FLAG_MONSTER)) {	467	if (QUERY_FLAG(op, FLAG_MONSTER)) {
441	if (op->stats.hp > op->stats.maxhp)	468	if (op->stats.hp > op->stats.maxhp)
442	LOG(llevDebug,"Monster %s has hp set higher than maxhp (%d>%d)\n",	469	LOG(llevDebug,"Monster %s has hp set higher than maxhp (%d>%d)\n",
443	op->name,	470	op_debug_info (op),
444	op->stats.hp, op->stats.maxhp);	471	op->stats.hp, op->stats.maxhp);
445		472
446	/* The archs just need to be updated for this */	473	/* The archs just need to be updated for this */
447	if (op->move_type ==0) op->move_type = MOVE_WALK;	474	if (op->move_type ==0) op->move_type = MOVE_WALK;
448	}	475	}
449	if ((QUERY_FLAG(op,FLAG_GENERATOR) && QUERY_FLAG(op,FLAG_CONTENT_ON_GEN))	476	if ((QUERY_FLAG(op,FLAG_GENERATOR) && QUERY_FLAG(op,FLAG_CONTENT_ON_GEN))
450	|| op->type == CREATOR	477	|| op->type == CREATOR
451	|| op->type == CONVERTER) {	478	|| op->type == CONVERTER) {
452	/* Object will duplicate it's content as part of the	479	/* Object will duplicate it's content as part of the
…		…
462	* would potentially cause them to be triggered when someone steps	489	* would potentially cause them to be triggered when someone steps
463	* on them). If move_type is set, presume person knows what they	490	* on them). If move_type is set, presume person knows what they
464	* are doing, otherwise, set move_type based on maxhp value.	491	* are doing, otherwise, set move_type based on maxhp value.
465	*/	492	*/
466	if (op->type == PLAYERMOVER) {	493	if (op->type == PLAYERMOVER) {
467	if (!op->move_type) {	494	if (!op->move_type) {
468	if (op->stats.maxhp) {	495	if (op->stats.maxhp) {
469	op->move_type = MOVE_ALL;	496	op->move_type = MOVE_ALL;
470	op->stats.maxhp=0;	497	op->stats.maxhp=0;
471	} else {	498	} else {
472	op->move_type = MOVE_WALK;	499	op->move_type = MOVE_WALK;
473	}	500	}
474	}	501	}
475	}	502	}
476		503
477	}	504	}
478		505
479	/* This extracts the key/value from the yytext field -	506	/* This extracts the key/value from the yytext field -
…		…
529		556
530	/* Got last character before null and strip	557	/* Got last character before null and strip
531	* off tailing whitespace	558	* off tailing whitespace
532	*/	559	*/
533	for (end = value + (strlen(cp)-1); isspace(*end); end--) {	560	for (end = value + (strlen(cp)-1); isspace(*end); end--) {
534	if (end == value) {	561	if (end == value) {
535	/* *blink blink* Still no value? */	562	/* *blink blink* Still no value? */
536	set_ob_key_value(op, key, NULL, TRUE);	563	set_ob_key_value(op, key, NULL, TRUE);
537	return;	564	return;
538	}	565	}
539	*end='\0';	566	*end='\0';
540	}	567	}
541	set_ob_key_value(op, key, value, TRUE);	568	set_ob_key_value(op, key, value, TRUE);
542	}	569	}
543		570
544	static void set_move(MoveType *mt, char *params) {	571	static void set_move(MoveType *mt, char *params) {
545	char *str;	572	char *str;
546	int i, negate;	573	int i, negate;
547		574
548	if (isdigit(*params)) {	575	if (isdigit(*params)) {
549	*mt = atoi(params);	576	*mt = atoi(params);
550	} else {	577	} else {
551	*mt=0;	578	*mt=0;
552	for (str=strtok(params, " "); str; str=strtok(NULL, " ")) {	579	for (str=strtok(params, " "); str; str=strtok(NULL, " ")) {
553	negate=0;	580	negate=0;
554	if (!strcasecmp(str, "all"))	581	if (!strcasecmp(str, "all"))
555	*mt |= MOVE_ALL;	582	*mt |= MOVE_ALL;
556	else {	583	else {
557	if (*str=='-') {	584	if (*str=='-') {
558	negate = 1;	585	negate = 1;
559	str++;	586	str++;
560	}	587	}
561	for (i=0; move_name[i] != NULL; i++) {	588	for (i=0; move_name[i] != NULL; i++) {
562	if (!strcasecmp(move_name[i], str)) {	589	if (!strcasecmp(move_name[i], str)) {
563	if (negate) {	590	if (negate) {
564	*mt &= ~(1<<i);	591	*mt &= ~(1<<i);
565	} else {	592	} else {
566	*mt |= (1<<i);	593	*mt |= (1<<i);
567	}	594	}
568	break;	595	break;
569	}	596	}
570	}	597	}
571	if (move_name[i] == NULL) {	598	if (move_name[i] == NULL) {
572	/* fly is a special case - covers both fly_low and	599	/* fly is a special case - covers both fly_low and
573	* fly_high - since it doesn't match to a specific	600	* fly_high - since it doesn't match to a specific
574	* single bit, have to special case it.	601	* single bit, have to special case it.
575	*/	602	*/
576	if (!strcasecmp(str,"flying")) {	603	if (!strcasecmp(str,"flying")) {
577	if (negate) {	604	if (negate) {
578	*mt &= ~MOVE_FLYING;	605	*mt &= ~MOVE_FLYING;
579	} else {	606	} else {
580	*mt |= MOVE_FLYING;	607	*mt |= MOVE_FLYING;
581	}	608	}
582	} else {	609	} else {
583	LOG(llevDebug, "common/loader.l: set_move - unknown move string '%s'\n", str);	610	LOG(llevDebug, "common/loader.l: set_move - unknown move string '%s'\n", str);
584	}	611	}
585	}	612	}
586	} /* Else not all move types */	613	} /* Else not all move types */
587	} /* for strtok */	614	} /* for strtok */
588	} /* Else not a numeric value */	615	} /* Else not a numeric value */
589	}	616	}
590		617
591	%}	618	%}
592		619
593		620
594		621
595	S [ \t]+.+	622	S [ \t]+.*
596	WS [ \t]*	623	WS [ \t]*
597	A .+	624	A .+
598		625
599	%x MESSAGE	626	%x MESSAGE
600	%x LORE	627	%x LORE
601	%x SCRIPT	628	%x SCRIPT
602		629
…		…
614		641
615	lex_error=0;	642	lex_error=0;
616		643
617	%}	644	%}
618		645
619	^msg{WS}$ { BEGIN( MESSAGE ); msgbuf[0]='\0'; }	646	^msg{WS}$ { BEGIN( MESSAGE ); msgbuf[0]='\0'; }
620	<MESSAGE>^endmsg{WS}$ { BEGIN( INITIAL );	647	<MESSAGE>^endmsg{WS}$ { BEGIN( INITIAL );
621	op->msg=add_string(msgbuf);
622	/* Just print a warning so we can be reasonably safe	648	/* Just print a warning so we can be reasonably safe
623	* about not overflowing the buffer.	649	* about not overflowing the buffer.
624	*/	650	*/
625	if (strlen(op->msg) > (HUGE_BUF/2))	651	if (strlen(msgbuf) >= HUGE_BUF)
626	LOG(llevDebug, "\n\tWarning message length > %d (max allowed=%d): %d\n>%.80s<\n",	652	{
627	HUGE_BUF/2, HUGE_BUF, strlen(op->msg),op->msg);	653	LOG(llevDebug, "\n\tError message length >= %d: %d\n>%.80s<\n",
628	}	654	HUGE_BUF, strlen(op->msg),op->msg);
		655	op->msg = add_string ("ERROR, please report: string too long, winged.\n");
		656	}
		657	else
		658	op->msg = add_string (msgbuf);
		659	}
629	<MESSAGE>.* {strcat(msgbuf, yytext); strcat(msgbuf,"\n"); }	660	<MESSAGE>.* {strcat(msgbuf, yytext); strcat(msgbuf,"\n"); }
630		661
631	^lore{WS}$ { BEGIN( LORE ); lorebuf[0]='\0'; }	662	^lore{WS}$ { BEGIN( LORE ); lorebuf[0]='\0'; }
632	<LORE>^endlore{WS}$ { BEGIN( INITIAL );	663	<LORE>^endlore{WS}$ { BEGIN( INITIAL );
633	op->lore=add_string(lorebuf);	664	op->lore=add_string(lorebuf);
634	/* Just print a warning so we can be reasonably safe	665	/* Just print a warning so we can be reasonably safe
635	* about not overflowing the buffer.	666	* about not overflowing the buffer.
636	*/	667	*/
637	if (strlen(op->lore) > (HUGE_BUF/2))	668	if (strlen(op->lore) > (HUGE_BUF/2))
638	LOG(llevDebug, "\n\tWarning lore length > %d (max allowed=%d): %d\n>%.80s<\n",	669	LOG(llevDebug, "\n\tWarning lore length > %d (max allowed=%d): %d\n>%.80s<\n",
639	HUGE_BUF/2, HUGE_BUF, strlen(op->lore),op->lore);	670	HUGE_BUF/2, HUGE_BUF, strlen(op->lore),op->lore);
640	}	671	}
641	<LORE>.* {strcat(lorebuf, yytext); strcat(lorebuf,"\n"); }	672	<LORE>.* {strcat(lorebuf, yytext); strcat(lorebuf,"\n"); }
642		673
643	^object{S} { char *yv=yval();	674	^object{S} { char *yv=yval();
644		675
645	if (*yv=='\0') {	676	if (*yv=='\0') {
646	LOG(llevError,"Object lacks name.\n");	677	LOG(llevError,"Object lacks name.\n");
647	return LL_IGNORED;	678	return LL_IGNORED;
648	}	679	}
649	if (!arch_init) {	680	if (!arch_init) {
650	LOG(llevError,"Got object info when not in arch_init (%s)?\n", yv);	681	LOG(llevError,"Got object info when not in arch_init (%s)?\n", yv);
651	} else {	682	} else {
652	if (op->arch!=NULL) op->arch->name=add_string(yv);	683	if (op->arch!=NULL) op->arch->name=add_string(yv);
653	op->name = add_string(yv);	684	op->name = add_string(yv);
654	}	685	}
655	}	686	}
656		687
657	^name{S} { char *yv=yval();	688	^name{S} { char *yv=yval();
658		689
659	if (*yv=='\0') LOG(llevError,"Name without val\n");	690	if (*yv=='\0') LOG(llevError,"Name without val\n");
660	else FREE_AND_COPY(op->name, yv);	691	else FREE_AND_COPY(op->name, yv);
661	}	692	}
662	^name_pl{S} { char *yv=yval();	693	^name_pl{S} { char *yv=yval();
663		694
664	if (*yv=='\0') LOG(llevError,"Name without val\n");	695	if (*yv=='\0') LOG(llevError,"Name without val\n");
665	else FREE_AND_COPY(op->name_pl, yv);	696	else FREE_AND_COPY(op->name_pl, yv);
666	}	697	}
		698	^attach{S} { char *yv=yval();
		699	if (*yv)
		700	op->attach = add_string (yv);
		701	}
667	^skill{S} FREE_AND_COPY(op->skill,yval());	702	^skill{S} FREE_AND_COPY(op->skill,yval());
668	^custom_name{S} { char *yv=yval();	703	^custom_name{S} { char *yv=yval();
669		704
670	if (*yv=='\0') LOG(llevError,"Custom name without val\n");	705	if (*yv=='\0') LOG(llevError,"Custom name without val\n");
671	else FREE_AND_COPY(op->custom_name, yv);	706	else FREE_AND_COPY(op->custom_name, yv);
672	}	707	}
673	^race{S} FREE_AND_COPY(op->race,yval());	708	^race{S} FREE_AND_COPY(op->race,yval());
674	^slaying{S} FREE_AND_COPY(op->slaying, yval());	709	^slaying{S} FREE_AND_COPY(op->slaying, yval());
675	^inventory.*$ LOG(llevError,"Got depreciated Inventory command?\n");	710	^inventory.*$ LOG(llevError,"Got depreciated Inventory command?\n");
676		711
677		712
678	^arch{S} { /* If op->arch has been set, then this new object	713	^arch{S} { /* If op->arch has been set, then this new object
679	* must be part of the inventory. So process	714	* must be part of the inventory. So process
680	* appropriately.	715	* appropriately.
681	*/	716	*/
682	if (op->arch) {	717	if (op->arch) {
683	object *tmp;	718	object *tmp;
684	char *yv=yval();	719	char *yv=yval();
685		720
686	tmp=get_object();	721	archetype *arch = find_archetype(yv);
687	tmp->arch = find_archetype(yv);	722	if (arch!=NULL)
688	if (tmp->arch!=NULL)	723	tmp = arch_to_object (arch);
689	copy_object(&tmp->arch->clone,tmp);	724	else {
690	else {	725	tmp = get_object ();
691	if (tmp->name) free_string(tmp->name);	726	if (tmp->name) free_string(tmp->name);
692	/* record the name of the broken object */	727	/* record the name of the broken object */
693	tmp->name = add_string(yv);	728	tmp->name = add_string(yv);
694	}	729	}
695	strcpy(msgbuf, "");	730	strcpy(msgbuf, "");
696	strcpy(lorebuf, "");	731	strcpy(lorebuf, "");
697	lex_load(tmp, map_flags);	732	lex_load(tmp, thawer, map_flags);
698	if (tmp->arch) {	733	if (tmp->arch) {
699	insert_ob_in_ob(tmp,op);	734	insert_ob_in_ob(tmp,op);
700	}	735	}
701	else {	736	else {
702	LOG(llevDebug,"Discarding object without arch: %s\n", tmp->name?tmp->name:"(null)");	737	LOG(llevDebug,"Discarding object without arch: %s\n", tmp->name?(const char *)tmp->name:"(null)");
703	free_object(tmp);	738	free_object(tmp);
704	}	739	}
705	}	740	}
706	/* This is the actual archetype definition then */	741	/* This is the actual archetype definition then */
707	else {	742	else {
708	char *yv=yval();	743	char *yv=yval();
709		744
710	op->arch=find_archetype(yv);	745	op->arch=find_archetype(yv);
711	if (op->arch!=NULL) copy_object(&op->arch->clone,op);	746	if (op->arch!=NULL) {
712	else if (!arch_init) {	747	copy_object(&op->arch->clone,op);
713	if (op->name) free_string(op->name);	748	} else if (!arch_init) {
714	/* record the name of the broken object */	749	if (op->name) free_string(op->name);
715	op->name = add_string(yv);	750	/* record the name of the broken object */
716	}	751	op->name = add_string(yv);
717	}	752	}
718	}	753	}
		754	}
719		755
720	^other_arch{S} op->other_arch=find_archetype(yval());	756	^other_arch{S} op->other_arch=find_archetype(yval());
721	^animation{S} {	757	^animation{S} {
722	if (strcmp (yval(), "NONE") == 0) {	758	if (strcmp (yval(), "NONE") == 0) {
723	op->animation_id = 0;	759	op->animation_id = 0;
724	CLEAR_FLAG (op, FLAG_ANIMATE);	760	CLEAR_FLAG (op, FLAG_ANIMATE);
725	} else {	761	} else {
726	op->animation_id = find_animation (yval());	762	op->animation_id = find_animation (yval());
727	SET_FLAG (op, FLAG_ANIMATE);	763	SET_FLAG (op, FLAG_ANIMATE);
728	}	764	}
729	}	765	}
730		766
731	^more{WS}$ { /* We need to record that this is a multipart object,	767	^more{WS}$ { /* We need to record that this is a multipart object,
732	* so the calling function can glue things back together	768	* so the calling function can glue things back together
733	*/	769	*/
734	ismore=1;	770	ismore=1;
735	}	771	}
736
737	^end{WS}$ { check_loaded_object(op);	772	^end{WS}$ { check_loaded_object(op);
738	if (ismore) return LL_MORE;	773
739	else return LL_NORMAL;	774	if (!arch_init)
740	}	775	op->instantiate ();
		776
		777	if (ismore) return LL_MORE;
		778	else return LL_NORMAL;
		779	}
		780	^oid{S} {
		781	thawer.get (op, IVAL);
		782	}
741	^last_heal{S} op->last_heal = IVAL;	783	^last_heal{S} op->last_heal = IVAL;
742	^last_sp{S} op->last_sp = IVAL;	784	^last_sp{S} op->last_sp = IVAL;
743	^last_grace{S} op->last_grace = IVAL;	785	^last_grace{S} op->last_grace = IVAL;
744	^last_eat{S} op->last_eat = IVAL;	786	^last_eat{S} op->last_eat = IVAL;
745	^speed{S} { op->speed = FVAL;	787	^speed{S} { op->speed = FVAL;
746	if (!(map_flags & MAP_STYLE)) {	788	if (!(map_flags & MAP_STYLE)) {
747	if (op->speed<0) op->speed_left = op->speed_left-RANDOM()%100/100.0;	789	if (op->speed<0) op->speed_left = op->speed_left-RANDOM()%100/100.0;
748	update_ob_speed(op);	790	update_ob_speed(op);
749	}	791	}
750	}	792	}
751	^speed_left{S} op->speed_left = FVAL;	793	^speed_left{S} op->speed_left = FVAL;
752	^slow_move{S} { op->move_slow |= MOVE_WALK;	794	^slow_move{S} { op->move_slow |= MOVE_WALK;
753	op->move_slow_penalty = FVAL;	795	op->move_slow_penalty = FVAL;
754	}	796	}
755	^title{S} { char *y=yval();	797	^title{S} { char *y=yval();
756	if (*y=='\0') LOG(llevError,"Title without value.\n");	798	if (*y=='\0') LOG(llevError,"Title without value.\n");
757	else FREE_AND_COPY(op->title, y);	799	else FREE_AND_COPY(op->title, y);
758	}	800	}
759		801
760	^face{S} op->face = &new_faces[FindFace(yval(), 0)];	802	^face{S} op->face = &new_faces[FindFace(yval(), 0)];
761	^str{S} op->stats.Str = IVAL;	803	^str{S} op->stats.Str = IVAL;
762	^dex{S} op->stats.Dex = IVAL;	804	^dex{S} op->stats.Dex = IVAL;
763	^con{S} op->stats.Con = IVAL;	805	^con{S} op->stats.Con = IVAL;
764	^wis{S} op->stats.Wis = IVAL;	806	^wis{S} op->stats.Wis = IVAL;
765	^cha{S} op->stats.Cha = IVAL;	807	^cha{S} op->stats.Cha = IVAL;
766	^int{S} op->stats.Int = IVAL;	808	^int{S} op->stats.Int = IVAL;
767	^pow{S} op->stats.Pow = IVAL;	809	^pow{S} op->stats.Pow = IVAL;
768	^hp{S} op->stats.hp = IVAL;	810	^hp{S} op->stats.hp = IVAL;
769	^maxhp{S} op->stats.maxhp = IVAL;	811	^maxhp{S} op->stats.maxhp = IVAL;
770	^sp{S} op->stats.sp = IVAL;	812	^sp{S} op->stats.sp = IVAL;
771	^maxsp{S} op->stats.maxsp = IVAL;	813	^maxsp{S} op->stats.maxsp = IVAL;
772	^grace{S} op->stats.grace = IVAL;	814	^grace{S} op->stats.grace = IVAL;
773	^maxgrace{S} op->stats.maxgrace = IVAL;	815	^maxgrace{S} op->stats.maxgrace = IVAL;
774	^exp{S} op->stats.exp = atoll(yval());	816	^exp{S} op->stats.exp = atoll(yval());
775	^perm_exp{S} op->perm_exp = atoll(yval());	817	^perm_exp{S} op->perm_exp = atoll(yval());
776	^food{S} op->stats.food = IVAL;	818	^food{S} op->stats.food = IVAL;
777	^dam{S} op->stats.dam = IVAL;	819	^dam{S} op->stats.dam = IVAL;
778	^wc{S} op->stats.wc = IVAL;	820	^wc{S} op->stats.wc = IVAL;
779	^ac{S} op->stats.ac = IVAL;	821	^ac{S} op->stats.ac = IVAL;
780	^x{S} {op->x = IVAL; op->ox= op->x; }	822	^x{S} {op->x = IVAL; op->ox= op->x; }
781	^y{S} {op->y = IVAL; op->oy= op->y; }	823	^y{S} {op->y = IVAL; op->oy= op->y; }
782	^nrof{S} op->nrof= atol(yval());	824	^nrof{S} op->nrof= atol(yval());
783	^level{S} op->level = IVAL;	825	^level{S} op->level = IVAL;
784	^direction{S} op->direction = IVAL;	826	^direction{S} op->direction = IVAL;
785	^type{S} op->type = IVAL;	827	^type{S} op->type = IVAL;
786	^subtype{S} op->subtype = IVAL;	828	^subtype{S} op->subtype = IVAL;
787	^material{S} op->material = IVAL;	829	^material{S} op->material = IVAL;
788	^materialname{S} { char *yv=yval();	830	^materialname{S} { char *yv=yval();
789	if (*yv=='\0')	831	if (*yv=='\0')
790	LOG(llevError,"Materialname without val\n");	832	LOG(llevError,"Materialname without val\n");
791	else	833	else
792	FREE_AND_COPY(op->materialname, yv);	834	FREE_AND_COPY(op->materialname, yv);
793	}	835	}
794		836
795	^value{S} op->value = IVAL;	837	^value{S} op->value = IVAL;
796	^weight{S} op->weight = atol(yval());	838	^weight{S} op->weight = atol(yval());
797	^carrying{S} op->carrying = atol(yval());	839	^carrying{S} op->carrying = atol(yval());
798	^attacktype{S} op->attacktype = IVAL;	840	^attacktype{S} op->attacktype = IVAL;
799	^path_attuned{S} op->path_attuned = IVAL;	841	^path_attuned{S} op->path_attuned = IVAL;
800	^path_repelled{S} op->path_repelled = IVAL;	842	^path_repelled{S} op->path_repelled = IVAL;
801	^path_denied{S} op->path_denied = IVAL;	843	^path_denied{S} op->path_denied = IVAL;
802	^invisible{S} op->invisible = IVAL;	844	^invisible{S} op->invisible = IVAL;
803	^magic{S} op->magic = IVAL;	845	^magic{S} op->magic = IVAL;
804	^state{S} op->state = IVAL;	846	^state{S} op->state = IVAL;
805	^alive{S} SET_OR_CLEAR_FLAG(op, FLAG_ALIVE, IVAL);	847	^alive{S} SET_OR_CLEAR_FLAG(op, FLAG_ALIVE, IVAL);
806	^applied{S} SET_OR_CLEAR_FLAG(op, FLAG_APPLIED, IVAL);	848	^applied{S} SET_OR_CLEAR_FLAG(op, FLAG_APPLIED, IVAL);
807	^unpaid{S} SET_OR_CLEAR_FLAG(op, FLAG_UNPAID, IVAL);	849	^unpaid{S} SET_OR_CLEAR_FLAG(op, FLAG_UNPAID, IVAL);
808	^need_an{S} { /* not used - just ignore */ }	850	^need_an{S} { /* not used - just ignore */ }
809	^need_ie{S} { /* not used - jsut ignore */ }	851	^need_ie{S} { /* not used - jsut ignore */ }
810	^is_animated{S} SET_OR_CLEAR_FLAG(op, FLAG_ANIMATE, IVAL);	852	^is_animated{S} SET_OR_CLEAR_FLAG(op, FLAG_ANIMATE, IVAL);
811	^no_pick{S} SET_OR_CLEAR_FLAG(op, FLAG_NO_PICK, IVAL);	853	^no_pick{S} SET_OR_CLEAR_FLAG(op, FLAG_NO_PICK, IVAL);
812		854
813	%{ /* These are all legacy - any new objects should use the move_ .. values */	855	%{ /* These are all legacy - any new objects should use the move_ .. values */
814	%}	856	%}
815	^no_pass{S} { if (IVAL) op->move_block = MOVE_ALL; else op->move_block=0; }	857	^no_pass{S} { if (IVAL) op->move_block = MOVE_ALL; else op->move_block=0; }
816	^walk_on{S} { if (IVAL) op->move_on |= MOVE_WALK; else op->move_on &= ~MOVE_WALK; }	858	^walk_on{S} { if (IVAL) op->move_on |= MOVE_WALK; else op->move_on &= ~MOVE_WALK; }
817	^walk_off{S} { if (IVAL) op->move_off |= MOVE_WALK; else op->move_off &= ~MOVE_WALK; }	859	^walk_off{S} { if (IVAL) op->move_off |= MOVE_WALK; else op->move_off &= ~MOVE_WALK; }
818	^fly_on{S} { if (IVAL) op->move_on |= MOVE_FLY_LOW; else op->move_on &= ~MOVE_FLY_LOW; }	860	^fly_on{S} { if (IVAL) op->move_on |= MOVE_FLY_LOW; else op->move_on &= ~MOVE_FLY_LOW; }
819	^fly_off{S} { if (IVAL) op->move_off |= MOVE_FLY_LOW; else op->move_off &= ~MOVE_FLY_LOW; }	861	^fly_off{S} { if (IVAL) op->move_off |= MOVE_FLY_LOW; else op->move_off &= ~MOVE_FLY_LOW; }
820	^flying{S} { if (IVAL) op->move_type |= MOVE_FLY_LOW; else op->move_type &= ~MOVE_FLY_LOW; }	862	^flying{S} { if (IVAL) op->move_type |= MOVE_FLY_LOW; else op->move_type &= ~MOVE_FLY_LOW; }
821		863
822	%{ /* These are the new values */	864	%{ /* These are the new values */
823	%}	865	%}
824	^move_block{S} set_move(&op->move_block, yval());	866	^move_block{S} set_move(&op->move_block, yval());
825	^move_allow{S} set_move(&op->move_allow, yval());	867	^move_allow{S} set_move(&op->move_allow, yval());
826	^move_type{S} set_move(&op->move_type, yval());	868	^move_type{S} set_move(&op->move_type, yval());
827	^move_on{S} set_move(&op->move_on, yval());	869	^move_on{S} set_move(&op->move_on, yval());
828	^move_off{S} set_move(&op->move_off, yval());	870	^move_off{S} set_move(&op->move_off, yval());
829	^move_slow{S} set_move(&op->move_slow, yval());	871	^move_slow{S} set_move(&op->move_slow, yval());
830	^move_slow_penalty{S} op->move_slow_penalty = FVAL;	872	^move_slow_penalty{S} op->move_slow_penalty = FVAL;
831		873
832		874
833	^monster{S} SET_OR_CLEAR_FLAG(op, FLAG_MONSTER, IVAL);	875	^monster{S} SET_OR_CLEAR_FLAG(op, FLAG_MONSTER, IVAL);
834	^neutral{S} SET_OR_CLEAR_FLAG(op, FLAG_NEUTRAL, IVAL);	876	^neutral{S} SET_OR_CLEAR_FLAG(op, FLAG_NEUTRAL, IVAL);
835	^no_attack{S} SET_OR_CLEAR_FLAG(op, FLAG_NO_ATTACK, IVAL);	877	^no_attack{S} SET_OR_CLEAR_FLAG(op, FLAG_NO_ATTACK, IVAL);
836	^no_damage{S} SET_OR_CLEAR_FLAG(op, FLAG_NO_DAMAGE, IVAL);	878	^no_damage{S} SET_OR_CLEAR_FLAG(op, FLAG_NO_DAMAGE, IVAL);
837	^friendly{S} { if (IVAL) {	879	^friendly{S} { if (IVAL) {
838	SET_FLAG(op, FLAG_FRIENDLY);	880	SET_FLAG(op, FLAG_FRIENDLY);
839	if (op->type != PLAYER)	881	if (op->type != PLAYER)
840	add_friendly_object (op);	882	add_friendly_object (op);
841	}	883	}
842	else CLEAR_FLAG(op, FLAG_FRIENDLY);	884	else CLEAR_FLAG(op, FLAG_FRIENDLY);
843	}	885	}
844	^generator{S} SET_OR_CLEAR_FLAG(op, FLAG_GENERATOR, IVAL);	886	^generator{S} SET_OR_CLEAR_FLAG(op, FLAG_GENERATOR, IVAL);
845	^use_content_on_gen{S} SET_OR_CLEAR_FLAG (op,FLAG_CONTENT_ON_GEN, IVAL);	887	^use_content_on_gen{S} SET_OR_CLEAR_FLAG (op,FLAG_CONTENT_ON_GEN, IVAL);
846	^is_thrown{S} SET_OR_CLEAR_FLAG(op, FLAG_IS_THROWN, IVAL);	888	^is_thrown{S} SET_OR_CLEAR_FLAG(op, FLAG_IS_THROWN, IVAL);
847	^auto_apply{S} SET_OR_CLEAR_FLAG(op, FLAG_AUTO_APPLY, IVAL);	889	^auto_apply{S} SET_OR_CLEAR_FLAG(op, FLAG_AUTO_APPLY, IVAL);
848	^treasure{S} SET_OR_CLEAR_FLAG(op, FLAG_TREASURE, IVAL);	890	^treasure{S} SET_OR_CLEAR_FLAG(op, FLAG_TREASURE, IVAL);
849	^see_invisible{S} SET_OR_CLEAR_FLAG(op, FLAG_SEE_INVISIBLE, IVAL);	891	^see_invisible{S} SET_OR_CLEAR_FLAG(op, FLAG_SEE_INVISIBLE, IVAL);
850	^can_roll{S} SET_OR_CLEAR_FLAG(op, FLAG_CAN_ROLL, IVAL);	892	^can_roll{S} SET_OR_CLEAR_FLAG(op, FLAG_CAN_ROLL, IVAL);
851	^overlay_floor{S} SET_OR_CLEAR_FLAG(op, FLAG_OVERLAY_FLOOR, IVAL);	893	^overlay_floor{S} SET_OR_CLEAR_FLAG(op, FLAG_OVERLAY_FLOOR, IVAL);
852	^is_turnable{S} SET_OR_CLEAR_FLAG(op, FLAG_IS_TURNABLE, IVAL);	894	^is_turnable{S} SET_OR_CLEAR_FLAG(op, FLAG_IS_TURNABLE, IVAL);
853	^is_used_up{S} SET_OR_CLEAR_FLAG(op, FLAG_IS_USED_UP, IVAL);	895	^is_used_up{S} SET_OR_CLEAR_FLAG(op, FLAG_IS_USED_UP, IVAL);
854	^identified{S} { if (IVAL) {	896	^identified{S} { if (IVAL) {
855	SET_FLAG(op, FLAG_IDENTIFIED);	897	SET_FLAG(op, FLAG_IDENTIFIED);
856	CLEAR_FLAG(op, FLAG_KNOWN_MAGICAL);	898	CLEAR_FLAG(op, FLAG_KNOWN_MAGICAL);
857	}	899	}
858	else CLEAR_FLAG(op, FLAG_IDENTIFIED);	900	else CLEAR_FLAG(op, FLAG_IDENTIFIED);
859	}	901	}
860	^reflecting{S} SET_OR_CLEAR_FLAG(op, FLAG_REFLECTING, IVAL);	902	^reflecting{S} SET_OR_CLEAR_FLAG(op, FLAG_REFLECTING, IVAL);
861	^changing{S} SET_OR_CLEAR_FLAG(op, FLAG_CHANGING, IVAL);	903	^changing{S} SET_OR_CLEAR_FLAG(op, FLAG_CHANGING, IVAL);
862	^splitting{S} SET_OR_CLEAR_FLAG(op, FLAG_SPLITTING, IVAL);	904	^splitting{S} SET_OR_CLEAR_FLAG(op, FLAG_SPLITTING, IVAL);
863	^hitback{S} SET_OR_CLEAR_FLAG(op, FLAG_HITBACK, IVAL);	905	^hitback{S} SET_OR_CLEAR_FLAG(op, FLAG_HITBACK, IVAL);
864	^startequip{S} SET_OR_CLEAR_FLAG(op, FLAG_STARTEQUIP, IVAL);	906	^startequip{S} SET_OR_CLEAR_FLAG(op, FLAG_STARTEQUIP, IVAL);
865	^blocksview{S} SET_OR_CLEAR_FLAG(op, FLAG_BLOCKSVIEW, IVAL);	907	^blocksview{S} SET_OR_CLEAR_FLAG(op, FLAG_BLOCKSVIEW, IVAL);
866	^editable{S} op->arch->editable = IVAL;	908	^editable{S} op->arch->editable = IVAL;
867	^editor_folder{S} { }	909	^editor_folder{S} { }
868	^undead{S} SET_OR_CLEAR_FLAG(op, FLAG_UNDEAD, IVAL);	910	^undead{S} SET_OR_CLEAR_FLAG(op, FLAG_UNDEAD, IVAL);
869	^scared{S} SET_OR_CLEAR_FLAG(op, FLAG_SCARED, IVAL);	911	^scared{S} SET_OR_CLEAR_FLAG(op, FLAG_SCARED, IVAL);
870	^unaggressive{S} SET_OR_CLEAR_FLAG(op, FLAG_UNAGGRESSIVE, IVAL);	912	^unaggressive{S} SET_OR_CLEAR_FLAG(op, FLAG_UNAGGRESSIVE, IVAL);
871	^reflect_missile{S} SET_OR_CLEAR_FLAG(op, FLAG_REFL_MISSILE, IVAL);	913	^reflect_missile{S} SET_OR_CLEAR_FLAG(op, FLAG_REFL_MISSILE, IVAL);
872	^reflect_spell{S} SET_OR_CLEAR_FLAG(op, FLAG_REFL_SPELL, IVAL);	914	^reflect_spell{S} SET_OR_CLEAR_FLAG(op, FLAG_REFL_SPELL, IVAL);
873	^no_magic{S} SET_OR_CLEAR_FLAG(op, FLAG_NO_MAGIC, IVAL);	915	^no_magic{S} SET_OR_CLEAR_FLAG(op, FLAG_NO_MAGIC, IVAL);
874	^wiz{S} { if (IVAL) {	916	^wiz{S} { if (IVAL) {
875	SET_FLAG(op, FLAG_WIZ);	917	SET_FLAG(op, FLAG_WIZ);
876	SET_FLAG(op, FLAG_WAS_WIZ);	918	SET_FLAG(op, FLAG_WAS_WIZ);
877	SET_FLAG(op, FLAG_WIZPASS);	919	SET_FLAG(op, FLAG_WIZPASS);
878	SET_FLAG(op, FLAG_WIZCAST);	920	SET_FLAG(op, FLAG_WIZCAST);
879	}	921	}
880	else {	922	else {
881	CLEAR_FLAG(op, FLAG_WIZ);	923	CLEAR_FLAG(op, FLAG_WIZ);
882	CLEAR_FLAG(op, FLAG_WIZPASS);	924	CLEAR_FLAG(op, FLAG_WIZPASS);
883	CLEAR_FLAG(op, FLAG_WIZCAST);	925	CLEAR_FLAG(op, FLAG_WIZCAST);
884	}	926	}
885	}	927	}
886	^was_wiz{S} SET_OR_CLEAR_FLAG(op, FLAG_WAS_WIZ, IVAL);	928	^was_wiz{S} SET_OR_CLEAR_FLAG(op, FLAG_WAS_WIZ, IVAL);
887	^no_fix_player{S} SET_OR_CLEAR_FLAG(op, FLAG_NO_FIX_PLAYER, IVAL);	929	^no_fix_player{S} SET_OR_CLEAR_FLAG(op, FLAG_NO_FIX_PLAYER, IVAL);
888	^is_lightable{S} SET_OR_CLEAR_FLAG(op, FLAG_IS_LIGHTABLE, IVAL);	930	^is_lightable{S} SET_OR_CLEAR_FLAG(op, FLAG_IS_LIGHTABLE, IVAL);
889	^tear_down{S} SET_OR_CLEAR_FLAG(op, FLAG_TEAR_DOWN, IVAL);	931	^tear_down{S} SET_OR_CLEAR_FLAG(op, FLAG_TEAR_DOWN, IVAL);
890	^luck{S} op->stats.luck = IVAL;	932	^luck{S} op->stats.luck = IVAL;
891	^run_away{S} op->run_away = IVAL;	933	^run_away{S} op->run_away = IVAL;
892	^pick_up{S} op->pick_up = IVAL;	934	^pick_up{S} op->pick_up = IVAL;
893	^item_power{S} op->item_power = IVAL;	935	^item_power{S} op->item_power = IVAL;
894	^gen_sp_armour{S} op->gen_sp_armour = IVAL;	936	^gen_sp_armour{S} op->gen_sp_armour = IVAL;
895	^anim_speed{S} op->anim_speed = IVAL;	937	^anim_speed{S} op->anim_speed = IVAL;
896	^container{S} op->weight_limit = IVAL;	938	^container{S} op->weight_limit = IVAL;
897	^no_drop{S} SET_OR_CLEAR_FLAG(op, FLAG_NO_DROP, IVAL);	939	^no_drop{S} SET_OR_CLEAR_FLAG(op, FLAG_NO_DROP, IVAL);
898	^will_apply{S} op->will_apply = IVAL;	940	^will_apply{S} op->will_apply = IVAL;
899	^random_movement{S} SET_OR_CLEAR_FLAG(op, FLAG_RANDOM_MOVE, IVAL);	941	^random_movement{S} SET_OR_CLEAR_FLAG(op, FLAG_RANDOM_MOVE, IVAL);
900	^can_apply{S} { }	942	^can_apply{S} { }
901	^can_use_shield{S} SET_OR_CLEAR_FLAG(op, FLAG_USE_SHIELD, IVAL);	943	^can_use_shield{S} SET_OR_CLEAR_FLAG(op, FLAG_USE_SHIELD, IVAL);
902	^can_cast_spell{S} SET_OR_CLEAR_FLAG(op, FLAG_CAST_SPELL, IVAL);	944	^can_cast_spell{S} SET_OR_CLEAR_FLAG(op, FLAG_CAST_SPELL, IVAL);
903	^can_use_scroll{S} SET_OR_CLEAR_FLAG(op, FLAG_USE_SCROLL, IVAL);	945	^can_use_scroll{S} SET_OR_CLEAR_FLAG(op, FLAG_USE_SCROLL, IVAL);
904	^can_use_range{S} SET_OR_CLEAR_FLAG(op, FLAG_USE_RANGE, IVAL);	946	^can_use_range{S} SET_OR_CLEAR_FLAG(op, FLAG_USE_RANGE, IVAL);
905	^can_use_bow{S} SET_OR_CLEAR_FLAG(op, FLAG_USE_BOW, IVAL);	947	^can_use_bow{S} SET_OR_CLEAR_FLAG(op, FLAG_USE_BOW, IVAL);
906	^can_use_armour{S} SET_OR_CLEAR_FLAG(op, FLAG_USE_ARMOUR, IVAL);	948	^can_use_armour{S} SET_OR_CLEAR_FLAG(op, FLAG_USE_ARMOUR, IVAL);
907	^can_use_weapon{S} SET_OR_CLEAR_FLAG(op, FLAG_USE_WEAPON, IVAL);	949	^can_use_weapon{S} SET_OR_CLEAR_FLAG(op, FLAG_USE_WEAPON, IVAL);
908	^can_use_ring{S} SET_OR_CLEAR_FLAG(op, FLAG_USE_RING, IVAL);	950	^can_use_ring{S} SET_OR_CLEAR_FLAG(op, FLAG_USE_RING, IVAL);
909	^has_ready_bow{S} SET_OR_CLEAR_FLAG(op, FLAG_READY_BOW, IVAL);	951	^has_ready_bow{S} SET_OR_CLEAR_FLAG(op, FLAG_READY_BOW, IVAL);
910	^xrays{S} SET_OR_CLEAR_FLAG(op, FLAG_XRAYS, IVAL);	952	^xrays{S} SET_OR_CLEAR_FLAG(op, FLAG_XRAYS, IVAL);
911	^is_floor{S} SET_OR_CLEAR_FLAG(op, FLAG_IS_FLOOR, IVAL);	953	^is_floor{S} SET_OR_CLEAR_FLAG(op, FLAG_IS_FLOOR, IVAL);
912	^lifesave{S} SET_OR_CLEAR_FLAG(op, FLAG_LIFESAVE, IVAL);	954	^lifesave{S} SET_OR_CLEAR_FLAG(op, FLAG_LIFESAVE, IVAL);
913	^no_strength{S} SET_OR_CLEAR_FLAG(op, FLAG_NO_STRENGTH, IVAL);	955	^no_strength{S} SET_OR_CLEAR_FLAG(op, FLAG_NO_STRENGTH, IVAL);
914	^sleep{S} {	956	^sleep{S} {
915	SET_OR_CLEAR_FLAG(op, FLAG_SLEEP, IVAL);	957	SET_OR_CLEAR_FLAG(op, FLAG_SLEEP, IVAL);
916	/*(LOG(llevDebug," Warning: Object %s has sleep set in arch.\n",op->name);*/	958	/*(LOG(llevDebug," Warning: Object %s has sleep set in arch.\n",op->name);*/
917	}	959	}
918	^stand_still{S} SET_OR_CLEAR_FLAG(op, FLAG_STAND_STILL, IVAL);	960	^stand_still{S} SET_OR_CLEAR_FLAG(op, FLAG_STAND_STILL, IVAL);
919	^random_move{S} SET_OR_CLEAR_FLAG(op, FLAG_RANDOM_MOVE, IVAL);	961	^random_move{S} SET_OR_CLEAR_FLAG(op, FLAG_RANDOM_MOVE, IVAL);
920	^only_attack{S} SET_OR_CLEAR_FLAG(op, FLAG_ONLY_ATTACK, IVAL);	962	^only_attack{S} SET_OR_CLEAR_FLAG(op, FLAG_ONLY_ATTACK, IVAL);
921		963
922	^activate_on_push{S} SET_OR_CLEAR_FLAG(op, FLAG_ACTIVATE_ON_PUSH, IVAL);	964	^activate_on_push{S} SET_OR_CLEAR_FLAG(op, FLAG_ACTIVATE_ON_PUSH, IVAL);
923	^activate_on_release{S} SET_OR_CLEAR_FLAG(op, FLAG_ACTIVATE_ON_RELEASE, IVAL);	965	^activate_on_release{S} SET_OR_CLEAR_FLAG(op, FLAG_ACTIVATE_ON_RELEASE, IVAL);
924		966
925	/* armour is loaded for compatiblity reasons */	967	/* armour is loaded for compatiblity reasons */
926	^armour{S} SET_RESIST(op, ATNR_PHYSICAL, IVAL);	968	^armour{S} SET_RESIST(op, ATNR_PHYSICAL, IVAL);
927	/* Start of various attacktypes */	969	/* Start of various attacktypes */
928	^resist_physical{S} SET_RESIST(op, ATNR_PHYSICAL, IVAL);	970	^resist_physical{S} SET_RESIST(op, ATNR_PHYSICAL, IVAL);
929	^resist_magic{S} SET_RESIST(op, ATNR_MAGIC, IVAL);	971	^resist_magic{S} SET_RESIST(op, ATNR_MAGIC, IVAL);
930	^resist_fire{S} SET_RESIST(op, ATNR_FIRE, IVAL);	972	^resist_fire{S} SET_RESIST(op, ATNR_FIRE, IVAL);
931	^resist_electricity{S} SET_RESIST(op, ATNR_ELECTRICITY, IVAL);	973	^resist_electricity{S} SET_RESIST(op, ATNR_ELECTRICITY, IVAL);
932	^resist_cold{S} SET_RESIST(op, ATNR_COLD, IVAL);	974	^resist_cold{S} SET_RESIST(op, ATNR_COLD, IVAL);
933	^resist_confusion{S} SET_RESIST(op, ATNR_CONFUSION, IVAL);	975	^resist_confusion{S} SET_RESIST(op, ATNR_CONFUSION, IVAL);
934	^resist_acid{S} SET_RESIST(op, ATNR_ACID, IVAL);	976	^resist_acid{S} SET_RESIST(op, ATNR_ACID, IVAL);
935	^resist_drain{S} SET_RESIST(op, ATNR_DRAIN, IVAL);	977	^resist_drain{S} SET_RESIST(op, ATNR_DRAIN, IVAL);
936	^resist_weaponmagic{S} SET_RESIST(op, ATNR_WEAPONMAGIC, IVAL);	978	^resist_weaponmagic{S} SET_RESIST(op, ATNR_WEAPONMAGIC, IVAL);
937	^resist_ghosthit{S} SET_RESIST(op, ATNR_GHOSTHIT, IVAL);	979	^resist_ghosthit{S} SET_RESIST(op, ATNR_GHOSTHIT, IVAL);
938	^resist_poison{S} SET_RESIST(op, ATNR_POISON, IVAL);	980	^resist_poison{S} SET_RESIST(op, ATNR_POISON, IVAL);
939	^resist_slow{S} SET_RESIST(op, ATNR_SLOW, IVAL);	981	^resist_slow{S} SET_RESIST(op, ATNR_SLOW, IVAL);
940	^resist_paralyze{S} SET_RESIST(op, ATNR_PARALYZE, IVAL);	982	^resist_paralyze{S} SET_RESIST(op, ATNR_PARALYZE, IVAL);
941	^resist_turn_undead{S} SET_RESIST(op, ATNR_TURN_UNDEAD, IVAL);	983	^resist_turn_undead{S} SET_RESIST(op, ATNR_TURN_UNDEAD, IVAL);
942	^resist_fear{S} SET_RESIST(op, ATNR_FEAR, IVAL);	984	^resist_fear{S} SET_RESIST(op, ATNR_FEAR, IVAL);
943	^resist_cancellation{S} SET_RESIST(op, ATNR_CANCELLATION, IVAL);	985	^resist_cancellation{S} SET_RESIST(op, ATNR_CANCELLATION, IVAL);
944	^resist_deplete{S} SET_RESIST(op, ATNR_DEPLETE, IVAL);	986	^resist_deplete{S} SET_RESIST(op, ATNR_DEPLETE, IVAL);
945	^resist_death{S} SET_RESIST(op, ATNR_DEATH, IVAL);	987	^resist_death{S} SET_RESIST(op, ATNR_DEATH, IVAL);
946	^resist_chaos{S} SET_RESIST(op, ATNR_CHAOS, IVAL);	988	^resist_chaos{S} SET_RESIST(op, ATNR_CHAOS, IVAL);
947	^resist_counterspell{S} SET_RESIST(op, ATNR_COUNTERSPELL, IVAL);	989	^resist_counterspell{S} SET_RESIST(op, ATNR_COUNTERSPELL, IVAL);
948	^resist_godpower{S} SET_RESIST(op, ATNR_GODPOWER, IVAL);	990	^resist_godpower{S} SET_RESIST(op, ATNR_GODPOWER, IVAL);
949	^resist_holyword{S} SET_RESIST(op, ATNR_HOLYWORD, IVAL);	991	^resist_holyword{S} SET_RESIST(op, ATNR_HOLYWORD, IVAL);
950	^resist_blind{S} SET_RESIST(op, ATNR_BLIND, IVAL);	992	^resist_blind{S} SET_RESIST(op, ATNR_BLIND, IVAL);
951	^resist_internal{S} SET_RESIST(op, ATNR_INTERNAL, IVAL);	993	^resist_internal{S} SET_RESIST(op, ATNR_INTERNAL, IVAL);
952	^resist_life_stealing{S} SET_RESIST(op, ATNR_LIFE_STEALING, IVAL);	994	^resist_life_stealing{S} SET_RESIST(op, ATNR_LIFE_STEALING, IVAL);
953	^resist_disease{S} SET_RESIST(op, ATNR_DISEASE, IVAL);	995	^resist_disease{S} SET_RESIST(op, ATNR_DISEASE, IVAL);
954		996
955	/* Old style resistances */	997	/* Old style resistances */
956	^immune{S} set_protection(op, IVAL, RESIST_IMMUNE);	998	^immune{S} set_protection(op, IVAL, RESIST_IMMUNE);
957	^protected{S} set_protection(op, IVAL, RESIST_PROT);	999	^protected{S} set_protection(op, IVAL, RESIST_PROT);
958	^vulnerable{S} set_protection(op, IVAL, RESIST_VULN);	1000	^vulnerable{S} set_protection(op, IVAL, (uint16) RESIST_VULN);
959		1001
960	/* old values - keep them around for now, but they should be removed at some point */	1002	/* old values - keep them around for now, but they should be removed at some point */
961	^has_ready_rod{S} SET_OR_CLEAR_FLAG(op, FLAG_READY_RANGE, IVAL);	1003	^has_ready_rod{S} SET_OR_CLEAR_FLAG(op, FLAG_READY_RANGE, IVAL);
962	^has_ready_horn{S} SET_OR_CLEAR_FLAG(op, FLAG_READY_RANGE, IVAL);	1004	^has_ready_horn{S} SET_OR_CLEAR_FLAG(op, FLAG_READY_RANGE, IVAL);
963	^has_ready_wand{S} SET_OR_CLEAR_FLAG(op, FLAG_READY_RANGE, IVAL);	1005	^has_ready_wand{S} SET_OR_CLEAR_FLAG(op, FLAG_READY_RANGE, IVAL);
964	^can_use_wand{S} SET_OR_CLEAR_FLAG(op, FLAG_USE_RANGE, IVAL);	1006	^can_use_wand{S} SET_OR_CLEAR_FLAG(op, FLAG_USE_RANGE, IVAL);
965		1007
966	^attack_movement{S} op->attack_movement = IVAL;	1008	^attack_movement{S} op->attack_movement = IVAL;
967	^move_state{S} op->move_status = IVAL;	1009	^move_state{S} op->move_status = IVAL;
968	^confused{S} SET_OR_CLEAR_FLAG(op, FLAG_CONFUSED, IVAL);	1010	^confused{S} SET_OR_CLEAR_FLAG(op, FLAG_CONFUSED, IVAL);
969	^stealth{S} SET_OR_CLEAR_FLAG(op, FLAG_STEALTH, IVAL);	1011	^stealth{S} SET_OR_CLEAR_FLAG(op, FLAG_STEALTH, IVAL);
970	^connected{S} add_button_link(op, op->map, IVAL);	1012	^connected{S} add_button_link(op, op->map, IVAL);
971	^cursed{S} SET_OR_CLEAR_FLAG(op, FLAG_CURSED, IVAL);	1013	^cursed{S} SET_OR_CLEAR_FLAG(op, FLAG_CURSED, IVAL);
972	^damned{S} SET_OR_CLEAR_FLAG(op, FLAG_DAMNED, IVAL);	1014	^damned{S} SET_OR_CLEAR_FLAG(op, FLAG_DAMNED, IVAL);
973	^see_anywhere{S} SET_OR_CLEAR_FLAG(op, FLAG_SEE_ANYWHERE, IVAL);	1015	^see_anywhere{S} SET_OR_CLEAR_FLAG(op, FLAG_SEE_ANYWHERE, IVAL);
974	^known_magical{S} SET_OR_CLEAR_FLAG(op, FLAG_KNOWN_MAGICAL, IVAL);	1016	^known_magical{S} SET_OR_CLEAR_FLAG(op, FLAG_KNOWN_MAGICAL, IVAL);
975	^known_cursed{S} SET_OR_CLEAR_FLAG(op, FLAG_KNOWN_CURSED, IVAL);	1017	^known_cursed{S} SET_OR_CLEAR_FLAG(op, FLAG_KNOWN_CURSED, IVAL);
976	^can_use_skill{S} SET_OR_CLEAR_FLAG(op, FLAG_CAN_USE_SKILL, IVAL);	1018	^can_use_skill{S} SET_OR_CLEAR_FLAG(op, FLAG_CAN_USE_SKILL, IVAL);
977	^been_applied{S} SET_OR_CLEAR_FLAG(op, FLAG_BEEN_APPLIED, IVAL);	1019	^been_applied{S} SET_OR_CLEAR_FLAG(op, FLAG_BEEN_APPLIED, IVAL);
978	^has_ready_scroll{S} SET_OR_CLEAR_FLAG(op, FLAG_READY_SCROLL, IVAL);	1020	^has_ready_scroll{S} SET_OR_CLEAR_FLAG(op, FLAG_READY_SCROLL, IVAL);
979	^can_use_rod{S} SET_OR_CLEAR_FLAG(op, FLAG_USE_ROD, IVAL);	1021	^can_use_rod{S} SET_OR_CLEAR_FLAG(op, FLAG_USE_ROD, IVAL);
980	^can_use_horn{S} SET_OR_CLEAR_FLAG(op, FLAG_USE_HORN, IVAL);	1022	^can_use_horn{S} SET_OR_CLEAR_FLAG(op, FLAG_USE_HORN, IVAL);
981	^expmul{S} op->expmul = FVAL;	1023	^expmul{S} op->expmul = FVAL;
982	^unique{S} SET_OR_CLEAR_FLAG(op, FLAG_UNIQUE, IVAL);	1024	^unique{S} SET_OR_CLEAR_FLAG(op, FLAG_UNIQUE, IVAL);
983	^make_invisible{S} SET_OR_CLEAR_FLAG(op, FLAG_MAKE_INVIS, IVAL);	1025	^make_invisible{S} SET_OR_CLEAR_FLAG(op, FLAG_MAKE_INVIS, IVAL);
984	^inv_locked{S} SET_OR_CLEAR_FLAG(op, FLAG_INV_LOCKED, IVAL);	1026	^inv_locked{S} SET_OR_CLEAR_FLAG(op, FLAG_INV_LOCKED, IVAL);
985	^is_wooded{S} SET_OR_CLEAR_FLAG(op, FLAG_IS_WOODED, IVAL);	1027	^is_wooded{S} SET_OR_CLEAR_FLAG(op, FLAG_IS_WOODED, IVAL);
986	^is_hilly{S} SET_OR_CLEAR_FLAG(op, FLAG_IS_HILLY, IVAL);	1028	^is_hilly{S} SET_OR_CLEAR_FLAG(op, FLAG_IS_HILLY, IVAL);
987	^is_water{S} SET_OR_CLEAR_FLAG(op, FLAG_IS_WATER, IVAL);	1029	^is_water{S} SET_OR_CLEAR_FLAG(op, FLAG_IS_WATER, IVAL);
988	^has_ready_skill{S} SET_OR_CLEAR_FLAG(op, FLAG_READY_SKILL, IVAL);	1030	^has_ready_skill{S} SET_OR_CLEAR_FLAG(op, FLAG_READY_SKILL, IVAL);
989	^has_ready_weapon{S} SET_OR_CLEAR_FLAG(op, FLAG_READY_WEAPON, IVAL);	1031	^has_ready_weapon{S} SET_OR_CLEAR_FLAG(op, FLAG_READY_WEAPON, IVAL);
990	^no_skill_ident{S} SET_OR_CLEAR_FLAG(op, FLAG_NO_SKILL_IDENT, IVAL);	1032	^no_skill_ident{S} SET_OR_CLEAR_FLAG(op, FLAG_NO_SKILL_IDENT, IVAL);
991	^glow_radius{S} op->glow_radius = IVAL;	1033	^glow_radius{S} op->glow_radius = IVAL;
992	^is_blind{S} SET_OR_CLEAR_FLAG(op, FLAG_BLIND, IVAL);	1034	^is_blind{S} SET_OR_CLEAR_FLAG(op, FLAG_BLIND, IVAL);
993	^can_see_in_dark{S} SET_OR_CLEAR_FLAG(op, FLAG_SEE_IN_DARK, IVAL);	1035	^can_see_in_dark{S} SET_OR_CLEAR_FLAG(op, FLAG_SEE_IN_DARK, IVAL);
994	^is_cauldron{S} SET_OR_CLEAR_FLAG(op, FLAG_IS_CAULDRON, IVAL);	1036	^is_cauldron{S} SET_OR_CLEAR_FLAG(op, FLAG_IS_CAULDRON, IVAL);
995	^randomitems{S} op->randomitems = find_treasurelist(yval());	1037	^randomitems{S} op->randomitems = find_treasurelist(yval());
996	^no_steal{S} SET_OR_CLEAR_FLAG(op, FLAG_NO_STEAL, IVAL);	1038	^no_steal{S} SET_OR_CLEAR_FLAG(op, FLAG_NO_STEAL, IVAL);
997	^one_hit{S} SET_OR_CLEAR_FLAG(op, FLAG_ONE_HIT, IVAL);	1039	^one_hit{S} SET_OR_CLEAR_FLAG(op, FLAG_ONE_HIT, IVAL);
998	^berserk{S} SET_OR_CLEAR_FLAG(op, FLAG_BERSERK, IVAL);	1040	^berserk{S} SET_OR_CLEAR_FLAG(op, FLAG_BERSERK, IVAL);
999		1041
1000	^can_knockback{S} { /* Some archetypes have these values in them */ }	1042	^can_knockback{S} { /* Some archetypes have these values in them */ }
1001	^can_parry{S} { /* Probably the pupland archetypes - I imagined */ }	1043	^can_parry{S} { /* Probably the pupland archetypes - I imagined */ }
1002	^can_impale{S} { /* That these are for the new combat code */ }	1044	^can_impale{S} { /* That these are for the new combat code */ }
1003	^can_cut{S} { /* just ignore for now */ }	1045	^can_cut{S} { /* just ignore for now */ }
1004	^can_dam_armour{S} { }	1046	^can_dam_armour{S} { }
1005	^weapontype{S} op->weapontype = IVAL;	1047	^weapontype{S} op->weapontype = IVAL;
1006	^tooltype{S} op->tooltype = IVAL;	1048	^tooltype{S} op->tooltype = IVAL;
1007	^casting_time{S} op->casting_time = FVAL;	1049	^casting_time{S} op->casting_time = (sint16) FVAL;
1008	^elevation{S} op->elevation = IVAL;	1050	^elevation{S} op->elevation = IVAL;
1009	^smoothlevel{S} op->smoothlevel = IVAL;	1051	^smoothlevel{S} op->smoothlevel = IVAL;
1010	^client_type{S} op->client_type = IVAL;	1052	^client_type{S} op->client_type = IVAL;
1011	^body_{A} set_body_info(op, yytext);	1053	^body_{A} set_body_info(op, yytext);
1012	^duration{S} op->duration = IVAL;	1054	^duration{S} op->duration = IVAL;
1013	^range{S} op->range = IVAL;	1055	^range{S} op->range = IVAL;
1014	^range_modifier{S} op->range_modifier = IVAL;	1056	^range_modifier{S} op->range_modifier = IVAL;
1015	^dam_modifier{S} op->dam_modifier = IVAL;	1057	^dam_modifier{S} op->dam_modifier = IVAL;
1016	^duration_modifier{S} op->duration_modifier = IVAL;	1058	^duration_modifier{S} op->duration_modifier = IVAL;
1017	^is_buildable{S} SET_OR_CLEAR_FLAG( op, FLAG_IS_BUILDABLE, IVAL );	1059	^is_buildable{S} SET_OR_CLEAR_FLAG( op, FLAG_IS_BUILDABLE, IVAL );
1018		1060
1019	^event_apply{S} {	1061	^event_ {
1020	char *yv=yval();	1062	LOG (llevError, "stray event_* in map file, skipping.");
1021	if (*yv=='\0')
1022	LOG(llevError,"Event (apply) without val\n");
1023	else
1024	insert_event(op,EVENT_APPLY,yv,NULL,NULL);
1025	}	1063	}
1026		1064
1027	^event_apply_plugin{S} {
1028	char *yv=yval();
1029	if (*yv=='\0')
1030	LOG(llevError,"Event (apply) without plugin\n");
1031	else
1032	insert_event(op,EVENT_APPLY,NULL,yv,NULL);
1033	}
1034
1035	^event_apply_options{S} {
1036	char *yv=yval();
1037	if (*yv=='\0')
1038	LOG(llevError,"Event (apply) without options\n");
1039	else
1040	insert_event(op,EVENT_APPLY,NULL,NULL,yv);
1041	}
1042
1043	^event_attack{S} {
1044	char *yv=yval();
1045	if (*yv=='\0')
1046	LOG(llevError,"Event (attack) without val\n");
1047	else
1048	insert_event(op,EVENT_ATTACK,yv,NULL,NULL);
1049	}
1050
1051	^event_attack_plugin{S} {
1052	char *yv=yval();
1053	if (*yv=='\0')
1054	LOG(llevError,"Event (attack) without plugin\n");
1055	else
1056	insert_event(op,EVENT_ATTACK,NULL,yv,NULL);
1057	}
1058
1059	^event_attack_options{S} {
1060	char *yv=yval();
1061	if (*yv=='\0')
1062	LOG(llevError,"Event (attack) without options\n");
1063	else
1064	insert_event(op,EVENT_ATTACK,NULL,NULL,yv);
1065	}
1066	^event_death{S} {
1067	char *yv=yval();
1068	if (*yv=='\0')
1069	LOG(llevError,"Event (death) without val\n");
1070	else
1071	insert_event(op,EVENT_DEATH,yv,NULL,NULL);
1072	}
1073
1074	^event_death_plugin{S} {
1075	char *yv=yval();
1076	if (*yv=='\0')
1077	LOG(llevError,"Event (death) without plugin\n");
1078	else
1079	insert_event(op,EVENT_DEATH,NULL,yv,NULL);
1080	}
1081
1082	^event_death_options{S} {
1083	char *yv=yval();
1084	if (*yv=='\0')
1085	LOG(llevError,"Event (death) without options\n");
1086	else
1087	insert_event(op,EVENT_DEATH,NULL,NULL,yv);
1088	}
1089	^event_drop{S} {
1090	char *yv=yval();
1091	if (*yv=='\0')
1092	LOG(llevError,"Event (drop) without val\n");
1093	else
1094	insert_event(op,EVENT_DROP,yv,NULL,NULL);
1095	}
1096
1097	^event_drop_plugin{S} {
1098	char *yv=yval();
1099	if (*yv=='\0')
1100	LOG(llevError,"Event (drop) without plugin\n");
1101	else
1102	insert_event(op,EVENT_DROP,NULL,yv,NULL);
1103	}
1104
1105	^event_drop_options{S} {
1106	char *yv=yval();
1107	if (*yv=='\0')
1108	LOG(llevError,"Event (drop) without options\n");
1109	else
1110	insert_event(op,EVENT_DROP,NULL,NULL,yv);
1111	}
1112	^event_pickup{S} {
1113	char *yv=yval();
1114	if (*yv=='\0')
1115	LOG(llevError,"Event (pickup) without val\n");
1116	else
1117	insert_event(op,EVENT_PICKUP,yv,NULL,NULL);
1118	}
1119
1120	^event_pickup_plugin{S} {
1121	char *yv=yval();
1122	if (*yv=='\0')
1123	LOG(llevError,"Event (pickup) without plugin\n");
1124	else
1125	insert_event(op,EVENT_PICKUP,NULL,yv,NULL);
1126	}
1127
1128	^event_pickup_options{S} {
1129	char *yv=yval();
1130	if (*yv=='\0')
1131	LOG(llevError,"Event (pickup) without options\n");
1132	else
1133	insert_event(op,EVENT_PICKUP,NULL,NULL,yv);
1134	}
1135	^event_say{S} {
1136	char *yv=yval();
1137	if (*yv=='\0')
1138	LOG(llevError,"Event (say) without val\n");
1139	else
1140	insert_event(op,EVENT_SAY,yv,NULL,NULL);
1141	}
1142
1143	^event_say_plugin{S} {
1144	char *yv=yval();
1145	if (*yv=='\0')
1146	LOG(llevError,"Event (say) without plugin\n");
1147	else
1148	insert_event(op,EVENT_SAY,NULL,yv,NULL);
1149	}
1150
1151	^event_say_options{S} {
1152	char *yv=yval();
1153	if (*yv=='\0')
1154	LOG(llevError,"Event (say) without options\n");
1155	else
1156	insert_event(op,EVENT_SAY,NULL,NULL,yv);
1157	}
1158	^event_stop{S} {
1159	char *yv=yval();
1160	if (*yv=='\0')
1161	LOG(llevError,"Event (stop) without val\n");
1162	else
1163	insert_event(op,EVENT_STOP,yv,NULL,NULL);
1164	}
1165
1166	^event_stop_plugin{S} {
1167	char *yv=yval();
1168	if (*yv=='\0')
1169	LOG(llevError,"Event (stop) without plugin\n");
1170	else
1171	insert_event(op,EVENT_STOP,NULL,yv,NULL);
1172	}
1173
1174	^event_stop_options{S} {
1175	char *yv=yval();
1176	if (*yv=='\0')
1177	LOG(llevError,"Event (stop) without options\n");
1178	else
1179	insert_event(op,EVENT_STOP,NULL,NULL,yv);
1180	}
1181	^event_time{S} {
1182	char *yv=yval();
1183	if (*yv=='\0')
1184	LOG(llevError,"Event (time) without val\n");
1185	else
1186	insert_event(op,EVENT_TIME,yv,NULL,NULL);
1187	}
1188
1189	^event_time_plugin{S} {
1190	char *yv=yval();
1191	if (*yv=='\0')
1192	LOG(llevError,"Event (time) without plugin\n");
1193	else
1194	insert_event(op,EVENT_TIME,NULL,yv,NULL);
1195	}
1196
1197	^event_time_options{S} {
1198	char *yv=yval();
1199	if (*yv=='\0')
1200	LOG(llevError,"Event (time) without options\n");
1201	else
1202	insert_event(op,EVENT_TIME,NULL,NULL,yv);
1203	}
1204	^event_throw{S} {
1205	char *yv=yval();
1206	if (*yv=='\0')
1207	LOG(llevError,"Event (throw) without val\n");
1208	else
1209	insert_event(op,EVENT_THROW,yv,NULL,NULL);
1210	}
1211
1212	^event_throw_plugin{S} {
1213	char *yv=yval();
1214	if (*yv=='\0')
1215	LOG(llevError,"Event (throw) without plugin\n");
1216	else
1217	insert_event(op,EVENT_THROW,NULL,yv,NULL);
1218	}
1219
1220	^event_throw_options{S} {
1221	char *yv=yval();
1222	if (*yv=='\0')
1223	LOG(llevError,"Event (apply) without options\n");
1224	else
1225	insert_event(op,EVENT_THROW,NULL,NULL,yv);
1226	}
1227	^event_trigger{S} {
1228	char *yv=yval();
1229	if (*yv=='\0')
1230	LOG(llevError,"Event (trigger) without val\n");
1231	else
1232	insert_event(op,EVENT_TRIGGER,yv,NULL,NULL);
1233	}
1234
1235	^event_trigger_plugin{S} {
1236	char *yv=yval();
1237	if (*yv=='\0')
1238	LOG(llevError,"Event (trigger) without plugin\n");
1239	else
1240	insert_event(op,EVENT_TRIGGER,NULL,yv,NULL);
1241	}
1242
1243	^event_trigger_options{S} {
1244	char *yv=yval();
1245	if (*yv=='\0')
1246	LOG(llevError,"Event (trigger) without options\n");
1247	else
1248	insert_event(op,EVENT_TRIGGER,NULL,NULL,yv);
1249	}
1250	^event_close{S} {
1251	char *yv=yval();
1252	if (*yv=='\0')
1253	LOG(llevError,"Event (close) without val\n");
1254	else
1255	insert_event(op,EVENT_CLOSE,yv,NULL,NULL);
1256	}
1257
1258	^event_close_plugin{S} {
1259	char *yv=yval();
1260	if (*yv=='\0')
1261	LOG(llevError,"Event (close) without plugin\n");
1262	else
1263	insert_event(op,EVENT_CLOSE,NULL,yv,NULL);
1264	}
1265
1266	^event_close_options{S} {
1267	char *yv=yval();
1268	if (*yv=='\0')
1269	LOG(llevError,"Event (close) without options\n");
1270	else
1271	insert_event(op,EVENT_CLOSE,NULL,NULL,yv);
1272	}
1273	^event_timer{S} {
1274	char *yv=yval();
1275	if (*yv=='\0')
1276	LOG(llevError,"Event (timer) without val\n");
1277	else
1278	insert_event(op,EVENT_TIMER,yv,NULL,NULL);
1279	}
1280
1281	^event_timer_plugin{S} {
1282	char *yv=yval();
1283	if (*yv=='\0')
1284	LOG(llevError,"Event (timer) without plugin\n");
1285	else
1286	insert_event(op,EVENT_TIMER,NULL,yv,NULL);
1287	}
1288
1289	^event_timer_options{S} {
1290	char *yv=yval();
1291	if (*yv=='\0')
1292	LOG(llevError,"Event (timer) without options\n");
1293	else
1294	insert_event(op,EVENT_TIMER,NULL,NULL,yv);
1295	}
1296
1297	^current_weapon_script{S} { char *yv=yval();
1298
1299	if (*yv=='\0') LOG(llevError,"Script (current weapon) without val\n");
1300	else
1301	{
1302	FREE_AND_COPY(op->current_weapon_script, yv);
1303	};
1304	}
1305
1306	<*>(^{WS}$)|\n {/* ignore empty lines, newlines we don't do above */}	1065	<*>(^{WS}$)|\n {/* ignore empty lines, newlines we don't do above */}
1307	#.*\n {}	1066	#.*\n {}
1308		1067
1309	<<EOF>> {/* If we got an error, return the error. Otherwise, return that we got EOF */	1068	<<EOF>> {/* If we got an error, return the error. Otherwise, return that we got EOF */
1310	if (lex_error!=0) return lex_error; else return LL_EOF;}	1069	if (lex_error!=0) return lex_error; else return LL_EOF;}
1311	.* { add_key_value(op); }	1070	.* { add_key_value(op); }
1312	%%	1071	%%
1313		1072
1314		1073
1315	int yyerror(char *s)	1074	int yyerror(char *s)
1316	{	1075	{
…		…
1330	static char *em="";	1089	static char *em="";
1331	char *cp,*end;	1090	char *cp,*end;
1332		1091
1333	/* First skip over start of line, like animation or name */	1092	/* First skip over start of line, like animation or name */
1334	for (cp=yytext; *cp!=' '; cp++) {	1093	for (cp=yytext; *cp!=' '; cp++) {
1335	if (*cp=='\0') {	1094	if (*cp=='\0') {
1336	return em;	1095	return em;
1337	}	1096	}
1338	}	1097	}
1339		1098
1340	/* Skip over whitespace */	1099	/* Skip over whitespace */
1341	for (; *cp==' '; cp++) {	1100	for (; *cp==' '; cp++) {
1342	if (*cp=='\0') {	1101	if (*cp=='\0') {
1343	return em;	1102	return em;
1344	}	1103	}
1345	}	1104	}
1346	/* Got last character before null and strip	1105	/* Got last character before null and strip
1347	* off tailing whitespace	1106	* off tailing whitespace
1348	*/	1107	*/
1349	for (end=cp+strlen(cp)-1; *end==' '; end--) {	1108	for (end=cp+strlen(cp)-1; *end==' '; end--) {
1350	if (end==cp) return em;	1109	if (end==cp) return em;
1351	*end='\0';	1110	*end='\0';
1352	}	1111	}
1353	return cp;	1112	return cp;
1354	}	1113	}
1355		1114
1356		1115
…		…
1360	* until the string "end" is reached, or the end of the file.	1119	* until the string "end" is reached, or the end of the file.
1361	*	1120	*
1362	* bufstat is used to determine various file attributes:	1121	* bufstat is used to determine various file attributes:
1363	* LO_REPATE (0): We are reading from the same buffer as the last call.	1122	* LO_REPATE (0): We are reading from the same buffer as the last call.
1364	* LO_LINEMODE (1): file that is being read from is multi purpose (ie, other functions	1123	* LO_LINEMODE (1): file that is being read from is multi purpose (ie, other functions
1365	* will also be reading from this (treasure file, artifacts.)	1124	* will also be reading from this (treasure file, artifacts.)
1366	* LO_NEWFILE (2): This is the first read from a particular file, so the buffers should	1125	* LO_NEWFILE (2): This is the first read from a particular file, so the buffers should
1367	* be reset.	1126	* be reset.
1368	* LO_NOREAD (3): Reset the buffers, but don't read from it. (op can be null)	1127	* LO_NOREAD (3): Reset the buffers, but don't read from it. (op can be null)
1369	*	1128	*
1370	*/	1129	*/
1371		1130
1372	int load_object(FILE *fp, object *op, int bufstate, int map_flags) {	1131	int load_object(object_thawer &fp, object *op, int bufstate, int map_flags) {
1373	int retval;	1132	int retval;
1374	char inbuf[MAX_BUF];	1133	char inbuf[MAX_BUF];
1375		1134
1376	strcpy(msgbuf, "");	1135	strcpy(msgbuf, "");
1377	strcpy(lorebuf, "");	1136	strcpy(lorebuf, "");
1378	if (bufstate==LO_NEWFILE || bufstate==LO_NOREAD) {	1137	if (bufstate==LO_NEWFILE || bufstate==LO_NOREAD) {
1379	/* LOG(llevDebug,"Switching lex buffers\n");*/	1138	/* LOG(llevDebug,"Switching lex buffers\n");*/
1380	yy_delete_buffer(YY_CURRENT_BUFFER);	1139	yy_delete_buffer(YY_CURRENT_BUFFER);
1381	yy_switch_to_buffer(yy_create_buffer(fp, YY_BUF_SIZE));	1140	yy_switch_to_buffer(yy_create_buffer(fp, YY_BUF_SIZE));
1382	if (bufstate==LO_NOREAD) return LL_NORMAL;	1141	if (bufstate==LO_NOREAD) return LL_NORMAL;
1383	}	1142	}
1384	if (bufstate==LO_LINEMODE) {	1143	if (bufstate==LO_LINEMODE) {
1385	YY_BUFFER_STATE yybufstate;	1144	YY_BUFFER_STATE yybufstate;
1386	while (fgets(inbuf, MAX_BUF-3, fp)) {	1145	while (fgets(inbuf, MAX_BUF-3, fp)) {
1387	yybufstate=yy_scan_string(inbuf);	1146	yybufstate=yy_scan_string(inbuf);
1388	retval=lex_load(op, map_flags);	1147	retval=lex_load(op, fp, map_flags);
1389	yy_delete_buffer(yybufstate);	1148	yy_delete_buffer(yybufstate);
1390	if (retval==LL_NORMAL) return retval;	1149	if (retval==LL_NORMAL) return retval;
1391	}	1150	}
1392	LOG(llevDebug,"Got eof while scanning strings\n");	1151	LOG(llevDebug,"Got eof while scanning strings\n");
1393	return LL_EOF;	1152	return LL_EOF;
1394	}	1153	}
1395		1154
1396	retval=lex_load(op, map_flags);	1155	retval=lex_load(op, fp, map_flags);
1397	if (op->current_weapon_script != NULL)
1398	{
1399	op->current_weapon = find_best_weapon_used_match(op, op->current_weapon_script);
1400	LOG(llevDebug, "CurrentWeapon Loaded !\n");
1401	};
1402		1156
1403	/* LOG(llevDebug," load completed, object=%s\n",op->name);*/	1157	/* LOG(llevDebug," load completed, object=%s\n",op->name);*/
1404	return retval;	1158	return retval;
1405	}	1159	}
1406		1160
…		…
1412	* override values and in c_wiz to mutate values.	1166	* override values and in c_wiz to mutate values.
1413	*/	1167	*/
1414	int set_variable(object *op,char *buf) {	1168	int set_variable(object *op,char *buf) {
1415	YY_BUFFER_STATE yybufstate,yycurbuf=YY_CURRENT_BUFFER;	1169	YY_BUFFER_STATE yybufstate,yycurbuf=YY_CURRENT_BUFFER;
1416	int retval;	1170	int retval;
		1171	object_thawer thawer (0);
1417		1172
1418	strcpy(msgbuf, "");	1173	strcpy(msgbuf, "");
1419	strcpy(lorebuf, "");	1174	strcpy(lorebuf, "");
1420	yy_push_state(INITIAL);	1175	yy_push_state(INITIAL);
1421	yybufstate=yy_scan_string(buf);	1176	yybufstate=yy_scan_string(buf);
1422	retval=lex_load(op,0);	1177	retval=lex_load(op,thawer,0);
1423	yy_switch_to_buffer(yycurbuf);	1178	yy_switch_to_buffer(yycurbuf);
1424	yy_delete_buffer(yybufstate);	1179	yy_delete_buffer(yybufstate);
1425	yy_pop_state();	1180	yy_pop_state();
1426	return retval;	1181	return retval;
1427	}	1182	}
…		…
1443	"is_animated", NULL /* slow_move */,	1198	"is_animated", NULL /* slow_move */,
1444	NULL /* flying */, "monster", "friendly", "generator",	1199	NULL /* flying */, "monster", "friendly", "generator",
1445	"is_thrown", "auto_apply", "treasure", "player sold", /* 20 */	1200	"is_thrown", "auto_apply", "treasure", "player sold", /* 20 */
1446	"see_invisible", "can_roll", "overlay_floor",	1201	"see_invisible", "can_roll", "overlay_floor",
1447	"is_turnable", NULL /* walk_off */, NULL /* fly_on */,	1202	"is_turnable", NULL /* walk_off */, NULL /* fly_on */,
1448	NULL /*fly_off*/, "is_used_up", "identified", "reflecting", /* 30 */	1203	NULL /*fly_off*/, "is_used_up", "identified", "reflecting", /* 30 */
1449	"changing", "splitting", "hitback", "startequip",	1204	"changing", "splitting", "hitback", "startequip",
1450	"blocksview", "undead", "scared", "unaggressive",	1205	"blocksview", "undead", "scared", "unaggressive",
1451	"reflect_missile", "reflect_spell", /* 40 */	1206	"reflect_missile", "reflect_spell", /* 40 */
1452	"no_magic", "no_fix_player", "is_lightable", "tear_down",	1207	"no_magic", "no_fix_player", "is_lightable", "tear_down",
1453	"run_away", NULL /*pass_thru */, NULL /*can_pass_thru*/,	1208	"run_away", NULL /*pass_thru */, NULL /*can_pass_thru*/,
1454	"pick_up", "unique", "no_drop", /* 50 */	1209	"pick_up", "unique", "no_drop", /* 50 */
1455	NULL /* wizcast*/, "can_cast_spell", "can_use_scroll", "can_use_range",	1210	NULL /* wizcast*/, "can_cast_spell", "can_use_scroll", "can_use_range",
1456	"can_use_bow", "can_use_armour", "can_use_weapon",	1211	"can_use_bow", "can_use_armour", "can_use_weapon",
1457	"can_use_ring", "has_ready_range", "has_ready_bow", /* 60 */	1212	"can_use_ring", "has_ready_range", "has_ready_bow", /* 60 */
1458	"xrays", NULL, "is_floor", "lifesave", "no_strength", "sleep",	1213	"xrays", NULL, "is_floor", "lifesave", "no_strength", "sleep",
1459	"stand_still", "random_move", "only_attack", "confused", /* 70 */	1214	"stand_still", "random_move", "only_attack", "confused", /* 70 */
…		…
1462	"can_use_skill", "been_applied", /* 80 */	1217	"can_use_skill", "been_applied", /* 80 */
1463	"has_ready_scroll", "can_use_rod", NULL,	1218	"has_ready_scroll", "can_use_rod", NULL,
1464	"can_use_horn", "make_invisible", "inv_locked", "is_wooded",	1219	"can_use_horn", "make_invisible", "inv_locked", "is_wooded",
1465	"is_hilly", "has_ready_skill", "has_ready_weapon", /* 90 */	1220	"is_hilly", "has_ready_skill", "has_ready_weapon", /* 90 */
1466	"no_skill_ident", "is_blind", "can_see_in_dark", "is_cauldron",	1221	"no_skill_ident", "is_blind", "can_see_in_dark", "is_cauldron",
1467	"is_dust", "no_steal", "one_hit", NULL, "berserk", "neutral", /* 100 */	1222	"is_dust", "no_steal", "one_hit", NULL, "berserk", "neutral", /* 100 */
1468	"no_attack", "no_damage", NULL, NULL, "activate_on_push",	1223	"no_attack", "no_damage", NULL, NULL, "activate_on_push",
1469	"activate_on_release", "is_water", "use_content_on_gen", NULL, "is_buildable", /* 110 */	1224	"activate_on_release", "is_water", "use_content_on_gen", NULL, "is_buildable", /* 110 */
1470	NULL	1225	NULL
1471	};	1226	};
1472		1227
…		…
1477	*/	1232	*/
1478		1233
1479	void init_vars() {	1234	void init_vars() {
1480	}	1235	}
1481		1236
1482	/*For get_ob_diff speed reason*/
1483	typedef struct {
1484	const char *name;
1485	int length;
1486	}genericname;
1487	static genericname evtnames[13]=
1488	{
1489	{"event_none ",11},
1490	{"event_apply ",12},
1491	{"event_attack ",13},
1492	{"event_death ",12},
1493	{"event_drop ",11},
1494	{"event_pickup ",13},
1495	{"event_say ",10},
1496	{"event_stop ",11},
1497	{"event_time ",11},
1498	{"event_throw ",12},
1499	{"event_trigger ",14},
1500	{"event_close ",12},
1501	{"event_timer ",12}
1502	} ;
1503
1504	static genericname plgnames[13]=
1505	{
1506	{"event_none_plugin ",18},
1507	{"event_apply_plugin ",19},
1508	{"event_attack_plugin ",20},
1509	{"event_death_plugin ",19},
1510	{"event_drop_plugin ",18},
1511	{"event_pickup_plugin ",20},
1512	{"event_say_plugin ",17},
1513	{"event_stop_plugin ",18},
1514	{"event_time_plugin ",18},
1515	{"event_throw_plugin ",19},
1516	{"event_trigger_plugin ",21},
1517	{"event_close_plugin ",19},
1518	{"event_timer_plugin ",19}
1519	};
1520
1521	static genericname plgoptions[13]=
1522	{
1523	{"event_none_options ",19},
1524	{"event_apply_options ",20},
1525	{"event_attack_options ",21},
1526	{"event_death_options ",20},
1527	{"event_drop_options ",19},
1528	{"event_pickup_options ",21},
1529	{"event_say_options ",18},
1530	{"event_stop_options ",19},
1531	{"event_time_options ",19},
1532	{"event_throw_options ",20},
1533	{"event_trigger_options ",22},
1534	{"event_close_options ",20},
1535	{"event_timer_options ",20}
1536	};
1537
1538	/* This returns a string of the integer movement type */	1237	/* This returns a string of the integer movement type */
1539	static char* get_string_move_type(MoveType mt)	1238	static char* get_string_move_type(MoveType mt)
1540	{	1239	{
1541	static char retbuf[MAX_BUF], retbuf_all[MAX_BUF];	1240	static char retbuf[MAX_BUF], retbuf_all[MAX_BUF];
1542	int i, all_count=0, count;	1241	int i, all_count=0, count;
1543		1242
1544	strcpy(retbuf,"");	1243	strcpy(retbuf,"");
1545	strcpy(retbuf_all," all");	1244	strcpy(retbuf_all," all");
1546		1245
1547	/* Quick check, and probably fairly common */	1246	/* Quick check, and probably fairly common */
1548	if (mt == MOVE_ALL) return retbuf_all+1;	1247	if (mt == MOVE_ALL) return retbuf_all+1;
1549	if (mt == 0) {	1248	if (mt == 0) {
1550	strcpy(retbuf,"0");	1249	strcpy(retbuf,"0");
1551	return retbuf;	1250	return retbuf;
1552	}	1251	}
1553		1252
1554	/* We basically slide the bits down. Why look at MOVE_ALL?	1253	/* We basically slide the bits down. Why look at MOVE_ALL?
1555	* because we may want to return a string like 'all -swim',	1254	* because we may want to return a string like 'all -swim',
1556	* and if we just looked at mt, we couldn't get that.	1255	* and if we just looked at mt, we couldn't get that.
1557	*/	1256	*/
1558	for (i=MOVE_ALL, count=0; i!=0; i >>= 1, count++) {	1257	for (i=MOVE_ALL, count=0; i!=0; i >>= 1, count++) {
1559	if (mt & (1<<count)) {	1258	if (mt & (1<<count)) {
1560	strcat(retbuf, " ");	1259	strcat(retbuf, " ");
1561	strcat(retbuf, move_name[count]);	1260	strcat(retbuf, move_name[count]);
1562	} else {	1261	} else {
1563	strcat(retbuf_all, " -");	1262	strcat(retbuf_all, " -");
1564	strcat(retbuf_all, move_name[count]);	1263	strcat(retbuf_all, move_name[count]);
1565	all_count++;	1264	all_count++;
1566	}	1265	}
1567	}	1266	}
1568	/* Basically, if there is a single negation, return it, eg	1267	/* Basically, if there is a single negation, return it, eg
1569	* 'all -swim'. But more than that, just return the	1268	* 'all -swim'. But more than that, just return the
1570	* enumerated values. It doesn't make sense to return	1269	* enumerated values. It doesn't make sense to return
1571	* 'all -walk -fly_low' - it is shorter to return 'fly_high swim'	1270	* 'all -walk -fly_low' - it is shorter to return 'fly_high swim'
…		…
1585	* we should use strlen entryname instead. Any smart compiler should	1284	* we should use strlen entryname instead. Any smart compiler should
1586	* optimize that out.	1285	* optimize that out.
1587	*/	1286	*/
1588		1287
1589		1288
1590	/*static int eol_size=strlen("\n");*/
1591	static int eol_size=sizeof("\n")-1; /*Substract 1 to suppress terminal 0*/
1592	#define ADD_STRINGLINE_ENTRY(buf__,entryname__,entryvalue__,entrysize__){\	1289	#define ADD_STRINGLINE_ENTRY(buf__,entryname__,entryvalue__,entrysize__){\
1593	FAST_STRNCAT(buf__,entryname__,entrysize__);\	1290	FAST_STRNCAT(buf__,entryname__,entrysize__);\
1594	FAST_STRCAT(buf__,entryvalue__);\	1291	FAST_STRCAT(buf__,entryvalue__);\
1595	FAST_STRNCAT(buf__,"\n",eol_size);}	1292	FAST_STRNCAT(buf__,"\n",1);}
1596	#define FAST_SAVE_LONG(buf__,entryname__,entryvalue__,entrysize__) \	1293	#define FAST_SAVE_LONG(buf__,entryname__,entryvalue__,entrysize__) \
1597	ADD_STRINGLINE_ENTRY(buf__,entryname__,ltostr10(entryvalue__),entrysize__)	1294	ADD_STRINGLINE_ENTRY(buf__,entryname__,ltostr10(entryvalue__),entrysize__)
1598	#define FAST_SAVE_DOUBLE(buf__,entryname__,entryvalue__,entrysize__) \	1295	#define FAST_SAVE_DOUBLE(buf__,entryname__,entryvalue__,entrysize__) \
1599	ADD_STRINGLINE_ENTRY(buf__,entryname__,doubletostr10(entryvalue__),entrysize__)	1296	ADD_STRINGLINE_ENTRY(buf__,entryname__,doubletostr10(entryvalue__),entrysize__)
1600		1297
1601		1298
1602		1299
1603	char *get_ob_diff(object *op,object *op2) {/* I plan to optimize this heavily */	1300	// compare *op against *tmp and output differences
1604		1301	void
1605	/* Too late, have done it already :P	1302	put (object_freezer &f, object *op, object *tmp)
1606	* Tchize	1303	{
1607	*/
1608
1609	/*
1610	* A bit of explantion on strings handling in this function:
1611	* buf is never null terminated until the end. So
1612	* works only with buf2 and fastbuf. What concern fastbuf,
1613	* use ONLY through the FAST macros. Classical C string handling
1614	* functions will fail since it is a pointer to the end of the
1615	* string.
1616	* NEVER touch buf between PREPARE_FASTCAT(buf) and
1617	* FINISH_FASTCAT(buf)
1618	*/
1619	static int already_run = 0;
1620	static int flag_lens[NUM_FLAGS];
1621	static char buf2[HUGE_BUF];
1622	static char buf[HUGE_BUF];
1623	char* fastbuf;
1624	int tmp;
1625	int i;	1304	int i;
1626	#if 0
1627	/*Memory polluting code. Should help detect problems, very slow*/
1628	for (i=0;i<HUGE_BUF;i++){
1629	buf[i]='a'+(unsigned short)(i%25);
1630	}
1631	#endif
1632	event *etmp;
1633	event *etmp2;
1634	key_value * my_field;
1635	key_value * arch_field;
1636
1637	/*first init this function if first call*/
1638	if (!already_run){
1639	for (i=0;i<NUM_FLAGS;i++)
1640	flag_lens[i]=flag_names[i]?strlen(flag_names[i]):0; /* some flags may be null? :/*/
1641	already_run=1;
1642	}
1643	buf[0]='\0';
1644	fastbuf=PREPARE_FASTCAT(buf);
1645		1305
1646	/* This saves the key/value lists. We do it first so that any	1306	/* This saves the key/value lists. We do it first so that any
1647	* keys that match field names will be overwritten by the loader.	1307	* keys that match field names will be overwritten by the loader.
1648	*/	1308	*/
1649	for (my_field = op->key_values; my_field != NULL; my_field = my_field->next) {	1309	for (key_value *my_field = op->key_values; my_field != NULL; my_field = my_field->next)
		1310	{
1650	/* Find the field in the opposing member. */	1311	/* Find the field in the opposing member. */
1651	arch_field = get_ob_key_link(op2, my_field->key);	1312	key_value *arch_field = get_ob_key_link (tmp, my_field->key);
1652		1313
1653	/* If there's no partnering field, or it's got a different value, save our field. */	1314	/* If there's no partnering field, or it's got a different value, save our field. */
1654	if (arch_field == NULL || my_field->value != arch_field->value) {	1315	if (arch_field == NULL || my_field->value != arch_field->value)
1655	FAST_STRCAT(fastbuf, my_field->key);	1316	f.put (my_field->key, my_field->value);
1656	FAST_STRNCAT(fastbuf, " ", 1);
1657	/* If this is null, then saving it as a space should
1658	* cause it to be null again.
1659	*/
1660	if (my_field->value) FAST_STRCAT(fastbuf, my_field->value);
1661	FAST_STRNCAT(fastbuf, "\n", eol_size);
1662	}	1317	}
1663	}	1318
1664	/* We don't need to worry about the arch's extra fields - they	1319	/* We don't need to worry about the arch's extra fields - they
1665	* will get taken care of the copy_object function.	1320	* will get taken care of the copy_object function.
1666	*/	1321	*/
1667		1322
		1323	# define CMP_OUT(v) if (op->v != tmp->v) f.put (KW_ ## v, op->v)
		1324	# define CMP_OUT2(k,v) if (op->v != tmp->v) f.put (KW_ ## k, op->v)
1668		1325
1669	if(op->name && op->name!=op2->name) {	1326	CMP_OUT (name);
1670	ADD_STRINGLINE_ENTRY(fastbuf,"name ",op->name,5);	1327	CMP_OUT (name_pl);
1671	}	1328	CMP_OUT (custom_name);
1672	if(op->name_pl && op->name_pl!=op2->name_pl) {	1329	CMP_OUT (title);
1673	ADD_STRINGLINE_ENTRY(fastbuf,"name_pl ",op->name_pl,8);	1330	CMP_OUT (race);
1674	}	1331	CMP_OUT (slaying);
1675	if(op->custom_name && op->custom_name!=op2->custom_name) {
1676	ADD_STRINGLINE_ENTRY(fastbuf,"custom_name ",op->custom_name,12);
1677	}
1678	if(op->title && op->title!=op2->title) {
1679	ADD_STRINGLINE_ENTRY(fastbuf,"title ",op->title,6);
1680	}
1681	if(op->race && op->race!=op2->race) {
1682	ADD_STRINGLINE_ENTRY(fastbuf,"race ",op->race,5);
1683	}
1684	if(op->slaying && op->slaying!=op2->slaying) {
1685	ADD_STRINGLINE_ENTRY(fastbuf,"slaying ",op->slaying,8);
1686	}
1687	if(op->skill && op->skill!=op2->skill) {
1688	ADD_STRINGLINE_ENTRY(fastbuf,"skill ",op->skill,6);
1689	}
1690	if(op->msg && op->msg!=op2->msg) {
1691	FAST_STRNCAT(fastbuf,"msg\n",3+eol_size);
1692	FAST_STRCAT(fastbuf,op->msg);
1693	FAST_STRNCAT(fastbuf,"endmsg\n",6+eol_size);
1694	}
1695	if(op->lore && op->lore!=op2->lore) {
1696	FAST_STRNCAT(fastbuf,"lore\n",4+eol_size);
1697	FAST_STRCAT(fastbuf,op->lore);
1698	FAST_STRNCAT(fastbuf,"endlore\n",7+eol_size);
1699		1332
1700	}	1333	if (op->msg != tmp->msg ) f.put (KW_msg , KW_endmsg , op->msg);
1701	if(op->other_arch!=op2->other_arch&&op->other_arch!=NULL &&	1334	if (op->lore != tmp->lore) f.put (KW_lore, KW_endlore, op->lore);
1702	op->other_arch->name) {
1703	ADD_STRINGLINE_ENTRY(fastbuf,"other_arch ",op->other_arch->name,11);
1704	}
1705	if(op->face!=op2->face) {
1706	ADD_STRINGLINE_ENTRY(fastbuf,"face ",op->face->name,5);
1707	}
1708		1335
1709	for(etmp=op->events;etmp!=NULL;etmp=etmp->next)	1336	CMP_OUT (other_arch);
1710	{	1337	CMP_OUT (face);
1711	/* First we find the event for the reference object */	1338
1712	etmp2=find_event(op2,etmp->type);	1339	if (op->animation_id != tmp->animation_id)
1713	if ((etmp->hook != NULL) && ((etmp2 == NULL) || (etmp2->hook == NULL) || (strcmp(etmp2->hook,etmp->hook))))	1340	if (op->animation_id)
1714	/* Either there's no matching event in the reference object,
1715	* or the hook is different */
1716	{	1341	{
1717	ADD_STRINGLINE_ENTRY(fastbuf,evtnames[etmp->type].name,etmp->hook,evtnames[etmp->type].length);	1342	f.put (KW_animation, animations[GET_ANIM_ID (op)].name);
		1343
		1344	if (!QUERY_FLAG (op, FLAG_ANIMATE))
		1345	f.put (KW_is_animated, 0);
1718	}	1346	}
1719	if ((etmp->plugin != NULL) && ((etmp2 == NULL) || (etmp2->plugin == NULL) || (strcmp(etmp2->plugin,etmp->plugin))))
1720	{
1721
1722	ADD_STRINGLINE_ENTRY(fastbuf,plgnames[etmp->type].name,etmp->plugin,plgnames[etmp->type].length);
1723	}
1724	if ((etmp->options != NULL) && ((etmp2 == NULL) || (etmp2->options == NULL) || (strcmp(etmp2->options,etmp->options))))
1725	{
1726	ADD_STRINGLINE_ENTRY(fastbuf,plgoptions[etmp->type].name,etmp->options,plgoptions[etmp->type].length);
1727	}
1728
1729	}
1730
1731	if (op->animation_id != op2->animation_id) {
1732	if (op->animation_id) {
1733	ADD_STRINGLINE_ENTRY(fastbuf,"animation ",animations[GET_ANIM_ID(op)].name,10);
1734	if ( ! QUERY_FLAG (op, FLAG_ANIMATE)) {
1735	FAST_STRNCAT(fastbuf,"is_animated 0\n",13+eol_size);
1736	}
1737	} else {	1347	else
1738	FAST_STRNCAT(fastbuf,"animation NONE\n",14+eol_size);	1348	f.put (KW_animation, "NONE");
1739	}
1740	}
1741	if(op->stats.Str!=op2->stats.Str)
1742	FAST_SAVE_LONG(fastbuf,"Str ",op->stats.Str,4);
1743	if(op->stats.Dex!=op2->stats.Dex)
1744	FAST_SAVE_LONG(fastbuf,"Dex ",op->stats.Dex,4);
1745	if(op->stats.Con!=op2->stats.Con)
1746	FAST_SAVE_LONG(fastbuf,"Con ",op->stats.Con,4);
1747	if(op->stats.Wis!=op2->stats.Wis)
1748	FAST_SAVE_LONG(fastbuf,"Wis ",op->stats.Wis,4);
1749	if(op->stats.Pow!=op2->stats.Pow)
1750	FAST_SAVE_LONG(fastbuf,"Pow ",op->stats.Pow,4);
1751	if(op->stats.Cha!=op2->stats.Cha)
1752	FAST_SAVE_LONG(fastbuf,"Cha ",op->stats.Cha,4);
1753	if(op->stats.Int!=op2->stats.Int)
1754	FAST_SAVE_LONG(fastbuf,"Int ",op->stats.Int,4);
1755	if(op->stats.hp!=op2->stats.hp)
1756	FAST_SAVE_LONG(fastbuf,"hp ",op->stats.hp,3);
1757	if(op->stats.maxhp!=op2->stats.maxhp)
1758	FAST_SAVE_LONG(fastbuf,"maxhp ",op->stats.maxhp,6);
1759	if(op->stats.sp!=op2->stats.sp)
1760	FAST_SAVE_LONG(fastbuf,"sp ",op->stats.sp,3);
1761	if(op->stats.maxsp!=op2->stats.maxsp)
1762	FAST_SAVE_LONG(fastbuf,"maxsp ",op->stats.maxsp,6);
1763	if(op->stats.grace!=op2->stats.grace)
1764	FAST_SAVE_LONG(fastbuf,"grace ",op->stats.grace,6);
1765	if(op->stats.maxgrace!=op2->stats.maxgrace)
1766	FAST_SAVE_LONG(fastbuf,"maxgrace ",op->stats.maxgrace,9);
1767		1349
1768	if(op->stats.exp!=op2->stats.exp) {	1350	CMP_OUT2 (str , stats.Str);
1769	#ifndef WIN32	1351	CMP_OUT2 (dex , stats.Dex);
1770	sprintf(buf2,"%lld", op->stats.exp);	1352	CMP_OUT2 (con , stats.Con);
1771	#else	1353	CMP_OUT2 (wis , stats.Wis);
1772	sprintf(buf2,"%I64d", op->stats.exp);	1354	CMP_OUT2 (pow , stats.Pow);
1773	#endif	1355	CMP_OUT2 (cha , stats.Cha);
1774	ADD_STRINGLINE_ENTRY(fastbuf,"exp ", buf2, 4);	1356	CMP_OUT2 (int , stats.Int);
1775	}	1357	CMP_OUT2 (hp , stats.hp);
		1358	CMP_OUT2 (maxhp , stats.maxhp);
		1359	CMP_OUT2 (sp , stats.sp);
		1360	CMP_OUT2 (maxsp , stats.maxsp);
		1361	CMP_OUT2 (grace , stats.grace);
		1362	CMP_OUT2 (maxgrace, stats.maxgrace);
		1363	CMP_OUT2 (exp , stats.exp);
1776		1364
1777	if(op->perm_exp!=op2->perm_exp) {	1365	CMP_OUT (perm_exp);
1778	#ifndef WIN32	1366	CMP_OUT (expmul);
1779	sprintf(buf2,"%lld", op->perm_exp);
1780	#else
1781	sprintf(buf2,"%I64d", op->perm_exp);
1782	#endif
1783	ADD_STRINGLINE_ENTRY(fastbuf,"perm_exp ", buf2, 9);
1784	}
1785		1367
1786	if(op->expmul!=op2->expmul)	1368	CMP_OUT2 (food , stats.food);
1787	FAST_SAVE_DOUBLE(fastbuf,"expmul ",op->expmul,7);	1369	CMP_OUT2 (dam , stats.dam);
1788	if(op->stats.food!=op2->stats.food)	1370	CMP_OUT2 (luck , stats.luck);
1789	FAST_SAVE_LONG(fastbuf,"food ",op->stats.food,5);	1371	CMP_OUT2 (wc , stats.wc);
1790	if(op->stats.dam!=op2->stats.dam)	1372	CMP_OUT2 (ac , stats.ac);
1791	FAST_SAVE_LONG(fastbuf,"dam ",op->stats.dam,4);
1792	if(op->stats.luck!=op2->stats.luck)
1793	FAST_SAVE_LONG(fastbuf,"luck ",op->stats.luck,5);
1794	if(op->stats.wc!=op2->stats.wc)
1795	FAST_SAVE_LONG(fastbuf,"wc ",op->stats.wc,3);
1796	if(op->stats.ac!=op2->stats.ac)
1797	FAST_SAVE_LONG(fastbuf,"ac ",op->stats.ac,3);
1798	if(op->x!=op2->x)
1799	FAST_SAVE_LONG(fastbuf,"x ",op->x,2);
1800	if(op->y!=op2->y)
1801	FAST_SAVE_LONG(fastbuf,"y ",op->y,2);
1802	if(op->speed!=op2->speed) {
1803	FAST_SAVE_DOUBLE(fastbuf,"speed ",op->speed,6);
1804	}
1805	if(op->speed > 0 && op->speed_left!=op2->speed_left) {
1806	FAST_SAVE_DOUBLE(fastbuf,"speed_left ",op->speed_left,11);
1807	}
1808	if(op->move_status != op2->move_status)
1809	FAST_SAVE_LONG(fastbuf,"move_state ",op->move_status,11);
1810	if(op->attack_movement != op2->attack_movement)
1811	FAST_SAVE_LONG(fastbuf,"attack_movement ",op->attack_movement,16);
1812	if(op->nrof!=op2->nrof)
1813	FAST_SAVE_LONG(fastbuf,"nrof ",op->nrof,5);
1814	if(op->level!=op2->level)
1815	FAST_SAVE_LONG(fastbuf,"level ",op->level,6);
1816	if(op->direction!=op2->direction)
1817	FAST_SAVE_LONG(fastbuf,"direction ",op->direction,10);
1818	if(op->type!=op2->type)
1819	FAST_SAVE_LONG(fastbuf,"type ",op->type,5);
1820	if(op->subtype!=op2->subtype)
1821	FAST_SAVE_LONG(fastbuf,"subtype ",op->subtype,8);
1822	if(op->attacktype!=op2->attacktype)
1823	FAST_SAVE_LONG(fastbuf,"attacktype ",op->attacktype,11);
1824		1373
		1374	CMP_OUT (x);
		1375	CMP_OUT (y);
		1376	CMP_OUT (speed);
		1377	CMP_OUT (speed_left);
		1378	CMP_OUT2 (move_state, move_status);
		1379	CMP_OUT (attack_movement);
		1380	CMP_OUT (nrof);
		1381	CMP_OUT (level);
		1382	CMP_OUT (direction);
		1383	CMP_OUT (type);
		1384	CMP_OUT (subtype);
		1385	CMP_OUT (attacktype);
		1386
1825	for (tmp=0; tmp < NROFATTACKS; tmp++) {	1387	for (i = 0; i < NROFATTACKS; i++)
1826	if (op->resist[tmp] != op2->resist[tmp]) {	1388	if (op->resist [i] != tmp->resist [i])
1827	FAST_STRNCAT(fastbuf,"resist_",7);	1389	f.put (resist_save [i], op->resist [i]);
1828	FAST_SAVE_LONG(fastbuf,resist_save[tmp],op->resist[tmp],strlen(resist_save[tmp]));
1829	}
1830	}
1831		1390
1832	if(op->path_attuned!=op2->path_attuned)	1391	CMP_OUT (path_attuned);
1833	FAST_SAVE_LONG(fastbuf,"path_attuned ",op->path_attuned,13);	1392	CMP_OUT (path_repelled);
1834	if(op->path_repelled!=op2->path_repelled)	1393	CMP_OUT (path_denied);
1835	FAST_SAVE_LONG(fastbuf,"path_repelled ",op->path_repelled,14);	1394	CMP_OUT (material);
1836	if(op->path_denied!=op2->path_denied)	1395	CMP_OUT (materialname);
1837	FAST_SAVE_LONG(fastbuf,"path_denied ",op->path_denied,12);	1396	CMP_OUT (value);
1838	if(op->material!=op2->material)	1397	CMP_OUT (carrying);
1839	FAST_SAVE_LONG(fastbuf,"material ",op->material,9);	1398	CMP_OUT (weight);
1840	if(op->materialname && op->materialname!=op2->materialname) {	1399	CMP_OUT (invisible);
1841	ADD_STRINGLINE_ENTRY(fastbuf,"materialname ",op->materialname,13);	1400	CMP_OUT (state);
1842	}	1401	CMP_OUT (magic);
1843	if(op->value!=op2->value)	1402	CMP_OUT (last_heal);
1844	FAST_SAVE_LONG(fastbuf,"value ",op->value,6);	1403	CMP_OUT (last_sp);
1845	if(op->carrying!=op2->carrying)	1404	CMP_OUT (last_grace);
1846	FAST_SAVE_LONG(fastbuf,"carrying ",op->carrying,9);	1405	CMP_OUT (last_eat);
1847	if(op->weight!=op2->weight)	1406	CMP_OUT (glow_radius);
1848	FAST_SAVE_LONG(fastbuf,"weight ",op->weight,7);	1407
1849	if(op->invisible!=op2->invisible)
1850	FAST_SAVE_LONG(fastbuf,"invisible ",op->invisible,10);
1851	if(op->state!=op2->state)
1852	FAST_SAVE_LONG(fastbuf,"state ",op->state,6);
1853	if(op->magic!=op2->magic)
1854	FAST_SAVE_LONG(fastbuf,"magic ",op->magic,6);
1855	if(op->last_heal!=op2->last_heal)
1856	FAST_SAVE_LONG(fastbuf,"last_heal ",op->last_heal,10);
1857	if(op->last_sp!=op2->last_sp)
1858	FAST_SAVE_LONG(fastbuf,"last_sp ",op->last_sp,8);
1859	if(op->last_grace!=op2->last_grace)
1860	FAST_SAVE_LONG(fastbuf,"last_grace ",op->last_grace,11);
1861	if(op->last_eat!=op2->last_eat)
1862	FAST_SAVE_LONG(fastbuf,"last_eat ",op->last_eat,9);
1863	if(QUERY_FLAG(op,FLAG_IS_LINKED) && (tmp = get_button_value(op)))	1408	if (QUERY_FLAG (op, FLAG_IS_LINKED) && (i = get_button_value (op)))
1864	FAST_SAVE_LONG(fastbuf,"connected ",tmp,10);	1409	f.put (KW_connected, i);
1865	if(op->glow_radius!=op2->glow_radius)
1866	FAST_SAVE_LONG(fastbuf,"glow_radius ",op->glow_radius,12);
1867	if (op->randomitems!=op2->randomitems) {
1868	ADD_STRINGLINE_ENTRY(fastbuf,"randomitems ",(op->randomitems?op->randomitems->name:"none"),12);
1869	}
1870	#ifdef NPC_PROG
1871	if(op->npc_status!=op2->npc_status)
1872	FAST_SAVE_LONG(fastbuf,"npc_status ",op->npc_status,11);
1873	if(op->npc_program!=op2->npc_program)
1874	FAST_SAVE_LONG(fastbuf,"npc_program ",op->npc_program,12);
1875	#endif
1876		1410
		1411	CMP_OUT (randomitems);
		1412	CMP_OUT2 (container, weight_limit);
1877		1413
1878	if(op->run_away!=op2->run_away)	1414	CMP_OUT (run_away);
1879	FAST_SAVE_LONG(fastbuf,"run_away ",op->run_away,9);	1415	CMP_OUT (pick_up);
1880	if(op->pick_up!=op2->pick_up)	1416	CMP_OUT (will_apply);
1881	FAST_SAVE_LONG(fastbuf,"pick_up ",op->pick_up,8);	1417	CMP_OUT (smoothlevel);
1882	if(op->weight_limit!=op2->weight_limit)	1418	CMP_OUT (weapontype);
1883	FAST_SAVE_LONG(fastbuf,"container ",op->weight_limit,10);	1419	CMP_OUT (tooltype);
1884	if (op->will_apply!=op2->will_apply)	1420	CMP_OUT (elevation);
1885	FAST_SAVE_LONG(fastbuf,"will_apply ",op->will_apply,11);	1421	CMP_OUT (client_type);
1886	if(op->smoothlevel!=op2->smoothlevel)	1422	CMP_OUT (item_power);
1887	FAST_SAVE_LONG(fastbuf,"smoothlevel ",op->smoothlevel,12);	1423	CMP_OUT (duration);
		1424	CMP_OUT (range);
		1425	CMP_OUT (range_modifier);
		1426	CMP_OUT (duration_modifier);
		1427	CMP_OUT (dam_modifier);
		1428	CMP_OUT (gen_sp_armour);
1888		1429
1889	if (op->current_weapon_script!=op2->current_weapon_script){	1430	CMP_OUT (move_type);
1890	ADD_STRINGLINE_ENTRY(fastbuf,"current_weapon_script ",op->current_weapon_script,22);	1431	CMP_OUT (move_block);
1891	};	1432	CMP_OUT (move_allow);
		1433	CMP_OUT (move_on);
		1434	CMP_OUT (move_off);
		1435	CMP_OUT (move_slow);
		1436	CMP_OUT (move_slow_penalty);
1892		1437
1893	if(op->weapontype && op->weapontype!=op2->weapontype) {
1894	FAST_SAVE_LONG(fastbuf,"weapontype ",op->weapontype,11);
1895	}
1896	if(op->tooltype && op->tooltype!=op2->tooltype) {
1897	FAST_SAVE_LONG(fastbuf,"tooltype ",op->tooltype,9);
1898	}
1899	if (op->elevation && op->elevation != op2->elevation) {
1900	FAST_SAVE_LONG(fastbuf,"elevation ",op->elevation,10);
1901	}
1902	if (op->client_type && op->client_type != op2->client_type) {
1903	FAST_SAVE_LONG(fastbuf,"client_type ",op->client_type,12);
1904	}
1905
1906	if (op->item_power != op2->item_power) {
1907	FAST_SAVE_LONG(fastbuf,"item_power ",op->item_power,11);
1908	}
1909
1910	if (op->duration != op2->duration)
1911	FAST_SAVE_LONG(fastbuf,"duration ",op->duration,9);
1912
1913	if (op->range != op2->range)
1914	FAST_SAVE_LONG(fastbuf,"range ",op->range,6);
1915
1916	if (op->range_modifier != op2->range_modifier)
1917	FAST_SAVE_LONG(fastbuf,"range_modifier ",op->range_modifier,15);
1918
1919	if (op->duration_modifier != op2->duration_modifier)
1920	FAST_SAVE_LONG(fastbuf,"duration_modifier ", op->duration_modifier,18);
1921
1922	if (op->dam_modifier != op2->dam_modifier)
1923	FAST_SAVE_LONG(fastbuf,"dam_modifier ", op->dam_modifier,13);
1924
1925	if (op->gen_sp_armour != op2->gen_sp_armour) {
1926	FAST_SAVE_LONG(fastbuf,"gen_sp_armour ",op->gen_sp_armour,14);
1927	}
1928
1929	/* I've kept the old int move type saving code commented out.
1930	* In an ideal world, we'd know if we want to do a quick
1931	* save (say to a temp map, where we don't care about strings),
1932	* or a slower save/dm dump, where printing out strings is handy.
1933	*/
1934	if (op->move_type != op2->move_type) {
1935	/*FAST_SAVE_LONG(fastbuf,"move_type ",op->move_type,10)*/
1936	ADD_STRINGLINE_ENTRY(fastbuf,"move_type ",
1937	get_string_move_type(op->move_type),
1938	10);
1939	}
1940	if (op->move_block != op2->move_block) {
1941	/*FAST_SAVE_LONG(fastbuf,"move_block ",op->move_block,11)*/
1942	ADD_STRINGLINE_ENTRY(fastbuf,"move_block ",
1943	get_string_move_type(op->move_block),
1944	11);
1945	}
1946	if (op->move_allow != op2->move_allow) {
1947	/*FAST_SAVE_LONG(fastbuf,"move_allow ",op->move_allow,11);*/
1948	ADD_STRINGLINE_ENTRY(fastbuf,"move_allow ",
1949	get_string_move_type(op->move_allow),
1950	11);
1951	}
1952	if (op->move_on != op2->move_on) {
1953	/*FAST_SAVE_LONG(fastbuf,"move_on ",op->move_on,8);*/
1954	ADD_STRINGLINE_ENTRY(fastbuf,"move_on ",
1955	get_string_move_type(op->move_on),
1956	8);
1957	}
1958	if (op->move_off != op2->move_off) {
1959	/*FAST_SAVE_LONG(fastbuf,"move_off ",op->move_off,9);*/
1960	ADD_STRINGLINE_ENTRY(fastbuf,"move_off ",
1961	get_string_move_type(op->move_off),
1962	9);
1963	}
1964	if (op->move_slow != op2->move_slow) {
1965	/*FAST_SAVE_LONG(fastbuf,"move_slow ",op->move_slow,10);*/
1966	ADD_STRINGLINE_ENTRY(fastbuf,"move_slow ",
1967	get_string_move_type(op->move_slow),
1968	10);
1969	}
1970
1971	if (op->move_slow_penalty != op2->move_slow_penalty) {
1972	FAST_SAVE_LONG(fastbuf,"move_slow_penalty ",op->move_slow_penalty,18);
1973	}
1974
1975	if (!COMPARE_FLAGS(op,op2)) {	1438	if (!COMPARE_FLAGS (op, tmp))
1976	for (tmp=0; tmp <= NUM_FLAGS; tmp++) {	1439	for (i = 0; i <= NUM_FLAGS; i++)
1977	if (flag_names[tmp] && (QUERY_FLAG(op, tmp) != QUERY_FLAG(op2, tmp))) {	1440	if (flag_names [i]
1978	ADD_STRINGLINE_ENTRY(fastbuf,flag_names[tmp],QUERY_FLAG(op, tmp)?" 1":" 0",flag_lens[tmp]);	1441	&& (QUERY_FLAG (op, i) != QUERY_FLAG (tmp, i)))
1979	}	1442	f.put (flag_names [i], QUERY_FLAG (op, i) ? "1" : 0);
1980	}
1981	}
1982		1443
1983	/* Save body locations */	1444	/* Save body locations */
1984	for (i=0; i<NUM_BODY_LOCATIONS; i++) {	1445	for (i = 0; i < NUM_BODY_LOCATIONS; i++)
1985	if (op->body_info[i] != op2->body_info[i]) {	1446	if (op->body_info[i] != tmp->body_info[i])
1986	FAST_STRCAT(fastbuf,body_locations[i].save_name);	1447	f.put (body_locations[i].save_name, op->body_info[i]);
1987	FAST_SAVE_LONG(fastbuf," ",op->body_info[i],1);
1988	}
1989	}
1990	FINISH_FASTCAT(fastbuf);
1991	if(buf[0]=='\0') /*did not cat anything...*/
1992	return NULL;
1993
1994	return buf;
1995	}	1448	}
1996		1449
1997	/*	1450	/*
1998	* Dumps all variables in an object to a file.	1451	* Dumps all variables in an object to a file.
1999	* If bit 0 of flag is set, unpaid objects will be saved. As of now,	1452	* If bit 0 of flag is set, unpaid objects will be saved. As of now,
2000	* the only place this is not set is when saving the player.	1453	* the only place this is not set is when saving the player.
2001	* If bit 1 of flag is set, don't remove the object after save. As of now,	1454	* If bit 1 of flag is set, don't remove the object after save. As of now,
2002	* all of the callers are setting this.	1455	* all of the callers are setting this.
2003	*/	1456	*/
2004		1457
2005	void save_object(FILE *fp,object *op, int flag) {	1458	void
		1459	save_object (object_freezer &fp, object *op, int flag)
		1460	{
2006	archetype *at;	1461	archetype *at;
2007	char *cp;
2008	object *tmp,*old;	1462	object *tmp, *old;
2009		1463
2010	/* Even if the object does have an owner, it would seem that we should	1464	/* Even if the object does have an owner, it would seem that we should
2011	* still save it.	1465	* still save it.
2012	*/	1466	*/
2013	if(op->owner!=NULL || fp == NULL)	1467	if (op->owner != NULL)
2014	return;	1468	return;
2015		1469
2016	/* If it is unpaid and we don't want to save those, just return. */	1470	/* If it is unpaid and we don't want to save those, just return. */
2017	if(!(flag&1)&&(QUERY_FLAG(op, FLAG_UNPAID))) {	1471	if (!(flag & 1) && (QUERY_FLAG (op, FLAG_UNPAID)))
2018	return;	1472	return;
2019	}
2020		1473
2021	if((at=op->arch)==NULL) at=empty_archetype;	1474	if ((at = op->arch) == NULL)
2022	fprintf(fp,"arch %s\n",at->name);	1475	at = empty_archetype;
2023		1476
2024	if((cp=get_ob_diff(op,&at->clone))!=NULL)	1477	fp.put (KW_arch, at->name);
2025	fputs(cp,fp); /* We really should do some status checking on this */
2026		1478
		1479	put (fp, op, &at->clone);
		1480
2027	/* Eneq(@csd.uu.se): Added this to allow containers being saved with contents*/	1481	/* Eneq(@csd.uu.se): Added this to allow containers being saved with contents */
2028		1482
2029	old=NULL;	1483	old = NULL;
2030		1484
2031	if (flag & 2 )	1485	if (flag & 2)
2032	for(tmp=op->inv;tmp!=NULL;tmp=tmp->below)	1486	for (tmp = op->inv; tmp != NULL; tmp = tmp->below)
2033	save_object(fp,tmp,flag);	1487	save_object (fp, tmp, flag);
2034		1488	else
2035	/* Slightly different logic because tmp/op will be removed by	1489	/* Slightly different logic because tmp/op will be removed by
2036	* the save_object we call. So we just keep looking at op->inv	1490	* the save_object we call. So we just keep looking at op->inv
2037	* until there is nothing left. In theory, the variable old	1491	* until there is nothing left. In theory, the variable old
2038	* should not be needed, as recursive loops shouldn't happen.	1492	* should not be needed, as recursive loops shouldn't happen.
2039	*/	1493	*/
2040	else while ((tmp=op->inv)!=NULL) {	1494	while ((tmp = op->inv) != NULL)
2041	if(old==tmp) {	1495	{
		1496	if (old == tmp)
		1497	{
2042	LOG(llevError," Recursive loop in inventory\n");	1498	LOG (llevError, " Recursive loop in inventory\n");
2043	break;	1499	break;
2044	}	1500	}
		1501
2045	save_object(fp,tmp,flag);	1502	save_object (fp, tmp, flag);
2046	old=tmp;	1503	old = tmp;
2047	}	1504	}
2048		1505
2049	if (!(flag&2)) {	1506	if (!(flag & 2))
		1507	{
2050	remove_ob(op);	1508	remove_ob (op);
2051	free_object (op);	1509	free_object (op);
2052	}	1510	}
2053		1511
		1512	fp.put (op);
2054	fprintf(fp,"end\n");	1513	fprintf (fp, "end\n");
2055	}	1514	}
2056		1515
2057	void insert_event(object* op, int etype, char *ehook, char *eplug, char *eoptions)	1516	event *
		1517	find_event (object *op, int etype)
2058	{	1518	{
2059	event *evt;
2060	event *tmp;
2061
2062	evt = find_event(op,etype);
2063	if (evt == NULL)
2064	{
2065	evt = (event *)malloc(sizeof(event));
2066	evt->next = NULL;
2067	evt->type = etype;
2068	evt->hook = NULL;
2069	evt->plugin = NULL;
2070	evt->options = NULL;
2071	if (op->events==NULL)
2072	{
2073	op->events=evt;
2074	}
2075	else
2076	{
2077	for(tmp=op->events;;tmp=tmp->next)
2078	{
2079	if (tmp->next == NULL)
2080	{
2081	tmp->next = evt;
2082	break;
2083	}
2084	}
2085	}
2086	}
2087	if (ehook != NULL)
2088	FREE_AND_COPY(evt->hook,ehook);
2089	if (eplug != NULL)
2090	FREE_AND_COPY(evt->plugin,eplug);
2091	if (eoptions != NULL)
2092	FREE_AND_COPY(evt->options,eoptions);
2093	}
2094
2095	event* find_event(object* op, int etype)
2096	{
2097	event *found;
2098	for(found=op->events;found!=NULL;found=found->next)	1519	for (event *found = op->events; found != NULL; found = found->next)
2099	{
2100	if (found->type == etype)	1520	if (found->type == etype)
2101	return found;	1521	return found;
2102	}	1522
2103	return NULL;	1523	return NULL;
2104	}	1524	}

Diff Legend

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