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.229 by root, Fri Mar 26 20:17:48 2010 UTC vs.
Revision 1.253 by root, Sat Apr 10 05:12:57 2010 UTC

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

Diff Legend

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