ViewVC Help

View File | Revision Log | Show Annotations | Download File

/cvs/deliantra/server/server/apply.C

Comparing deliantra/server/server/apply.C (file contents):
Revision 1.201 by root, Mon Oct 12 14:00:58 2009 UTC vs.
Revision 1.251 by root, Tue Apr 6 23:39:45 2010 UTC

1	/*	1	/*
2	* This file is part of Deliantra, the Roguelike Realtime MMORPG.	2	* This file is part of Deliantra, the Roguelike Realtime MMORPG.
3	*	3	*
4	* Copyright (©) 2005,2006,2007,2008 Marc Alexander Lehmann / Robin Redeker / the Deliantra team	4	* Copyright (©) 2005,2006,2007,2008,2009,2010 Marc Alexander Lehmann / Robin Redeker / the Deliantra team
5	* Copyright (©) 2001,2007 Mark Wedel & Crossfire Development Team	5	* Copyright (©) 2001 Mark Wedel & Crossfire Development Team
6	* Copyright (©) 1992,2007 Frank Tore Johansen	6	* Copyright (©) 1992 Frank Tore Johansen
7	*	7	*
8	* Deliantra is free software: you can redistribute it and/or modify it under	8	* Deliantra is free software: you can redistribute it and/or modify it under
9	* the terms of the Affero GNU General Public License as published by the	9	* the terms of the Affero GNU General Public License as published by the
10	* Free Software Foundation, either version 3 of the License, or (at your	10	* Free Software Foundation, either version 3 of the License, or (at your
11	* option) any later version.	11	* option) any later version.
…		…
30	#include <skills.h>	30	#include <skills.h>
31	#include <tod.h>	31	#include <tod.h>
32		32
33	#include <sproto.h>	33	#include <sproto.h>
34		34
35	/* Want this regardless of rplay. */	35	// these must be in the inventory before they can be applied
36	#include <sounds.h>
37		36
38	/**	37	static const struct apply_types_inv_only : typeset
39	* Check if op should abort moving victim because of it's race or slaying.
40	* Returns 1 if it should abort, returns 0 if it should continue.
41	*/
42	int
43	should_director_abort (object *op, object *victim)
44	{	38	{
45	int arch_flag, name_flag, race_flag;	39	apply_types_inv_only ()
46
47	/* Get flags to determine what of arch, name, and race should be checked.
48	* This is stored in subtype, and is a bitmask, the LSB is the arch flag,
49	* the next is the name flag, and the last is the race flag. Also note,
50	* if subtype is set to zero, that also goes to defaults of all affecting
51	* it. Examples:
52	* subtype 1: only arch
53	* subtype 3: arch or name
54	* subtype 5: arch or race
55	* subtype 7: all three
56	*/
57	if (op->subtype)
58	{	40	{
59	arch_flag = op->subtype & 1;	41	set (WEAPON);
60	name_flag = op->subtype & 2;	42	set (ARMOUR);
61	race_flag = op->subtype & 4;	43	set (BOOTS);
		44	set (GLOVES);
		45	set (AMULET);
		46	set (GIRDLE);
		47	set (BRACERS);
		48	set (SHIELD);
		49	set (HELMET);
		50	set (RING);
		51	set (CLOAK);
		52	set (WAND);
		53	set (ROD);
		54	set (HORN);
		55	set (SKILL);
		56	set (SPELL);
		57	set (BOW);
		58	set (RANGED);
		59	set (BUILDER);
		60	set (SKILL_TOOL);
62	}	61	}
63	else	62	} apply_types_inv_only;
		63
		64	// these only make sense for the player
		65
		66	static const struct apply_types_player_only : typeset
		67	{
		68	apply_types_player_only ()
64	{	69	{
65	arch_flag = 1;	70	set (EXIT);
66	name_flag = 1;	71	set (BOOK);
67	race_flag = 1;	72	set (SIGN);
		73	set (BOOK);
		74	set (SKILLSCROLL);
		75	set (SPELLBOOK);
		76	set (INSCRIBABLE);
		77	set (TREASURE);
		78	set (SAVEBED);
		79	set (ARMOUR_IMPROVER);
		80	set (WEAPON_IMPROVER);
		81	set (CLOCK);
		82	set (MENU);
		83	set (LIGHTER); /* for lighting torches/lanterns/etc */
68	}	84	}
		85	} apply_types_player_only;
69		86
70	/* If the director has race set, only affect objects with a arch,	87	// applying these _can_ be attempted, others cannot
71	* name or race that matches.	88	// be applied at all. used by e.g. apply below.
72	*/
73	if ((op->race) &&
74	((!(victim->arch && arch_flag && victim->arch->archname) || op->race != victim->arch->archname)) &&
75	((!(victim->name && name_flag) || op->race != victim->name)) &&
76	((!(victim->race && race_flag) || op->race != victim->race)))
77	return 1;
78		89
79	/* If the director has slaying set, only affect objects where none	90	static const struct apply_types : typeset
80	* of arch, name, or race match.
81	*/
82	if ((op->slaying) && (((victim->arch && arch_flag && victim->arch->archname && op->slaying == victim->arch->archname))) ||
83	((victim->name && name_flag && op->slaying == victim->name)) ||
84	((victim->race && race_flag && op->slaying == victim->race)))
85	return 1;
86
87	return 0;
88	}
89
90	/**
91	* This handles a player dropping money on an altar to identify stuff.
92	* It'll identify marked item, if none all items up to dropped money.
93	* Return value: 1 if money was destroyed, 0 if not.
94	*/
95	static int
96	apply_id_altar (object *money, object *altar, object *pl)
97	{	91	{
98	dynbuf_text &buf = msg_dynbuf; buf.clear ();	92	apply_types ()
99		93	: typeset ((typeset)apply_types_player_only | (typeset)apply_types_inv_only)
100	if (!pl || pl->type != PLAYER)
101	return 0;
102
103	/* Check for MONEY type is a special hack - it prevents 'nothing needs
104	* identifying' from being printed out more than it needs to be.
105	*/
106	if (!check_altar_sacrifice (altar, money, pl) || money->type != MONEY)
107	return 0;
108
109	/* if the player has a marked item, identify that if it needs to be
110	* identified. If it doesn't, then go through the player inventory.
111	*/
112	if (object *marked = find_marked_object (pl))
113	if (!QUERY_FLAG (marked, FLAG_IDENTIFIED) && need_identify (marked))
114	{
115	if (operate_altar (altar, &money, pl))
116	{
117	identify (marked);
118
119	buf.printf ("You have %s.\r", long_desc (marked, pl));
120	if (marked->msg)
121	buf << "The item has a story:\r" << marked->msg << "\n\n";
122
123	return !money;
124	}
125	}
126
127	for (object *id = pl->inv; id; id = id->below)
128	{	94	{
129	if (!QUERY_FLAG (id, FLAG_IDENTIFIED) && !id->invisible && need_identify (id))	95	set (T_HANDLE);
130	{	96	set (TRIGGER);
131	if (operate_altar (altar, &money, pl))	97	set (SCROLL);
132	{	98	set (POTION);
133	identify (id);	99	set (CLOSE_CON);
134		100	set (CONTAINER);
135	buf.printf ("You have %s.\r", long_desc (id, pl));	101	set (LAMP);
136	if (id->msg)	102	set (TORCH);
137	buf << "The item has a story:\r" << id->msg << "\n\n";	103	set (DRINK);
138		104	set (FOOD);
139	/* If no more money, might as well quit now */	105	set (FLESH);
140	if (!money || !check_altar_sacrifice (altar, money))	106	set (POISON);
141	break;	107	set (POWER_CRYSTAL);
142	}	108	set (ITEM_TRANSFORMER);
143	else
144	{
145	LOG (llevError, "check_id_altar: Couldn't do sacrifice when we should have been able to\n");
146	break;
147	}
148	}
149	}	109	}
150		110	} apply_types;
151	if (buf.empty ())
152	pl->failmsg ("You have nothing that needs identifying");
153	else
154	pl->contr->infobox (MSG_CHANNEL ("identify"), buf);
155
156	return !money;
157	}
158
159	/**
160	* This checks whether the object has a "on_use_yield" field, and if so generated and drops
161	* matching item.
162	**/
163	void
164	handle_apply_yield (object *tmp)
165	{
166	if (shstr_tmp yield = tmp->kv (shstr_on_use_yield))
167	archetype::get (yield)->insert_at (tmp, tmp, INS_BELOW_ORIGINATOR);
168	}
169
170	/**
171	* Handles applying a potion.
172	*/
173	int
174	apply_potion (object *op, object *tmp)
175	{
176	int got_one = 0, i;
177	object *force = 0, *floor = 0;
178
179	floor = GET_MAP_OB (op->map, op->x, op->y);
180
181	if (get_map_flags (op->map, NULL, op->x, op->y, NULL, NULL) & P_SAFE)
182	{
183	op->failmsg ("Gods prevent you from using this here, it's sacred ground!");
184
185	CLEAR_FLAG (tmp, FLAG_APPLIED);
186	return 0;
187	}
188
189	if (op->type == PLAYER)
190	if (!QUERY_FLAG (tmp, FLAG_IDENTIFIED))
191	identify (tmp);
192
193	handle_apply_yield (tmp);
194
195	/* Potion of restoration - only for players */
196	if (op->type == PLAYER && (tmp->attacktype & AT_DEPLETE))
197	{
198	object *depl;
199	archetype *at;
200
201	if (QUERY_FLAG (tmp, FLAG_CURSED) || QUERY_FLAG (tmp, FLAG_DAMNED))
202	{
203	op->drain_stat ();
204	op->update_stats ();
205	tmp->decrease ();
206	return 1;
207	}
208
209	if (!(at = archetype::find (ARCH_DEPLETION)))
210	{
211	LOG (llevError, "Could not find archetype depletion\n");
212	return 0;
213	}
214
215	depl = present_arch_in_ob (at, op);
216
217	if (depl)
218	{
219	for (i = 0; i < NUM_STATS; i++)
220	if (depl->stats.stat (i))
221	op->statusmsg (restore_msg[i]);
222
223	depl->destroy ();
224	op->update_stats ();
225	}
226	else
227	op->statusmsg ("Your potion had no effect.");
228
229	tmp->decrease ();
230	return 1;
231	}
232
233	/* improvement potion - only for players */
234	if (op->type == PLAYER && (tmp->attacktype & AT_GODPOWER))
235	{
236	for (i = 1; i < MIN (11, op->level); i++)
237	{
238	if (QUERY_FLAG (tmp, FLAG_CURSED) || QUERY_FLAG (tmp, FLAG_DAMNED))
239	{
240	if (op->contr->levhp[i] != 1)
241	{
242	op->contr->levhp[i] = 1;
243	break;
244	}
245
246	if (op->contr->levsp[i] != 1)
247	{
248	op->contr->levsp[i] = 1;
249	break;
250	}
251
252	if (op->contr->levgrace[i] != 1)
253	{
254	op->contr->levgrace[i] = 1;
255	break;
256	}
257	}
258	else
259	{
260	if (op->contr->levhp[i] < 9)
261	{
262	op->contr->levhp[i] = 9;
263	break;
264	}
265
266	if (op->contr->levsp[i] < 6)
267	{
268	op->contr->levsp[i] = 6;
269	break;
270	}
271
272	if (op->contr->levgrace[i] < 3)
273	{
274	op->contr->levgrace[i] = 3;
275	break;
276	}
277	}
278	}
279
280	/* Just makes checking easier */
281	if (i < MIN (11, op->level))
282	got_one = 1;
283
284	if (!QUERY_FLAG (tmp, FLAG_CURSED) && !QUERY_FLAG (tmp, FLAG_DAMNED))
285	{
286	if (got_one)
287	{
288	op->update_stats ();
289	op->statusmsg ("The Gods smile upon you and remake you "
290	"a little more in their image. "
291	"You feel a little more perfect.", NDI_GREEN);
292	}
293	else
294	op->statusmsg ("The potion had no effect - you are already perfect.");
295	}
296	else
297	{ /* cursed potion */
298	if (got_one)
299	{
300	op->update_stats ();
301	op->failmsg ("The Gods are angry and punish you.");
302	}
303	else
304	op->statusmsg ("You are fortunate that you are so pathetic.", NDI_DK_ORANGE);
305	}
306
307	tmp->decrease ();
308	return 1;
309	}
310
311
312	/* A potion that casts a spell. Healing, restore spellpoint (power potion)
313	* and heroism all fit into this category. Given the spell object code,
314	* there is no limit to the number of spells that potions can be cast,
315	* but direction is problematic to try and imbue fireball potions for example.
316	*/
317	if (tmp->inv)
318	{
319	if (QUERY_FLAG (tmp, FLAG_CURSED) || QUERY_FLAG (tmp, FLAG_DAMNED))
320	{
321	op->failmsg ("Yech! Your lungs are on fire!");
322	create_exploding_ball_at (op, op->level);
323	}
324	else
325	cast_spell (op, tmp, op->facing, tmp->inv, NULL);
326
327	tmp->decrease ();
328
329	/* if youre dead, no point in doing this... */
330	if (!QUERY_FLAG (op, FLAG_REMOVED))
331	op->update_stats ();
332
333	return 1;
334	}
335
336	/* Deal with protection potions */
337	force = NULL;
338	for (i = 0; i < NROFATTACKS; i++)
339	{
340	if (tmp->resist[i])
341	{
342	if (!force)
343	force = get_archetype (FORCE_NAME);
344
345	memcpy (force->resist, tmp->resist, sizeof (tmp->resist));
346	force->type = POTION_EFFECT;
347	break; /* Only need to find one protection since we copy entire batch */
348	}
349	}
350
351	/* This is a protection potion */
352	if (force)
353	{
354	/* cursed items last longer */
355	if (QUERY_FLAG (tmp, FLAG_CURSED) || QUERY_FLAG (tmp, FLAG_DAMNED))
356	{
357	force->stats.food *= 10;
358	for (i = 0; i < NROFATTACKS; i++)
359	if (force->resist[i] > 0)
360	force->resist[i] = -force->resist[i]; /* prot => vuln */
361	}
362
363	force->speed_left = -1;
364	force = insert_ob_in_ob (force, op);
365	CLEAR_FLAG (tmp, FLAG_APPLIED);
366	SET_FLAG (force, FLAG_APPLIED);
367	change_abil (op, force);
368	tmp->decrease ();
369	return 1;
370	}
371
372	/* Only thing left are the stat potions */
373	if (op->type == PLAYER)
374	{ /* only for players */
375	if ((QUERY_FLAG (tmp, FLAG_CURSED)
376	|| QUERY_FLAG (tmp, FLAG_DAMNED))
377	&& tmp->value != 0)
378	CLEAR_FLAG (tmp, FLAG_APPLIED);
379	else
380	SET_FLAG (tmp, FLAG_APPLIED);
381
382	if (!change_abil (op, tmp))
383	op->statusmsg ("Nothing happened.");
384	}
385
386	/* CLEAR_FLAG is so that if the character has other potions
387	* that were grouped with the one consumed, his
388	* stat will not be raised by them. fix_player just clears
389	* up all the stats.
390	*/
391	CLEAR_FLAG (tmp, FLAG_APPLIED);
392	op->update_stats ();
393	tmp->decrease ();
394	return 1;
395	}
396		111
397	/****************************************************************************	112	/****************************************************************************
398	* Weapon improvement code follows	113	* Weapon improvement code follows
399	****************************************************************************/	114	****************************************************************************/
400		115
401	/**	116	/**
402	* This function just checks whether who can handle equipping an item	117	* This function just checks whether who can handle equipping an item
403	* with item_power.	118	* with item_power.
404	*/	119	*/
405		120	static bool
406	bool
407	check_item_power (object *who, int item_power)	121	check_item_power (object *who, int item_power)
408	{	122	{
409	if (who->type == PLAYER	123	if (who->type == PLAYER
410	&& item_power	124	&& item_power
411	&& item_power + who->contr->item_power > settings.item_power_factor * who->level)	125	&& item_power + who->contr->item_power > settings.item_power_factor * who->level)
…		…
532		246
533	/**	247	/**
534	* This does the prepare weapon scroll.	248	* This does the prepare weapon scroll.
535	* Checks for sacrifice, and so on.	249	* Checks for sacrifice, and so on.
536	*/	250	*/
537	int	251	static int
538	prepare_weapon (object *op, object *improver, object *weapon)	252	prepare_weapon (object *op, object *improver, object *weapon)
539	{	253	{
540	int sacrifice_count, i;	254	int sacrifice_count, i;
541	char buf[MAX_BUF];	255	char buf[MAX_BUF];
542		256
…		…
595	*	309	*
596	* We are hiding extra information about the weapon in the level and	310	* We are hiding extra information about the weapon in the level and
597	* last_eat numbers for an object. Hopefully this won't break anything ??	311	* last_eat numbers for an object. Hopefully this won't break anything ??
598	* level == max improve last_eat == current improve	312	* level == max improve last_eat == current improve
599	*/	313	*/
600	int	314	static int
601	improve_weapon (object *op, object *improver, object *weapon)	315	improve_weapon (object *op, object *improver, object *weapon)
602	{	316	{
603	int sacrifice_count, sacrifice_needed = 0;	317	int sacrifice_count, sacrifice_needed = 0;
604		318
605	if (improver->stats.sp == IMPROVE_PREPARE)	319	if (improver->stats.sp == IMPROVE_PREPARE)
…		…
707	/**	421	/**
708	* Handles the applying of improve/prepare/enchant weapon scroll.	422	* Handles the applying of improve/prepare/enchant weapon scroll.
709	* Checks a few things (not on a non-magic square, marked weapon, ...),	423	* Checks a few things (not on a non-magic square, marked weapon, ...),
710	* then calls improve_weapon to do the dirty work.	424	* then calls improve_weapon to do the dirty work.
711	*/	425	*/
712	int	426	static int
713	check_improve_weapon (object *op, object *tmp)	427	check_improve_weapon (object *op, object *tmp)
714	{	428	{
715	object *otmp;	429	object *otmp;
716		430
717	if (op->type != PLAYER)	431	if (op->type != PLAYER)
…		…
764	* the armour value of the piece of equipment exceed either	478	* the armour value of the piece of equipment exceed either
765	* the users level or 90)	479	* the users level or 90)
766	* Modified by MSW for partial resistance. Only support	480	* Modified by MSW for partial resistance. Only support
767	* changing of physical area right now.	481	* changing of physical area right now.
768	*/	482	*/
769	int	483	static int
770	improve_armour (object *op, object *improver, object *armour)	484	improve_armour (object *op, object *improver, object *armour)
771	{	485	{
772	object *tmp;	486	object *tmp;
773		487
774	if (armour->magic >= settings.armor_max_enchant)	488	if (armour->magic >= settings.armor_max_enchant)
…		…
861	* what the converter wants, this will not do anything.	575	* what the converter wants, this will not do anything.
862	*/	576	*/
863	int	577	int
864	convert_item (object *item, object *converter)	578	convert_item (object *item, object *converter)
865	{	579	{
866	sint64 nr, price_in;	580	sint64 nr = 0, price_in;
867		581
868	if (item->flag [FLAG_UNPAID])	582	if (item->flag [FLAG_UNPAID])
869	return 0;	583	return 0;
870		584
871	shstr conv_from = converter->slaying;	585	shstr conv_from = converter->slaying;
872	archetype *conv_to = converter->other_arch;	586	archetype *conv_to = converter->other_arch;
873	sint64 need = converter->stats.food;	587	sint64 need = converter->stats.food;
874	sint64 give = converter->stats.sp;	588	sint64 give = converter->stats.sp;
875		589
…		…
952	item->nrof *= nr;	666	item->nrof *= nr;
953		667
954	if (converter->flag [FLAG_PRECIOUS])	668	if (converter->flag [FLAG_PRECIOUS])
955	SET_FLAG (item, FLAG_UNPAID);	669	SET_FLAG (item, FLAG_UNPAID);
956		670
957	if (is_in_shop (converter))	671	if (converter->is_in_shop ())
958	{	672	{
959	// converters on shop floors don't work anymore, bug lets check for it	673	// converters on shop floors don't work anymore, bug lets check for it
960	// and report in case someone still does it.	674	// and report in case someone still does it.
961	LOG (llevDebug, "ITEMBUG: broken converter, converters on shop floor don't work: %s\n",	675	LOG (llevDebug, "ITEMBUG: broken converter, converters on shop floor don't work: %s\n",
962	converter->debug_desc ());	676	converter->debug_desc ());
…		…
985	* Handle apply on containers.	699	* Handle apply on containers.
986	* By Eneq(@csd.uu.se).	700	* By Eneq(@csd.uu.se).
987	* Moved to own function and added many features [Tero.Haatanen@lut.fi]	701	* Moved to own function and added many features [Tero.Haatanen@lut.fi]
988	* added the alchemical cauldron to the code -b.t.	702	* added the alchemical cauldron to the code -b.t.
989	*/	703	*/
990	int	704	static int
991	apply_container (object *op, object *sack)	705	apply_container (object *op, object *sack)
992	{	706	{
993	if (op->type != PLAYER || !op->contr->ns)	707	if (op->type != PLAYER || !op->contr->ns)
994	return 0; /* This might change */	708	return 0; /* This might change */
995		709
…		…
1008	}	722	}
1009		723
1010	// already applied == open on ground, or open in inv, or active in inv	724	// already applied == open on ground, or open in inv, or active in inv
1011	if (sack->flag [FLAG_APPLIED])	725	if (sack->flag [FLAG_APPLIED])
1012	{	726	{
1013	if (op->container == sack)	727	if (op->container_ () == sack)
1014	{	728	{
1015	// open on ground or inv, so close	729	// open on ground or inv, so close
1016	op->close_container ();	730	op->close_container ();
1017	return 1;	731	return 1;
1018	}	732	}
…		…
1165	/* this is only used for players */	879	/* this is only used for players */
1166	rv = teleport (shop_mat, SHOP_MAT, op);	880	rv = teleport (shop_mat, SHOP_MAT, op);
1167		881
1168	if (has_unpaid)	882	if (has_unpaid)
1169	op->contr->play_sound (sound_find ("shop_buy"));	883	op->contr->play_sound (sound_find ("shop_buy"));
1170	else if (is_in_shop (op))	884	else if (op->is_in_shop ())
1171	op->contr->play_sound (sound_find ("shop_enter"));	885	op->contr->play_sound (sound_find ("shop_enter"));
1172	else	886	else
1173	op->contr->play_sound (sound_find ("shop_leave"));	887	op->contr->play_sound (sound_find ("shop_leave"));
1174		888
1175	if (shop_mat->msg)	889	if (shop_mat->msg)
1176	op->statusmsg (shop_mat->msg);	890	op->statusmsg (shop_mat->msg);
1177	/* This check below is a bit simplistic - generally it should be correct,	891	/* This check below is a bit simplistic - generally it should be correct,
1178	* but there is never a guarantee that the bottom space on the map is	892	* but there is never a guarantee that the bottom space on the map is
1179	* actually the shop floor.	893	* actually the shop floor.
1180	*/	894	*/
1181	else if (!rv && !is_in_shop (op))	895	else if (!rv && !op->is_in_shop ())
1182	{	896	{
1183	opinion = shopkeeper_approval (op->map, op);	897	opinion = shopkeeper_approval (op->map, op);
1184		898
1185	op->statusmsg (	899	op->statusmsg (
1186	opinion >= 0.90 ? "The shopkeeper gives you a friendly wave."	900	opinion >= 0.90 ? "The shopkeeper gives you a friendly wave."
…		…
1305	EXIT_Y (trap) + freearr_y[dir],	1019	EXIT_Y (trap) + freearr_y[dir],
1306	0, victim);	1020	0, victim);
1307	}	1021	}
1308		1022
1309	/**	1023	/**
1310	* 'victim' moves onto 'trap'
1311	* 'victim' leaves 'trap'
1312	* effect is determined by move_on/move_off of trap and move_type of victime.
1313	*
1314	* originator: Player, monster or other object that caused 'victim' to move
1315	* onto 'trap'. Will receive messages caused by this action. May be NULL.
1316	* However, some types of traps require an originator to function.
1317	*/
1318	void
1319	move_apply (object *trap, object *victim, object *originator)
1320	{
1321	static int recursion_depth = 0;
1322
1323	/* Only exits affect DMs. */
1324	if (QUERY_FLAG (victim, FLAG_WIZPASS) && trap->type != EXIT && trap->type != SIGN)
1325	return;
1326
1327	/* move_apply() is the most likely candidate for causing unwanted and
1328	* possibly unlimited recursion.
1329	*/
1330	/* The following was changed because it was causing perfeclty correct
1331	* maps to fail. 1) it's not an error to recurse:
1332	* rune detonates, summoning monster. monster lands on nearby rune.
1333	* nearby rune detonates. This sort of recursion is expected and
1334	* proper. This code was causing needless crashes.
1335	*/
1336	if (recursion_depth >= 500)
1337	{
1338	LOG (llevDebug, "WARNING: move_apply(): aborting recursion "
1339	"[trap arch %s, name %s; victim arch %s, name %s]\n", &trap->arch->archname, &trap->name, &victim->arch->archname, &victim->name);
1340	return;
1341	}
1342
1343	recursion_depth++;
1344	if (trap->head)
1345	trap = trap->head;
1346
1347	if (!INVOKE_OBJECT (MOVE_TRIGGER, trap, ARG_OBJECT (victim), ARG_OBJECT (originator)))
1348	switch (trap->type)
1349	{
1350	case PLAYERMOVER:
1351	if (trap->attacktype && (trap->level || victim->type != PLAYER) && !should_director_abort (trap, victim))
1352	{
1353	if (!trap->stats.maxsp)
1354	trap->stats.maxsp = 2;
1355
1356	/* Is this correct? From the docs, it doesn't look like it
1357	* should be divided by trap->speed
1358	*/
1359	victim->speed_left = -FABS (trap->stats.maxsp * victim->speed / trap->speed);
1360
1361	/* Just put in some sanity check. I think there is a bug in the
1362	* above with some objects have zero speed, and thus the player
1363	* getting permanently paralyzed.
1364	*/
1365	if (victim->speed_left < -50.f)
1366	victim->speed_left = -50.f;
1367	/* LOG(llevDebug, "apply, playermove, player speed_left=%f\n", victim->speed_left); */
1368	}
1369	break;
1370
1371	case SPINNER:
1372	if (victim->direction)
1373	{
1374	victim->direction = absdir (victim->direction - trap->stats.sp);
1375	update_turn_face (victim);
1376	}
1377	break;
1378
1379	case DIRECTOR:
1380	if (victim->direction && !should_director_abort (trap, victim))
1381	{
1382	victim->direction = trap->stats.sp;
1383	update_turn_face (victim);
1384	}
1385	break;
1386
1387	case BUTTON:
1388	case PEDESTAL:
1389	update_button (trap, originator);
1390	break;
1391
1392	case ALTAR:
1393	/* sacrifice victim on trap */
1394	apply_altar (trap, victim, originator);
1395	break;
1396
1397	case THROWN_OBJ:
1398	if (trap->inv == NULL)
1399	break;
1400	/* fallthrough */
1401
1402	case ARROW:
1403	/* bad bug: monster throw a object, make a step forwards, step on object ,
1404	* trigger this here and get hit by own missile - and will be own enemy.
1405	* Victim then is his own enemy and will start to kill herself (this is
1406	* removed) but we have not synced victim and his missile. To avoid senseless
1407	* action, we avoid hits here
1408	*/
1409	if ((QUERY_FLAG (victim, FLAG_ALIVE) && trap->speed) && trap->owner != victim)
1410	hit_with_arrow (trap, victim);
1411	break;
1412
1413	case SPELL_EFFECT:
1414	apply_spell_effect (trap, victim);
1415	break;
1416
1417	case TRAPDOOR:
1418	{
1419	int max, sound_was_played;
1420	object *ab, *ab_next;
1421
1422	if (!trap->value)
1423	{
1424	int tot;
1425
1426	for (ab = trap->above, tot = 0; ab; ab = ab->above)
1427	if ((ab->move_type && trap->move_on) || ab->move_type == 0)
1428	tot += ab->head_ ()->total_weight ();
1429
1430	if (!(trap->value = (tot > trap->weight) ? 1 : 0))
1431	break;
1432
1433	SET_ANIMATION (trap, trap->value);
1434	update_object (trap, UP_OBJ_FACE);
1435	}
1436
1437	for (ab = trap->above, max = 100, sound_was_played = 0; --max && ab; ab = ab_next)
1438	{
1439	/* need to set this up, since if we do transfer the object,
1440	* ab->above would be bogus
1441	*/
1442	ab_next = ab->above;
1443
1444	if ((ab->move_type && trap->move_on) || ab->move_type == 0)
1445	{
1446	if (!sound_was_played)
1447	{
1448	trap->play_sound (trap->sound ? trap->sound : sound_find ("fall_hole"));
1449	sound_was_played = 1;
1450	}
1451
1452	ab->statusmsg ("You fall into a trapdoor!", NDI_RED);
1453	transfer_ob (ab, EXIT_X (trap), EXIT_Y (trap), 0, ab);
1454	}
1455	}
1456	break;
1457	}
1458
1459	case CONVERTER:
1460	if (convert_item (victim, trap) < 0)
1461	{
1462	originator->failmsg (format ("The %s seems to be broken!", query_name (trap)));
1463	archetype::get (shstr_burnout)->insert_at (trap, trap);
1464	}
1465
1466	break;
1467
1468	case TRIGGER_BUTTON:
1469	case TRIGGER_PEDESTAL:
1470	case TRIGGER_ALTAR:
1471	check_trigger (trap, victim, originator);
1472	break;
1473
1474	case DEEP_SWAMP:
1475	walk_on_deep_swamp (trap, victim);
1476	break;
1477
1478	case CHECK_INV:
1479	check_inv (victim, trap);
1480	break;
1481
1482	case HOLE:
1483	move_apply_hole (trap, victim);
1484	break;
1485
1486	case EXIT:
1487	if (victim->type == PLAYER && EXIT_PATH (trap))
1488	{
1489	/* Basically, don't show exits leading to random maps the
1490	* players output.
1491	*/
1492	if (trap->msg && !EXIT_PATH (trap).starts_with ("/!"))
1493	victim->statusmsg (trap->msg, NDI_NAVY);
1494
1495	trap->play_sound (trap->sound);
1496	victim->enter_exit (trap);
1497	}
1498	break;
1499
1500	case ENCOUNTER:
1501	/* may be some leftovers on this */
1502	break;
1503
1504	case SHOP_MAT:
1505	apply_shop_mat (trap, victim);
1506	break;
1507
1508	/* Drop a certain amount of gold, and have one item identified */
1509	case IDENTIFY_ALTAR:
1510	apply_id_altar (victim, trap, originator);
1511	break;
1512
1513	case SIGN:
1514	if (victim->type != PLAYER && trap->stats.food > 0)
1515	break; /* monsters musn't apply magic_mouths with counters */
1516
1517	apply_sign (victim, trap, 1);
1518	break;
1519
1520	case CONTAINER:
1521	apply_container (victim, trap);
1522	break;
1523
1524	case RUNE:
1525	case TRAP:
1526	if (trap->level && QUERY_FLAG (victim, FLAG_ALIVE))
1527	spring_trap (trap, victim);
1528	break;
1529
1530	default:
1531	LOG (llevDebug, "name %s, arch %s, type %d with fly/walk on/off not "
1532	"handled in move_apply()\n", &trap->name, &trap->arch->archname, trap->type);
1533	break;
1534	}
1535
1536	recursion_depth--;
1537	}
1538
1539	/**
1540	* Handles reading a regular (ie not containing a spell) book.
1541	*/
1542	static void
1543	apply_book (object *op, object *tmp)
1544	{
1545	int lev_diff;
1546	object *skill_ob;
1547
1548	if (QUERY_FLAG (op, FLAG_BLIND) && !QUERY_FLAG (op, FLAG_WIZ))
1549	{
1550	op->failmsg ("You are unable to read while blind!");
1551	return;
1552	}
1553
1554	if (!tmp->msg)
1555	{
1556	op->failmsg (format ("You open the %s and find it empty.", &tmp->name));
1557	return;
1558	}
1559
1560	/* need a literacy skill to read stuff! */
1561	skill_ob = find_skill_by_name (op, tmp->skill);
1562	if (!skill_ob)
1563	{
1564	op->failmsg (format ("You are unable to decipher the strange symbols. H<You lack the %s skill to read this.>", &tmp->skill));
1565	return;
1566	}
1567
1568	lev_diff = tmp->level - (skill_ob->level + 5);
1569	if (!QUERY_FLAG (op, FLAG_WIZ) && lev_diff > 0)
1570	{
1571	op->failmsg (lev_diff < 2 ? "This book is just barely beyond your comprehension."
1572	: lev_diff < 3 ? "This book is slightly beyond your comprehension."
1573	: lev_diff < 5 ? "This book is beyond your comprehension."
1574	: lev_diff < 8 ? "This book is quite a bit beyond your comprehension."
1575	: lev_diff < 15 ? "This book is way beyond your comprehension."
1576	: "This book is totally beyond your comprehension.");
1577	return;
1578	}
1579
1580	readable_message_type *msgType = get_readable_message_type (tmp);
1581
1582	if (player *pl = op->contr)
1583	if (client *ns = pl->ns)
1584	pl->infobox (MSG_CHANNEL ("book"), format ("T<%s>\n\n%s", (char *)long_desc (tmp, op), &tmp->msg));
1585
1586	/* gain xp from reading */
1587	if (!QUERY_FLAG (tmp, FLAG_NO_SKILL_IDENT))
1588	{ /* only if not read before */
1589	int exp_gain = calc_skill_exp (op, tmp, skill_ob);
1590
1591	if (!QUERY_FLAG (tmp, FLAG_IDENTIFIED))
1592	{
1593	/*exp_gain *= 2; because they just identified it too */
1594	SET_FLAG (tmp, FLAG_IDENTIFIED);
1595
1596	if (object *pl = tmp->visible_to ())
1597	esrv_update_item (UPD_FLAGS | UPD_NAME, pl, tmp);
1598	}
1599
1600	change_exp (op, exp_gain, skill_ob->skill, 0);
1601	SET_FLAG (tmp, FLAG_NO_SKILL_IDENT); /* so no more xp gained from this book */
1602	}
1603	}
1604
1605	/**
1606	* Handles the applying of a skill scroll, calling learn_skill straight.
1607	* op is the person learning the skill, tmp is the skill scroll object
1608	*/
1609	static void
1610	apply_skillscroll (object *op, object *tmp)
1611	{
1612	switch (learn_skill (op, tmp))
1613	{
1614	case 0:
1615	op->play_sound (sound_find ("generic_fail"));
1616	op->failmsg (format ("You already possess the knowledge held within the %s.", query_name (tmp)));
1617	break;
1618
1619	case 1:
1620	tmp->decrease ();
1621	op->play_sound (sound_find ("skill_learn"));
1622	op->statusmsg (format ("You succeed in learning %s", &tmp->skill));
1623	break;
1624
1625	default:
1626	tmp->decrease ();
1627	op->play_sound (sound_find ("generic_fail"));
1628	op->failmsg (format ("You fail to learn the knowledge of the %s.\n", query_name (tmp)));
1629	break;
1630	}
1631	}
1632
1633	/**
1634	* Actually makes op learn spell.
1635	* Informs player of what happens.
1636	*/
1637	void
1638	do_learn_spell (object *op, object *spell, int special_prayer)
1639	{
1640	object *tmp;
1641
1642	if (op->type != PLAYER)
1643	{
1644	LOG (llevError, "BUG: do_learn_spell(): not a player\n");
1645	return;
1646	}
1647
1648	/* Upgrade special prayers to normal prayers */
1649	if ((tmp = check_spell_known (op, spell->name)) != NULL)
1650	{
1651	if (special_prayer && !QUERY_FLAG (tmp, FLAG_STARTEQUIP))
1652	{
1653	LOG (llevError, "BUG: do_learn_spell(): spell already known, but not marked as startequip\n");
1654	return;
1655	}
1656	return;
1657	}
1658
1659	op->contr->play_sound (sound_find ("learn_spell"));
1660
1661	tmp = spell->clone ();
1662	insert_ob_in_ob (tmp, op);
1663
1664	if (special_prayer)
1665	SET_FLAG (tmp, FLAG_STARTEQUIP);
1666
1667	esrv_add_spells (op->contr, tmp);
1668	}
1669
1670	/**
1671	* Erases spell from player's inventory.
1672	*/
1673	void
1674	do_forget_spell (object *op, const char *spell)
1675	{
1676	object *spob;
1677
1678	if (op->type != PLAYER)
1679	{
1680	LOG (llevError, "BUG: do_forget_spell(): not a player\n");
1681	return;
1682	}
1683	if ((spob = check_spell_known (op, spell)) == NULL)
1684	{
1685	LOG (llevError, "BUG: do_forget_spell(): spell not known\n");
1686	return;
1687	}
1688
1689	op->failmsg (format ("You lose knowledge of %s.", spell));
1690	player_unready_range_ob (op->contr, spob);
1691	esrv_remove_spell (op->contr, spob);
1692	spob->destroy ();
1693	}
1694
1695	/**
1696	* Handles player applying a spellbook.
1697	* Checks whether player has knowledge of required skill, doesn't already know the spell,
1698	* stuff like that. Random learning failure too.
1699	*/
1700	static void
1701	apply_spellbook (object *op, object *tmp)
1702	{
1703	object *skop, *spell, *spell_skill;
1704
1705	if (QUERY_FLAG (op, FLAG_BLIND) && !QUERY_FLAG (op, FLAG_WIZ))
1706	{
1707	op->failmsg ("You are unable to read while blind.");
1708	return;
1709	}
1710
1711	/* artifact_spellbooks have 'slaying' field point to a spell name,
1712	* instead of having their spell stored in stats.sp. These are
1713	* legacy spellbooks
1714	*/
1715	if (tmp->slaying)
1716	{
1717	spell = arch_to_object (find_archetype_by_object_name (tmp->slaying));
1718	if (!spell)
1719	{
1720	op->failmsg (format ("The book's formula for %s is incomplete.", &tmp->slaying));
1721	return;
1722	}
1723	else
1724	insert_ob_in_ob (spell, tmp);
1725
1726	tmp->slaying = 0;
1727	}
1728
1729	skop = find_skill_by_name (op, tmp->skill);
1730
1731	/* need a literacy skill to learn spells. Also, having a literacy level
1732	* lower than the spell will make learning the spell more difficult */
1733	if (!skop)
1734	{
1735	op->failmsg (format ("You can't read! Your attempt fails. H<You lack the %s skill.>", &tmp->skill));
1736	return;
1737	}
1738
1739	spell = tmp->inv;
1740
1741	if (!spell)
1742	{
1743	LOG (llevError, "apply_spellbook: Book %s has no spell in it!\n", &tmp->name);
1744	op->failmsg ("The spellbook symbols make no sense. This is a bug, please report!");
1745	return;
1746	}
1747
1748	int learn_level = sqrtf (spell->level) * 1.5f;
1749	if (skop->level < learn_level)
1750	{
1751	op->failmsg (format ("You are unable to decipher the strange symbols. H<Your %s level is too low, it must be at least %d.>",
1752	&tmp->skill, learn_level));
1753	return;
1754	}
1755
1756	op->statusmsg (format ("The spellbook contains the %s level spell %s.", get_levelnumber (spell->level), &spell->name));
1757
1758	if (!QUERY_FLAG (tmp, FLAG_IDENTIFIED))
1759	identify (tmp);
1760
1761	/* I removed the check for special_prayer_mark here - it didn't make
1762	* a lot of sense - special prayers are not found in spellbooks, and
1763	* if the player doesn't know the spell, doesn't make a lot of sense that
1764	* they would have a special prayer mark.
1765	*/
1766	if (check_spell_known (op, spell->name))
1767	{
1768	op->statusmsg ("You already know that spell. H<It makes no sense to learn spells twice, and would only waste the spellbook.>\n");
1769	return;
1770	}
1771
1772	if (spell->skill)
1773	{
1774	spell_skill = find_skill_by_name (op, spell->skill);
1775
1776	if (!spell_skill)
1777	{
1778	op->failmsg (format ("You lack the skill %s to use this spell.", &spell->skill));
1779	return;
1780	}
1781
1782	if (spell_skill->level < spell->level)
1783	{
1784	op->failmsg (format ("You need to be level %d in %s to learn this spell.", spell->level, &spell->skill));
1785	return;
1786	}
1787	}
1788
1789	/* Logic as follows
1790	*
1791	* 1- MU spells use Int to learn, Cleric spells use Wisdom
1792	*
1793	* 2- The learner's skill level in literacy adjusts the chance to learn
1794	* a spell.
1795	*
1796	* 3 -Automatically fail to learn if you read while confused
1797	*
1798	* Overall, chances are the same but a player will find having a high
1799	* literacy rate very useful! -b.t.
1800	*/
1801	if (QUERY_FLAG (op, FLAG_CONFUSED))
1802	{
1803	op->failmsg ("In your confused state you flub the wording of the text!");
1804	scroll_failure (op, 0 - random_roll (0, spell->level, op, PREFER_LOW), MAX (spell->stats.sp, spell->stats.grace));
1805	}
1806	else if (QUERY_FLAG (tmp, FLAG_STARTEQUIP) ||
1807	(random_roll (0, 100, op, PREFER_LOW) - (5 * skop->level)) < learn_spell[spell->stats.grace ? op->stats.Wis : op->stats.Int])
1808	{
1809	op->statusmsg ("You succeed in learning the spell!", NDI_GREEN);
1810	do_learn_spell (op, spell, 0);
1811
1812	/* xp gain to literacy for spell learning */
1813	if (!QUERY_FLAG (tmp, FLAG_STARTEQUIP))
1814	change_exp (op, calc_skill_exp (op, tmp, skop), skop->skill, 0);
1815	}
1816	else
1817	{
1818	op->contr->play_sound (sound_find ("fumble_spell"));
1819	op->failmsg ("You fail to learn the spell. H<Wis (priests) or Int (wizards) governs the chance of learning a prayer or spell.>\n");
1820	}
1821
1822	tmp->decrease ();
1823	}
1824
1825	/**
1826	* Handles applying a spell scroll.
1827	*/
1828	void
1829	apply_scroll (object *op, object *tmp, int dir)
1830	{
1831	object *skop;
1832
1833	if (QUERY_FLAG (op, FLAG_BLIND) && !QUERY_FLAG (op, FLAG_WIZ))
1834	{
1835	op->failmsg ("You are unable to read while blind.");
1836	return;
1837	}
1838
1839	if (!tmp->inv || tmp->inv->type != SPELL)
1840	{
1841	op->failmsg ("The scroll just doesn't make sense! H<...and never will make sense.>");
1842	return;
1843	}
1844
1845	if (op->type == PLAYER)
1846	{
1847	/* players need a literacy skill to read stuff! */
1848	int exp_gain = 0;
1849
1850	/* hard code literacy - tmp->skill points to where the exp
1851	* should go for anything killed by the spell.
1852	*/
1853	skop = find_skill_by_name (op, skill_names[SK_LITERACY]);
1854
1855	if (!skop)
1856	{
1857	op->failmsg (format ("You are unable to decipher the strange symbols. H<You lack the %s skill.>", &skill_names[SK_LITERACY]));
1858	return;
1859	}
1860
1861	if ((exp_gain = calc_skill_exp (op, tmp, skop)))
1862	change_exp (op, exp_gain, skop->skill, 0);
1863	}
1864
1865	if (!QUERY_FLAG (tmp, FLAG_IDENTIFIED))
1866	identify (tmp);
1867
1868	op->statusmsg (format ("The scroll of %s turns to dust.", &tmp->inv->name));
1869
1870	cast_spell (op, tmp, dir, tmp->inv, NULL);
1871	tmp->decrease ();
1872	}
1873
1874	/**
1875	* Applies a treasure object - by default, chest. op
1876	* is the person doing the applying, tmp is the treasure
1877	* chest.
1878	*/
1879	static void
1880	apply_treasure (object *op, object *tmp)
1881	{
1882	/* Nice side effect of this treasure creation method is that the treasure
1883	* for the chest is done when the chest is created, and put into the chest
1884	* inventory. So that when the chest burns up, the items still exist. Also
1885	* prevents people from moving chests to more difficult maps to get better
1886	* treasure
1887	*/
1888	object *treas = tmp->inv;
1889
1890	if (!treas)
1891	{
1892	op->statusmsg ("The chest was empty.");
1893	tmp->decrease ();
1894	return;
1895	}
1896
1897	while (tmp->inv)
1898	{
1899	treas = tmp->inv;
1900	treas->remove ();
1901
1902	treas->x = op->x;
1903	treas->y = op->y;
1904	treas = insert_ob_in_map (treas, op->map, op, INS_BELOW_ORIGINATOR);
1905
1906	if (treas && (treas->type == RUNE || treas->type == TRAP) && treas->level && QUERY_FLAG (op, FLAG_ALIVE))
1907	spring_trap (treas, op);
1908
1909	/* If either player or container was destroyed, no need to do
1910	* further processing. I think this should be enclused with
1911	* spring trap above, as I don't think there is otherwise
1912	* any way for the treasure chest or player to get killed.
1913	*/
1914	if (op->destroyed () || tmp->destroyed ())
1915	break;
1916	}
1917
1918	if (!tmp->destroyed () && !tmp->inv)
1919	tmp->decrease (true);
1920	}
1921
1922	/**
1923	* op eats food.
1924	* If player, takes care of messages and dragon special food.
1925	*/
1926	static void
1927	apply_food (object *op, object *tmp)
1928	{
1929	int capacity_remaining;
1930
1931	if (op->type != PLAYER)
1932	op->stats.hp = op->stats.maxhp;
1933	else
1934	{
1935	/* check if this is a dragon (player), eating some flesh */
1936	if (tmp->type == FLESH && is_dragon_pl (op) && dragon_eat_flesh (op, tmp))
1937	;
1938	else
1939	{
1940	/* usual case - no dragon meal: */
1941	if (op->stats.food + tmp->stats.food > 999)
1942	{
1943	if (tmp->type == FOOD || tmp->type == FLESH)
1944	op->failmsg ("You feel full, but what a waste of food!");
1945	else
1946	op->statusmsg ("Most of the drink goes down your face not your throat!");
1947	}
1948
1949	tmp->play_sound (
1950	tmp->sound
1951	? tmp->sound
1952	: tmp->type == DRINK
1953	? sound_find ("eat_drink")
1954	: sound_find ("eat_food")
1955	);
1956
1957	if (!QUERY_FLAG (tmp, FLAG_CURSED))
1958	{
1959	const char *buf;
1960
1961	if (!is_dragon_pl (op))
1962	{
1963	/* eating message for normal players */
1964	if (tmp->type == DRINK)
1965	buf = format ("Ahhh...that %s tasted good.", &tmp->name);
1966	else
1967	buf = format ("The %s tasted %s", &tmp->name, tmp->type == FLESH ? "terrible!" : "good.");
1968	}
1969	else
1970	/* eating message for dragon players */
1971	buf = format ("The %s tasted terrible!", &tmp->name);
1972
1973	op->statusmsg (buf);
1974
1975	capacity_remaining = 999 - op->stats.food;
1976	op->stats.food += tmp->stats.food;
1977	if (capacity_remaining < tmp->stats.food)
1978	op->stats.hp += capacity_remaining / 50;
1979	else
1980	op->stats.hp += tmp->stats.food / 50;
1981
1982	if (op->stats.hp > op->stats.maxhp)
1983	op->stats.hp = op->stats.maxhp;
1984	if (op->stats.food > 999)
1985	op->stats.food = 999;
1986	}
1987
1988	/* special food hack -b.t. */
1989	if (tmp->title || QUERY_FLAG (tmp, FLAG_CURSED))
1990	eat_special_food (op, tmp);
1991	}
1992	}
1993
1994	handle_apply_yield (tmp);
1995	tmp->decrease ();
1996	}
1997
1998	/**
1999	* A dragon is eating some flesh. If the flesh contains resistances,
2000	* there is a chance for the dragon's skin to get improved.
2001	*
2002	* attributes:
2003	* object *op the object (dragon player) eating the flesh
2004	* object *meal the flesh item, getting chewed in dragon's mouth
2005	* return:
2006	* int 1 if eating successful, 0 if it doesn't work
2007	*/
2008	int
2009	dragon_eat_flesh (object *op, object *meal)
2010	{
2011	object *skin = NULL; /* pointer to dragon skin force */
2012	object *abil = NULL; /* pointer to dragon ability force */
2013	object *tmp = NULL; /* tmp. object */
2014
2015	double chance; /* improvement-chance of one resistance type */
2016	double totalchance = 1; /* total chance of gaining one resistance */
2017	double bonus = 0; /* level bonus (improvement is easier at lowlevel) */
2018	double mbonus = 0; /* monster bonus */
2019	int atnr_winner[NROFATTACKS]; /* winning candidates for resistance improvement */
2020	int winners = 0; /* number of winners */
2021	int i; /* index */
2022
2023	/* let's make sure and doublecheck the parameters */
2024	if (meal->type != FLESH || !is_dragon_pl (op))
2025	return 0;
2026
2027	/* now grab the 'dragon_skin'- and 'dragon_ability'-forces
2028	from the player's inventory */
2029	for (tmp = op->inv; tmp; tmp = tmp->below)
2030	if (tmp->type == FORCE)
2031	if (tmp->arch->archname == shstr_dragon_skin_force)
2032	skin = tmp;
2033	else if (tmp->arch->archname == shstr_dragon_ability_force)
2034	abil = tmp;
2035
2036	/* if either skin or ability are missing, this is an old player
2037	which is not to be considered a dragon -> bail out */
2038	if (skin == NULL || abil == NULL)
2039	return 0;
2040
2041	/* now start by filling stomache and health, according to food-value */
2042	if ((999 - op->stats.food) < meal->stats.food)
2043	op->stats.hp += (999 - op->stats.food) / 50;
2044	else
2045	op->stats.hp += meal->stats.food / 50;
2046
2047	if (op->stats.hp > op->stats.maxhp)
2048	op->stats.hp = op->stats.maxhp;
2049
2050	op->stats.food = MIN (999, op->stats.food + meal->stats.food);
2051
2052	/*LOG(llevDebug, "-> player: %d, flesh: %d\n", op->level, meal->level); */
2053
2054	/* on to the interesting part: chances for adding resistance */
2055	for (i = 0; i < NROFATTACKS; i++)
2056	{
2057	if (meal->resist[i] > 0 && atnr_is_dragon_enabled (i))
2058	{
2059	/* got positive resistance, now calculate improvement chance (0-100) */
2060
2061	/* this bonus makes resistance increase easier at lower levels */
2062	bonus = (settings.max_level - op->level) * 30. / ((double) settings.max_level);
2063	if (i == abil->stats.exp)
2064	bonus += 5; /* additional bonus for resistance of ability-focus */
2065
2066	/* monster bonus increases with level, because high-level
2067	flesh is too rare */
2068	mbonus = op->level * 20. / ((double) settings.max_level);
2069
2070	chance = (((double) MIN (op->level + bonus, meal->level + bonus + mbonus)) * 100. /
2071	((double) settings.max_level)) - skin->resist[i];
2072
2073	if (chance >= 0.)
2074	chance += 1.;
2075	else
2076	chance = (chance < -12) ? 0. : 1. / pow (2., -chance);
2077
2078	/* chance is proportional to amount of resistance (max. 50) */
2079	chance *= ((double) (MIN (meal->resist[i], 50))) / 50.;
2080
2081	/* doubled chance for resistance of ability-focus */
2082	if (i == abil->stats.exp)
2083	chance = MIN (100., chance * 2.);
2084
2085	/* now make the throw and save all winners (Don't insert luck bonus here!) */
2086	if (rndm (10000) < (unsigned int) (chance * 100))
2087	{
2088	atnr_winner[winners] = i;
2089	winners++;
2090	}
2091
2092	if (chance >= 0.01)
2093	totalchance *= 1 - chance / 100;
2094
2095	/*LOG(llevDebug, " %s: bonus %.1f, chance %.1f\n", attacks[i], bonus, chance); */
2096	}
2097	}
2098
2099	/* inverse totalchance as until now we have the failure-chance */
2100	totalchance = 100 - totalchance * 100;
2101
2102	/* print message according to totalchance */
2103	const char *buf;
2104	if (totalchance > 50.)
2105	buf = format ("Hmm! The %s tasted delicious!", &meal->name);
2106	else if (totalchance > 10.)
2107	buf = format ("The %s tasted very good.", &meal->name);
2108	else if (totalchance > 1.)
2109	buf = format ("The %s tasted good.", &meal->name);
2110	else if (totalchance > 0.1)
2111	buf = format ("The %s tasted bland.", &meal->name);
2112	else if (totalchance >= 0.01)
2113	buf = format ("The %s had a boring taste.", &meal->name);
2114	else if (meal->last_eat > 0 && atnr_is_dragon_enabled (meal->last_eat))
2115	buf = format ("The %s tasted strange.", &meal->name);
2116	else
2117	buf = format ("The %s had no taste.", &meal->name);
2118
2119	op->statusmsg (buf);
2120
2121	/* now choose a winner if we have any */
2122	i = -1;
2123	if (winners > 0)
2124	i = atnr_winner [rndm (winners)];
2125
2126	if (i >= 0 && i < NROFATTACKS && skin->resist[i] < 95)
2127	{
2128	/* resistance increased! */
2129	skin->resist[i]++;
2130	op->update_stats ();
2131
2132	op->statusmsg (format ("Your skin is now more resistant to %s!", change_resist_msg[i]));
2133	}
2134
2135	/* if this flesh contains a new ability focus, we mark it
2136	into the ability_force and it will take effect on next level */
2137	if (meal->last_eat > 0 && atnr_is_dragon_enabled (meal->last_eat) && meal->last_eat != abil->last_eat)
2138	{
2139	abil->last_eat = meal->last_eat; /* write: last_eat <new attnr focus> */
2140
2141	if (meal->last_eat != abil->stats.exp)
2142	op->statusmsg (format (
2143	"Your metabolism prepares to focus on %s!\n"
2144	"The change will happen at level %d.",
2145	change_resist_msg[meal->last_eat],
2146	abil->level + 1
2147	));
2148	else
2149	{
2150	op->statusmsg (format ("Your metabolism will continue to focus on %s.", change_resist_msg[meal->last_eat]));
2151	abil->last_eat = 0;
2152	}
2153	}
2154
2155	return 1;
2156	}
2157
2158	/**
2159	* Handles applying an improve armor scroll.
2160	* Does some sanity checks, then calls improve_armour.
2161	*/
2162	static void
2163	apply_armour_improver (object *op, object *tmp)
2164	{
2165	object *armor;
2166
2167	if (!QUERY_FLAG (op, FLAG_WIZCAST) && (get_map_flags (op->map, 0, op->x, op->y, 0, 0) & P_NO_MAGIC))
2168	{
2169	op->failmsg ("Something blocks the magic of the scroll. H<This area prevents magic effects.>");
2170	return;
2171	}
2172
2173	armor = find_marked_object (op);
2174
2175	if (!armor)
2176	{
2177	op->failmsg ("You need to mark an armor object. Use the right mouse button popup or the mark command to do this.");
2178	return;
2179	}
2180
2181	if (armor->type != ARMOUR
2182	&& armor->type != CLOAK
2183	&& armor->type != BOOTS && armor->type != GLOVES && armor->type != BRACERS && armor->type != SHIELD && armor->type != HELMET)
2184	{
2185	op->failmsg ("Your marked item is not armour!\n");
2186	return;
2187	}
2188
2189	op->statusmsg ("Applying armour enchantment.");
2190	improve_armour (op, tmp, armor);
2191	}
2192
2193	void
2194	apply_poison (object *op, object *tmp)
2195	{
2196	// need to do it now when it is still on the map
2197	handle_apply_yield (tmp);
2198
2199	object *poison = tmp->split (1);
2200
2201	if (op->type == PLAYER)
2202	{
2203	op->contr->play_sound (sound_find ("drink_poison"));
2204	op->failmsg ("Yech! That tasted poisonous!");
2205	op->contr->killer = poison;
2206	}
2207
2208	if (poison->stats.hp > 0)
2209	{
2210	LOG (llevDebug, "Trying to poison player/monster for %d hp\n", poison->stats.hp);
2211	hit_player (op, poison->stats.hp, tmp, AT_POISON, 1);
2212	}
2213
2214	op->stats.food -= op->stats.food / 4;
2215	poison->destroy ();
2216	}
2217
2218	/**
2219	* This function return true if the exit is not a 2 ways one or it is 2 ways, valid exit.
2220	* A valid 2 way exit means:
2221	* -You can come back (there is another exit at the other side)
2222	* -You are
2223	* ° the owner of the exit
2224	* ° or in the same party as the owner
2225	*
2226	* Note: a owner in a 2 way exit is saved as the owner's name
2227	* in the field exit->name cause the field exit->owner doesn't
2228	* survive in the swapping (in fact the whole exit doesn't survive).
2229	*/
2230	int
2231	is_legal_2ways_exit (object *op, object *exit)
2232	{
2233	if (exit->stats.exp != 1)
2234	return 1; /*This is not a 2 way, so it is legal */
2235
2236	#if 0 //TODO
2237	if (!has_been_loaded (EXIT_PATH (exit)) && exit->race)
2238	return 0; /* This is a reset town portal */
2239	#endif
2240
2241	LOG (llevError | logBacktrace, "sync map load due to %s\n", exit->debug_desc ());
2242
2243	maptile *exitmap = maptile::find_sync (EXIT_PATH (exit), exit->map);
2244
2245	if (exitmap)
2246	{
2247	exitmap->load_sync ();
2248
2249	object *tmp = exitmap->at (EXIT_X (exit), EXIT_Y (exit)).bot;
2250
2251	if (!tmp)
2252	return 0;
2253
2254	for (; tmp; tmp = tmp->above)
2255	{
2256	if (tmp->type != EXIT)
2257	continue; /*Not an exit */
2258
2259	if (!EXIT_PATH (tmp))
2260	continue; /*Not a valid exit */
2261
2262	if ((EXIT_X (tmp) != exit->x) || (EXIT_Y (tmp) != exit->y))
2263	continue; /*Not in the same place */
2264
2265	if (exit->map->path != EXIT_PATH (tmp))
2266	continue; /*Not in the same map */
2267
2268	/* From here we have found the exit is valid. However we do
2269	* here the check of the exit owner. It is important for the
2270	* town portals to prevent strangers from visiting your appartments
2271	*/
2272	if (!exit->race)
2273	return 1; /*No owner, free for all! */
2274
2275	object *exit_owner = 0;
2276
2277	for_all_players (pp)
2278	{
2279	if (!pp->ob)
2280	continue;
2281
2282	if (pp->ob->name != exit->race)
2283	continue;
2284
2285	exit_owner = pp->ob; /*We found a player which correspond to the player name */
2286	break;
2287	}
2288
2289	if (!exit_owner)
2290	return 0; /* No more owner */
2291
2292	if (exit_owner->contr == op->contr)
2293	return 1; /*It is your exit */
2294
2295	if (exit_owner && /*There is a owner */
2296	(op->contr) && /*A player tries to pass */
2297	((exit_owner->contr->party == NULL) || /*No pass if controller has no party */
2298	(exit_owner->contr->party != op->contr->party))) /* Or not the same as op */
2299	return 0;
2300
2301	return 1;
2302	}
2303	}
2304
2305	return 0;
2306	}
2307
2308	/**
2309	* This function will try to apply a lighter and in case no lighter
2310	* is specified it will try to find a lighter in the players inventory,
2311	* and inform him about this requirement.
2312	*
2313	* who - the player
2314	* op - the item we want to light
2315	* lighter - the lighter or 0 if a lighter has yet to be found
2316	*/
2317	static object *
2318	auto_apply_lighter (object *who, object *op, object *lighter)
2319	{
2320	if (lighter == 0)
2321	{
2322	for (object *tmp = who->inv; tmp; tmp = tmp->below)
2323	{
2324	if (tmp->type == LIGHTER)
2325	{
2326	lighter = tmp;
2327	break;
2328	}
2329	}
2330
2331	if (!lighter)
2332	{
2333	who->failmsg (format (
2334	"You can't light up the %s with your bare hands! "
2335	"H<You need a lighter in your inventory, for example a flint and steel.>",
2336	&op->name));
2337	return 0;
2338	}
2339	}
2340
2341	// last_eat == 0 means the lighter is not being used up!
2342	if (lighter->last_eat && lighter->stats.food)
2343	{
2344	/* lighter gets used up */
2345	lighter = lighter->split ();
2346	lighter->stats.food--;
2347	who->insert (lighter);
2348	}
2349	else if (lighter->last_eat)
2350	{
2351	/* no charges left in lighter */
2352	who->failmsg (format (
2353	"You attempt to light the %s with a used up %s.",
2354	&op->name, &lighter->name));
2355	return 0;
2356	}
2357
2358	return lighter;
2359	}
2360
2361	/**
2362	* Designed primarily to light torches/lanterns/etc.
2363	* Also burns up burnable material too. First object in the inventory is
2364	* the selected object to "burn". -b.t.
2365	*/
2366	void
2367	apply_lighter (object *who, object *lighter)
2368	{
2369	object *item;
2370	int is_player_env = 0;
2371
2372	item = find_marked_object (who);
2373	if (item)
2374	{
2375	if (!auto_apply_lighter (who, item, lighter))
2376	return;
2377
2378	/* Perhaps we should split what we are trying to light on fire?
2379	* I can't see many times when you would want to light multiple
2380	* objects at once.
2381	*/
2382
2383	save_throw_object (item, AT_FIRE, who);
2384
2385	if (item->destroyed ()
2386	|| ((item->type == LAMP || item->type == TORCH)
2387	&& item->glow_radius > 0))
2388	who->statusmsg (format (
2389	"You light the %s with the %s.",
2390	&item->name, &lighter->name));
2391	else
2392	who->failmsg (format (
2393	"You attempt to light the %s with the %s and fail.",
2394	&item->name, &lighter->name));
2395	}
2396	else
2397	who->failmsg ("You need to mark a lightable object.");
2398	}
2399
2400	/**
2401	* This function generates a cursed effect for cursed lamps and torches.
2402	*/
2403	void player_apply_lamp_cursed_effect (object *who, object *op)
2404	{
2405	if (op->level)
2406	{
2407	who->failmsg (format (
2408	"The %s was cursed, it explodes in a big fireball!",
2409	&op->name));
2410	create_exploding_ball_at (who, op->level);
2411	}
2412	else
2413	{
2414	who->failmsg (format (
2415	"The %s was cursed, it crumbles to dust, at least it didn't explode.!",
2416	&op->name));
2417	}
2418
2419	op->destroy ();
2420	}
2421
2422	/**
2423	* Apply for players and lamps
2424	*
2425	* who - the player
2426	* op - the lamp
2427	*/
2428	void player_apply_lamp (object *who, object *op)
2429	{
2430	bool switch_on = op->glow_radius ? false : true;
2431
2432	if (switch_on)
2433	{
2434	object *lighter = 0;
2435
2436	if (op->flag [FLAG_IS_LIGHTABLE]
2437	&& !(lighter = auto_apply_lighter (who, op, 0)))
2438	return;
2439
2440	if (op->stats.food < 1)
2441	{
2442	if (op->type == LAMP)
2443	who->failmsg (format (
2444	"The %s is out of fuel! "
2445	"H<Lamps and similar items need fuel. They cannot be refilled.>",
2446	&op->name));
2447	else
2448	who->failmsg (format (
2449	"The %s is burnt out! "
2450	"H<Torches and similar items burn out and become worthless.>",
2451	&op->name));
2452	return;
2453	}
2454
2455	if (op->flag [FLAG_CURSED])
2456	{
2457	player_apply_lamp_cursed_effect (who, op);
2458	return;
2459	}
2460
2461	if (lighter)
2462	who->statusmsg (format (
2463	"You light up the %s with the %s.", &op->name, &lighter->name));
2464	else
2465	who->statusmsg (format ("You light up the %s.", &op->name));
2466	}
2467	else
2468	{
2469	if (op->flag [FLAG_CURSED])
2470	{
2471	player_apply_lamp_cursed_effect (who, op);
2472	return;
2473	}
2474
2475	if (op->type == TORCH)
2476	{
2477	if (!op->flag [FLAG_IS_LIGHTABLE])
2478	{
2479	who->statusmsg (format (
2480	"You put out the %s. "
2481	"H<The %s can't be used anymore, as it can't be lighted up again.>",
2482	&op->name, &op->name));
2483	}
2484	else
2485	who->statusmsg (format (
2486	"You put out the %s."
2487	"H<Torches wear out if you put them out.>",
2488	&op->name));
2489	}
2490	else
2491	who->statusmsg (format ("You turn off the %s.", &op->name));
2492	}
2493
2494	apply_lamp (op, switch_on);
2495	}
2496
2497	void get_animation_from_arch (object *op, arch_ptr a)
2498	{
2499	op->animation_id = a->animation_id;
2500	op->flag [FLAG_IS_TURNABLE] = a->flag [FLAG_IS_TURNABLE];
2501	op->flag [FLAG_ANIMATE] = a->flag [FLAG_ANIMATE];
2502	op->anim_speed = a->anim_speed;
2503	op->last_anim = 0;
2504	op->state = 0;
2505	op->face = a->face;
2506
2507	if (NUM_ANIMATIONS(op) > 1)
2508	{
2509	SET_ANIMATION(op, 0);
2510	animate_object (op, op->direction);
2511	}
2512	else
2513	update_object (op, UP_OBJ_FACE);
2514	}
2515
2516	/**
2517	* Apply for LAMPs and TORCHes.
2518	*
2519	* op - the lamp
2520	* switch_on - a flag which says whether the lamp should be switched on or off
2521	*/
2522	void apply_lamp (object *op, bool switch_on)
2523	{
2524	op->set_glow_radius (switch_on ? op->range : 0);
2525	op->set_speed (switch_on ? op->arch->speed : 0);
2526
2527	// torches wear out if you put them out
2528	if (op->type == TORCH && !switch_on)
2529	{
2530	if (op->flag [FLAG_IS_LIGHTABLE])
2531	{
2532	op->stats.food -= (double) op->arch->stats.food / 15;
2533	if (op->stats.food < 0)
2534	op->stats.food = 0;
2535	}
2536	else
2537	op->stats.food = 0;
2538	}
2539
2540	// lamps and torched get worthless when used up
2541	if (op->stats.food <= 0)
2542	op->value = 0;
2543
2544	// FIXME: This is a hack to make the more sane torches and lamps
2545	// still animated ;-/
2546	if (op->other_arch)
2547	get_animation_from_arch (op, switch_on ? op->other_arch : op->arch);
2548
2549	if (object *pl = op->visible_to ())
2550	esrv_update_item (UPD_ANIM | UPD_FACE | UPD_NAME, pl, op);
2551	}
2552
2553	/**
2554	* Main apply handler.
2555	*
2556	* Checks for unpaid items before applying.
2557	*
2558	* Return value:
2559	* 0: player or monster can't apply objects of that type
2560	* 1: has been applied, or there was an error applying the object
2561	* 2: objects of that type can't be applied if not in inventory
2562	*
2563	* who is the object that is causing object to be applied, op is the object
2564	* being applied.
2565	*
2566	* aflag is special (always apply/unapply) flags. Nothing is done with
2567	* them in this function - they are passed to apply_special
2568	*/
2569	int
2570	manual_apply (object *who, object *op, int aflag)
2571	{
2572	op = op->head_ ();
2573
2574	if (QUERY_FLAG (op, FLAG_UNPAID) && !QUERY_FLAG (op, FLAG_APPLIED))
2575	{
2576	if (who->type == PLAYER)
2577	{
2578	examine (who, op);
2579	//who->failmsg ("You should pay for it first! H<You cannot use items marked as unpaid.>");//TODO remove
2580	return 1;
2581	}
2582	else
2583	return 0; /* monsters just skip unpaid items */
2584	}
2585
2586	if (INVOKE_OBJECT (APPLY, op, ARG_OBJECT (who)))
2587	return RESULT_INT (0);
2588
2589	switch (op->type)
2590	{
2591	case CF_HANDLE:
2592	who->play_sound (sound_find ("turn_handle"));
2593	who->statusmsg ("You turn the handle.");
2594	op->value = op->value ? 0 : 1;
2595	SET_ANIMATION (op, op->value);
2596	update_object (op, UP_OBJ_FACE);
2597	push_button (op, who);
2598	return 1;
2599
2600	case TRIGGER:
2601	if (check_trigger (op, who, who))
2602	{
2603	who->statusmsg ("You turn the handle.");
2604	who->play_sound (sound_find ("turn_handle"));
2605	}
2606	else
2607	who->failmsg ("The handle doesn't move.");
2608
2609	return 1;
2610
2611	case EXIT:
2612	if (who->type != PLAYER)
2613	return 0;
2614
2615	if (!EXIT_PATH (op) || !is_legal_2ways_exit (who, op))
2616	who->failmsg (format ("The %s is closed. H<And will stay closed, until somebody fires up the map editor and adds it.>", query_name (op)));
2617	else
2618	{
2619	/* Don't display messages for random maps. */
2620	if (op->msg && !EXIT_PATH (op).starts_with ("/!"))
2621	who->statusmsg (op->msg, NDI_NAVY);
2622
2623	who->enter_exit (op);
2624	}
2625
2626	return 1;
2627
2628	case INSCRIBABLE:
2629	who->statusmsg (op->msg);
2630	// maybe show a spell menu to chose from or something like that
2631	return 1;
2632
2633	case SIGN:
2634	apply_sign (who, op, 0);
2635	return 1;
2636
2637	case BOOK:
2638	if (who->type == PLAYER)
2639	{
2640	apply_book (who, op);
2641	return 1;
2642	}
2643	else
2644	return 0;
2645
2646	case SKILLSCROLL:
2647	if (who->type == PLAYER)
2648	{
2649	apply_skillscroll (who, op);
2650	return 1;
2651	}
2652	else
2653	return 0;
2654
2655	case SPELLBOOK:
2656	if (who->type == PLAYER)
2657	{
2658	apply_spellbook (who, op);
2659	return 1;
2660	}
2661	else
2662	return 0;
2663
2664	case SCROLL:
2665	apply_scroll (who, op, 0);
2666	return 1;
2667
2668	case POTION:
2669	apply_potion (who, op);
2670	return 1;
2671
2672	/* Eneq(@csd.uu.se): Handle apply on containers. */
2673	//TODO: remove, as it is unsed?
2674	case CLOSE_CON:
2675	apply_container (who, op->env);
2676	return 1;
2677
2678	case CONTAINER:
2679	apply_container (who, op);
2680	return 1;
2681
2682	case TREASURE:
2683	if (who->type == PLAYER)
2684	{
2685	apply_treasure (who, op);
2686	return 1;
2687	}
2688	else
2689	return 0;
2690
2691	case LAMP:
2692	case TORCH:
2693	player_apply_lamp (who, op);
2694	return 1;
2695
2696	case WEAPON:
2697	case ARMOUR:
2698	case BOOTS:
2699	case GLOVES:
2700	case AMULET:
2701	case GIRDLE:
2702	case BRACERS:
2703	case SHIELD:
2704	case HELMET:
2705	case RING:
2706	case CLOAK:
2707	case WAND:
2708	case ROD:
2709	case HORN:
2710	case SKILL:
2711	case BOW:
2712	case BUILDER:
2713	case SKILL_TOOL:
2714	if (op->env != who)
2715	return 2; /* not in inventory */
2716
2717	apply_special (who, op, aflag);
2718	return 1;
2719
2720	case DRINK:
2721	case FOOD:
2722	case FLESH:
2723	apply_food (who, op);
2724	return 1;
2725
2726	case POISON:
2727	apply_poison (who, op);
2728	return 1;
2729
2730	case SAVEBED:
2731	return 1;
2732
2733	case ARMOUR_IMPROVER:
2734	if (who->type == PLAYER)
2735	{
2736	apply_armour_improver (who, op);
2737	return 1;
2738	}
2739	else
2740	return 0;
2741
2742	case WEAPON_IMPROVER:
2743	check_improve_weapon (who, op);
2744	return 1;
2745
2746	case CLOCK:
2747	if (who->type == PLAYER)
2748	{
2749	char buf[MAX_BUF];
2750	timeofday_t tod;
2751
2752	get_tod (&tod);
2753	who->play_sound (sound_find ("sound_clock"));
2754	who->statusmsg (format (
2755	"It is %d minute%s past %d o'clock %s",
2756	tod.minute + 1, ((tod.minute + 1 < 2) ? "" : "s"),
2757	((tod.hour % 14 == 0) ? 14 : ((tod.hour) % 14)), ((tod.hour >= 14) ? "pm" : "am")
2758	));
2759	return 1;
2760	}
2761	else
2762	return 0;
2763
2764	case MENU:
2765	if (who->type == PLAYER)
2766	{
2767	shop_listing (op, who);
2768	return 1;
2769	}
2770	else
2771	return 0;
2772
2773	case POWER_CRYSTAL:
2774	apply_power_crystal (who, op); /* see egoitem.c */
2775	return 1;
2776
2777	case LIGHTER: /* for lighting torches/lanterns/etc */
2778	if (who->type == PLAYER)
2779	{
2780	apply_lighter (who, op);
2781	return 1;
2782	}
2783	else
2784	return 0;
2785
2786	case ITEM_TRANSFORMER:
2787	apply_item_transformer (who, op);
2788	return 1;
2789
2790	default:
2791	return 0;
2792	}
2793	}
2794
2795	/* quiet suppresses the "don't know how to apply" and "you must get it first"
2796	* messages as needed by player_apply_below(). But there can still be
2797	* "but you are floating high above the ground" messages.
2798	*
2799	* Same return value as apply() function.
2800	*/
2801	int
2802	player_apply (object *pl, object *op, int aflag, int quiet)
2803	{
2804	if (!op->env && (pl->move_type & MOVE_FLYING))
2805	{
2806	/* player is flying and applying object not in inventory */
2807	if (!QUERY_FLAG (pl, FLAG_WIZ) && !(op->move_type & MOVE_FLYING))
2808	{
2809	pl->failmsg ("But you are floating high above the ground! "
2810	"H<You have to stop levitating first, if you can, either by using your levitation skill, "
2811	"or waiting till the levitation effect wears off.>");
2812	return 0;
2813	}
2814	}
2815
2816	pl->contr->last_used = op;
2817
2818	int tmp = manual_apply (pl, op, aflag);
2819
2820	if (!quiet)
2821	{
2822	if (tmp == 0)
2823	pl->statusmsg (format ("I don't know how to apply the %s.", query_name (op)));
2824	else if (tmp == 2)
2825	pl->failmsg ("You must get it first!\n");
2826	}
2827
2828	return tmp;
2829	}
2830
2831	/**
2832	* player_apply_below attempts to apply the object 'below' the player.
2833	* If the player has an open container, we use that for below, otherwise
2834	* we use the ground.
2835	*/
2836	void
2837	player_apply_below (object *pl)
2838	{
2839	int floors = 0;
2840
2841	/* If using a container, set the starting item to be the top
2842	* item in the container. Otherwise, use the map.
2843	* This is perhaps more complicated. However, I want to make sure that
2844	* we don't use a corrupt pointer for the next object, so we get the
2845	* next object in the stack before applying. This is can only be a
2846	* problem if player_apply() has a bug in that it uses the object but does
2847	* not return a proper value.
2848	*/
2849	for (object *next, *tmp = pl->container ? pl->container->inv : pl->below; tmp; tmp = next)
2850	{
2851	next = tmp->below;
2852
2853	if (QUERY_FLAG (tmp, FLAG_IS_FLOOR))
2854	floors++;
2855	else if (floors > 0)
2856	return; /* process only floor objects after first floor object */
2857
2858	/* If it is visible, player can apply it. If it is applied by
2859	* person moving on it, also activate. Added code to make it
2860	* so that at least one of players movement types be that which
2861	* the item needs.
2862	*/
2863	if (!tmp->invisible || (tmp->move_on & pl->move_type))
2864	if (player_apply (pl, tmp, 0, 1) == 1)
2865	return;
2866
2867	if (floors >= 2)
2868	return; /* process at most two floor objects */
2869	}
2870	}
2871
2872	/**
2873	* Unapplies specified item.	1024	* Unapplies specified item.
2874	* No check done on cursed/damned.	1025	* No check done on cursed/damned.
2875	* Break this out of apply_special - this is just done	1026	* Break this out of apply_special - this is just done
2876	* to keep the size of apply_special to a more managable size.	1027	* to keep the size of apply_special to a more managable size.
2877	*/	1028	*/
2878	static int	1029	static bool
2879	unapply_special (object *who, object *op, int aflags)	1030	unapply_special (object *who, object *op, int aflags)
2880	{	1031	{
2881	if (INVOKE_OBJECT (BE_UNREADY, op, ARG_OBJECT (who), ARG_INT (aflags))	1032	if (INVOKE_OBJECT (BE_UNREADY, op, ARG_OBJECT (who), ARG_INT (aflags))
2882	|| INVOKE_OBJECT (UNREADY, who, ARG_OBJECT (op), ARG_INT (aflags)))	1033	|| INVOKE_OBJECT (UNREADY, who, ARG_OBJECT (op), ARG_INT (aflags)))
2883	return RESULT_INT (0);	1034	return RESULT_INT (0);
2884		1035
2885	CLEAR_FLAG (op, FLAG_APPLIED);	1036	if (who->current_weapon == op)
		1037	who->current_weapon = 0;
		1038
		1039	op->flag [FLAG_APPLIED] = false;
2886		1040
2887	switch (op->type)	1041	switch (op->type)
2888	{	1042	{
2889	case SKILL_TOOL:	1043	case SKILL:
		1044	if (player *pl = who->contr)
		1045	if (op->invisible)
		1046	pl->statusmsg (format ("You can no longer use the %s skill.", &op->skill));
		1047	else
		1048	pl->statusmsg (format ("You stop using the %s.", query_name (op)));
		1049
		1050	change_abil (who, op);
		1051	who->flag [FLAG_READY_SKILL] = false;
		1052	break;
		1053
		1054	case WEAPON:
		1055	who->statusmsg (format ("You unwield %s.", query_name (op)));
		1056	change_abil (who, op);
		1057	who->flag [FLAG_READY_WEAPON] = false;
		1058
2890	// unapplying a skill tool should also unapply the skill it governs	1059	// unapplying a weapon or skill tool should also unapply the skill it governs
2891	// but this is hard, as it shouldn't do so when the skill can	1060	// but this is hard, as it shouldn't do so when the skill can
2892	// be used for other reasons	1061	// be used for other reasons
2893	for (object *tmp = who->inv; tmp; tmp = tmp->below)	1062	if (who->chosen_skill)
2894	if (tmp->skill == op->skill	1063	if (!who->chosen_skill->flag [FLAG_CAN_USE_SKILL])
2895	&& tmp->type == SKILL
2896	&& tmp->flag [FLAG_APPLIED]
2897	&& !tmp->flag [FLAG_CAN_USE_SKILL])
2898	unapply_special (who, tmp, 0);	1064	unapply_special (who, op, 0);
2899		1065
2900	change_abil (who, op);
2901	break;	1066	break;
2902		1067
		1068	case BOW:
2903	case WEAPON:	1069	case WAND:
		1070	case ROD:
		1071	case HORN:
		1072	case RANGED:
2904	if (player *pl = who->contr)	1073	if (player *pl = who->contr)
2905	if (op == pl->combat_ob)
2906	{
2907	pl->combat_ob = 0;
2908	who->change_weapon (pl->ranged_ob);
2909	}
2910
2911	who->statusmsg (format ("You unwield %s.", query_name (op)));
2912
2913	change_abil (who, op);
2914	CLEAR_FLAG (who, FLAG_READY_WEAPON);
2915	break;
2916
2917	case SKILL:
2918	if (who->contr)
2919	{	1074	{
2920	if (IS_COMBAT_SKILL (op->subtype))	1075	who->statusmsg (format ("You unready %s.", query_name (op)));
2921	who->change_weapon (who->contr->combat_ob = 0);	1076	change_abil (who, op);
2922	else if (IS_RANGED_SKILL (op->subtype))	1077	}
2923	who->change_weapon (who->contr->ranged_ob = 0);	1078	else
		1079	{
		1080	who->change_skill (0);
2924		1081
2925	if (op->invisible)	1082	if (op->type == BOW)
2926	who->statusmsg (format ("You can no longer use the skill: %s.", &op->skill));	1083	op->flag [FLAG_READY_BOW ] = false;
2927	else	1084	else
2928	who->statusmsg (format ("You stop using the %s.", query_name (op)));	1085	op->flag [FLAG_READY_RANGE] = false;
2929	}	1086	}
2930		1087
2931	change_abil (who, op);
2932	CLEAR_FLAG (who, FLAG_READY_SKILL);
2933	break;	1088	break;
2934		1089
2935	case ARMOUR:	1090	case ARMOUR:
2936	case HELMET:	1091	case HELMET:
2937	case SHIELD:	1092	case SHIELD:
…		…
2944	case CLOAK:	1099	case CLOAK:
2945	who->statusmsg (format ("You unwear %s.", query_name (op)));	1100	who->statusmsg (format ("You unwear %s.", query_name (op)));
2946	change_abil (who, op);	1101	change_abil (who, op);
2947	break;	1102	break;
2948		1103
		1104	case SPELL:
2949	case BOW:	1105	case BUILDER:
2950	case WAND:
2951	case ROD:
2952	case HORN:
2953	if (player *pl = who->contr)
2954	{
2955	if (op == pl->ranged_ob)
2956	{
2957	pl->ranged_ob = 0;
2958	who->change_weapon (pl->combat_ob);
2959	}
2960
2961	who->statusmsg (format ("You unready %s.", query_name (op)));	1106	who->statusmsg (format ("You unready %s.", query_name (op)));
2962	}
2963	else
2964	{
2965	who->change_skill (0);
2966
2967	if (op->type == BOW)
2968	CLEAR_FLAG (who, FLAG_READY_BOW);
2969	else
2970	CLEAR_FLAG (who, FLAG_READY_RANGE);
2971	}
2972
2973	break;	1107	break;
2974		1108
2975	case BUILDER:	1109	//case SKILL_TOOL://TODO
2976	if (who->contr)
2977	who->statusmsg (format ("You unready %s.", query_name (op)));
2978	break;
2979
2980	default:	1110	default:
2981	who->statusmsg (format ("You unapply %s.", query_name (op)));	1111	who->statusmsg (format ("You unapply %s.", query_name (op)));
2982	break;	1112	break;
2983	}	1113	}
2984		1114
…		…
2986	if (object *pl = op->visible_to ())	1116	if (object *pl = op->visible_to ())
2987	esrv_send_item (pl, op);	1117	esrv_send_item (pl, op);
2988		1118
2989	who->update_stats ();	1119	who->update_stats ();
2990		1120
2991	return 0;	1121	return 1;
2992	}	1122	}
2993		1123
2994	/**	1124	/**
2995	* Returns the object that is using location 'loc'.	1125	* Returns the object that is using location 'loc'.
2996	* Note that 'start' is the first object to start examing - we	1126	* Note that 'start' is the first object to start examing - we
…		…
3008	static object *	1138	static object *
3009	get_next_item_from_body_location (int loc, object *start)	1139	get_next_item_from_body_location (int loc, object *start)
3010	{	1140	{
3011	for (object *tmp = start; tmp; tmp = tmp->below)	1141	for (object *tmp = start; tmp; tmp = tmp->below)
3012	if (tmp->flag [FLAG_APPLIED]	1142	if (tmp->flag [FLAG_APPLIED]
3013	&& tmp->slot[loc].info	1143	&& tmp->slot [loc].info
3014	&& (!tmp->invisible || tmp->type == SKILL))	1144	&& (!tmp->invisible || tmp->type == SKILL || tmp->type == SPELL))
3015	return tmp;	1145	return tmp;
3016		1146
3017	return 0;	1147	return 0;
3018	}	1148	}
3019		1149
…		…
3032	#define CANNOT_REMOVE_CURSED \	1162	#define CANNOT_REMOVE_CURSED \
3033	"H<You cannot remove cursed or damned items, you first have to remove the curse. " \	1163	"H<You cannot remove cursed or damned items, you first have to remove the curse. " \
3034	"Praying over an altar, scrolls of remove curse/damnation, " \	1164	"Praying over an altar, scrolls of remove curse/damnation, " \
3035	"priests or even other players might help.>"	1165	"priests or even other players might help.>"
3036		1166
3037	int	1167	static bool
3038	unapply_for_ob (object *who, object *op, int aflags)	1168	unapply_for_ob (object *who, object *op, int aflags)
3039	{	1169	{
3040	if (op->is_range ())	1170	if (op->is_range ())
3041	for (object *tmp = who->inv; tmp; tmp = tmp->below)	1171	for (object *tmp = who->inv; tmp; tmp = tmp->below)
3042	if (QUERY_FLAG (tmp, FLAG_APPLIED) && tmp->is_range ())	1172	if (QUERY_FLAG (tmp, FLAG_APPLIED) && tmp->is_range ())
…		…
3164	continue;	1294	continue;
3165	}	1295	}
3166		1296
3167	object *tmp1 = get_next_item_from_body_location (i, who->inv);	1297	object *tmp1 = get_next_item_from_body_location (i, who->inv);
3168	if (!tmp1)	1298	if (!tmp1)
3169	{
3170	#if 0
3171	/* This is sort of an error, but happens a lot when old players
3172	* join in with more stuff equipped than they are now allowed.
3173	*/
3174	LOG (llevError, "Can't find object using location %d on %s\n", i, who->name);
3175	#endif
3176	retval |= CAN_APPLY_NEVER;	1299	retval |= CAN_APPLY_NEVER;
3177	}
3178	else	1300	else
3179	{	1301	{
3180	/* need to unapply something. However, if this something	1302	/* need to unapply something. However, if this something
3181	* is different than we had found before, it means they need	1303	* is different than we had found before, it means they need
3182	* to apply multiple objects	1304	* to apply multiple objects
…		…
3262	*/	1384	*/
3263		1385
3264	#define LACK_ITEM_POWER \	1386	#define LACK_ITEM_POWER \
3265	" H<You lack enough unused item power to use this weapon, see the skills command.>"	1387	" H<You lack enough unused item power to use this weapon, see the skills command.>"
3266		1388
3267	int	1389	static bool
3268	apply_special (object *who, object *op, int aflags)	1390	apply_special (object *who, object *op, int aflags)
3269	{	1391	{
3270	int basic_flag = aflags & AP_BASIC_FLAGS;	1392	int basic_flag = aflags & AP_MODE;
3271	object *tmp, *tmp2, *skop = NULL;	1393	object *tmp, *tmp2, *skop = NULL;
3272		1394
3273	if (who == NULL)	1395	if (who == NULL)
3274	{	1396	{
3275	LOG (llevError, "apply_special() from object without environment.\n");	1397	LOG (llevError, "apply_special() from object without environment.\n");
3276	return 1;	1398	return 1;
3277	}	1399	}
3278		1400
		1401	//TODO: remove these when apply_special is no longer exposed
3279	if (op->env != who)	1402	if (op->env != who)
3280	return 1; /* op is not in inventory */	1403	return 1; /* op is not in inventory */
3281		1404
3282	/* trying to unequip op */	1405	/* trying to unequip op */
3283	if (QUERY_FLAG (op, FLAG_APPLIED))	1406	if (QUERY_FLAG (op, FLAG_APPLIED))
…		…
3294		1417
3295	return unapply_special (who, op, aflags);	1418	return unapply_special (who, op, aflags);
3296	}	1419	}
3297	else if (basic_flag == AP_UNAPPLY)	1420	else if (basic_flag == AP_UNAPPLY)
3298	return 0;	1421	return 0;
3299
3300	// if the item is combat/ranged, wield the relevant slot first
3301	// to resolve conflicts.
3302	if (player *pl = who->contr)
3303	switch (op->slottype ())
3304	{
3305	case slot_combat: who->change_weapon (pl->combat_ob); break;
3306	case slot_ranged: who->change_weapon (pl->ranged_ob); break;
3307	}
3308		1422
3309	splay (op);	1423	splay (op);
3310		1424
3311	/* Can't just apply this object. Lets see what not and what to do */	1425	/* Can't just apply this object. Lets see what not and what to do */
3312	if (int i = can_apply_object (who, op))	1426	if (int i = can_apply_object (who, op))
…		…
3346	}	1460	}
3347	}	1461	}
3348		1462
3349	if (op->skill && op->type != SKILL && op->type != SKILL_TOOL)	1463	if (op->skill && op->type != SKILL && op->type != SKILL_TOOL)
3350	{	1464	{
		1465	// try to ready attached skill first
3351	skop = find_skill_by_name (who, op->skill);	1466	skop = find_skill_by_name (who, op->skill);
3352		1467
3353	if (!skop)	1468	if (!skop)
3354	{	1469	{
3355	who->failmsg (format ("You need the %s skill to use this item!", &op->skill));	1470	who->failmsg (format ("You need the %s skill to use this item!", &op->skill));
3356	return 1;	1471	return 1;
3357	}	1472	}
3358	else	1473	else if (!who->apply (skop, AP_APPLY | AP_NO_SLOT))
3359	/* While experience will be credited properly, we want to change the
3360	* skill so that the dam and wc get updated
3361	*/	1474	{
3362	who->change_skill (skop);	1475	who->failmsg (format ("You can't use the required %s skill!", &op->skill));
		1476	return 1;
		1477	}
3363	}	1478	}
3364		1479
3365	if (!check_item_power (who, op->item_power))	1480	if (!check_item_power (who, op->item_power))
3366	{	1481	{
3367	who->failmsg ("Equipping that combined with other items would consume your soul!" LACK_ITEM_POWER);	1482	who->failmsg ("Equipping that combined with other items would consume your soul!" LACK_ITEM_POWER);
…		…
3370		1485
3371	/* Ok. We are now at the state where we can apply the new object.	1486	/* Ok. We are now at the state where we can apply the new object.
3372	* Note that we don't have the checks for can_use_...	1487	* Note that we don't have the checks for can_use_...
3373	* below - that is already taken care of by can_apply_object.	1488	* below - that is already taken care of by can_apply_object.
3374	*/	1489	*/
		1490
		1491	// split away all the other items from the stack, so only one item is left
3375	tmp = op->nrof > 1 ? op->split (op->nrof - 1) : 0;	1492	tmp = op->nrof > 1 ? op->split (op->nrof - 1) : 0;
3376		1493
3377	if (INVOKE_OBJECT (BE_READY, op, ARG_OBJECT (who)) || INVOKE_OBJECT (READY, who, ARG_OBJECT (op)))	1494	if (INVOKE_OBJECT (BE_READY, op, ARG_OBJECT (who)) || INVOKE_OBJECT (READY, who, ARG_OBJECT (op)))
3378	return RESULT_INT (0);	1495	return RESULT_INT (0);
3379		1496
3380	switch (op->type)	1497	switch (op->type)
3381	{	1498	{
3382	case WEAPON:	1499	case WEAPON:
3383	//TODO: this obviously fails for players using a shorter prefix	1500	if (op->level && (!op->name.starts_with (who->name) || op->name [who->name.length ()] != '\''))
3384	// i.e. "R" can use Ragnarok's sword.
3385	if (op->level && !op->name.starts_with (who->name))
3386	{	1501	{
3387	/* if the weapon does not have the name as the character, can't use it. */	1502	/* if the weapon does not have the name as the character, can't use it. */
3388	/* (Ragnarok's sword attempted to be used by Foo: won't work) */	1503	/* (Ragnarok's sword attempted to be used by Foo: won't work) */
3389	who->failmsg ("The weapon does not recognize you as its owner. H<Its name indicates that it belongs to somebody else.>");	1504	who->failmsg ("The weapon does not recognize you as its owner. "
3390		1505	"H<Its name indicates that it belongs to somebody else.>");
3391	if (tmp)	1506	if (tmp) who->insert (tmp);
3392	insert_ob_in_ob (tmp, who);
3393
3394	return 1;	1507	return 1;
3395	}	1508	}
3396		1509
3397	if (!skop)	1510	op->flag [FLAG_APPLIED] = true;
		1511
		1512	if (player *pl = who->contr)
3398	{	1513	{
3399	who->failmsg (format ("The %s is broken, please report this to the dungeon master!", query_name (op)));//TODO	1514	who->statusmsg (format ("You wield %s.", query_name (op)));
3400	return 1;	1515	change_abil (who, op);
3401	}	1516	}
3402		1517	else
3403	SET_FLAG (op, FLAG_APPLIED);
3404	who->change_skill (skop);	1518	who->change_skill (skop);
3405		1519
3406	if (who->contr)	1520	op->flag [FLAG_READY_WEAPON] = true;
3407	who->change_weapon (who->contr->combat_ob = op);
3408
3409	who->statusmsg (format ("You wield %s.", query_name (op)));
3410
3411	SET_FLAG (who, FLAG_READY_WEAPON);
3412	change_abil (who, op);
3413	break;	1521	break;
3414		1522
3415	case ARMOUR:	1523	case ARMOUR:
3416	case HELMET:	1524	case HELMET:
3417	case SHIELD:	1525	case SHIELD:
…		…
3426	who->statusmsg (format ("You wear %s.", query_name (op)));	1534	who->statusmsg (format ("You wear %s.", query_name (op)));
3427	change_abil (who, op);	1535	change_abil (who, op);
3428	break;	1536	break;
3429		1537
3430	case SKILL_TOOL:	1538	case SKILL_TOOL:
3431	// applying a skill tool also readies the skill	1539	// applying a skill tool does not ready the skill
		1540	// if something needs the skill, it has to ready it itself
		1541	//TODO: unapplying should unapply the skill, though
3432	SET_FLAG (op, FLAG_APPLIED);	1542	SET_FLAG (op, FLAG_APPLIED);
		1543	break;
3433		1544
		1545	case SKILL:
3434	if (!(aflags & AP_NO_READY))	1546	if (!(aflags & AP_NO_SLOT))
3435	{	1547	{
3436	skop = find_skill_by_name (who, op->skill);	1548	// skill is used on it's own, as opposed to being a chosen_skill
3437	if (!skop->flag [FLAG_APPLIED])
3438	apply_special (who, skop, AP_APPLY);
3439	}
3440	break;
3441		1549
3442	case SKILL:	1550	if (skill_flags [op->subtype] & (SF_NEED_ITEM | SF_MANA))
3443	if (player *pl = who->contr)
3444	{
3445	if (IS_COMBAT_SKILL (op->subtype))
3446	{	1551	{
3447	if (skill_flags [op->subtype] & SF_NEED_WEAPON)
3448	{
3449	for (object *item = who->inv; item; item = item->below)
3450	if (item->type == WEAPON && item->flag [FLAG_APPLIED])
3451	{
3452	if (item->skill == op->skill)
3453	{
3454	who->change_weapon (pl->combat_ob = item);
3455	goto found_weapon;
3456	}
3457	}
3458
3459	who->failmsg (format (	1552	who->failmsg (format (
3460	"You need to apply a '%s' melee weapon before readying this skill. "	1553	"You feel as if you wanted to do something funny, but you can't remember what. "
3461	"H<Some skills need an item, in this case a melee weapon, to function.>",	1554	"H<The %s skill needs something else to function, for example a tool, weapon, rod, or spell. "
3462	&op->skill	1555	"It cannot be used on its own.>",
3463	));
3464	return 1;
3465
3466	found_weapon:;
3467	}
3468	else
3469	who->change_weapon (pl->combat_ob = op);
3470	}
3471	else if (IS_RANGED_SKILL (op->subtype))
3472	{
3473	if (skill_flags [op->subtype] & SF_NEED_BOW)
3474	{
3475	for (object *item = who->inv; item; item = item->below)
3476	if (item->type == BOW && item->flag [FLAG_APPLIED])
3477	{
3478	//TODO: bows should/must all have skill missile weapon right now
3479	who->change_weapon (pl->ranged_ob = item);
3480	goto found_bow;
3481	}
3482
3483	who->failmsg (
3484	"You need to apply a missile weapon before readying this skill. "
3485	"H<Some skills need an item, in this case a missile weapon, to function.>"
3486	);
3487	return 1;
3488
3489	found_bow:;
3490	}
3491	else
3492	who->change_weapon (pl->ranged_ob = op);
3493	}
3494
3495	if (!op->invisible)
3496	{
3497	who->statusmsg (format (
3498	"You ready %s."
3499	"You can now use the skill: %s.",
3500	query_name (op),
3501	&op->skill	1556	&op->skill
3502	));	1557	));
		1558	if (tmp) who->insert (tmp);
		1559	return 1;
3503	}	1560	}
		1561
		1562	if (skill_flags [op->subtype] & SF_AUTARK
		1563	|| !(skill_flags [op->subtype] & (SF_COMBAT | SF_RANGED)))
		1564	{
		1565	if (skill_flags [op->subtype] & SF_USE)
		1566	who->failmsg (format (
		1567	"You feel as if you wanted to do something funny, but you can't remember what. "
		1568	"H<The %s skill cannot be readied, instead, try C<use_skill %s>.>",
		1569	&op->skill, &op->skill
		1570	));
		1571	else
		1572	who->failmsg (format (
		1573	"You feel as if you wanted to do something funny, but you can't remember what. "
		1574	"H<The %s skill cannot be readied or used, it is always active.>",
		1575	&op->skill
		1576	));
		1577
		1578	if (tmp) who->insert (tmp);
		1579
		1580	return 1;
		1581	}
		1582
		1583	if (who->contr)
		1584	if (op->invisible)
		1585	who->statusmsg (format ("You can now use the %s skill.", &op->skill));
3504	else	1586	else
3505	who->statusmsg (format ("Readied skill: %s.", op->skill ? &op->skill : &op->name));	1587	who->statusmsg (format ("You ready %s.", query_name (op)));
3506	}	1588	}
3507	else	1589
3508	{
3509	SET_FLAG (op, FLAG_APPLIED);
3510	change_abil (who, op);
3511	who->chosen_skill = op;
3512	SET_FLAG (who, FLAG_READY_SKILL);	1590	SET_FLAG (who, FLAG_READY_SKILL);
3513	}	1591	SET_FLAG (op, FLAG_APPLIED);
3514		1592	change_abil (who, op);
3515	break;	1593	break;
3516		1594
3517	case BOW:	1595	case BOW:
3518	if (op->level && !op->name.starts_with (who->name))	1596	if (op->level && (!op->name.starts_with (who->name) || op->name [who->name.length ()] != '\''))
3519	{	1597	{
3520	who->failmsg ("The weapon does not recognize you as its owner. "	1598	who->failmsg ("The weapon does not recognize you as its owner. "
3521	"H<Its name indicates that it belongs to somebody else.>");	1599	"H<Its name indicates that it belongs to somebody else.>");
3522	if (tmp)	1600	if (tmp) who->insert (tmp);
3523	insert_ob_in_ob (tmp, who);
3524
3525	return 1;	1601	return 1;
3526	}	1602	}
		1603
		1604	if (player *pl = who->contr)
		1605	{
		1606	op->flag [FLAG_APPLIED] = true;
		1607	who->statusmsg (format ("You wield the %s.", query_name (op)));
		1608	change_abil (who, op);
		1609	}
		1610	break;
		1611
		1612	case RANGED:
		1613	if (player *pl = who->contr)
		1614	{
		1615	op->flag [FLAG_APPLIED] = true;
		1616	who->statusmsg (format ("You applied the %s.", query_name (op)));
		1617	}
		1618	break;
		1619
		1620	case SPELL:
		1621	if (player *pl = who->contr)
		1622	{
		1623	op->flag [FLAG_APPLIED] = true;
		1624	who->statusmsg (format ("You ready the spell %s.", query_name (op)));
		1625	}
		1626	break;
3527		1627
3528	/*FALLTHROUGH*/	1628	/*FALLTHROUGH*/
3529	case WAND:	1629	case WAND:
3530	case ROD:	1630	case ROD:
3531	case HORN:	1631	case HORN:
3532	/* check for skill, alter player status */	1632	/* check for skill, alter player status */
3533		1633
3534	if (!skop)	1634	if (!skop)
3535	{	1635	{
3536	who->failmsg (format ("The %s is broken, please report this to the dungeon master!", query_name (op)));//TODO	1636	who->failmsg (format ("The %s is broken, please report this to the dungeon master!", query_name (op)));//TODO
		1637	if (tmp) who->insert (tmp);
3537	return 1;	1638	return 1;
3538	}	1639	}
3539		1640
3540	SET_FLAG (op, FLAG_APPLIED);	1641	op->flag [FLAG_APPLIED] = true;
3541	who->change_skill (skop);
3542		1642
3543	if (who->contr)	1643	if (player *pl = who->contr)
3544	{	1644	{
3545	who->contr->ranged_ob = op;
3546
3547	who->statusmsg (format ("You ready %s.", query_name (op)));	1645	who->statusmsg (format ("You ready %s.", query_name (op)));
3548		1646
3549	if (op->type == BOW)	1647	if (op->type == BOW)
3550	{
3551	who->current_weapon = op;
3552	change_abil (who, op);
3553	who->statusmsg (format ("You will now fire %s with %s.", op->race ? &op->race : "nothing", query_name (op)));	1648	who->statusmsg (format ("You will now fire %s with %s.", op->race ? &op->race : "nothing", query_name (op)));
3554	}	1649
		1650	change_abil (who, op);
3555	}	1651	}
3556	else	1652	else
3557	{	1653	{
		1654	who->change_skill (skop);
		1655
3558	if (op->type == BOW)	1656	if (op->type == BOW)
3559	SET_FLAG (who, FLAG_READY_BOW);	1657	op->flag [FLAG_READY_BOW ] = true;
3560	else	1658	else
3561	SET_FLAG (who, FLAG_READY_RANGE);	1659	op->flag [FLAG_READY_RANGE] = true;
3562	}	1660	}
3563		1661
3564	break;	1662	break;
3565		1663
3566	case BUILDER:	1664	case BUILDER:
3567	if (who->type == PLAYER)	1665	if (player *pl = who->contr)
3568	{	1666	{
3569	//TODO: wtf does this do? shouldn't this be managed automatically (slots?)
3570	if (who->contr->ranged_ob && who->contr->ranged_ob->type == BUILDER)
3571	unapply_special (who, who->contr->ranged_ob, 0);
3572
3573	who->statusmsg (format ("You ready your %s.", query_name (op)));	1667	who->statusmsg (format ("You ready your %s.", query_name (op)));
3574		1668	//TODO: change_abil?
3575	who->contr->ranged_ob = op;
3576	}	1669	}
3577	break;	1670	break;
3578		1671
3579	default:	1672	default:
3580	who->statusmsg (format ("You apply %s.", query_name (op)));	1673	who->statusmsg (format ("You apply %s.", query_name (op)));
3581	}	1674	}
3582		1675
3583	SET_FLAG (op, FLAG_APPLIED);	1676	SET_FLAG (op, FLAG_APPLIED);
3584		1677
3585	if (tmp)
3586	who->insert (tmp);	1678	if (tmp) who->insert (tmp);
3587		1679
3588	who->update_stats ();	1680	who->update_stats ();
3589		1681
3590	/* We exclude spell casting objects. The fire code will set the	1682	/* We exclude spell casting objects. The fire code will set the
3591	* been applied flag when they are used - until that point,	1683	* been applied flag when they are used - until that point,
…		…
3608	esrv_send_item (pl, op);	1700	esrv_send_item (pl, op);
3609		1701
3610	return 0;	1702	return 0;
3611	}	1703	}
3612		1704
		1705	/**
		1706	* Check if op should abort moving victim because of it's race or slaying.
		1707	* Returns 1 if it should abort, returns 0 if it should continue.
		1708	*/
3613	int	1709	int
3614	monster_apply_special (object *who, object *op, int aflags)	1710	should_director_abort (object *op, object *victim)
3615	{	1711	{
3616	if (QUERY_FLAG (op, FLAG_UNPAID) && !QUERY_FLAG (op, FLAG_APPLIED))	1712	int arch_flag, name_flag, race_flag;
		1713
		1714	/* Get flags to determine what of arch, name, and race should be checked.
		1715	* This is stored in subtype, and is a bitmask, the LSB is the arch flag,
		1716	* the next is the name flag, and the last is the race flag. Also note,
		1717	* if subtype is set to zero, that also goes to defaults of all affecting
		1718	* it. Examples:
		1719	* subtype 1: only arch
		1720	* subtype 3: arch or name
		1721	* subtype 5: arch or race
		1722	* subtype 7: all three
		1723	*/
		1724	if (op->subtype)
		1725	{
		1726	arch_flag = op->subtype & 1;
		1727	name_flag = op->subtype & 2;
		1728	race_flag = op->subtype & 4;
		1729	}
		1730	else
		1731	{
		1732	arch_flag = 1;
		1733	name_flag = 1;
		1734	race_flag = 1;
		1735	}
		1736
		1737	/* If the director has race set, only affect objects with a arch,
		1738	* name or race that matches.
		1739	*/
		1740	if ((op->race) &&
		1741	((!(victim->arch && arch_flag && victim->arch->archname) || op->race != victim->arch->archname)) &&
		1742	((!(victim->name && name_flag) || op->race != victim->name)) &&
		1743	((!(victim->race && race_flag) || op->race != victim->race)))
3617	return 1;	1744	return 1;
3618		1745
		1746	/* If the director has slaying set, only affect objects where none
		1747	* of arch, name, or race match.
		1748	*/
		1749	if ((op->slaying) && (((victim->arch && arch_flag && victim->arch->archname && op->slaying == victim->arch->archname))) ||
		1750	((victim->name && name_flag && op->slaying == victim->name)) ||
		1751	((victim->race && race_flag && op->slaying == victim->race)))
		1752	return 1;
		1753
		1754	return 0;
		1755	}
		1756
		1757	/**
		1758	* This handles a player dropping money on an altar to identify stuff.
		1759	* It'll identify marked item, if none all items up to dropped money.
		1760	* Return value: 1 if money was destroyed, 0 if not.
		1761	*/
		1762	static int
		1763	apply_id_altar (object *money, object *altar, object *pl)
		1764	{
		1765	dynbuf_text &buf = msg_dynbuf; buf.clear ();
		1766
		1767	if (!pl || pl->type != PLAYER)
		1768	return 0;
		1769
		1770	/* Check for MONEY type is a special hack - it prevents 'nothing needs
		1771	* identifying' from being printed out more than it needs to be.
		1772	*/
		1773	if (!check_altar_sacrifice (altar, money, pl) || money->type != MONEY)
		1774	return 0;
		1775
		1776	/* if the player has a marked item, identify that if it needs to be
		1777	* identified. If it doesn't, then go through the player inventory.
		1778	*/
		1779	if (object *marked = find_marked_object (pl))
		1780	if (!QUERY_FLAG (marked, FLAG_IDENTIFIED) && need_identify (marked))
		1781	{
		1782	if (operate_altar (altar, &money, pl))
		1783	{
		1784	identify (marked);
		1785
		1786	buf.printf ("You have %s.\r", long_desc (marked, pl));
		1787	if (marked->msg)
		1788	buf << "The item has a story:\r" << marked->msg << "\n\n";
		1789
		1790	return !money;
		1791	}
		1792	}
		1793
		1794	for (object *id = pl->inv; id; id = id->below)
		1795	{
		1796	if (!QUERY_FLAG (id, FLAG_IDENTIFIED) && !id->invisible && need_identify (id))
		1797	{
		1798	if (operate_altar (altar, &money, pl))
		1799	{
		1800	identify (id);
		1801
		1802	buf.printf ("You have %s.\r", long_desc (id, pl));
		1803	if (id->msg)
		1804	buf << "The item has a story:\r" << id->msg << "\n\n";
		1805
		1806	/* If no more money, might as well quit now */
		1807	if (!money || !check_altar_sacrifice (altar, money))
		1808	break;
		1809	}
		1810	else
		1811	{
		1812	LOG (llevError, "check_id_altar: Couldn't do sacrifice when we should have been able to\n");
		1813	break;
		1814	}
		1815	}
		1816	}
		1817
		1818	if (buf.empty ())
		1819	pl->failmsg ("You have nothing that needs identifying");
		1820	else
		1821	pl->contr->infobox (MSG_CHANNEL ("identify"), buf);
		1822
		1823	return !money;
		1824	}
		1825
		1826	/**
		1827	* This checks whether the object has a "on_use_yield" field, and if so generated and drops
		1828	* matching item.
		1829	**/
		1830	void
		1831	handle_apply_yield (object *tmp)
		1832	{
		1833	if (shstr_tmp yield = tmp->kv (shstr_on_use_yield))
		1834	archetype::get (yield)->insert_at (tmp, tmp, INS_BELOW_ORIGINATOR);
		1835	}
		1836
		1837	/**
		1838	* Handles applying a potion.
		1839	*/
		1840	int
		1841	apply_potion (object *op, object *tmp)
		1842	{
		1843	int got_one = 0, i;
		1844	object *force = 0;
		1845
		1846	object *floor = GET_MAP_OB (op->map, op->x, op->y);
		1847
		1848	if (get_map_flags (op->map, NULL, op->x, op->y, NULL, NULL) & P_SAFE)
		1849	{
		1850	op->failmsg ("Gods prevent you from using this here, it's sacred ground!");
		1851
		1852	CLEAR_FLAG (tmp, FLAG_APPLIED);
		1853	return 0;
		1854	}
		1855
		1856	if (op->type == PLAYER)
		1857	if (!QUERY_FLAG (tmp, FLAG_IDENTIFIED))
		1858	identify (tmp);
		1859
		1860	handle_apply_yield (tmp);
		1861
		1862	/* Potion of restoration - only for players */
		1863	if (op->type == PLAYER && (tmp->attacktype & AT_DEPLETE))
		1864	{
		1865	object *depl;
		1866	archetype *at;
		1867
		1868	if (QUERY_FLAG (tmp, FLAG_CURSED) || QUERY_FLAG (tmp, FLAG_DAMNED))
		1869	{
		1870	op->drain_stat ();
		1871	op->update_stats ();
		1872	tmp->decrease ();
		1873	return 1;
		1874	}
		1875
		1876	if (!(at = archetype::find (shstr_depletion)))
		1877	{
		1878	LOG (llevError, "Could not find archetype depletion\n");
		1879	return 0;
		1880	}
		1881
		1882	depl = present_arch_in_ob (at, op);
		1883
		1884	if (depl)
		1885	{
		1886	for (i = 0; i < NUM_STATS; i++)
		1887	if (depl->stats.stat (i))
		1888	op->statusmsg (restore_msg[i]);
		1889
		1890	depl->destroy ();
		1891	op->update_stats ();
		1892	}
		1893	else
		1894	op->statusmsg ("Your potion had no effect.");
		1895
		1896	tmp->decrease ();
		1897	return 1;
		1898	}
		1899
		1900	/* improvement potion - only for players */
		1901	if (op->type == PLAYER && (tmp->attacktype & AT_GODPOWER))
		1902	{
		1903	for (i = 1; i < min (11, op->level); i++)
		1904	{
		1905	if (QUERY_FLAG (tmp, FLAG_CURSED) || QUERY_FLAG (tmp, FLAG_DAMNED))
		1906	{
		1907	if (op->contr->levhp[i] != 1)
		1908	{
		1909	op->contr->levhp[i] = 1;
		1910	break;
		1911	}
		1912
		1913	if (op->contr->levsp[i] != 1)
		1914	{
		1915	op->contr->levsp[i] = 1;
		1916	break;
		1917	}
		1918
		1919	if (op->contr->levgrace[i] != 1)
		1920	{
		1921	op->contr->levgrace[i] = 1;
		1922	break;
		1923	}
		1924	}
		1925	else
		1926	{
		1927	if (op->contr->levhp[i] < 9)
		1928	{
		1929	op->contr->levhp[i] = 9;
		1930	break;
		1931	}
		1932
		1933	if (op->contr->levsp[i] < 6)
		1934	{
		1935	op->contr->levsp[i] = 6;
		1936	break;
		1937	}
		1938
		1939	if (op->contr->levgrace[i] < 3)
		1940	{
		1941	op->contr->levgrace[i] = 3;
		1942	break;
		1943	}
		1944	}
		1945	}
		1946
		1947	/* Just makes checking easier */
		1948	if (i < min (11, op->level))
		1949	got_one = 1;
		1950
		1951	if (!QUERY_FLAG (tmp, FLAG_CURSED) && !QUERY_FLAG (tmp, FLAG_DAMNED))
		1952	{
		1953	if (got_one)
		1954	{
		1955	op->update_stats ();
		1956	op->statusmsg ("The Gods smile upon you and remake you "
		1957	"a little more in their image. "
		1958	"You feel a little more perfect.", NDI_GREEN);
		1959	}
		1960	else
		1961	op->statusmsg ("The potion had no effect - you are already perfect.");
		1962	}
		1963	else
		1964	{ /* cursed potion */
		1965	if (got_one)
		1966	{
		1967	op->update_stats ();
		1968	op->failmsg ("The Gods are angry and punish you.");
		1969	}
		1970	else
		1971	op->statusmsg ("You are fortunate that you are so pathetic.", NDI_DK_ORANGE);
		1972	}
		1973
		1974	tmp->decrease ();
		1975	return 1;
		1976	}
		1977
		1978
		1979	/* A potion that casts a spell. Healing, restore spellpoint (power potion)
		1980	* and heroism all fit into this category. Given the spell object code,
		1981	* there is no limit to the number of spells that potions can be cast,
		1982	* but direction is problematic to try and imbue fireball potions for example.
		1983	*/
		1984	if (tmp->inv)
		1985	{
		1986	if (QUERY_FLAG (tmp, FLAG_CURSED) || QUERY_FLAG (tmp, FLAG_DAMNED))
		1987	{
		1988	op->failmsg ("Yech! Your lungs are on fire!");
		1989	create_exploding_ball_at (op, op->level);
		1990	}
		1991	else
		1992	cast_spell (op, tmp, op->facing, tmp->inv, NULL);
		1993
		1994	tmp->decrease ();
		1995
		1996	/* if youre dead, no point in doing this... */
		1997	if (!QUERY_FLAG (op, FLAG_REMOVED))
		1998	op->update_stats ();
		1999
		2000	return 1;
		2001	}
		2002
		2003	/* Deal with protection potions */
		2004	force = NULL;
		2005	for (i = 0; i < NROFATTACKS; i++)
		2006	{
		2007	if (tmp->resist[i])
		2008	{
		2009	if (!force)
		2010	force = get_archetype (FORCE_NAME);
		2011
		2012	memcpy (force->resist, tmp->resist, sizeof (tmp->resist));
		2013	force->type = POTION_EFFECT;
		2014	break; /* Only need to find one protection since we copy entire batch */
		2015	}
		2016	}
		2017
		2018	/* This is a protection potion */
		2019	if (force)
		2020	{
		2021	/* cursed items last longer */
		2022	if (QUERY_FLAG (tmp, FLAG_CURSED) || QUERY_FLAG (tmp, FLAG_DAMNED))
		2023	{
		2024	force->stats.food *= 10;
		2025	for (i = 0; i < NROFATTACKS; i++)
		2026	if (force->resist[i] > 0)
		2027	force->resist[i] = -force->resist[i]; /* prot => vuln */
		2028	}
		2029
		2030	force->speed_left = -1;
		2031	force = insert_ob_in_ob (force, op);
		2032	CLEAR_FLAG (tmp, FLAG_APPLIED);
		2033	SET_FLAG (force, FLAG_APPLIED);
		2034	change_abil (op, force);
		2035	tmp->decrease ();
		2036	return 1;
		2037	}
		2038
		2039	/* Only thing left are the stat potions */
		2040	if (op->type == PLAYER)
		2041	{ /* only for players */
		2042	if ((QUERY_FLAG (tmp, FLAG_CURSED)
		2043	|| QUERY_FLAG (tmp, FLAG_DAMNED))
		2044	&& tmp->value != 0)
		2045	CLEAR_FLAG (tmp, FLAG_APPLIED);
		2046	else
		2047	SET_FLAG (tmp, FLAG_APPLIED);
		2048
		2049	if (!change_abil (op, tmp))
		2050	op->statusmsg ("Nothing happened.");
		2051	}
		2052
		2053	/* CLEAR_FLAG is so that if the character has other potions
		2054	* that were grouped with the one consumed, his
		2055	* stat will not be raised by them. fix_player just clears
		2056	* up all the stats.
		2057	*/
		2058	CLEAR_FLAG (tmp, FLAG_APPLIED);
		2059	op->update_stats ();
		2060	tmp->decrease ();
		2061	return 1;
		2062	}
		2063
		2064	/**
		2065	* 'victim' moves onto 'trap'
		2066	* 'victim' leaves 'trap'
		2067	* effect is determined by move_on/move_off of trap and move_type of victime.
		2068	*
		2069	* originator: Player, monster or other object that caused 'victim' to move
		2070	* onto 'trap'. Will receive messages caused by this action. May be NULL.
		2071	* However, some types of traps require an originator to function.
		2072	*/
		2073	void
		2074	move_apply (object *trap, object *victim, object *originator)
		2075	{
		2076	static int recursion_depth = 0;
		2077
		2078	/* Only exits affect DMs. */
		2079	if (QUERY_FLAG (victim, FLAG_WIZPASS) && trap->type != EXIT && trap->type != SIGN)
		2080	return;
		2081
		2082	/* move_apply() is the most likely candidate for causing unwanted and
		2083	* possibly unlimited recursion.
		2084	*/
		2085	/* The following was changed because it was causing perfectly correct
		2086	* maps to fail. 1) it's not an error to recurse:
		2087	* rune detonates, summoning monster. monster lands on nearby rune.
		2088	* nearby rune detonates. This sort of recursion is expected and
		2089	* proper. This code was causing needless crashes.
		2090	*/
		2091	if (recursion_depth >= 500)
		2092	{
		2093	LOG (llevDebug, "WARNING: move_apply(): aborting recursion "
		2094	"[trap arch %s, name %s; victim arch %s, name %s]\n", &trap->arch->archname, &trap->name, &victim->arch->archname, &victim->name);
		2095	return;
		2096	}
		2097
		2098	recursion_depth++;
		2099	if (trap->head)
		2100	trap = trap->head;
		2101
		2102	if (!INVOKE_OBJECT (MOVE_TRIGGER, trap, ARG_OBJECT (victim), ARG_OBJECT (originator)))
		2103	switch (trap->type)
		2104	{
		2105	case PLAYERMOVER:
		2106	if (trap->attacktype && (trap->level || victim->type != PLAYER) && !should_director_abort (trap, victim))
		2107	{
		2108	if (!trap->stats.maxsp)
		2109	trap->stats.maxsp = 2;
		2110
		2111	/* Is this correct? From the docs, it doesn't look like it
		2112	* should be divided by trap->speed
		2113	*/
		2114	victim->speed_left = -trap->stats.maxsp * victim->speed / trap->speed;
		2115
		2116	/* Just put in some sanity check. I think there is a bug in the
		2117	* above with some objects have zero speed, and thus the player
		2118	* getting permanently paralyzed.
		2119	*/
		2120	if (victim->speed_left < -50.f)
		2121	victim->speed_left = -50.f;
		2122	/* LOG(llevDebug, "apply, playermove, player speed_left=%f\n", victim->speed_left); */
		2123	}
		2124	break;
		2125
		2126	case SPINNER:
		2127	if (victim->direction)
		2128	{
		2129	victim->direction = absdir (victim->direction - trap->stats.sp);
		2130	update_turn_face (victim);
		2131	}
		2132	break;
		2133
		2134	case DIRECTOR:
		2135	if (victim->direction && !should_director_abort (trap, victim))
		2136	{
		2137	victim->direction = trap->stats.sp;
		2138	update_turn_face (victim);
		2139	}
		2140	break;
		2141
		2142	case BUTTON:
		2143	case PEDESTAL:
		2144	case T_MATCH:
		2145	update_button (trap, originator);
		2146	break;
		2147
		2148	case ALTAR:
		2149	/* sacrifice victim on trap */
		2150	apply_altar (trap, victim, originator);
		2151	break;
		2152
		2153	case THROWN_OBJ:
		2154	if (trap->inv == NULL)
		2155	break;
		2156	/* fallthrough */
		2157
		2158	case ARROW:
		2159	/* bad bug: monster throw a object, make a step forwards, step on object ,
		2160	* trigger this here and get hit by own missile - and will be own enemy.
		2161	* Victim then is his own enemy and will start to kill herself (this is
		2162	* removed) but we have not synced victim and his missile. To avoid senseless
		2163	* action, we avoid hits here
		2164	*/
		2165	if ((QUERY_FLAG (victim, FLAG_ALIVE) && trap->has_active_speed ())
		2166	&& trap->owner != victim)
		2167	hit_with_arrow (trap, victim);
		2168	break;
		2169
		2170	case SPELL_EFFECT:
		2171	apply_spell_effect (trap, victim);
		2172	break;
		2173
		2174	case TRAPDOOR:
		2175	{
		2176	int max, sound_was_played;
		2177	object *ab, *ab_next;
		2178
		2179	if (!trap->value)
		2180	{
		2181	int tot;
		2182
		2183	for (ab = trap->above, tot = 0; ab; ab = ab->above)
		2184	if ((ab->move_type && trap->move_on) || ab->move_type == 0)
		2185	tot += ab->head_ ()->total_weight ();
		2186
		2187	if (!(trap->value = (tot > trap->weight) ? 1 : 0))
		2188	break;
		2189
		2190	SET_ANIMATION (trap, trap->value);
		2191	update_object (trap, UP_OBJ_FACE);
		2192	}
		2193
		2194	for (ab = trap->above, max = 100, sound_was_played = 0; --max && ab; ab = ab_next)
		2195	{
		2196	/* need to set this up, since if we do transfer the object,
		2197	* ab->above would be bogus
		2198	*/
		2199	ab_next = ab->above;
		2200
		2201	if ((ab->move_type && trap->move_on) || ab->move_type == 0)
		2202	{
		2203	if (!sound_was_played)
		2204	{
		2205	trap->play_sound (trap->sound ? trap->sound : sound_find ("fall_hole"));
		2206	sound_was_played = 1;
		2207	}
		2208
		2209	ab->statusmsg ("You fall into a trapdoor!", NDI_RED);
		2210	transfer_ob (ab, EXIT_X (trap), EXIT_Y (trap), 0, ab);
		2211	}
		2212	}
		2213	break;
		2214	}
		2215
		2216	case CONVERTER:
		2217	if (convert_item (victim, trap) < 0)
		2218	{
		2219	originator->failmsg (format ("The %s seems to be broken!", query_name (trap)));
		2220	archetype::get (shstr_burnout)->insert_at (trap, trap);
		2221	}
		2222
		2223	break;
		2224
		2225	case TRIGGER_BUTTON:
		2226	case TRIGGER_PEDESTAL:
		2227	case TRIGGER_ALTAR:
		2228	check_trigger (trap, victim, originator);
		2229	break;
		2230
		2231	case DEEP_SWAMP:
		2232	walk_on_deep_swamp (trap, victim);
		2233	break;
		2234
		2235	case CHECK_INV:
		2236	check_inv (victim, trap);
		2237	break;
		2238
		2239	case HOLE:
		2240	move_apply_hole (trap, victim);
		2241	break;
		2242
		2243	case EXIT:
		2244	if (victim->type == PLAYER && EXIT_PATH (trap))
		2245	{
		2246	/* Basically, don't show exits leading to random maps the
		2247	* players output.
		2248	*/
		2249	if (trap->msg && EXIT_PATH (trap) != shstr_random_map_exit)
		2250	victim->statusmsg (trap->msg, NDI_NAVY);
		2251
		2252	trap->play_sound (trap->sound);
		2253	victim->enter_exit (trap);
		2254	}
		2255	break;
		2256
		2257	case ENCOUNTER:
		2258	/* may be some leftovers on this */
		2259	break;
		2260
		2261	case SHOP_MAT:
		2262	apply_shop_mat (trap, victim);
		2263	break;
		2264
		2265	/* Drop a certain amount of gold, and have one item identified */
		2266	case IDENTIFY_ALTAR:
		2267	apply_id_altar (victim, trap, originator);
		2268	break;
		2269
		2270	case SIGN:
		2271	if (victim->type != PLAYER && trap->stats.food > 0)
		2272	break; /* monsters musn't apply magic_mouths with counters */
		2273
		2274	apply_sign (victim, trap, 1);
		2275	break;
		2276
		2277	case CONTAINER:
		2278	apply_container (victim, trap);
		2279	break;
		2280
		2281	case RUNE:
		2282	case TRAP:
		2283	if (trap->level && QUERY_FLAG (victim, FLAG_ALIVE))
		2284	spring_trap (trap, victim);
		2285	break;
		2286
		2287	default:
		2288	LOG (llevDebug, "name %s, arch %s, type %d with fly/walk on/off not "
		2289	"handled in move_apply()\n", &trap->name, &trap->arch->archname, trap->type);
		2290	break;
		2291	}
		2292
		2293	recursion_depth--;
		2294	}
		2295
		2296	/**
		2297	* Handles reading a regular (ie not containing a spell) book.
		2298	*/
		2299	static void
		2300	apply_book (object *op, object *tmp)
		2301	{
		2302	int lev_diff;
		2303	object *skill_ob;
		2304
		2305	if (QUERY_FLAG (op, FLAG_BLIND) && !QUERY_FLAG (op, FLAG_WIZ))
		2306	{
		2307	op->failmsg ("You are unable to read while blind!");
		2308	return;
		2309	}
		2310
		2311	if (!tmp->msg)
		2312	{
		2313	op->failmsg (format ("The %s contains nothing but meaningless gibberish. H<There is nothing interesting to read here.>", &tmp->name));
		2314	return;
		2315	}
		2316
		2317	/* need a literacy skill to read stuff! */
		2318	skill_ob = find_skill_by_name (op, tmp->skill);
		2319	if (!skill_ob)
		2320	{
		2321	op->failmsg (format ("You are unable to decipher the strange symbols. H<You lack the %s skill to read this.>", &tmp->skill));
		2322	return;
		2323	}
		2324
		2325	lev_diff = tmp->level - (skill_ob->level + 5);
		2326	if (!QUERY_FLAG (op, FLAG_WIZ) && lev_diff > 0)
		2327	{
		2328	op->failmsg (lev_diff < 2 ? "This book is just barely beyond your comprehension."
		2329	: lev_diff < 3 ? "This book is slightly beyond your comprehension."
		2330	: lev_diff < 5 ? "This book is beyond your comprehension."
		2331	: lev_diff < 8 ? "This book is quite a bit beyond your comprehension."
		2332	: lev_diff < 15 ? "This book is way beyond your comprehension."
		2333	: "This book is totally beyond your comprehension.");
		2334	return;
		2335	}
		2336
		2337	// we currently don't use the message types for anything.
		2338	// readable_message_type *msgType = get_readable_message_type (tmp);
		2339
		2340	tmp->play_sound (tmp->sound ? tmp->sound : sound_find ("apply_book"));
		2341
		2342	if (player *pl = op->contr)
		2343	if (client *ns = pl->ns)
		2344	pl->infobox (MSG_CHANNEL ("book"), format ("T<%s>\n\n%s", (char *)long_desc (tmp, op), &tmp->msg));
		2345
		2346	/* gain xp from reading */
		2347	if (!QUERY_FLAG (tmp, FLAG_NO_SKILL_IDENT))
		2348	{ /* only if not read before */
		2349	int exp_gain = calc_skill_exp (op, tmp, skill_ob);
		2350
		2351	if (!QUERY_FLAG (tmp, FLAG_IDENTIFIED))
		2352	{
		2353	/*exp_gain *= 2; because they just identified it too */
		2354	SET_FLAG (tmp, FLAG_IDENTIFIED);
		2355
		2356	if (object *pl = tmp->visible_to ())
		2357	esrv_update_item (UPD_FLAGS | UPD_NAME, pl, tmp);
		2358	}
		2359
		2360	change_exp (op, exp_gain, skill_ob->skill, 0);
		2361	SET_FLAG (tmp, FLAG_NO_SKILL_IDENT); /* so no more xp gained from this book */
		2362	}
		2363	}
		2364
		2365	/**
		2366	* op made some mistake with a scroll, this takes care of punishment.
		2367	* scroll_failure()- hacked directly from spell_failure
		2368	*/
		2369	static void
		2370	scroll_failure (object *op, int failure, int power)
		2371	{
		2372	if (abs (failure / 4) > power)
		2373	power = abs (failure / 4); /* set minimum effect */
		2374
		2375	if (failure <= -1 && failure > -15)
		2376	{ /* wonder */
		2377	object *tmp;
		2378
		2379	op->failmsg ("Your spell warps!");
		2380	tmp = get_archetype (SPELL_WONDER);
		2381	cast_wonder (op, op, 0, tmp);
		2382	tmp->destroy ();
		2383	}
		2384	else if (failure <= -15 && failure > -35)
		2385	{ /* drain mana */
		2386	op->failmsg ("Your mana is drained!");
		2387	op->stats.sp -= random_roll (0, power - 1, op, PREFER_LOW);
		2388	if (op->stats.sp < 0)
		2389	op->stats.sp = 0;
		2390	}
		2391	else if (settings.spell_failure_effects == TRUE)
		2392	{
		2393	if (failure <= -35 && failure > -60)
		2394	{ /* confusion */
		2395	op->failmsg ("The magic recoils on you!");
		2396	confuse_player (op, op, power);
		2397	}
		2398	else if (failure <= -60 && failure > -70)
		2399	{ /* paralysis */
		2400	op->failmsg ("The magic recoils and paralyzes you!");
		2401	paralyze_player (op, op, power);
		2402	}
		2403	else if (failure <= -70 && failure > -80)
		2404	{ /* blind */
		2405	op->failmsg ("The magic recoils on you!");
		2406	blind_player (op, op, power);
		2407	}
		2408	else if (failure <= -80)
		2409	{ /* blast the immediate area */
		2410	object *tmp = get_archetype (LOOSE_MANA);
		2411	cast_magic_storm (op, tmp, power);
		2412	op->failmsg ("You unleash uncontrolled mana!");
		2413	tmp->destroy ();
		2414	}
		2415	}
		2416	}
		2417
		2418	/**
		2419	* Handles the applying of a skill scroll, calling learn_skill straight.
		2420	* op is the person learning the skill, tmp is the skill scroll object
		2421	*/
		2422	static void
		2423	apply_skillscroll (object *op, object *tmp)
		2424	{
		2425	switch (learn_skill (op, tmp))
		2426	{
		2427	case 0:
		2428	op->play_sound (sound_find ("generic_fail"));
		2429	op->failmsg (format ("You already possess the knowledge held within the %s.", query_name (tmp)));
		2430	break;
		2431
		2432	case 1:
		2433	tmp->decrease ();
		2434	op->play_sound (sound_find ("skill_learn"));
		2435	op->statusmsg (format ("You succeed in learning %s", &tmp->skill));
		2436	break;
		2437
		2438	default:
		2439	tmp->decrease ();
		2440	op->play_sound (sound_find ("generic_fail"));
		2441	op->failmsg (format ("You fail to learn the knowledge of the %s.\n", query_name (tmp)));
		2442	break;
		2443	}
		2444	}
		2445
		2446	/**
		2447	* Actually makes op learn spell.
		2448	* Informs player of what happens.
		2449	*/
		2450	void
		2451	do_learn_spell (object *op, object *spell, int special_prayer)
		2452	{
		2453	object *tmp;
		2454
		2455	if (op->type != PLAYER)
		2456	{
		2457	LOG (llevError, "BUG: do_learn_spell(): not a player\n");
		2458	return;
		2459	}
		2460
		2461	/* Upgrade special prayers to normal prayers */
		2462	if ((tmp = check_spell_known (op, spell->name)) != NULL)
		2463	{
		2464	if (special_prayer && !QUERY_FLAG (tmp, FLAG_STARTEQUIP))
		2465	{
		2466	LOG (llevError, "BUG: do_learn_spell(): spell already known, but not marked as startequip\n");
		2467	return;
		2468	}
		2469	return;
		2470	}
		2471
		2472	op->contr->play_sound (sound_find ("learn_spell"));
		2473
		2474	tmp = spell->clone ();
		2475	insert_ob_in_ob (tmp, op);
		2476
		2477	if (special_prayer)
		2478	SET_FLAG (tmp, FLAG_STARTEQUIP);
		2479
		2480	esrv_add_spells (op->contr, tmp);
		2481	}
		2482
		2483	/**
		2484	* Erases spell from player's inventory.
		2485	*/
		2486	void
		2487	do_forget_spell (object *op, const char *spell)
		2488	{
		2489	object *spob;
		2490
		2491	if (op->type != PLAYER)
		2492	{
		2493	LOG (llevError, "BUG: do_forget_spell(): not a player\n");
		2494	return;
		2495	}
		2496	if ((spob = check_spell_known (op, spell)) == NULL)
		2497	{
		2498	LOG (llevError, "BUG: do_forget_spell(): spell not known\n");
		2499	return;
		2500	}
		2501
		2502	op->failmsg (format ("You lose knowledge of %s.", spell));
		2503	esrv_remove_spell (op->contr, spob);
		2504	spob->destroy ();
		2505	}
		2506
		2507	/**
		2508	* Handles player applying a spellbook.
		2509	* Checks whether player has knowledge of required skill, doesn't already know the spell,
		2510	* stuff like that. Random learning failure too.
		2511	*/
		2512	static void
		2513	apply_spellbook (object *op, object *tmp)
		2514	{
		2515	object *skop, *spell, *spell_skill;
		2516
		2517	if (QUERY_FLAG (op, FLAG_BLIND) && !QUERY_FLAG (op, FLAG_WIZ))
		2518	{
		2519	op->failmsg ("You are unable to read while blind.");
		2520	return;
		2521	}
		2522
		2523	/* artifact_spellbooks have 'slaying' field point to a spell name,
		2524	* instead of having their spell stored in stats.sp. These are
		2525	* legacy spellbooks
		2526	*/
		2527	if (tmp->slaying)
		2528	{
		2529	spell = find_archetype_by_object_name (tmp->slaying)->instance ();
		2530
		2531	if (!spell)
		2532	{
		2533	op->failmsg (format ("The book's formula for %s is incomplete.", &tmp->slaying));
		2534	return;
		2535	}
		2536	else
		2537	insert_ob_in_ob (spell, tmp);
		2538
		2539	tmp->slaying = 0;
		2540	}
		2541
		2542	skop = find_skill_by_name (op, tmp->skill);
		2543
		2544	/* need a literacy skill to learn spells. Also, having a literacy level
		2545	* lower than the spell will make learning the spell more difficult */
		2546	if (!skop)
		2547	{
		2548	op->failmsg (format ("You can't read! Your attempt fails. H<You lack the %s skill.>", &tmp->skill));
		2549	return;
		2550	}
		2551
		2552	spell = tmp->inv;
		2553
		2554	if (!spell)
		2555	{
		2556	LOG (llevError, "apply_spellbook: Book %s has no spell in it!\n", &tmp->name);
		2557	op->failmsg ("The spellbook symbols make no sense. This is a bug, please report!");
		2558	return;
		2559	}
		2560
		2561	int learn_level = sqrtf (spell->level) * 1.5f;
		2562	if (skop->level < learn_level)
		2563	{
		2564	op->failmsg (format ("You are unable to decipher the strange symbols. H<Your %s level is too low, it must be at least %d.>",
		2565	&tmp->skill, learn_level));
		2566	return;
		2567	}
		2568
		2569	op->statusmsg (format ("The spellbook contains the %s level spell %s.", ordinal (spell->level), &spell->name));
		2570
		2571	if (!QUERY_FLAG (tmp, FLAG_IDENTIFIED))
		2572	identify (tmp);
		2573
		2574	/* I removed the check for special_prayer_mark here - it didn't make
		2575	* a lot of sense - special prayers are not found in spellbooks, and
		2576	* if the player doesn't know the spell, doesn't make a lot of sense that
		2577	* they would have a special prayer mark.
		2578	*/
		2579	if (check_spell_known (op, spell->name))
		2580	{
		2581	op->statusmsg ("You already know that spell. H<It makes no sense to learn spells twice, and would only waste the spellbook.>\n");
		2582	return;
		2583	}
		2584
		2585	if (spell->skill)
		2586	{
		2587	spell_skill = find_skill_by_name (op, spell->skill);
		2588
		2589	if (!spell_skill)
		2590	{
		2591	op->failmsg (format ("You lack the %s skill to use this spell.", &spell->skill));
		2592	return;
		2593	}
		2594
		2595	if (spell_skill->level < spell->level)
		2596	{
		2597	op->failmsg (format ("You need to be level %d in %s to learn this spell.", spell->level, &spell->skill));
		2598	return;
		2599	}
		2600	}
		2601
		2602	/* Logic as follows
		2603	*
		2604	* 1- MU spells use Int to learn, Cleric spells use Wisdom
		2605	*
		2606	* 2- The learner's skill level in literacy adjusts the chance to learn
		2607	* a spell.
		2608	*
		2609	* 3 -Automatically fail to learn if you read while confused
		2610	*
		2611	* Overall, chances are the same but a player will find having a high
		2612	* literacy rate very useful! -b.t.
		2613	*/
		2614	if (QUERY_FLAG (op, FLAG_CONFUSED))
		2615	{
		2616	op->failmsg ("In your confused state you flub the wording of the text!");
		2617	scroll_failure (op, 0 - random_roll (0, spell->level, op, PREFER_LOW), max (spell->stats.sp, spell->stats.grace));
		2618	}
		2619	else if (QUERY_FLAG (tmp, FLAG_STARTEQUIP) ||
		2620	(random_roll (0, 100, op, PREFER_LOW) - (5 * skop->level)) < learn_spell[spell->stats.grace ? op->stats.Wis : op->stats.Int])
		2621	{
		2622	op->statusmsg ("You succeed in learning the spell!", NDI_GREEN);
		2623	do_learn_spell (op, spell, 0);
		2624
		2625	/* xp gain to literacy for spell learning */
		2626	if (!QUERY_FLAG (tmp, FLAG_STARTEQUIP))
		2627	change_exp (op, calc_skill_exp (op, tmp, skop), skop->skill, 0);
		2628	}
		2629	else
		2630	{
		2631	op->contr->play_sound (sound_find ("fumble_spell"));
		2632	op->failmsg ("You fail to learn the spell. H<Wis (priests) or Int (wizards) governs the chance of learning a prayer or spell.>\n");
		2633	}
		2634
		2635	tmp->decrease ();
		2636	}
		2637
		2638	/**
		2639	* Handles applying a spell scroll.
		2640	*/
		2641	void
		2642	apply_scroll (object *op, object *tmp, int dir)
		2643	{
		2644	object *skop;
		2645
		2646	if (QUERY_FLAG (op, FLAG_BLIND) && !QUERY_FLAG (op, FLAG_WIZ))
		2647	{
		2648	op->failmsg ("You are unable to read while blind.");
		2649	return;
		2650	}
		2651
		2652	if (!tmp->inv || tmp->inv->type != SPELL)
		2653	{
		2654	op->failmsg ("The scroll just doesn't make sense! H<...and never will make sense.>");
		2655	return;
		2656	}
		2657
		2658	if (op->type == PLAYER)
		2659	{
		2660	/* players need a literacy skill to read stuff! */
		2661	int exp_gain = 0;
		2662
		2663	/* hard code literacy - tmp->skill points to where the exp
		2664	* should go for anything killed by the spell.
		2665	*/
		2666	skop = find_skill_by_name (op, skill_names[SK_LITERACY]);
		2667
		2668	if (!skop)
		2669	{
		2670	op->failmsg (format ("You are unable to decipher the strange symbols. H<You lack the %s skill.>", &skill_names[SK_LITERACY]));
		2671	return;
		2672	}
		2673
		2674	if ((exp_gain = calc_skill_exp (op, tmp, skop)))
		2675	change_exp (op, exp_gain, skop->skill, 0);
		2676	}
		2677
		2678	if (!QUERY_FLAG (tmp, FLAG_IDENTIFIED))
		2679	identify (tmp);
		2680
		2681	op->statusmsg (format ("The scroll of %s turns to dust.", &tmp->inv->name));
		2682
		2683	cast_spell (op, tmp, dir, tmp->inv, NULL);
		2684	tmp->decrease ();
		2685	}
		2686
		2687	/**
		2688	* Applies a treasure object - by default, chest. op
		2689	* is the person doing the applying, tmp is the treasure
		2690	* chest.
		2691	*/
		2692	static void
		2693	apply_treasure (object *op, object *tmp)
		2694	{
		2695	/* Nice side effect of this treasure creation method is that the treasure
		2696	* for the chest is done when the chest is created, and put into the chest
		2697	* inventory. So that when the chest burns up, the items still exist. Also
		2698	* prevents people from moving chests to more difficult maps to get better
		2699	* treasure
		2700	*/
		2701	object *treas = tmp->inv;
		2702
		2703	if (!treas)
		2704	{
		2705	op->statusmsg ("The chest was empty.");
		2706	tmp->decrease ();
		2707	return;
		2708	}
		2709
		2710	while (tmp->inv)
		2711	{
		2712	treas = tmp->inv;
		2713	treas->remove ();
		2714
		2715	treas->x = op->x;
		2716	treas->y = op->y;
		2717	treas = insert_ob_in_map (treas, op->map, op, INS_BELOW_ORIGINATOR);
		2718
		2719	if (treas && (treas->type == RUNE || treas->type == TRAP) && treas->level && QUERY_FLAG (op, FLAG_ALIVE))
		2720	spring_trap (treas, op);
		2721
		2722	/* If either player or container was destroyed, no need to do
		2723	* further processing. I think this should be enclused with
		2724	* spring trap above, as I don't think there is otherwise
		2725	* any way for the treasure chest or player to get killed.
		2726	*/
		2727	if (op->destroyed () || tmp->destroyed ())
		2728	break;
		2729	}
		2730
		2731	if (!tmp->destroyed () && !tmp->inv)
		2732	tmp->decrease (true);
		2733	}
		2734
		2735	/**
		2736	* A dragon is eating some flesh. If the flesh contains resistances,
		2737	* there is a chance for the dragon's skin to get improved.
		2738	*
		2739	* attributes:
		2740	* object *op the object (dragon player) eating the flesh
		2741	* object *meal the flesh item, getting chewed in dragon's mouth
		2742	* return:
		2743	* int 1 if eating successful, 0 if it doesn't work
		2744	*/
		2745	static int
		2746	dragon_eat_flesh (object *op, object *meal)
		2747	{
		2748	object *skin = NULL; /* pointer to dragon skin force */
		2749	object *abil = NULL; /* pointer to dragon ability force */
		2750	object *tmp = NULL; /* tmp. object */
		2751
		2752	double chance; /* improvement-chance of one resistance type */
		2753	double totalchance = 1; /* total chance of gaining one resistance */
		2754	double bonus = 0; /* level bonus (improvement is easier at lowlevel) */
		2755	double mbonus = 0; /* monster bonus */
		2756	int atnr_winner[NROFATTACKS]; /* winning candidates for resistance improvement */
		2757	int winners = 0; /* number of winners */
		2758	int i; /* index */
		2759
		2760	/* let's make sure and doublecheck the parameters */
		2761	if (meal->type != FLESH || !op->is_dragon ())
		2762	return 0;
		2763
		2764	/* now grab the 'dragon_skin'- and 'dragon_ability'-forces
		2765	from the player's inventory */
		2766	for (tmp = op->inv; tmp; tmp = tmp->below)
		2767	if (tmp->type == FORCE)
		2768	if (tmp->arch->archname == shstr_dragon_skin_force)
		2769	skin = tmp;
		2770	else if (tmp->arch->archname == shstr_dragon_ability_force)
		2771	abil = tmp;
		2772
		2773	/* if either skin or ability are missing, this is an old player
		2774	which is not to be considered a dragon -> bail out */
		2775	if (skin == NULL || abil == NULL)
		2776	return 0;
		2777
		2778	/* now start by filling stomache and health, according to food-value */
		2779	if ((MAX_FOOD - op->stats.food) < meal->stats.food)
		2780	op->stats.hp += (MAX_FOOD - op->stats.food) / 50;
		2781	else
		2782	op->stats.hp += meal->stats.food / 50;
		2783
		2784	min_it (op->stats.hp, op->stats.maxhp);
		2785	op->stats.food = min (MAX_FOOD, op->stats.food + meal->stats.food);
		2786
		2787	/*LOG(llevDebug, "-> player: %d, flesh: %d\n", op->level, meal->level); */
		2788
		2789	/* on to the interesting part: chances for adding resistance */
		2790	for (i = 0; i < NROFATTACKS; i++)
		2791	{
		2792	if (meal->resist[i] > 0 && atnr_is_dragon_enabled (i))
		2793	{
		2794	/* got positive resistance, now calculate improvement chance (0-100) */
		2795
		2796	/* this bonus makes resistance increase easier at lower levels */
		2797	bonus = (settings.max_level - op->level) * 30. / ((double) settings.max_level);
		2798	if (i == abil->stats.exp)
		2799	bonus += 5; /* additional bonus for resistance of ability-focus */
		2800
		2801	/* monster bonus increases with level, because high-level
		2802	flesh is too rare */
		2803	mbonus = op->level * 20. / ((double) settings.max_level);
		2804
		2805	chance = (((double)min (op->level + bonus, meal->level + bonus + mbonus)) * 100. /
		2806	((double)settings.max_level)) - skin->resist[i];
		2807
		2808	if (chance >= 0.)
		2809	chance += 1.;
		2810	else
		2811	chance = (chance < -12) ? 0. : 1. / pow (2., -chance);
		2812
		2813	/* chance is proportional to amount of resistance (max. 50) */
		2814	chance *= ((double)(min (meal->resist[i], 50))) / 50.;
		2815
		2816	/* doubled chance for resistance of ability-focus */
		2817	if (i == abil->stats.exp)
		2818	chance = min (100., chance * 2.);
		2819
		2820	/* now make the throw and save all winners (Don't insert luck bonus here!) */
		2821	if (rndm (10000) < (unsigned int)(chance * 100))
		2822	{
		2823	atnr_winner[winners] = i;
		2824	winners++;
		2825	}
		2826
		2827	if (chance >= 0.01)
		2828	totalchance *= 1 - chance / 100;
		2829
		2830	/*LOG(llevDebug, " %s: bonus %.1f, chance %.1f\n", attacks[i], bonus, chance); */
		2831	}
		2832	}
		2833
		2834	/* inverse totalchance as until now we have the failure-chance */
		2835	totalchance = 100 - totalchance * 100;
		2836
		2837	/* print message according to totalchance */
		2838	const char *buf;
		2839	if (totalchance > 50.)
		2840	buf = format ("Hmm! The %s tasted delicious!", &meal->name);
		2841	else if (totalchance > 10.)
		2842	buf = format ("The %s tasted very good.", &meal->name);
		2843	else if (totalchance > 1.)
		2844	buf = format ("The %s tasted good.", &meal->name);
		2845	else if (totalchance > 0.1)
		2846	buf = format ("The %s tasted bland.", &meal->name);
		2847	else if (totalchance >= 0.01)
		2848	buf = format ("The %s had a boring taste.", &meal->name);
		2849	else if (meal->last_eat > 0 && atnr_is_dragon_enabled (meal->last_eat))
		2850	buf = format ("The %s tasted strange.", &meal->name);
		2851	else
		2852	buf = format ("The %s had no taste.", &meal->name);
		2853
		2854	op->statusmsg (buf);
		2855
		2856	/* now choose a winner if we have any */
		2857	i = -1;
		2858	if (winners > 0)
		2859	i = atnr_winner [rndm (winners)];
		2860
		2861	if (i >= 0 && i < NROFATTACKS && skin->resist[i] < 95)
		2862	{
		2863	/* resistance increased! */
		2864	skin->resist[i]++;
		2865	op->update_stats ();
		2866
		2867	op->statusmsg (format ("Your skin is now more resistant to %s!", change_resist_msg[i]));
		2868	}
		2869
		2870	/* if this flesh contains a new ability focus, we mark it
		2871	into the ability_force and it will take effect on next level */
		2872	if (meal->last_eat > 0 && atnr_is_dragon_enabled (meal->last_eat) && meal->last_eat != abil->last_eat)
		2873	{
		2874	abil->last_eat = meal->last_eat; /* write: last_eat <new attnr focus> */
		2875
		2876	if (meal->last_eat != abil->stats.exp)
		2877	op->statusmsg (format (
		2878	"Your metabolism prepares to focus on %s!\n"
		2879	"The change will happen at level %d.",
		2880	change_resist_msg[meal->last_eat],
		2881	abil->level + 1
		2882	));
		2883	else
		2884	{
		2885	op->statusmsg (format ("Your metabolism will continue to focus on %s.", change_resist_msg[meal->last_eat]));
		2886	abil->last_eat = 0;
		2887	}
		2888	}
		2889
		2890	return 1;
		2891	}
		2892
		2893	/**
		2894	* op eats food.
		2895	* If player, takes care of messages and dragon special food.
		2896	*/
		2897	static void
		2898	apply_food (object *op, object *tmp)
		2899	{
		2900	int capacity_remaining;
		2901
		2902	if (op->type != PLAYER)
		2903	op->stats.hp = op->stats.maxhp;
		2904	else
		2905	{
		2906	/* check if this is a dragon (player), eating some flesh */
		2907	if (tmp->type == FLESH && op->is_dragon () && dragon_eat_flesh (op, tmp))
		2908	;
		2909	else
		2910	{
		2911	/* usual case - no dragon meal: */
		2912	if (op->stats.food + tmp->stats.food > MAX_FOOD)
		2913	{
		2914	if (tmp->type == FOOD || tmp->type == FLESH)
		2915	op->failmsg ("You feel full, but what a waste of food!");
		2916	else
		2917	op->statusmsg ("Most of the drink goes down your face not your throat!");
		2918	}
		2919
		2920	tmp->play_sound (
		2921	tmp->sound
		2922	? tmp->sound
		2923	: tmp->type == DRINK
		2924	? sound_find ("eat_drink")
		2925	: sound_find ("eat_food")
		2926	);
		2927
		2928	if (!QUERY_FLAG (tmp, FLAG_CURSED))
		2929	{
		2930	const char *buf;
		2931
		2932	if (!op->is_dragon ())
		2933	{
		2934	/* eating message for normal players */
		2935	if (tmp->type == DRINK)
		2936	buf = format ("Ahhh...that %s tasted good.", &tmp->name);
		2937	else
		2938	buf = format ("The %s tasted %s", &tmp->name, tmp->type == FLESH ? "terrible!" : "good.");
		2939	}
		2940	else
		2941	/* eating message for dragon players */
		2942	buf = format ("The %s tasted terrible!", &tmp->name);
		2943
		2944	op->statusmsg (buf);
		2945
		2946	capacity_remaining = MAX_FOOD - op->stats.food;
		2947	op->stats.food += tmp->stats.food;
		2948	if (capacity_remaining < tmp->stats.food)
		2949	op->stats.hp += capacity_remaining / 50;
		2950	else
		2951	op->stats.hp += tmp->stats.food / 50;
		2952
		2953	min_it (op->stats.hp, op->stats.maxhp);
		2954	min_it (op->stats.food, MAX_FOOD);
		2955	}
		2956
		2957	/* special food hack -b.t. */
		2958	if (tmp->title || QUERY_FLAG (tmp, FLAG_CURSED))
		2959	eat_special_food (op, tmp);
		2960	}
		2961	}
		2962
		2963	handle_apply_yield (tmp);
		2964	tmp->decrease ();
		2965	}
		2966
		2967	/**
		2968	* Handles applying an improve armor scroll.
		2969	* Does some sanity checks, then calls improve_armour.
		2970	*/
		2971	static void
		2972	apply_armour_improver (object *op, object *tmp)
		2973	{
		2974	object *armor;
		2975
		2976	if (!QUERY_FLAG (op, FLAG_WIZCAST) && (get_map_flags (op->map, 0, op->x, op->y, 0, 0) & P_NO_MAGIC))
		2977	{
		2978	op->failmsg ("Something blocks the magic of the scroll. H<This area prevents magic effects.>");
		2979	return;
		2980	}
		2981
		2982	armor = find_marked_object (op);
		2983
		2984	if (!armor)
		2985	{
		2986	op->failmsg ("You need to mark an armor object. Use the right mouse button popup or the mark command to do this.");
		2987	return;
		2988	}
		2989
		2990	if (armor->type != ARMOUR
		2991	&& armor->type != CLOAK
		2992	&& armor->type != BOOTS && armor->type != GLOVES && armor->type != BRACERS && armor->type != SHIELD && armor->type != HELMET)
		2993	{
		2994	op->failmsg ("Your marked item is not armour!\n");
		2995	return;
		2996	}
		2997
		2998	op->statusmsg ("Applying armour enchantment.");
		2999	improve_armour (op, tmp, armor);
		3000	}
		3001
		3002	void
		3003	apply_poison (object *op, object *tmp)
		3004	{
		3005	// need to do it now when it is still on the map
		3006	handle_apply_yield (tmp);
		3007
		3008	object *poison = tmp->split (1);
		3009
		3010	if (op->type == PLAYER)
		3011	{
		3012	op->contr->play_sound (sound_find ("drink_poison"));
		3013	op->failmsg ("Yech! That tasted poisonous!");
		3014	op->contr->killer = poison;
		3015	}
		3016
		3017	if (poison->stats.hp > 0)
		3018	{
		3019	LOG (llevDebug, "Trying to poison player/monster for %d hp\n", poison->stats.hp);
		3020	hit_player (op, poison->stats.hp, tmp, AT_POISON, 1);
		3021	}
		3022
		3023	op->stats.food -= op->stats.food / 4;
		3024	poison->destroy ();
		3025	}
		3026
		3027	/**
		3028	* This function will try to apply a lighter and in case no lighter
		3029	* is specified it will try to find a lighter in the players inventory,
		3030	* and inform him about this requirement.
		3031	*
		3032	* who - the player
		3033	* op - the item we want to light
		3034	* lighter - the lighter or 0 if a lighter has yet to be found
		3035	*/
		3036	static object *
		3037	auto_apply_lighter (object *who, object *op, object *lighter)
		3038	{
		3039	if (lighter == 0)
		3040	{
		3041	for (object *tmp = who->inv; tmp; tmp = tmp->below)
		3042	{
		3043	if (tmp->type == LIGHTER)
		3044	{
		3045	lighter = tmp;
		3046	break;
		3047	}
		3048	}
		3049
		3050	if (!lighter)
		3051	{
		3052	who->failmsg (format (
		3053	"You can't light up the %s with your bare hands! "
		3054	"H<You need a lighter in your inventory, for example a flint and steel.>",
		3055	&op->name));
		3056	return 0;
		3057	}
		3058	}
		3059
		3060	// last_eat == 0 means the lighter is not being used up!
		3061	if (lighter->last_eat && lighter->stats.food)
		3062	{
		3063	/* lighter gets used up */
		3064	lighter = lighter->split ();
		3065	lighter->stats.food--;
		3066	who->insert (lighter);
		3067	}
		3068	else if (lighter->last_eat)
		3069	{
		3070	/* no charges left in lighter */
		3071	who->failmsg (format (
		3072	"You attempt to light the %s with a used up %s.",
		3073	&op->name, &lighter->name));
		3074	return 0;
		3075	}
		3076
		3077	return lighter;
		3078	}
		3079
		3080	/**
		3081	* Designed primarily to light torches/lanterns/etc.
		3082	* Also burns up burnable material too. First object in the inventory is
		3083	* the selected object to "burn". -b.t.
		3084	*/
		3085	static void
		3086	apply_lighter (object *who, object *lighter)
		3087	{
		3088	object *item;
		3089	int is_player_env = 0;
		3090
		3091	item = find_marked_object (who);
		3092	if (item)
		3093	{
		3094	if (!auto_apply_lighter (who, item, lighter))
		3095	return;
		3096
		3097	/* Perhaps we should split what we are trying to light on fire?
		3098	* I can't see many times when you would want to light multiple
		3099	* objects at once.
		3100	*/
		3101
		3102	save_throw_object (item, AT_FIRE, who);
		3103
		3104	if (item->destroyed ()
		3105	|| ((item->type == LAMP || item->type == TORCH)
		3106	&& item->glow_radius > 0))
		3107	who->statusmsg (format (
		3108	"You light the %s with the %s.",
		3109	&item->name, &lighter->name));
		3110	else
		3111	who->failmsg (format (
		3112	"You attempt to light the %s with the %s and fail.",
		3113	&item->name, &lighter->name));
		3114	}
		3115	else
		3116	who->failmsg ("You need to mark a lightable object.");
		3117	}
		3118
		3119	/**
		3120	* This function generates a cursed effect for cursed lamps and torches.
		3121	*/
		3122	static void
		3123	player_apply_lamp_cursed_effect (object *who, object *op)
		3124	{
		3125	if (op->level)
		3126	{
		3127	who->failmsg (format (
		3128	"The %s was cursed, it explodes in a big fireball!",
		3129	&op->name));
		3130	create_exploding_ball_at (who, op->level);
		3131	}
		3132	else
		3133	{
		3134	who->failmsg (format (
		3135	"The %s was cursed, it crumbles to dust, at least it didn't explode.!",
		3136	&op->name));
		3137	}
		3138
		3139	op->destroy ();
		3140	}
		3141
		3142	/**
		3143	* Apply for players and lamps
		3144	*
		3145	* who - the player
		3146	* op - the lamp
		3147	*/
		3148	static void
		3149	player_apply_lamp (object *who, object *op)
		3150	{
		3151	bool switch_on = op->glow_radius ? false : true;
		3152
		3153	if (switch_on)
		3154	{
		3155	object *lighter = 0;
		3156
		3157	if (op->flag [FLAG_IS_LIGHTABLE]
		3158	&& !(lighter = auto_apply_lighter (who, op, 0)))
		3159	return;
		3160
		3161	if (op->stats.food < 1)
		3162	{
		3163	if (op->type == LAMP)
		3164	who->failmsg (format (
		3165	"The %s is out of fuel! "
		3166	"H<Lamps and similar items need fuel. They cannot be refilled.>",
		3167	&op->name));
		3168	else
		3169	who->failmsg (format (
		3170	"The %s is burnt out! "
		3171	"H<Torches and similar items burn out and become worthless.>",
		3172	&op->name));
		3173	return;
		3174	}
		3175
		3176	if (op->flag [FLAG_CURSED])
		3177	{
		3178	player_apply_lamp_cursed_effect (who, op);
		3179	return;
		3180	}
		3181
		3182	if (lighter)
		3183	who->statusmsg (format (
		3184	"You light up the %s with the %s.", &op->name, &lighter->name));
		3185	else
		3186	who->statusmsg (format ("You light up the %s.", &op->name));
		3187	}
		3188	else
		3189	{
		3190	if (op->flag [FLAG_CURSED])
		3191	{
		3192	player_apply_lamp_cursed_effect (who, op);
		3193	return;
		3194	}
		3195
		3196	if (op->type == TORCH)
		3197	{
		3198	if (!op->flag [FLAG_IS_LIGHTABLE])
		3199	{
		3200	who->statusmsg (format (
		3201	"You put out the %s. "
		3202	"H<The %s can't be used anymore, as it can't be lighted up again.>",
		3203	&op->name, &op->name));
		3204	}
		3205	else
		3206	who->statusmsg (format (
		3207	"You put out the %s."
		3208	"H<Torches wear out if you put them out.>",
		3209	&op->name));
		3210	}
		3211	else
		3212	who->statusmsg (format ("You turn off the %s.", &op->name));
		3213	}
		3214
		3215	apply_lamp (op, switch_on);
		3216	}
		3217
		3218	void get_animation_from_arch (object *op, arch_ptr a)
		3219	{
		3220	op->animation_id = a->animation_id;
		3221	op->flag [FLAG_IS_TURNABLE] = a->flag [FLAG_IS_TURNABLE];
		3222	op->flag [FLAG_ANIMATE] = a->flag [FLAG_ANIMATE];
		3223	op->anim_speed = a->anim_speed;
		3224	op->last_anim = 0;
		3225	op->state = 0;
		3226	op->face = a->face;
		3227
		3228	if (NUM_ANIMATIONS(op) > 1)
		3229	{
		3230	SET_ANIMATION(op, 0);
		3231	animate_object (op, op->direction);
		3232	}
		3233	else
		3234	update_object (op, UP_OBJ_FACE);
		3235	}
		3236
		3237	/**
		3238	* Apply for LAMPs and TORCHes.
		3239	*
		3240	* op - the lamp
		3241	* switch_on - a flag which says whether the lamp should be switched on or off
		3242	*/
		3243	void apply_lamp (object *op, bool switch_on)
		3244	{
		3245	op->set_glow_radius (switch_on ? op->range : 0);
		3246	op->set_speed (switch_on ? op->arch->speed : 0);
		3247
		3248	// torches wear out if you put them out
		3249	if (op->type == TORCH && !switch_on)
		3250	{
		3251	if (op->flag [FLAG_IS_LIGHTABLE])
		3252	{
		3253	op->stats.food -= (double) op->arch->stats.food / 15;
		3254	if (op->stats.food < 0)
		3255	op->stats.food = 0;
		3256	}
		3257	else
		3258	op->stats.food = 0;
		3259	}
		3260
		3261	// lamps and torched get worthless when used up
		3262	if (op->stats.food <= 0)
		3263	op->value = 0;
		3264
		3265	// FIXME: This is a hack to make the more sane torches and lamps
		3266	// still animated ;-/
		3267	if (op->other_arch)
		3268	get_animation_from_arch (op, switch_on ? op->other_arch : op->arch);
		3269
		3270	if (object *pl = op->visible_to ())
		3271	esrv_update_item (UPD_ANIM | UPD_FACE | UPD_NAME, pl, op);
		3272	}
		3273
		3274	/**
		3275	* This handles items of type 'transformer'.
		3276	* Basically those items, used with a marked item, transform both items into something
		3277	* else.
		3278	* "Transformer" item has food decreased by 1, removed if 0 (0 at start means illimited)..
		3279	* Change information is contained in the 'slaying' field of the marked item.
		3280	* The format is as follow: transformer:[number ]yield[;transformer:...].
		3281	* This way an item can be transformed in many things, and/or many objects.
		3282	* The 'slaying' field for transformer is used as verb for the action.
		3283	*/
		3284	static void
		3285	apply_item_transformer (object *pl, object *transformer)
		3286	{
		3287	object *marked;
		3288	object *new_item;
		3289	const char *find;
		3290	char *separator;
		3291	int yield;
		3292	char got[MAX_BUF];
		3293	int len;
		3294
		3295	if (!pl || !transformer)
		3296	return;
		3297
		3298	marked = find_marked_object (pl);
		3299
		3300	if (!marked)
		3301	{
		3302	pl->failmsg (format ("Use the %s with what item?", query_name (transformer)));
		3303	return;
		3304	}
		3305
		3306	if (!marked->slaying)
		3307	{
		3308	pl->failmsg (format ("You can't use the %s with your %s!", query_name (transformer), query_name (marked)));
		3309	return;
		3310	}
		3311
		3312	/* check whether they are compatible or not */
		3313	find = strstr (&marked->slaying, transformer->arch->archname);
		3314	if (!find || (*(find + strlen (transformer->arch->archname)) != ':'))
		3315	{
		3316	pl->failmsg (format ("You can't use the %s with your %s!", query_name (transformer), query_name (marked)));
		3317	return;
		3318	}
		3319
		3320	find += strlen (transformer->arch->archname) + 1;
		3321	/* Item can be used, now find how many and what it yields */
		3322	if (isdigit (*(find)))
		3323	{
		3324	yield = atoi (find);
		3325	if (yield < 1)
		3326	{
		3327	LOG (llevDebug, "apply_item_transformer: item %s has slaying-yield %d.", query_base_name (marked, 0), yield);
		3328	yield = 1;
		3329	}
		3330	}
		3331	else
		3332	yield = 1;
		3333
		3334	while (isdigit (*find))
		3335	find++;
		3336
		3337	while (*find == ' ')
		3338	find++;
		3339
		3340	memset (got, 0, MAX_BUF);
		3341
		3342	if ((separator = (char *) strchr (find, ';')))
		3343	len = separator - find;
		3344	else
		3345	len = strlen (find);
		3346
		3347	min_it (len, MAX_BUF - 1);
		3348
		3349	strcpy (got, find);
		3350	got[len] = '\0';
		3351
		3352	/* Now create new item, remove used ones when required. */
		3353	new_item = get_archetype (got);
		3354	if (!new_item)
		3355	{
		3356	pl->failmsg (format ("This %s is strange, better to not use it.", query_base_name (marked, 0)));
		3357	return;
		3358	}
		3359
		3360	new_item->nrof = yield;
		3361
		3362	pl->statusmsg (format ("You %s the %s.", &transformer->slaying, query_base_name (marked, 0)));
		3363
		3364	pl->insert (new_item);
		3365	/* Eat up one item */
		3366	marked->decrease ();
		3367
		3368	/* Eat one transformer if needed */
		3369	if (transformer->stats.food)
		3370	if (--transformer->stats.food == 0)
		3371	transformer->decrease ();
		3372	}
		3373
		3374	/**
		3375	* Main apply handler.
		3376	*
		3377	* Checks for unpaid items before applying.
		3378	*
		3379	* Return value is currently not used
		3380	*
		3381	* who is the object that is causing object to be applied, op is the object
		3382	* being applied.
		3383	*
		3384	* aflag is special (always apply/unapply) flags. Nothing is done with
		3385	* them in this function - they are passed to apply_special
		3386	*/
		3387	static bool
		3388	manual_apply (object *who, object *op, int aflag)
		3389	{
		3390	op = op->head_ ();
		3391
		3392	if (op->flag [FLAG_UNPAID] && !op->flag [FLAG_APPLIED])
		3393	{
		3394	if (who->contr)
		3395	{
		3396	examine (who, op);
		3397	//who->failmsg ("You should pay for it first! H<You cannot use items marked as unpaid.>");//TODO remove
		3398	return 1;
		3399	}
		3400	else
		3401	return 0; /* monsters just skip unpaid items */
		3402	}
		3403
		3404	if (INVOKE_OBJECT (APPLY, op, ARG_OBJECT (who)))
		3405	return RESULT_INT (0);
		3406	else if (apply_types_inv_only [op->type])
		3407	{
		3408	// special item, using slot system, needs to be in inv
		3409	if (op->env == who)
3619	return apply_special (who, op, aflags);	3410	return apply_special (who, op, aflag);
		3411
		3412	who->failmsg (format ("You must get it first! H<You can only apply the %s if it is in your inventory.>\n", query_name (op)));
		3413	}
		3414	else if (!who->contr && apply_types_player_only [op->type])
		3415	return 0; // monsters shouldn't try to apply player-only stuff
		3416	else if (apply_types [op->type])
		3417	{
		3418	// ordinary stuff, may be on the floor
		3419	switch (op->type)
		3420	{
		3421	case T_HANDLE:
		3422	who->play_sound (sound_find ("turn_handle"));
		3423	who->statusmsg ("You turn the handle.");
		3424	op->value = op->value ? 0 : 1;
		3425	SET_ANIMATION (op, op->value);
		3426	update_object (op, UP_OBJ_FACE);
		3427	push_button (op, who);
		3428	break;
		3429
		3430	case TRIGGER:
		3431	if (check_trigger (op, who, who))
		3432	{
		3433	who->statusmsg ("You turn the handle.");
		3434	who->play_sound (sound_find ("turn_handle"));
		3435	}
		3436	else
		3437	who->failmsg ("The handle doesn't move.");
		3438
		3439	break;
		3440
		3441	case EXIT:
		3442	if (!EXIT_PATH (op))
		3443	who->failmsg (format ("The %s is closed. H<And will stay closed, until somebody fires up the map editor and adds it.>", query_name (op)));
		3444	else
		3445	{
		3446	/* Don't display messages for random maps. */
		3447	if (op->msg && EXIT_PATH (op) != shstr_random_map_exit)
		3448	who->statusmsg (op->msg, NDI_NAVY);
		3449
		3450	who->enter_exit (op);
		3451	}
		3452
		3453	break;
		3454
		3455	case INSCRIBABLE:
		3456	who->statusmsg (op->msg);
		3457	// maybe show a spell menu to chose from or something like that
		3458	break;
		3459
		3460	case SIGN:
		3461	apply_sign (who, op, 0);
		3462	break;
		3463
		3464	case BOOK:
		3465	apply_book (who, op);
		3466	break;
		3467
		3468	case SKILLSCROLL:
		3469	apply_skillscroll (who, op);
		3470	break;
		3471
		3472	case SPELLBOOK:
		3473	apply_spellbook (who, op);
		3474	break;
		3475
		3476	case SCROLL:
		3477	apply_scroll (who, op, 0);
		3478	break;
		3479
		3480	case POTION:
		3481	apply_potion (who, op);
		3482	break;
		3483
		3484	/* Eneq(@csd.uu.se): Handle apply on containers. */
		3485	//TODO: remove, as it is unsed?
		3486	case CLOSE_CON:
		3487	apply_container (who, op->env);
		3488	break;
		3489
		3490	case CONTAINER:
		3491	apply_container (who, op);
		3492	break;
		3493
		3494	case TREASURE:
		3495	apply_treasure (who, op);
		3496	break;
		3497
		3498	case LAMP:
		3499	case TORCH:
		3500	player_apply_lamp (who, op);
		3501	break;
		3502
		3503	case DRINK:
		3504	case FOOD:
		3505	case FLESH:
		3506	apply_food (who, op);
		3507	break;
		3508
		3509	case POISON:
		3510	apply_poison (who, op);
		3511	break;
		3512
		3513	case SAVEBED:
		3514	break;
		3515
		3516	case ARMOUR_IMPROVER:
		3517	apply_armour_improver (who, op);
		3518	break;
		3519
		3520	case WEAPON_IMPROVER:
		3521	check_improve_weapon (who, op);
		3522	break;
		3523
		3524	case CLOCK:
		3525	{
		3526	char buf[MAX_BUF];
		3527	timeofday_t tod;
		3528
		3529	get_tod (&tod);
		3530	who->play_sound (sound_find ("sound_clock"));
		3531	who->statusmsg (format (
		3532	"It is %d minute%s past %d o'clock %s",
		3533	tod.minute + 1, ((tod.minute + 1 < 2) ? "" : "s"),
		3534	((tod.hour % 14 == 0) ? 14 : ((tod.hour) % 14)), ((tod.hour >= 14) ? "pm" : "am")
		3535	));
		3536	}
		3537	break;
		3538
		3539	case MENU:
		3540	shop_listing (op, who);
		3541	break;
		3542
		3543	case POWER_CRYSTAL:
		3544	apply_power_crystal (who, op); /* see egoitem.c */
		3545	break;
		3546
		3547	case LIGHTER: /* for lighting torches/lanterns/etc */
		3548	apply_lighter (who, op);
		3549	break;
		3550
		3551	case ITEM_TRANSFORMER:
		3552	apply_item_transformer (who, op);
		3553	break;
		3554	}
		3555
		3556	return 1;
		3557	}
		3558	else
		3559	{
		3560	who->statusmsg (format ("I don't know how to apply the %s.", query_name (op)));
		3561	return 0;
		3562	}
		3563	}
		3564
		3565	/**
		3566	* player_apply_below attempts to apply the object 'below' the player.
		3567	* If the player has an open container, we use that for below, otherwise
		3568	* we use the ground.
		3569	*/
		3570	void
		3571	player_apply_below (object *pl)
		3572	{
		3573	object *top = pl->container_ () ? pl->container_ ()->inv : pl->below;
		3574
		3575	/* If using a container, set the starting item to be the top
		3576	* item in the container. Otherwise, use the map.
		3577	*/
		3578
		3579	// first try to apply "applyables"
		3580	for (object *tmp = top; tmp; tmp = tmp->below)
		3581	if (!tmp->invisible && apply_types [tmp->type])
		3582	{
		3583	// If it is visible, player can apply it.
		3584	pl->apply (tmp);
		3585	return;
		3586	}
		3587
		3588	while (top && top->invisible)
		3589	top = top->below;
		3590
		3591	if (!top || top->flag [FLAG_IS_FLOOR])
		3592	pl->failmsg ("You inspect this space, but find no way to apply anything. "
		3593	"H<There is nothing here that you can apply.>");
		3594	else
		3595	// next, try to explain the topmost object
		3596	switch (top->type)
		3597	{
		3598	// TODO: all this should move to examine
		3599	case ALTAR:
		3600	case IDENTIFY_ALTAR:
		3601	case TRIGGER_ALTAR:
		3602	case CONVERTER:
		3603	//case TRIGGER_PEDESTAL:
		3604	pl->failmsg (format (
		3605	"You see no obvious mechanism on the %s."
		3606	"H<You have to drop one or more specific items here.>",
		3607	query_short_name (top)
		3608	));
		3609	break;
		3610
		3611	case BUTTON:
		3612	case TRIGGER_BUTTON:
		3613	pl->failmsg (format (
		3614	"The %s looks as if you could activate it with somehting heavy. "
		3615	"H<You must put enough items here to activate it.>",
		3616	query_short_name (top)
		3617	));
		3618	break;
		3619
		3620	default:
		3621	examine (pl, top);
		3622	break;
		3623	}
		3624	}
		3625
		3626	// saner interface, returns successful status
		3627	bool
		3628	object::apply (object *ob, int aflags)
		3629	{
		3630	if (!ob) // simplifies a lot of callers
		3631	return true;
		3632
		3633	if (contr)
		3634	{
		3635	if (!ob->env && (move_type & MOVE_FLYING))
		3636	{
		3637	/* player is flying and applying object not in inventory */
		3638	if (!flag [FLAG_WIZ] && !(ob->move_type & MOVE_FLYING))
		3639	{
		3640	failmsg ("But you are floating high above the ground! "
		3641	"H<You have to stop levitating first, if you can, either by using your levitation skill, "
		3642	"or waiting till the levitation effect wears off.>");
		3643	return 0;
		3644	}
		3645	}
		3646
		3647	contr->last_used = ob;
		3648	}
		3649
		3650	bool want_apply =
		3651	aflags & AP_APPLY ? true
		3652	: aflags & AP_UNAPPLY ? false
		3653	: !ob->flag [FLAG_APPLIED]; // AP_TOGGLE
		3654
		3655	object_ptr *slot = 0;
		3656
		3657	// detect the slot, if this is a player
		3658	if (contr && !(aflags & AP_NO_SLOT))
		3659	{
		3660	object *oslot;
		3661
		3662	switch (ob->type)
		3663	{
		3664	case WEAPON:
		3665	slot = &contr->combat_ob;
		3666	oslot = contr->ranged_ob;
		3667	break;
		3668
		3669	case BOW:
		3670	case RANGED:
		3671	case SPELL:
		3672	case WAND:
		3673	case ROD:
		3674	case HORN:
		3675	case BUILDER:
		3676	slot = &contr->ranged_ob;
		3677	oslot = contr->combat_ob;
		3678	break;
		3679
		3680	// oh, the humanity
		3681	case SKILL:
		3682	if (aflags & AP_NO_SLOT)
		3683	break;
		3684
		3685	if (skill_flags [ob->subtype] & SF_NEED_ITEM)
		3686	break;
		3687
		3688	if (skill_flags [ob->subtype] & SF_COMBAT)
		3689	{
		3690	slot = &contr->combat_ob;
		3691	oslot = contr->ranged_ob;
		3692	}
		3693	else if (skill_flags [ob->subtype] & SF_RANGED)
		3694	{
		3695	slot = &contr->ranged_ob;
		3696	oslot = contr->combat_ob;
		3697	}
		3698
		3699	break;
		3700	}
		3701
		3702	// now handle slot exclusions
		3703	if (slot)
		3704	{
		3705	// only one slot can be active
		3706	if (want_apply)
		3707	{
		3708	// clear slot unless we are in it already
		3709	if (*slot != ob)
		3710	apply (*slot, AP_UNAPPLY);
		3711
		3712	// unapply other slot, because we want to become active
		3713	apply (oslot, AP_UNAPPLY);
		3714	}
		3715
		3716	// clear item from slot if applied
		3717	if (!want_apply && current_weapon == ob)
		3718	current_weapon = 0;
		3719	}
		3720	}
		3721
		3722	if (ob->flag [FLAG_APPLIED] != want_apply)
		3723	manual_apply (this, ob, aflags);
		3724
		3725	if (ob->flag [FLAG_APPLIED] != want_apply)
		3726	return false;
		3727
		3728	if (slot && want_apply)
		3729	current_weapon = *slot = ob;
		3730
		3731	return true;
3620	}	3732	}
3621		3733
3622	/**	3734	/**
3623	* Map was just loaded, handle op's initialisation.	3735	* Map was just loaded, handle op's initialisation.
3624	*	3736	*
…		…
3731	* treasure again for this object	3843	* treasure again for this object
3732	*/	3844	*/
3733	invtmp->randomitems = NULL;	3845	invtmp->randomitems = NULL;
3734	}	3846	}
3735	}	3847	}
		3848
3736	/* This is really temporary - the code at the bottom will	3849	/* This is really temporary - the code at the bottom will
3737	* also set randomitems to null. The problem is there are bunches	3850	* also set randomitems to null. The problem is there are bunches
3738	* of maps/players already out there with items that have spells	3851	* of maps/players already out there with items that have spells
3739	* which haven't had the randomitems set to null yet.	3852	* which haven't had the randomitems set to null yet.
3740	* MSW 2004-05-13	3853	* MSW 2004-05-13
…		…
3744	* Ryo 2004-08-16	3857	* Ryo 2004-08-16
3745	*/	3858	*/
3746	if (tmp->type == WAND || tmp->type == ROD || tmp->type == SCROLL	3859	if (tmp->type == WAND || tmp->type == ROD || tmp->type == SCROLL
3747	|| tmp->type == HORN || tmp->type == FIREWALL || tmp->type == POTION || tmp->type == ALTAR || tmp->type == SPELLBOOK)	3860	|| tmp->type == HORN || tmp->type == FIREWALL || tmp->type == POTION || tmp->type == ALTAR || tmp->type == SPELLBOOK)
3748	tmp->randomitems = NULL;	3861	tmp->randomitems = NULL;
3749
3750	}	3862	}
3751		3863
3752	if (QUERY_FLAG (tmp, FLAG_AUTO_APPLY))	3864	if (QUERY_FLAG (tmp, FLAG_AUTO_APPLY))
3753	auto_apply (tmp);	3865	auto_apply (tmp);
3754	else if ((tmp->type == TREASURE || (tmp->type == CONTAINER)) && tmp->has_random_items ())	3866	else if ((tmp->type == TREASURE || (tmp->type == CONTAINER)) && tmp->has_random_items ())
…		…
3811	/* bigger morsel of food = longer effect time */	3923	/* bigger morsel of food = longer effect time */
3812	int duration = TIME2TICK (food->stats.food);	3924	int duration = TIME2TICK (food->stats.food);
3813		3925
3814	if (force = who->force_find (key))	3926	if (force = who->force_find (key))
3815	{	3927	{
3816	if (duration > abs (force->speed_left / force->speed))	3928	if (duration > fabs (force->speed_left / force->speed))
3817	{	3929	{
3818	new_draw_info_format (NDI_UNIQUE, 0, who, "More magical force spreads through you. H<The effect will last for about %.10g more seconds.>", TICK2TIME (duration));	3930	new_draw_info_format (NDI_UNIQUE, 0, who, "More magical force spreads through you. H<The effect will last for about %.10g more seconds.>", TICK2TIME (duration));
3819	force->force_set_timer (duration);	3931	force->force_set_timer (duration);
3820	}	3932	}
3821	else	3933	else
…		…
3893	/* place limit on max sp from food? */	4005	/* place limit on max sp from food? */
3894	}	4006	}
3895	}	4007	}
3896		4008
3897	who->update_stats ();	4009	who->update_stats ();
3898	}
3899
3900
3901	/**
3902	* op made some mistake with a scroll, this takes care of punishment.
3903	* scroll_failure()- hacked directly from spell_failure
3904	*/
3905	void
3906	scroll_failure (object *op, int failure, int power)
3907	{
3908	if (abs (failure / 4) > power)
3909	power = abs (failure / 4); /* set minimum effect */
3910
3911	if (failure <= -1 && failure > -15)
3912	{ /* wonder */
3913	object *tmp;
3914
3915	op->failmsg ("Your spell warps!");
3916	tmp = get_archetype (SPELL_WONDER);
3917	cast_wonder (op, op, 0, tmp);
3918	tmp->destroy ();
3919	}
3920	else if (failure <= -15 && failure > -35)
3921	{ /* drain mana */
3922	op->failmsg ("Your mana is drained!");
3923	op->stats.sp -= random_roll (0, power - 1, op, PREFER_LOW);
3924	if (op->stats.sp < 0)
3925	op->stats.sp = 0;
3926	}
3927	else if (settings.spell_failure_effects == TRUE)
3928	{
3929	if (failure <= -35 && failure > -60)
3930	{ /* confusion */
3931	op->failmsg ("The magic recoils on you!");
3932	confuse_player (op, op, power);
3933	}
3934	else if (failure <= -60 && failure > -70)
3935	{ /* paralysis */
3936	op->failmsg ("The magic recoils and paralyzes you!");
3937	paralyze_player (op, op, power);
3938	}
3939	else if (failure <= -70 && failure > -80)
3940	{ /* blind */
3941	op->failmsg ("The magic recoils on you!");
3942	blind_player (op, op, power);
3943	}
3944	else if (failure <= -80)
3945	{ /* blast the immediate area */
3946	object *tmp = get_archetype (LOOSE_MANA);
3947	cast_magic_storm (op, tmp, power);
3948	op->failmsg ("You unleash uncontrolled mana!");
3949	tmp->destroy ();
3950	}
3951	}
3952	}	4010	}
3953		4011
3954	void	4012	void
3955	apply_changes_to_player (object *pl, object *change)	4013	apply_changes_to_player (object *pl, object *change)
3956	{	4014	{
…		…
4033	break;	4091	break;
4034	}	4092	}
4035	}	4093	}
4036	}	4094	}
4037		4095
4038	/**
4039	* This handles items of type 'transformer'.
4040	* Basically those items, used with a marked item, transform both items into something
4041	* else.
4042	* "Transformer" item has food decreased by 1, removed if 0 (0 at start means illimited)..
4043	* Change information is contained in the 'slaying' field of the marked item.
4044	* The format is as follow: transformer:[number ]yield[;transformer:...].
4045	* This way an item can be transformed in many things, and/or many objects.
4046	* The 'slaying' field for transformer is used as verb for the action.
4047	*/
4048	void
4049	apply_item_transformer (object *pl, object *transformer)
4050	{
4051	object *marked;
4052	object *new_item;
4053	char *find;
4054	char *separator;
4055	int yield;
4056	char got[MAX_BUF];
4057	int len;
4058
4059	if (!pl || !transformer)
4060	return;
4061
4062	marked = find_marked_object (pl);
4063
4064	if (!marked)
4065	{
4066	pl->failmsg (format ("Use the %s with what item?", query_name (transformer)));
4067	return;
4068	}
4069
4070	if (!marked->slaying)
4071	{
4072	pl->failmsg (format ("You can't use the %s with your %s!", query_name (transformer), query_name (marked)));
4073	return;
4074	}
4075
4076	/* check whether they are compatible or not */
4077	find = strstr (&marked->slaying, transformer->arch->archname);
4078	if (!find || (*(find + strlen (transformer->arch->archname)) != ':'))
4079	{
4080	pl->failmsg (format ("You can't use the %s with your %s!", query_name (transformer), query_name (marked)));
4081	return;
4082	}
4083
4084	find += strlen (transformer->arch->archname) + 1;
4085	/* Item can be used, now find how many and what it yields */
4086	if (isdigit (*(find)))
4087	{
4088	yield = atoi (find);
4089	if (yield < 1)
4090	{
4091	LOG (llevDebug, "apply_item_transformer: item %s has slaying-yield %d.", query_base_name (marked, 0), yield);
4092	yield = 1;
4093	}
4094	}
4095	else
4096	yield = 1;
4097
4098	while (isdigit (*find))
4099	find++;
4100
4101	while (*find == ' ')
4102	find++;
4103
4104	memset (got, 0, MAX_BUF);
4105
4106	if ((separator = strchr (find, ';')) != NULL)
4107	len = separator - find;
4108	else
4109	len = strlen (find);
4110
4111	if (len > MAX_BUF - 1)
4112	len = MAX_BUF - 1;
4113
4114	strcpy (got, find);
4115	got[len] = '\0';
4116
4117	/* Now create new item, remove used ones when required. */
4118	new_item = get_archetype (got);
4119	if (!new_item)
4120	{
4121	pl->failmsg (format ("This %s is strange, better to not use it.", query_base_name (marked, 0)));
4122	return;
4123	}
4124
4125	new_item->nrof = yield;
4126
4127	pl->statusmsg (format ("You %s the %s.", &transformer->slaying, query_base_name (marked, 0)));
4128
4129	pl->insert (new_item);
4130	/* Eat up one item */
4131	marked->decrease ();
4132
4133	/* Eat one transformer if needed */
4134	if (transformer->stats.food)
4135	if (--transformer->stats.food == 0)
4136	transformer->decrease ();
4137	}
4138

Diff Legend

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