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.249 by root, Tue Apr 6 21:11:49 2010 UTC

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

Diff Legend

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