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.240 by root, Mon Apr 5 20:33:13 2010 UTC vs.
Revision 1.266 by root, Tue May 25 02:49:11 2010 UTC

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

Diff Legend

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