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

Diff Legend

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