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

Diff Legend

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