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.213 by elmex, Mon Nov 9 13:38:36 2009 UTC vs.
Revision 1.252 by root, Sat Apr 10 04:54:09 2010 UTC

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

Diff Legend

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