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.207 by root, Thu Nov 5 16:09:51 2009 UTC vs.
Revision 1.240 by root, Mon Apr 5 20:33:13 2010 UTC

1	/*	1	/*
2	* This file is part of Deliantra, the Roguelike Realtime MMORPG.	2	* This file is part of Deliantra, the Roguelike Realtime MMORPG.
3	*	3	*
4	* Copyright (©) 2005,2006,2007,2008 Marc Alexander Lehmann / Robin Redeker / the Deliantra team	4	* Copyright (©) 2005,2006,2007,2008,2009,2010 Marc Alexander Lehmann / Robin Redeker / the Deliantra team
5	* Copyright (©) 2001,2007 Mark Wedel & Crossfire Development Team	5	* Copyright (©) 2001 Mark Wedel & Crossfire Development Team
6	* Copyright (©) 1992,2007 Frank Tore Johansen	6	* Copyright (©) 1992 Frank Tore Johansen
7	*	7	*
8	* Deliantra is free software: you can redistribute it and/or modify it under	8	* Deliantra is free software: you can redistribute it and/or modify it under
9	* the terms of the Affero GNU General Public License as published by the	9	* the terms of the Affero GNU General Public License as published by the
10	* Free Software Foundation, either version 3 of the License, or (at your	10	* Free Software Foundation, either version 3 of the License, or (at your
11	* option) any later version.	11	* option) any later version.
…		…
30	#include <skills.h>	30	#include <skills.h>
31	#include <tod.h>	31	#include <tod.h>
32		32
33	#include <sproto.h>	33	#include <sproto.h>
34		34
35	/* Want this regardless of rplay. */
36	#include <sounds.h>
37
38	/**	35	/**
39	* Check if op should abort moving victim because of it's race or slaying.	36	* 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.	37	* Returns 1 if it should abort, returns 0 if it should continue.
41	*/	38	*/
42	int	39	int
…		…
172	*/	169	*/
173	int	170	int
174	apply_potion (object *op, object *tmp)	171	apply_potion (object *op, object *tmp)
175	{	172	{
176	int got_one = 0, i;	173	int got_one = 0, i;
177	object *force = 0, *floor = 0;	174	object *force = 0;
178		175
179	floor = GET_MAP_OB (op->map, op->x, op->y);	176	object *floor = GET_MAP_OB (op->map, op->x, op->y);
180		177
181	if (get_map_flags (op->map, NULL, op->x, op->y, NULL, NULL) & P_SAFE)	178	if (get_map_flags (op->map, NULL, op->x, op->y, NULL, NULL) & P_SAFE)
182	{	179	{
183	op->failmsg ("Gods prevent you from using this here, it's sacred ground!");	180	op->failmsg ("Gods prevent you from using this here, it's sacred ground!");
184		181
…		…
204	op->update_stats ();	201	op->update_stats ();
205	tmp->decrease ();	202	tmp->decrease ();
206	return 1;	203	return 1;
207	}	204	}
208		205
209	if (!(at = archetype::find (ARCH_DEPLETION)))	206	if (!(at = archetype::find (shstr_depletion)))
210	{	207	{
211	LOG (llevError, "Could not find archetype depletion\n");	208	LOG (llevError, "Could not find archetype depletion\n");
212	return 0;	209	return 0;
213	}	210	}
214		211
…		…
231	}	228	}
232		229
233	/* improvement potion - only for players */	230	/* improvement potion - only for players */
234	if (op->type == PLAYER && (tmp->attacktype & AT_GODPOWER))	231	if (op->type == PLAYER && (tmp->attacktype & AT_GODPOWER))
235	{	232	{
236	for (i = 1; i < MIN (11, op->level); i++)	233	for (i = 1; i < min (11, op->level); i++)
237	{	234	{
238	if (QUERY_FLAG (tmp, FLAG_CURSED) || QUERY_FLAG (tmp, FLAG_DAMNED))	235	if (QUERY_FLAG (tmp, FLAG_CURSED) || QUERY_FLAG (tmp, FLAG_DAMNED))
239	{	236	{
240	if (op->contr->levhp[i] != 1)	237	if (op->contr->levhp[i] != 1)
241	{	238	{
…		…
276	}	273	}
277	}	274	}
278	}	275	}
279		276
280	/* Just makes checking easier */	277	/* Just makes checking easier */
281	if (i < MIN (11, op->level))	278	if (i < min (11, op->level))
282	got_one = 1;	279	got_one = 1;
283		280
284	if (!QUERY_FLAG (tmp, FLAG_CURSED) && !QUERY_FLAG (tmp, FLAG_DAMNED))	281	if (!QUERY_FLAG (tmp, FLAG_CURSED) && !QUERY_FLAG (tmp, FLAG_DAMNED))
285	{	282	{
286	if (got_one)	283	if (got_one)
…		…
400		397
401	/**	398	/**
402	* This function just checks whether who can handle equipping an item	399	* This function just checks whether who can handle equipping an item
403	* with item_power.	400	* with item_power.
404	*/	401	*/
405		402	static bool
406	bool
407	check_item_power (object *who, int item_power)	403	check_item_power (object *who, int item_power)
408	{	404	{
409	if (who->type == PLAYER	405	if (who->type == PLAYER
410	&& item_power	406	&& item_power
411	&& item_power + who->contr->item_power > settings.item_power_factor * who->level)	407	&& item_power + who->contr->item_power > settings.item_power_factor * who->level)
…		…
532		528
533	/**	529	/**
534	* This does the prepare weapon scroll.	530	* This does the prepare weapon scroll.
535	* Checks for sacrifice, and so on.	531	* Checks for sacrifice, and so on.
536	*/	532	*/
537	int	533	static int
538	prepare_weapon (object *op, object *improver, object *weapon)	534	prepare_weapon (object *op, object *improver, object *weapon)
539	{	535	{
540	int sacrifice_count, i;	536	int sacrifice_count, i;
541	char buf[MAX_BUF];	537	char buf[MAX_BUF];
542		538
…		…
595	*	591	*
596	* We are hiding extra information about the weapon in the level and	592	* We are hiding extra information about the weapon in the level and
597	* last_eat numbers for an object. Hopefully this won't break anything ??	593	* last_eat numbers for an object. Hopefully this won't break anything ??
598	* level == max improve last_eat == current improve	594	* level == max improve last_eat == current improve
599	*/	595	*/
600	int	596	static int
601	improve_weapon (object *op, object *improver, object *weapon)	597	improve_weapon (object *op, object *improver, object *weapon)
602	{	598	{
603	int sacrifice_count, sacrifice_needed = 0;	599	int sacrifice_count, sacrifice_needed = 0;
604		600
605	if (improver->stats.sp == IMPROVE_PREPARE)	601	if (improver->stats.sp == IMPROVE_PREPARE)
…		…
707	/**	703	/**
708	* Handles the applying of improve/prepare/enchant weapon scroll.	704	* Handles the applying of improve/prepare/enchant weapon scroll.
709	* Checks a few things (not on a non-magic square, marked weapon, ...),	705	* Checks a few things (not on a non-magic square, marked weapon, ...),
710	* then calls improve_weapon to do the dirty work.	706	* then calls improve_weapon to do the dirty work.
711	*/	707	*/
712	int	708	static int
713	check_improve_weapon (object *op, object *tmp)	709	check_improve_weapon (object *op, object *tmp)
714	{	710	{
715	object *otmp;	711	object *otmp;
716		712
717	if (op->type != PLAYER)	713	if (op->type != PLAYER)
…		…
764	* the armour value of the piece of equipment exceed either	760	* the armour value of the piece of equipment exceed either
765	* the users level or 90)	761	* the users level or 90)
766	* Modified by MSW for partial resistance. Only support	762	* Modified by MSW for partial resistance. Only support
767	* changing of physical area right now.	763	* changing of physical area right now.
768	*/	764	*/
769	int	765	static int
770	improve_armour (object *op, object *improver, object *armour)	766	improve_armour (object *op, object *improver, object *armour)
771	{	767	{
772	object *tmp;	768	object *tmp;
773		769
774	if (armour->magic >= settings.armor_max_enchant)	770	if (armour->magic >= settings.armor_max_enchant)
…		…
861	* what the converter wants, this will not do anything.	857	* what the converter wants, this will not do anything.
862	*/	858	*/
863	int	859	int
864	convert_item (object *item, object *converter)	860	convert_item (object *item, object *converter)
865	{	861	{
866	sint64 nr, price_in;	862	sint64 nr = 0, price_in;
867		863
868	if (item->flag [FLAG_UNPAID])	864	if (item->flag [FLAG_UNPAID])
869	return 0;	865	return 0;
870		866
871	shstr conv_from = converter->slaying;	867	shstr conv_from = converter->slaying;
872	archetype *conv_to = converter->other_arch;	868	archetype *conv_to = converter->other_arch;
873	sint64 need = converter->stats.food;	869	sint64 need = converter->stats.food;
874	sint64 give = converter->stats.sp;	870	sint64 give = converter->stats.sp;
875		871
…		…
952	item->nrof *= nr;	948	item->nrof *= nr;
953		949
954	if (converter->flag [FLAG_PRECIOUS])	950	if (converter->flag [FLAG_PRECIOUS])
955	SET_FLAG (item, FLAG_UNPAID);	951	SET_FLAG (item, FLAG_UNPAID);
956		952
957	if (is_in_shop (converter))	953	if (converter->is_in_shop ())
958	{	954	{
959	// converters on shop floors don't work anymore, bug lets check for it	955	// converters on shop floors don't work anymore, bug lets check for it
960	// and report in case someone still does it.	956	// and report in case someone still does it.
961	LOG (llevDebug, "ITEMBUG: broken converter, converters on shop floor don't work: %s\n",	957	LOG (llevDebug, "ITEMBUG: broken converter, converters on shop floor don't work: %s\n",
962	converter->debug_desc ());	958	converter->debug_desc ());
…		…
985	* Handle apply on containers.	981	* Handle apply on containers.
986	* By Eneq(@csd.uu.se).	982	* By Eneq(@csd.uu.se).
987	* Moved to own function and added many features [Tero.Haatanen@lut.fi]	983	* Moved to own function and added many features [Tero.Haatanen@lut.fi]
988	* added the alchemical cauldron to the code -b.t.	984	* added the alchemical cauldron to the code -b.t.
989	*/	985	*/
990	int	986	static int
991	apply_container (object *op, object *sack)	987	apply_container (object *op, object *sack)
992	{	988	{
993	if (op->type != PLAYER || !op->contr->ns)	989	if (op->type != PLAYER || !op->contr->ns)
994	return 0; /* This might change */	990	return 0; /* This might change */
995		991
…		…
1165	/* this is only used for players */	1161	/* this is only used for players */
1166	rv = teleport (shop_mat, SHOP_MAT, op);	1162	rv = teleport (shop_mat, SHOP_MAT, op);
1167		1163
1168	if (has_unpaid)	1164	if (has_unpaid)
1169	op->contr->play_sound (sound_find ("shop_buy"));	1165	op->contr->play_sound (sound_find ("shop_buy"));
1170	else if (is_in_shop (op))	1166	else if (op->is_in_shop ())
1171	op->contr->play_sound (sound_find ("shop_enter"));	1167	op->contr->play_sound (sound_find ("shop_enter"));
1172	else	1168	else
1173	op->contr->play_sound (sound_find ("shop_leave"));	1169	op->contr->play_sound (sound_find ("shop_leave"));
1174		1170
1175	if (shop_mat->msg)	1171	if (shop_mat->msg)
1176	op->statusmsg (shop_mat->msg);	1172	op->statusmsg (shop_mat->msg);
1177	/* This check below is a bit simplistic - generally it should be correct,	1173	/* This check below is a bit simplistic - generally it should be correct,
1178	* but there is never a guarantee that the bottom space on the map is	1174	* but there is never a guarantee that the bottom space on the map is
1179	* actually the shop floor.	1175	* actually the shop floor.
1180	*/	1176	*/
1181	else if (!rv && !is_in_shop (op))	1177	else if (!rv && !op->is_in_shop ())
1182	{	1178	{
1183	opinion = shopkeeper_approval (op->map, op);	1179	opinion = shopkeeper_approval (op->map, op);
1184		1180
1185	op->statusmsg (	1181	op->statusmsg (
1186	opinion >= 0.90 ? "The shopkeeper gives you a friendly wave."	1182	opinion >= 0.90 ? "The shopkeeper gives you a friendly wave."
…		…
1354	trap->stats.maxsp = 2;	1350	trap->stats.maxsp = 2;
1355		1351
1356	/* Is this correct? From the docs, it doesn't look like it	1352	/* Is this correct? From the docs, it doesn't look like it
1357	* should be divided by trap->speed	1353	* should be divided by trap->speed
1358	*/	1354	*/
1359	victim->speed_left = -FABS (trap->stats.maxsp * victim->speed / trap->speed);	1355	victim->speed_left = -trap->stats.maxsp * victim->speed / trap->speed;
1360		1356
1361	/* Just put in some sanity check. I think there is a bug in the	1357	/* Just put in some sanity check. I think there is a bug in the
1362	* above with some objects have zero speed, and thus the player	1358	* above with some objects have zero speed, and thus the player
1363	* getting permanently paralyzed.	1359	* getting permanently paralyzed.
1364	*/	1360	*/
…		…
1405	* trigger this here and get hit by own missile - and will be own enemy.	1401	* trigger this here and get hit by own missile - and will be own enemy.
1406	* Victim then is his own enemy and will start to kill herself (this is	1402	* Victim then is his own enemy and will start to kill herself (this is
1407	* removed) but we have not synced victim and his missile. To avoid senseless	1403	* removed) but we have not synced victim and his missile. To avoid senseless
1408	* action, we avoid hits here	1404	* action, we avoid hits here
1409	*/	1405	*/
1410	if ((QUERY_FLAG (victim, FLAG_ALIVE) && trap->speed) && trap->owner != victim)	1406	if ((QUERY_FLAG (victim, FLAG_ALIVE) && trap->has_active_speed ())
		1407	&& trap->owner != victim)
1411	hit_with_arrow (trap, victim);	1408	hit_with_arrow (trap, victim);
1412	break;	1409	break;
1413		1410
1414	case SPELL_EFFECT:	1411	case SPELL_EFFECT:
1415	apply_spell_effect (trap, victim);	1412	apply_spell_effect (trap, victim);
…		…
1488	if (victim->type == PLAYER && EXIT_PATH (trap))	1485	if (victim->type == PLAYER && EXIT_PATH (trap))
1489	{	1486	{
1490	/* Basically, don't show exits leading to random maps the	1487	/* Basically, don't show exits leading to random maps the
1491	* players output.	1488	* players output.
1492	*/	1489	*/
1493	if (trap->msg && !EXIT_PATH (trap).starts_with ("/!"))	1490	if (trap->msg && EXIT_PATH (trap) != shstr_random_map_exit)
1494	victim->statusmsg (trap->msg, NDI_NAVY);	1491	victim->statusmsg (trap->msg, NDI_NAVY);
1495		1492
1496	trap->play_sound (trap->sound);	1493	trap->play_sound (trap->sound);
1497	victim->enter_exit (trap);	1494	victim->enter_exit (trap);
1498	}	1495	}
…		…
1576	: lev_diff < 15 ? "This book is way beyond your comprehension."	1573	: lev_diff < 15 ? "This book is way beyond your comprehension."
1577	: "This book is totally beyond your comprehension.");	1574	: "This book is totally beyond your comprehension.");
1578	return;	1575	return;
1579	}	1576	}
1580		1577
		1578	// we currently don't use the message types for anything.
1581	readable_message_type *msgType = get_readable_message_type (tmp);	1579	// readable_message_type *msgType = get_readable_message_type (tmp);
		1580
		1581	tmp->play_sound (tmp->sound ? tmp->sound : sound_find ("apply_book"));
1582		1582
1583	if (player *pl = op->contr)	1583	if (player *pl = op->contr)
1584	if (client *ns = pl->ns)	1584	if (client *ns = pl->ns)
1585	pl->infobox (MSG_CHANNEL ("book"), format ("T<%s>\n\n%s", (char *)long_desc (tmp, op), &tmp->msg));	1585	pl->infobox (MSG_CHANNEL ("book"), format ("T<%s>\n\n%s", (char *)long_desc (tmp, op), &tmp->msg));
1586		1586
…		…
1598	esrv_update_item (UPD_FLAGS | UPD_NAME, pl, tmp);	1598	esrv_update_item (UPD_FLAGS | UPD_NAME, pl, tmp);
1599	}	1599	}
1600		1600
1601	change_exp (op, exp_gain, skill_ob->skill, 0);	1601	change_exp (op, exp_gain, skill_ob->skill, 0);
1602	SET_FLAG (tmp, FLAG_NO_SKILL_IDENT); /* so no more xp gained from this book */	1602	SET_FLAG (tmp, FLAG_NO_SKILL_IDENT); /* so no more xp gained from this book */
		1603	}
		1604	}
		1605
		1606	/**
		1607	* op made some mistake with a scroll, this takes care of punishment.
		1608	* scroll_failure()- hacked directly from spell_failure
		1609	*/
		1610	static void
		1611	scroll_failure (object *op, int failure, int power)
		1612	{
		1613	if (abs (failure / 4) > power)
		1614	power = abs (failure / 4); /* set minimum effect */
		1615
		1616	if (failure <= -1 && failure > -15)
		1617	{ /* wonder */
		1618	object *tmp;
		1619
		1620	op->failmsg ("Your spell warps!");
		1621	tmp = get_archetype (SPELL_WONDER);
		1622	cast_wonder (op, op, 0, tmp);
		1623	tmp->destroy ();
		1624	}
		1625	else if (failure <= -15 && failure > -35)
		1626	{ /* drain mana */
		1627	op->failmsg ("Your mana is drained!");
		1628	op->stats.sp -= random_roll (0, power - 1, op, PREFER_LOW);
		1629	if (op->stats.sp < 0)
		1630	op->stats.sp = 0;
		1631	}
		1632	else if (settings.spell_failure_effects == TRUE)
		1633	{
		1634	if (failure <= -35 && failure > -60)
		1635	{ /* confusion */
		1636	op->failmsg ("The magic recoils on you!");
		1637	confuse_player (op, op, power);
		1638	}
		1639	else if (failure <= -60 && failure > -70)
		1640	{ /* paralysis */
		1641	op->failmsg ("The magic recoils and paralyzes you!");
		1642	paralyze_player (op, op, power);
		1643	}
		1644	else if (failure <= -70 && failure > -80)
		1645	{ /* blind */
		1646	op->failmsg ("The magic recoils on you!");
		1647	blind_player (op, op, power);
		1648	}
		1649	else if (failure <= -80)
		1650	{ /* blast the immediate area */
		1651	object *tmp = get_archetype (LOOSE_MANA);
		1652	cast_magic_storm (op, tmp, power);
		1653	op->failmsg ("You unleash uncontrolled mana!");
		1654	tmp->destroy ();
		1655	}
1603	}	1656	}
1604	}	1657	}
1605		1658
1606	/**	1659	/**
1607	* Handles the applying of a skill scroll, calling learn_skill straight.	1660	* Handles the applying of a skill scroll, calling learn_skill straight.
…		…
1686	LOG (llevError, "BUG: do_forget_spell(): spell not known\n");	1739	LOG (llevError, "BUG: do_forget_spell(): spell not known\n");
1687	return;	1740	return;
1688	}	1741	}
1689		1742
1690	op->failmsg (format ("You lose knowledge of %s.", spell));	1743	op->failmsg (format ("You lose knowledge of %s.", spell));
1691	player_unready_range_ob (op->contr, spob);
1692	esrv_remove_spell (op->contr, spob);	1744	esrv_remove_spell (op->contr, spob);
1693	spob->destroy ();	1745	spob->destroy ();
1694	}	1746	}
1695		1747
1696	/**	1748	/**
…		…
1713	* instead of having their spell stored in stats.sp. These are	1765	* instead of having their spell stored in stats.sp. These are
1714	* legacy spellbooks	1766	* legacy spellbooks
1715	*/	1767	*/
1716	if (tmp->slaying)	1768	if (tmp->slaying)
1717	{	1769	{
1718	spell = arch_to_object (find_archetype_by_object_name (tmp->slaying));	1770	spell = find_archetype_by_object_name (tmp->slaying)->instance ();
		1771
1719	if (!spell)	1772	if (!spell)
1720	{	1773	{
1721	op->failmsg (format ("The book's formula for %s is incomplete.", &tmp->slaying));	1774	op->failmsg (format ("The book's formula for %s is incomplete.", &tmp->slaying));
1722	return;	1775	return;
1723	}	1776	}
…		…
1752	op->failmsg (format ("You are unable to decipher the strange symbols. H<Your %s level is too low, it must be at least %d.>",	1805	op->failmsg (format ("You are unable to decipher the strange symbols. H<Your %s level is too low, it must be at least %d.>",
1753	&tmp->skill, learn_level));	1806	&tmp->skill, learn_level));
1754	return;	1807	return;
1755	}	1808	}
1756		1809
1757	op->statusmsg (format ("The spellbook contains the %s level spell %s.", get_levelnumber (spell->level), &spell->name));	1810	op->statusmsg (format ("The spellbook contains the %s level spell %s.", ordinal (spell->level), &spell->name));
1758		1811
1759	if (!QUERY_FLAG (tmp, FLAG_IDENTIFIED))	1812	if (!QUERY_FLAG (tmp, FLAG_IDENTIFIED))
1760	identify (tmp);	1813	identify (tmp);
1761		1814
1762	/* I removed the check for special_prayer_mark here - it didn't make	1815	/* I removed the check for special_prayer_mark here - it didn't make
…		…
1774	{	1827	{
1775	spell_skill = find_skill_by_name (op, spell->skill);	1828	spell_skill = find_skill_by_name (op, spell->skill);
1776		1829
1777	if (!spell_skill)	1830	if (!spell_skill)
1778	{	1831	{
1779	op->failmsg (format ("You lack the skill %s to use this spell.", &spell->skill));	1832	op->failmsg (format ("You lack the %s skill to use this spell.", &spell->skill));
1780	return;	1833	return;
1781	}	1834	}
1782		1835
1783	if (spell_skill->level < spell->level)	1836	if (spell_skill->level < spell->level)
1784	{	1837	{
…		…
1800	* literacy rate very useful! -b.t.	1853	* literacy rate very useful! -b.t.
1801	*/	1854	*/
1802	if (QUERY_FLAG (op, FLAG_CONFUSED))	1855	if (QUERY_FLAG (op, FLAG_CONFUSED))
1803	{	1856	{
1804	op->failmsg ("In your confused state you flub the wording of the text!");	1857	op->failmsg ("In your confused state you flub the wording of the text!");
1805	scroll_failure (op, 0 - random_roll (0, spell->level, op, PREFER_LOW), MAX (spell->stats.sp, spell->stats.grace));	1858	scroll_failure (op, 0 - random_roll (0, spell->level, op, PREFER_LOW), max (spell->stats.sp, spell->stats.grace));
1806	}	1859	}
1807	else if (QUERY_FLAG (tmp, FLAG_STARTEQUIP) ||	1860	else if (QUERY_FLAG (tmp, FLAG_STARTEQUIP) ||
1808	(random_roll (0, 100, op, PREFER_LOW) - (5 * skop->level)) < learn_spell[spell->stats.grace ? op->stats.Wis : op->stats.Int])	1861	(random_roll (0, 100, op, PREFER_LOW) - (5 * skop->level)) < learn_spell[spell->stats.grace ? op->stats.Wis : op->stats.Int])
1809	{	1862	{
1810	op->statusmsg ("You succeed in learning the spell!", NDI_GREEN);	1863	op->statusmsg ("You succeed in learning the spell!", NDI_GREEN);
…		…
1916	break;	1969	break;
1917	}	1970	}
1918		1971
1919	if (!tmp->destroyed () && !tmp->inv)	1972	if (!tmp->destroyed () && !tmp->inv)
1920	tmp->decrease (true);	1973	tmp->decrease (true);
1921	}
1922
1923	/**
1924	* op eats food.
1925	* If player, takes care of messages and dragon special food.
1926	*/
1927	static void
1928	apply_food (object *op, object *tmp)
1929	{
1930	int capacity_remaining;
1931
1932	if (op->type != PLAYER)
1933	op->stats.hp = op->stats.maxhp;
1934	else
1935	{
1936	/* check if this is a dragon (player), eating some flesh */
1937	if (tmp->type == FLESH && is_dragon_pl (op) && dragon_eat_flesh (op, tmp))
1938	;
1939	else
1940	{
1941	/* usual case - no dragon meal: */
1942	if (op->stats.food + tmp->stats.food > 999)
1943	{
1944	if (tmp->type == FOOD || tmp->type == FLESH)
1945	op->failmsg ("You feel full, but what a waste of food!");
1946	else
1947	op->statusmsg ("Most of the drink goes down your face not your throat!");
1948	}
1949
1950	tmp->play_sound (
1951	tmp->sound
1952	? tmp->sound
1953	: tmp->type == DRINK
1954	? sound_find ("eat_drink")
1955	: sound_find ("eat_food")
1956	);
1957
1958	if (!QUERY_FLAG (tmp, FLAG_CURSED))
1959	{
1960	const char *buf;
1961
1962	if (!is_dragon_pl (op))
1963	{
1964	/* eating message for normal players */
1965	if (tmp->type == DRINK)
1966	buf = format ("Ahhh...that %s tasted good.", &tmp->name);
1967	else
1968	buf = format ("The %s tasted %s", &tmp->name, tmp->type == FLESH ? "terrible!" : "good.");
1969	}
1970	else
1971	/* eating message for dragon players */
1972	buf = format ("The %s tasted terrible!", &tmp->name);
1973
1974	op->statusmsg (buf);
1975
1976	capacity_remaining = 999 - op->stats.food;
1977	op->stats.food += tmp->stats.food;
1978	if (capacity_remaining < tmp->stats.food)
1979	op->stats.hp += capacity_remaining / 50;
1980	else
1981	op->stats.hp += tmp->stats.food / 50;
1982
1983	if (op->stats.hp > op->stats.maxhp)
1984	op->stats.hp = op->stats.maxhp;
1985	if (op->stats.food > 999)
1986	op->stats.food = 999;
1987	}
1988
1989	/* special food hack -b.t. */
1990	if (tmp->title || QUERY_FLAG (tmp, FLAG_CURSED))
1991	eat_special_food (op, tmp);
1992	}
1993	}
1994
1995	handle_apply_yield (tmp);
1996	tmp->decrease ();
1997	}	1974	}
1998		1975
1999	/**	1976	/**
2000	* A dragon is eating some flesh. If the flesh contains resistances,	1977	* A dragon is eating some flesh. If the flesh contains resistances,
2001	* there is a chance for the dragon's skin to get improved.	1978	* there is a chance for the dragon's skin to get improved.
…		…
2004	* object *op the object (dragon player) eating the flesh	1981	* object *op the object (dragon player) eating the flesh
2005	* object *meal the flesh item, getting chewed in dragon's mouth	1982	* object *meal the flesh item, getting chewed in dragon's mouth
2006	* return:	1983	* return:
2007	* int 1 if eating successful, 0 if it doesn't work	1984	* int 1 if eating successful, 0 if it doesn't work
2008	*/	1985	*/
2009	int	1986	static int
2010	dragon_eat_flesh (object *op, object *meal)	1987	dragon_eat_flesh (object *op, object *meal)
2011	{	1988	{
2012	object *skin = NULL; /* pointer to dragon skin force */	1989	object *skin = NULL; /* pointer to dragon skin force */
2013	object *abil = NULL; /* pointer to dragon ability force */	1990	object *abil = NULL; /* pointer to dragon ability force */
2014	object *tmp = NULL; /* tmp. object */	1991	object *tmp = NULL; /* tmp. object */
…		…
2020	int atnr_winner[NROFATTACKS]; /* winning candidates for resistance improvement */	1997	int atnr_winner[NROFATTACKS]; /* winning candidates for resistance improvement */
2021	int winners = 0; /* number of winners */	1998	int winners = 0; /* number of winners */
2022	int i; /* index */	1999	int i; /* index */
2023		2000
2024	/* let's make sure and doublecheck the parameters */	2001	/* let's make sure and doublecheck the parameters */
2025	if (meal->type != FLESH || !is_dragon_pl (op))	2002	if (meal->type != FLESH || !op->is_dragon ())
2026	return 0;	2003	return 0;
2027		2004
2028	/* now grab the 'dragon_skin'- and 'dragon_ability'-forces	2005	/* now grab the 'dragon_skin'- and 'dragon_ability'-forces
2029	from the player's inventory */	2006	from the player's inventory */
2030	for (tmp = op->inv; tmp; tmp = tmp->below)	2007	for (tmp = op->inv; tmp; tmp = tmp->below)
…		…
2038	which is not to be considered a dragon -> bail out */	2015	which is not to be considered a dragon -> bail out */
2039	if (skin == NULL || abil == NULL)	2016	if (skin == NULL || abil == NULL)
2040	return 0;	2017	return 0;
2041		2018
2042	/* now start by filling stomache and health, according to food-value */	2019	/* now start by filling stomache and health, according to food-value */
2043	if ((999 - op->stats.food) < meal->stats.food)	2020	if ((MAX_FOOD - op->stats.food) < meal->stats.food)
2044	op->stats.hp += (999 - op->stats.food) / 50;	2021	op->stats.hp += (MAX_FOOD - op->stats.food) / 50;
2045	else	2022	else
2046	op->stats.hp += meal->stats.food / 50;	2023	op->stats.hp += meal->stats.food / 50;
2047		2024
2048	if (op->stats.hp > op->stats.maxhp)	2025	min_it (op->stats.hp, op->stats.maxhp);
2049	op->stats.hp = op->stats.maxhp;
2050
2051	op->stats.food = MIN (999, op->stats.food + meal->stats.food);	2026	op->stats.food = min (MAX_FOOD, op->stats.food + meal->stats.food);
2052		2027
2053	/*LOG(llevDebug, "-> player: %d, flesh: %d\n", op->level, meal->level); */	2028	/*LOG(llevDebug, "-> player: %d, flesh: %d\n", op->level, meal->level); */
2054		2029
2055	/* on to the interesting part: chances for adding resistance */	2030	/* on to the interesting part: chances for adding resistance */
2056	for (i = 0; i < NROFATTACKS; i++)	2031	for (i = 0; i < NROFATTACKS; i++)
…		…
2066		2041
2067	/* monster bonus increases with level, because high-level	2042	/* monster bonus increases with level, because high-level
2068	flesh is too rare */	2043	flesh is too rare */
2069	mbonus = op->level * 20. / ((double) settings.max_level);	2044	mbonus = op->level * 20. / ((double) settings.max_level);
2070		2045
2071	chance = (((double) MIN (op->level + bonus, meal->level + bonus + mbonus)) * 100. /	2046	chance = (((double)min (op->level + bonus, meal->level + bonus + mbonus)) * 100. /
2072	((double) settings.max_level)) - skin->resist[i];	2047	((double)settings.max_level)) - skin->resist[i];
2073		2048
2074	if (chance >= 0.)	2049	if (chance >= 0.)
2075	chance += 1.;	2050	chance += 1.;
2076	else	2051	else
2077	chance = (chance < -12) ? 0. : 1. / pow (2., -chance);	2052	chance = (chance < -12) ? 0. : 1. / pow (2., -chance);
2078		2053
2079	/* chance is proportional to amount of resistance (max. 50) */	2054	/* chance is proportional to amount of resistance (max. 50) */
2080	chance *= ((double) (MIN (meal->resist[i], 50))) / 50.;	2055	chance *= ((double)(min (meal->resist[i], 50))) / 50.;
2081		2056
2082	/* doubled chance for resistance of ability-focus */	2057	/* doubled chance for resistance of ability-focus */
2083	if (i == abil->stats.exp)	2058	if (i == abil->stats.exp)
2084	chance = MIN (100., chance * 2.);	2059	chance = min (100., chance * 2.);
2085		2060
2086	/* now make the throw and save all winners (Don't insert luck bonus here!) */	2061	/* now make the throw and save all winners (Don't insert luck bonus here!) */
2087	if (rndm (10000) < (unsigned int) (chance * 100))	2062	if (rndm (10000) < (unsigned int)(chance * 100))
2088	{	2063	{
2089	atnr_winner[winners] = i;	2064	atnr_winner[winners] = i;
2090	winners++;	2065	winners++;
2091	}	2066	}
2092		2067
…		…
2155		2130
2156	return 1;	2131	return 1;
2157	}	2132	}
2158		2133
2159	/**	2134	/**
		2135	* op eats food.
		2136	* If player, takes care of messages and dragon special food.
		2137	*/
		2138	static void
		2139	apply_food (object *op, object *tmp)
		2140	{
		2141	int capacity_remaining;
		2142
		2143	if (op->type != PLAYER)
		2144	op->stats.hp = op->stats.maxhp;
		2145	else
		2146	{
		2147	/* check if this is a dragon (player), eating some flesh */
		2148	if (tmp->type == FLESH && op->is_dragon () && dragon_eat_flesh (op, tmp))
		2149	;
		2150	else
		2151	{
		2152	/* usual case - no dragon meal: */
		2153	if (op->stats.food + tmp->stats.food > MAX_FOOD)
		2154	{
		2155	if (tmp->type == FOOD || tmp->type == FLESH)
		2156	op->failmsg ("You feel full, but what a waste of food!");
		2157	else
		2158	op->statusmsg ("Most of the drink goes down your face not your throat!");
		2159	}
		2160
		2161	tmp->play_sound (
		2162	tmp->sound
		2163	? tmp->sound
		2164	: tmp->type == DRINK
		2165	? sound_find ("eat_drink")
		2166	: sound_find ("eat_food")
		2167	);
		2168
		2169	if (!QUERY_FLAG (tmp, FLAG_CURSED))
		2170	{
		2171	const char *buf;
		2172
		2173	if (!op->is_dragon ())
		2174	{
		2175	/* eating message for normal players */
		2176	if (tmp->type == DRINK)
		2177	buf = format ("Ahhh...that %s tasted good.", &tmp->name);
		2178	else
		2179	buf = format ("The %s tasted %s", &tmp->name, tmp->type == FLESH ? "terrible!" : "good.");
		2180	}
		2181	else
		2182	/* eating message for dragon players */
		2183	buf = format ("The %s tasted terrible!", &tmp->name);
		2184
		2185	op->statusmsg (buf);
		2186
		2187	capacity_remaining = MAX_FOOD - op->stats.food;
		2188	op->stats.food += tmp->stats.food;
		2189	if (capacity_remaining < tmp->stats.food)
		2190	op->stats.hp += capacity_remaining / 50;
		2191	else
		2192	op->stats.hp += tmp->stats.food / 50;
		2193
		2194	min_it (op->stats.hp, op->stats.maxhp);
		2195	min_it (op->stats.food, MAX_FOOD);
		2196	}
		2197
		2198	/* special food hack -b.t. */
		2199	if (tmp->title || QUERY_FLAG (tmp, FLAG_CURSED))
		2200	eat_special_food (op, tmp);
		2201	}
		2202	}
		2203
		2204	handle_apply_yield (tmp);
		2205	tmp->decrease ();
		2206	}
		2207
		2208	/**
2160	* Handles applying an improve armor scroll.	2209	* Handles applying an improve armor scroll.
2161	* Does some sanity checks, then calls improve_armour.	2210	* Does some sanity checks, then calls improve_armour.
2162	*/	2211	*/
2163	static void	2212	static void
2164	apply_armour_improver (object *op, object *tmp)	2213	apply_armour_improver (object *op, object *tmp)
…		…
2212	hit_player (op, poison->stats.hp, tmp, AT_POISON, 1);	2261	hit_player (op, poison->stats.hp, tmp, AT_POISON, 1);
2213	}	2262	}
2214		2263
2215	op->stats.food -= op->stats.food / 4;	2264	op->stats.food -= op->stats.food / 4;
2216	poison->destroy ();	2265	poison->destroy ();
2217	}
2218
2219	/**
2220	* This function return true if the exit is not a 2 ways one or it is 2 ways, valid exit.
2221	* A valid 2 way exit means:
2222	* -You can come back (there is another exit at the other side)
2223	* -You are
2224	* ° the owner of the exit
2225	* ° or in the same party as the owner
2226	*
2227	* Note: a owner in a 2 way exit is saved as the owner's name
2228	* in the field exit->name cause the field exit->owner doesn't
2229	* survive in the swapping (in fact the whole exit doesn't survive).
2230	*/
2231	int
2232	is_legal_2ways_exit (object *op, object *exit)
2233	{
2234	if (exit->stats.exp != 1)
2235	return 1; /*This is not a 2 way, so it is legal */
2236
2237	#if 0 //TODO
2238	if (!has_been_loaded (EXIT_PATH (exit)) && exit->race)
2239	return 0; /* This is a reset town portal */
2240	#endif
2241
2242	LOG (llevError | logBacktrace, "sync map load due to %s\n", exit->debug_desc ());
2243
2244	maptile *exitmap = maptile::find_sync (EXIT_PATH (exit), exit->map);
2245
2246	if (exitmap)
2247	{
2248	exitmap->load_sync ();
2249
2250	object *tmp = exitmap->at (EXIT_X (exit), EXIT_Y (exit)).bot;
2251
2252	if (!tmp)
2253	return 0;
2254
2255	for (; tmp; tmp = tmp->above)
2256	{
2257	if (tmp->type != EXIT)
2258	continue; /*Not an exit */
2259
2260	if (!EXIT_PATH (tmp))
2261	continue; /*Not a valid exit */
2262
2263	if ((EXIT_X (tmp) != exit->x) || (EXIT_Y (tmp) != exit->y))
2264	continue; /*Not in the same place */
2265
2266	if (exit->map->path != EXIT_PATH (tmp))
2267	continue; /*Not in the same map */
2268
2269	/* From here we have found the exit is valid. However we do
2270	* here the check of the exit owner. It is important for the
2271	* town portals to prevent strangers from visiting your appartments
2272	*/
2273	if (!exit->race)
2274	return 1; /*No owner, free for all! */
2275
2276	object *exit_owner = 0;
2277
2278	for_all_players (pp)
2279	{
2280	if (!pp->ob)
2281	continue;
2282
2283	if (pp->ob->name != exit->race)
2284	continue;
2285
2286	exit_owner = pp->ob; /*We found a player which correspond to the player name */
2287	break;
2288	}
2289
2290	if (!exit_owner)
2291	return 0; /* No more owner */
2292
2293	if (exit_owner->contr == op->contr)
2294	return 1; /*It is your exit */
2295
2296	if (exit_owner && /*There is a owner */
2297	(op->contr) && /*A player tries to pass */
2298	((exit_owner->contr->party == NULL) || /*No pass if controller has no party */
2299	(exit_owner->contr->party != op->contr->party))) /* Or not the same as op */
2300	return 0;
2301
2302	return 1;
2303	}
2304	}
2305
2306	return 0;
2307	}	2266	}
2308		2267
2309	/**	2268	/**
2310	* This function will try to apply a lighter and in case no lighter	2269	* This function will try to apply a lighter and in case no lighter
2311	* is specified it will try to find a lighter in the players inventory,	2270	* is specified it will try to find a lighter in the players inventory,
…		…
2362	/**	2321	/**
2363	* Designed primarily to light torches/lanterns/etc.	2322	* Designed primarily to light torches/lanterns/etc.
2364	* Also burns up burnable material too. First object in the inventory is	2323	* Also burns up burnable material too. First object in the inventory is
2365	* the selected object to "burn". -b.t.	2324	* the selected object to "burn". -b.t.
2366	*/	2325	*/
2367	void	2326	static void
2368	apply_lighter (object *who, object *lighter)	2327	apply_lighter (object *who, object *lighter)
2369	{	2328	{
2370	object *item;	2329	object *item;
2371	int is_player_env = 0;	2330	int is_player_env = 0;
2372		2331
…		…
2399	}	2358	}
2400		2359
2401	/**	2360	/**
2402	* This function generates a cursed effect for cursed lamps and torches.	2361	* This function generates a cursed effect for cursed lamps and torches.
2403	*/	2362	*/
		2363	static void
2404	void player_apply_lamp_cursed_effect (object *who, object *op)	2364	player_apply_lamp_cursed_effect (object *who, object *op)
2405	{	2365	{
2406	if (op->level)	2366	if (op->level)
2407	{	2367	{
2408	who->failmsg (format (	2368	who->failmsg (format (
2409	"The %s was cursed, it explodes in a big fireball!",	2369	"The %s was cursed, it explodes in a big fireball!",
…		…
2424	* Apply for players and lamps	2384	* Apply for players and lamps
2425	*	2385	*
2426	* who - the player	2386	* who - the player
2427	* op - the lamp	2387	* op - the lamp
2428	*/	2388	*/
		2389	static void
2429	void player_apply_lamp (object *who, object *op)	2390	player_apply_lamp (object *who, object *op)
2430	{	2391	{
2431	bool switch_on = op->glow_radius ? false : true;	2392	bool switch_on = op->glow_radius ? false : true;
2432		2393
2433	if (switch_on)	2394	if (switch_on)
2434	{	2395	{
…		…
2547	if (op->other_arch)	2508	if (op->other_arch)
2548	get_animation_from_arch (op, switch_on ? op->other_arch : op->arch);	2509	get_animation_from_arch (op, switch_on ? op->other_arch : op->arch);
2549		2510
2550	if (object *pl = op->visible_to ())	2511	if (object *pl = op->visible_to ())
2551	esrv_update_item (UPD_ANIM | UPD_FACE | UPD_NAME, pl, op);	2512	esrv_update_item (UPD_ANIM | UPD_FACE | UPD_NAME, pl, op);
		2513	}
		2514
		2515	/**
		2516	* This handles items of type 'transformer'.
		2517	* Basically those items, used with a marked item, transform both items into something
		2518	* else.
		2519	* "Transformer" item has food decreased by 1, removed if 0 (0 at start means illimited)..
		2520	* Change information is contained in the 'slaying' field of the marked item.
		2521	* The format is as follow: transformer:[number ]yield[;transformer:...].
		2522	* This way an item can be transformed in many things, and/or many objects.
		2523	* The 'slaying' field for transformer is used as verb for the action.
		2524	*/
		2525	static void
		2526	apply_item_transformer (object *pl, object *transformer)
		2527	{
		2528	object *marked;
		2529	object *new_item;
		2530	const char *find;
		2531	char *separator;
		2532	int yield;
		2533	char got[MAX_BUF];
		2534	int len;
		2535
		2536	if (!pl || !transformer)
		2537	return;
		2538
		2539	marked = find_marked_object (pl);
		2540
		2541	if (!marked)
		2542	{
		2543	pl->failmsg (format ("Use the %s with what item?", query_name (transformer)));
		2544	return;
		2545	}
		2546
		2547	if (!marked->slaying)
		2548	{
		2549	pl->failmsg (format ("You can't use the %s with your %s!", query_name (transformer), query_name (marked)));
		2550	return;
		2551	}
		2552
		2553	/* check whether they are compatible or not */
		2554	find = strstr (&marked->slaying, transformer->arch->archname);
		2555	if (!find || (*(find + strlen (transformer->arch->archname)) != ':'))
		2556	{
		2557	pl->failmsg (format ("You can't use the %s with your %s!", query_name (transformer), query_name (marked)));
		2558	return;
		2559	}
		2560
		2561	find += strlen (transformer->arch->archname) + 1;
		2562	/* Item can be used, now find how many and what it yields */
		2563	if (isdigit (*(find)))
		2564	{
		2565	yield = atoi (find);
		2566	if (yield < 1)
		2567	{
		2568	LOG (llevDebug, "apply_item_transformer: item %s has slaying-yield %d.", query_base_name (marked, 0), yield);
		2569	yield = 1;
		2570	}
		2571	}
		2572	else
		2573	yield = 1;
		2574
		2575	while (isdigit (*find))
		2576	find++;
		2577
		2578	while (*find == ' ')
		2579	find++;
		2580
		2581	memset (got, 0, MAX_BUF);
		2582
		2583	if ((separator = (char *) strchr (find, ';')))
		2584	len = separator - find;
		2585	else
		2586	len = strlen (find);
		2587
		2588	min_it (len, MAX_BUF - 1);
		2589
		2590	strcpy (got, find);
		2591	got[len] = '\0';
		2592
		2593	/* Now create new item, remove used ones when required. */
		2594	new_item = get_archetype (got);
		2595	if (!new_item)
		2596	{
		2597	pl->failmsg (format ("This %s is strange, better to not use it.", query_base_name (marked, 0)));
		2598	return;
		2599	}
		2600
		2601	new_item->nrof = yield;
		2602
		2603	pl->statusmsg (format ("You %s the %s.", &transformer->slaying, query_base_name (marked, 0)));
		2604
		2605	pl->insert (new_item);
		2606	/* Eat up one item */
		2607	marked->decrease ();
		2608
		2609	/* Eat one transformer if needed */
		2610	if (transformer->stats.food)
		2611	if (--transformer->stats.food == 0)
		2612	transformer->decrease ();
2552	}	2613	}
2553		2614
2554	/**	2615	/**
2555	* Main apply handler.	2616	* Main apply handler.
2556	*	2617	*
…		…
2565	* being applied.	2626	* being applied.
2566	*	2627	*
2567	* aflag is special (always apply/unapply) flags. Nothing is done with	2628	* aflag is special (always apply/unapply) flags. Nothing is done with
2568	* them in this function - they are passed to apply_special	2629	* them in this function - they are passed to apply_special
2569	*/	2630	*/
2570	int	2631	static int
2571	manual_apply (object *who, object *op, int aflag)	2632	manual_apply (object *who, object *op, int aflag)
2572	{	2633	{
2573	op = op->head_ ();	2634	op = op->head_ ();
2574		2635
2575	if (QUERY_FLAG (op, FLAG_UNPAID) && !QUERY_FLAG (op, FLAG_APPLIED))	2636	if (op->flag [FLAG_UNPAID] && !op->flag [FLAG_APPLIED])
2576	{	2637	{
2577	if (who->type == PLAYER)	2638	if (who->type == PLAYER)
2578	{	2639	{
2579	examine (who, op);	2640	examine (who, op);
2580	//who->failmsg ("You should pay for it first! H<You cannot use items marked as unpaid.>");//TODO remove	2641	//who->failmsg ("You should pay for it first! H<You cannot use items marked as unpaid.>");//TODO remove
…		…
2611		2672
2612	case EXIT:	2673	case EXIT:
2613	if (who->type != PLAYER)	2674	if (who->type != PLAYER)
2614	return 0;	2675	return 0;
2615		2676
2616	if (!EXIT_PATH (op) || !is_legal_2ways_exit (who, op))	2677	if (!EXIT_PATH (op))
2617	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)));	2678	who->failmsg (format ("The %s is closed. H<And will stay closed, until somebody fires up the map editor and adds it.>", query_name (op)));
2618	else	2679	else
2619	{	2680	{
2620	/* Don't display messages for random maps. */	2681	/* Don't display messages for random maps. */
2621	if (op->msg && !EXIT_PATH (op).starts_with ("/!"))	2682	if (op->msg && EXIT_PATH (op) != shstr_random_map_exit)
2622	who->statusmsg (op->msg, NDI_NAVY);	2683	who->statusmsg (op->msg, NDI_NAVY);
2623		2684
2624	who->enter_exit (op);	2685	who->enter_exit (op);
2625	}	2686	}
2626		2687
…		…
2707	case CLOAK:	2768	case CLOAK:
2708	case WAND:	2769	case WAND:
2709	case ROD:	2770	case ROD:
2710	case HORN:	2771	case HORN:
2711	case SKILL:	2772	case SKILL:
		2773	case SPELL:
2712	case BOW:	2774	case BOW:
		2775	case RANGED:
2713	case BUILDER:	2776	case BUILDER:
2714	case SKILL_TOOL:	2777	case SKILL_TOOL:
2715	if (op->env != who)	2778	if (op->env != who)
2716	return 2; /* not in inventory */	2779	who->failmsg (format ("You must get it first! H<You can only apply the %s if it is in your inventory.>\n", query_name (op)));
2717		2780	else
2718	apply_special (who, op, aflag);	2781	apply_special (who, op, aflag);
		2782
2719	return 1;	2783	return 1;
2720		2784
2721	case DRINK:	2785	case DRINK:
2722	case FOOD:	2786	case FOOD:
2723	case FLESH:	2787	case FLESH:
…		…
2787	case ITEM_TRANSFORMER:	2851	case ITEM_TRANSFORMER:
2788	apply_item_transformer (who, op);	2852	apply_item_transformer (who, op);
2789	return 1;	2853	return 1;
2790		2854
2791	default:	2855	default:
		2856	who->statusmsg (format ("I don't know how to apply the %s.", query_name (op)));
2792	return 0;	2857	return 0;
2793	}	2858	}
2794	}	2859	}
2795		2860
2796	/* quiet suppresses the "don't know how to apply" and "you must get it first"	2861	/*
2797	* messages as needed by player_apply_below(). But there can still be
2798	* "but you are floating high above the ground" messages.
2799	*
2800	* Same return value as apply() function.	2862	* Same return value as apply() function.
2801	*/	2863	*/
2802	int	2864	bool
2803	player_apply (object *pl, object *op, int aflag, int quiet)	2865	player_apply (object *pl, object *op, int aflag)
2804	{	2866	{
2805	if (!op->env && (pl->move_type & MOVE_FLYING))	2867	if (!op->env && (pl->move_type & MOVE_FLYING))
2806	{	2868	{
2807	/* player is flying and applying object not in inventory */	2869	/* player is flying and applying object not in inventory */
2808	if (!QUERY_FLAG (pl, FLAG_WIZ) && !(op->move_type & MOVE_FLYING))	2870	if (!QUERY_FLAG (pl, FLAG_WIZ) && !(op->move_type & MOVE_FLYING))
…		…
2814	}	2876	}
2815	}	2877	}
2816		2878
2817	pl->contr->last_used = op;	2879	pl->contr->last_used = op;
2818		2880
2819	int tmp = manual_apply (pl, op, aflag);	2881	return pl->apply (op, aflag);
2820
2821	if (!quiet)
2822	{
2823	if (tmp == 0)
2824	pl->statusmsg (format ("I don't know how to apply the %s.", query_name (op)));
2825	else if (tmp == 2)
2826	pl->failmsg ("You must get it first!\n");
2827	}
2828
2829	return tmp;
2830	}	2882	}
2831		2883
2832	/**	2884	/**
2833	* player_apply_below attempts to apply the object 'below' the player.	2885	* player_apply_below attempts to apply the object 'below' the player.
2834	* If the player has an open container, we use that for below, otherwise	2886	* If the player has an open container, we use that for below, otherwise
…		…
2845	* we don't use a corrupt pointer for the next object, so we get the	2897	* we don't use a corrupt pointer for the next object, so we get the
2846	* next object in the stack before applying. This is can only be a	2898	* next object in the stack before applying. This is can only be a
2847	* problem if player_apply() has a bug in that it uses the object but does	2899	* problem if player_apply() has a bug in that it uses the object but does
2848	* not return a proper value.	2900	* not return a proper value.
2849	*/	2901	*/
		2902	//TODO: currently looks only at the topmost objetc, no longer at multiple floors
		2903	// and also not on move_on floors. what was this for, anyways?
2850	for (object *next, *tmp = pl->container_ () ? pl->container_ ()->inv : pl->below; tmp; tmp = next)	2904	for (object *next, *tmp = pl->container_ () ? pl->container_ ()->inv : pl->below; tmp; tmp = next)
2851	{	2905	{
2852	next = tmp->below;	2906	next = tmp->below;
2853		2907
2854	if (QUERY_FLAG (tmp, FLAG_IS_FLOOR))
2855	floors++;
2856	else if (floors > 0)
2857	return; /* process only floor objects after first floor object */
2858
2859	/* If it is visible, player can apply it. If it is applied by	2908	/* If it is visible, player can apply it.
2860	* person moving on it, also activate. Added code to make it
2861	* so that at least one of players movement types be that which
2862	* the item needs.
2863	*/	2909	*/
2864	if (!tmp->invisible || (tmp->move_on & pl->move_type))	2910	if (!tmp->invisible)
2865	if (player_apply (pl, tmp, 0, 1) == 1)	2911	if (player_apply (pl, tmp, 0))
2866	return;	2912	break;
2867		2913
2868	if (floors >= 2)	2914	break;
2869	return; /* process at most two floor objects */
2870	}	2915	}
2871	}	2916	}
2872		2917
2873	/**	2918	/**
2874	* Unapplies specified item.	2919	* Unapplies specified item.
…		…
2881	{	2926	{
2882	if (INVOKE_OBJECT (BE_UNREADY, op, ARG_OBJECT (who), ARG_INT (aflags))	2927	if (INVOKE_OBJECT (BE_UNREADY, op, ARG_OBJECT (who), ARG_INT (aflags))
2883	|| INVOKE_OBJECT (UNREADY, who, ARG_OBJECT (op), ARG_INT (aflags)))	2928	|| INVOKE_OBJECT (UNREADY, who, ARG_OBJECT (op), ARG_INT (aflags)))
2884	return RESULT_INT (0);	2929	return RESULT_INT (0);
2885		2930
2886	CLEAR_FLAG (op, FLAG_APPLIED);	2931	if (who->current_weapon == op)
		2932	who->current_weapon = 0;
		2933
		2934	op->flag [FLAG_APPLIED] = false;
2887		2935
2888	switch (op->type)	2936	switch (op->type)
2889	{	2937	{
2890	case SKILL_TOOL:	2938	case SKILL:
		2939	if (player *pl = who->contr)
		2940	if (op->invisible)
		2941	pl->statusmsg (format ("You can no longer use the %s skill.", &op->skill));
		2942	else
		2943	pl->statusmsg (format ("You stop using the %s.", query_name (op)));
		2944
		2945	change_abil (who, op);
		2946	who->flag [FLAG_READY_SKILL] = false;
		2947	break;
		2948
		2949	case WEAPON:
		2950	who->statusmsg (format ("You unwield %s.", query_name (op)));
		2951	change_abil (who, op);
		2952	who->flag [FLAG_READY_WEAPON] = false;
		2953
2891	// unapplying a skill tool should also unapply the skill it governs	2954	// unapplying a weapon or skill tool should also unapply the skill it governs
2892	// but this is hard, as it shouldn't do so when the skill can	2955	// but this is hard, as it shouldn't do so when the skill can
2893	// be used for other reasons	2956	// be used for other reasons
2894	for (object *tmp = who->inv; tmp; tmp = tmp->below)	2957	if (who->chosen_skill)
2895	if (tmp->skill == op->skill	2958	if (!who->chosen_skill->flag [FLAG_CAN_USE_SKILL])
2896	&& tmp->type == SKILL
2897	&& tmp->flag [FLAG_APPLIED]
2898	&& !tmp->flag [FLAG_CAN_USE_SKILL])
2899	unapply_special (who, tmp, 0);	2959	unapply_special (who, op, 0);
2900		2960
2901	change_abil (who, op);
2902	break;	2961	break;
2903		2962
		2963	case BOW:
2904	case WEAPON:	2964	case WAND:
		2965	case ROD:
		2966	case HORN:
		2967	case RANGED:
2905	if (player *pl = who->contr)	2968	if (player *pl = who->contr)
2906	if (op == pl->combat_ob)
2907	{
2908	pl->combat_ob = 0;
2909	who->change_weapon (pl->ranged_ob);
2910	}
2911
2912	who->statusmsg (format ("You unwield %s.", query_name (op)));
2913
2914	change_abil (who, op);
2915	CLEAR_FLAG (who, FLAG_READY_WEAPON);
2916	break;
2917
2918	case SKILL:
2919	if (who->contr)
2920	{	2969	{
2921	if (IS_COMBAT_SKILL (op->subtype))	2970	who->statusmsg (format ("You unready %s.", query_name (op)));
2922	who->change_weapon (who->contr->combat_ob = 0);	2971	change_abil (who, op);
2923	else if (IS_RANGED_SKILL (op->subtype))	2972	}
2924	who->change_weapon (who->contr->ranged_ob = 0);	2973	else
		2974	{
		2975	who->change_skill (0);
2925		2976
2926	if (op->invisible)	2977	if (op->type == BOW)
2927	who->statusmsg (format ("You can no longer use the skill: %s.", &op->skill));	2978	op->flag [FLAG_READY_BOW ] = false;
2928	else	2979	else
2929	who->statusmsg (format ("You stop using the %s.", query_name (op)));	2980	op->flag [FLAG_READY_RANGE] = false;
2930	}	2981	}
2931		2982
2932	change_abil (who, op);
2933	CLEAR_FLAG (who, FLAG_READY_SKILL);
2934	break;	2983	break;
2935		2984
2936	case ARMOUR:	2985	case ARMOUR:
2937	case HELMET:	2986	case HELMET:
2938	case SHIELD:	2987	case SHIELD:
…		…
2945	case CLOAK:	2994	case CLOAK:
2946	who->statusmsg (format ("You unwear %s.", query_name (op)));	2995	who->statusmsg (format ("You unwear %s.", query_name (op)));
2947	change_abil (who, op);	2996	change_abil (who, op);
2948	break;	2997	break;
2949		2998
		2999	case SPELL:
2950	case BOW:	3000	case BUILDER:
2951	case WAND:
2952	case ROD:
2953	case HORN:
2954	if (player *pl = who->contr)
2955	{
2956	if (op == pl->ranged_ob)
2957	{
2958	pl->ranged_ob = 0;
2959	who->change_weapon (pl->combat_ob);
2960	}
2961
2962	who->statusmsg (format ("You unready %s.", query_name (op)));	3001	who->statusmsg (format ("You unready %s.", query_name (op)));
2963	}
2964	else
2965	{
2966	who->change_skill (0);
2967
2968	if (op->type == BOW)
2969	CLEAR_FLAG (who, FLAG_READY_BOW);
2970	else
2971	CLEAR_FLAG (who, FLAG_READY_RANGE);
2972	}
2973
2974	break;	3002	break;
2975		3003
2976	case BUILDER:	3004	//case SKILL_TOOL://TODO
2977	if (who->contr)
2978	who->statusmsg (format ("You unready %s.", query_name (op)));
2979	break;
2980
2981	default:	3005	default:
2982	who->statusmsg (format ("You unapply %s.", query_name (op)));	3006	who->statusmsg (format ("You unapply %s.", query_name (op)));
2983	break;	3007	break;
2984	}	3008	}
2985		3009
…		…
3009	static object *	3033	static object *
3010	get_next_item_from_body_location (int loc, object *start)	3034	get_next_item_from_body_location (int loc, object *start)
3011	{	3035	{
3012	for (object *tmp = start; tmp; tmp = tmp->below)	3036	for (object *tmp = start; tmp; tmp = tmp->below)
3013	if (tmp->flag [FLAG_APPLIED]	3037	if (tmp->flag [FLAG_APPLIED]
3014	&& tmp->slot[loc].info	3038	&& tmp->slot [loc].info
3015	&& (!tmp->invisible || tmp->type == SKILL))	3039	&& (!tmp->invisible || tmp->type == SKILL || tmp->type == SPELL))
3016	return tmp;	3040	return tmp;
3017		3041
3018	return 0;	3042	return 0;
3019	}	3043	}
3020		3044
…		…
3033	#define CANNOT_REMOVE_CURSED \	3057	#define CANNOT_REMOVE_CURSED \
3034	"H<You cannot remove cursed or damned items, you first have to remove the curse. " \	3058	"H<You cannot remove cursed or damned items, you first have to remove the curse. " \
3035	"Praying over an altar, scrolls of remove curse/damnation, " \	3059	"Praying over an altar, scrolls of remove curse/damnation, " \
3036	"priests or even other players might help.>"	3060	"priests or even other players might help.>"
3037		3061
3038	int	3062	static int
3039	unapply_for_ob (object *who, object *op, int aflags)	3063	unapply_for_ob (object *who, object *op, int aflags)
3040	{	3064	{
3041	if (op->is_range ())	3065	if (op->is_range ())
3042	for (object *tmp = who->inv; tmp; tmp = tmp->below)	3066	for (object *tmp = who->inv; tmp; tmp = tmp->below)
3043	if (QUERY_FLAG (tmp, FLAG_APPLIED) && tmp->is_range ())	3067	if (QUERY_FLAG (tmp, FLAG_APPLIED) && tmp->is_range ())
…		…
3165	continue;	3189	continue;
3166	}	3190	}
3167		3191
3168	object *tmp1 = get_next_item_from_body_location (i, who->inv);	3192	object *tmp1 = get_next_item_from_body_location (i, who->inv);
3169	if (!tmp1)	3193	if (!tmp1)
3170	{
3171	#if 0
3172	/* This is sort of an error, but happens a lot when old players
3173	* join in with more stuff equipped than they are now allowed.
3174	*/
3175	LOG (llevError, "Can't find object using location %d on %s\n", i, who->name);
3176	#endif
3177	retval |= CAN_APPLY_NEVER;	3194	retval |= CAN_APPLY_NEVER;
3178	}
3179	else	3195	else
3180	{	3196	{
3181	/* need to unapply something. However, if this something	3197	/* need to unapply something. However, if this something
3182	* is different than we had found before, it means they need	3198	* is different than we had found before, it means they need
3183	* to apply multiple objects	3199	* to apply multiple objects
…		…
3234	if (op->type == BOW && !QUERY_FLAG (who, FLAG_USE_BOW))	3250	if (op->type == BOW && !QUERY_FLAG (who, FLAG_USE_BOW))
3235	retval |= CAN_APPLY_RESTRICTION;	3251	retval |= CAN_APPLY_RESTRICTION;
3236	}	3252	}
3237		3253
3238	return retval;	3254	return retval;
		3255	}
		3256
		3257	// saner interface, returns successful status
		3258	bool
		3259	object::apply (object *ob, int aflags)
		3260	{
		3261	if (!ob) // simplifies a lot of callers
		3262	return true;
		3263
		3264	bool want_apply =
		3265	aflags & AP_APPLY ? true
		3266	: aflags & AP_UNAPPLY ? false
		3267	: !ob->flag [FLAG_APPLIED]; // AP_TOGGLE
		3268
		3269	object_ptr *slot = 0;
		3270
		3271	// detect the slot, if this is a player
		3272	if (contr && !(aflags & AP_NO_SLOT))
		3273	{
		3274	object *oslot;
		3275
		3276	switch (ob->type)
		3277	{
		3278	case WEAPON:
		3279	slot = &contr->combat_ob;
		3280	oslot = contr->ranged_ob;
		3281	break;
		3282
		3283	case BOW:
		3284	case RANGED:
		3285	case SPELL:
		3286	case WAND:
		3287	case ROD:
		3288	case HORN:
		3289	case BUILDER:
		3290	slot = &contr->ranged_ob;
		3291	oslot = contr->combat_ob;
		3292	break;
		3293
		3294	// oh, the humanity
		3295	case SKILL:
		3296	if (aflags & AP_NO_SLOT)
		3297	break;
		3298
		3299	if (skill_flags [ob->subtype] & SF_NEED_ITEM)
		3300	break;
		3301
		3302	if (skill_flags [ob->subtype] & SF_COMBAT)
		3303	{
		3304	slot = &contr->combat_ob;
		3305	oslot = contr->ranged_ob;
		3306	}
		3307	else if (skill_flags [ob->subtype] & SF_RANGED)
		3308	{
		3309	slot = &contr->ranged_ob;
		3310	oslot = contr->combat_ob;
		3311	}
		3312
		3313	break;
		3314	}
		3315
		3316	// now handle slot exclusions
		3317	if (slot)
		3318	{
		3319	// only one slot can be active
		3320	if (want_apply)
		3321	apply (oslot, AP_UNAPPLY);
		3322
		3323	// clear item from slot if applied
		3324	if (!want_apply && *slot == ob)
		3325	{
		3326	*slot = 0;
		3327
		3328	if (current_weapon == ob)
		3329	current_weapon = 0;
		3330	}
		3331	}
		3332	}
		3333
		3334	if (ob->flag [FLAG_APPLIED] != want_apply)
		3335	manual_apply (this, ob, aflags);
		3336
		3337	if (ob->flag [FLAG_APPLIED] != want_apply)
		3338	return false;
		3339
		3340	if (slot)
		3341	current_weapon = *slot = ob;
		3342
		3343	return true;
3239	}	3344	}
3240		3345
3241	/**	3346	/**
3242	* who is the object using the object. It can be a monster.	3347	* who is the object using the object. It can be a monster.
3243	* op is the object they are using. op is an equipment type item,	3348	* op is the object they are using. op is an equipment type item,
…		…
3266	" H<You lack enough unused item power to use this weapon, see the skills command.>"	3371	" H<You lack enough unused item power to use this weapon, see the skills command.>"
3267		3372
3268	int	3373	int
3269	apply_special (object *who, object *op, int aflags)	3374	apply_special (object *who, object *op, int aflags)
3270	{	3375	{
3271	int basic_flag = aflags & AP_BASIC_FLAGS;	3376	int basic_flag = aflags & AP_MODE;
3272	object *tmp, *tmp2, *skop = NULL;	3377	object *tmp, *tmp2, *skop = NULL;
3273		3378
3274	if (who == NULL)	3379	if (who == NULL)
3275	{	3380	{
3276	LOG (llevError, "apply_special() from object without environment.\n");	3381	LOG (llevError, "apply_special() from object without environment.\n");
…		…
3295		3400
3296	return unapply_special (who, op, aflags);	3401	return unapply_special (who, op, aflags);
3297	}	3402	}
3298	else if (basic_flag == AP_UNAPPLY)	3403	else if (basic_flag == AP_UNAPPLY)
3299	return 0;	3404	return 0;
3300
3301	// if the item is combat/ranged, wield the relevant slot first
3302	// to resolve conflicts.
3303	if (player *pl = who->contr)
3304	switch (op->slottype ())
3305	{
3306	case slot_combat: who->change_weapon (pl->combat_ob); break;
3307	case slot_ranged: who->change_weapon (pl->ranged_ob); break;
3308	}
3309		3405
3310	splay (op);	3406	splay (op);
3311		3407
3312	/* Can't just apply this object. Lets see what not and what to do */	3408	/* Can't just apply this object. Lets see what not and what to do */
3313	if (int i = can_apply_object (who, op))	3409	if (int i = can_apply_object (who, op))
…		…
3347	}	3443	}
3348	}	3444	}
3349		3445
3350	if (op->skill && op->type != SKILL && op->type != SKILL_TOOL)	3446	if (op->skill && op->type != SKILL && op->type != SKILL_TOOL)
3351	{	3447	{
		3448	// try to ready attached skill first
3352	skop = find_skill_by_name (who, op->skill);	3449	skop = find_skill_by_name (who, op->skill);
3353		3450
3354	if (!skop)	3451	if (!skop)
3355	{	3452	{
3356	who->failmsg (format ("You need the %s skill to use this item!", &op->skill));	3453	who->failmsg (format ("You need the %s skill to use this item!", &op->skill));
3357	return 1;	3454	return 1;
3358	}	3455	}
3359	else	3456	else if (!who->apply (skop, AP_APPLY | AP_NO_SLOT))
3360	/* While experience will be credited properly, we want to change the
3361	* skill so that the dam and wc get updated
3362	*/	3457	{
3363	who->change_skill (skop);	3458	who->failmsg (format ("You can't use the required %s skill!", &op->skill));
		3459	return 1;
		3460	}
3364	}	3461	}
3365		3462
3366	if (!check_item_power (who, op->item_power))	3463	if (!check_item_power (who, op->item_power))
3367	{	3464	{
3368	who->failmsg ("Equipping that combined with other items would consume your soul!" LACK_ITEM_POWER);	3465	who->failmsg ("Equipping that combined with other items would consume your soul!" LACK_ITEM_POWER);
…		…
3371		3468
3372	/* Ok. We are now at the state where we can apply the new object.	3469	/* Ok. We are now at the state where we can apply the new object.
3373	* Note that we don't have the checks for can_use_...	3470	* Note that we don't have the checks for can_use_...
3374	* below - that is already taken care of by can_apply_object.	3471	* below - that is already taken care of by can_apply_object.
3375	*/	3472	*/
		3473
		3474	// split away all the other items from the stack, so only one item is left
3376	tmp = op->nrof > 1 ? op->split (op->nrof - 1) : 0;	3475	tmp = op->nrof > 1 ? op->split (op->nrof - 1) : 0;
3377		3476
3378	if (INVOKE_OBJECT (BE_READY, op, ARG_OBJECT (who)) || INVOKE_OBJECT (READY, who, ARG_OBJECT (op)))	3477	if (INVOKE_OBJECT (BE_READY, op, ARG_OBJECT (who)) || INVOKE_OBJECT (READY, who, ARG_OBJECT (op)))
3379	return RESULT_INT (0);	3478	return RESULT_INT (0);
3380		3479
3381	switch (op->type)	3480	switch (op->type)
3382	{	3481	{
3383	case WEAPON:	3482	case WEAPON:
3384	//TODO: this obviously fails for players using a shorter prefix	3483	if (op->level && (!op->name.starts_with (who->name) || op->name [who->name.length ()] != '\''))
3385	// i.e. "R" can use Ragnarok's sword.
3386	if (op->level && !op->name.starts_with (who->name))
3387	{	3484	{
3388	/* if the weapon does not have the name as the character, can't use it. */	3485	/* if the weapon does not have the name as the character, can't use it. */
3389	/* (Ragnarok's sword attempted to be used by Foo: won't work) */	3486	/* (Ragnarok's sword attempted to be used by Foo: won't work) */
3390	who->failmsg ("The weapon does not recognize you as its owner. H<Its name indicates that it belongs to somebody else.>");	3487	who->failmsg ("The weapon does not recognize you as its owner. "
3391		3488	"H<Its name indicates that it belongs to somebody else.>");
3392	if (tmp)	3489	if (tmp) who->insert (tmp);
3393	insert_ob_in_ob (tmp, who);
3394
3395	return 1;	3490	return 1;
3396	}	3491	}
3397		3492
3398	if (!skop)	3493	op->flag [FLAG_APPLIED] = true;
		3494
		3495	if (player *pl = who->contr)
3399	{	3496	{
3400	who->failmsg (format ("The %s is broken, please report this to the dungeon master!", query_name (op)));//TODO	3497	who->statusmsg (format ("You wield %s.", query_name (op)));
3401	return 1;	3498	change_abil (who, op);
3402	}	3499	}
3403		3500	else
3404	SET_FLAG (op, FLAG_APPLIED);
3405	who->change_skill (skop);	3501	who->change_skill (skop);
3406		3502
3407	if (who->contr)	3503	op->flag [FLAG_READY_WEAPON] = true;
3408	who->change_weapon (who->contr->combat_ob = op);
3409
3410	who->statusmsg (format ("You wield %s.", query_name (op)));
3411
3412	SET_FLAG (who, FLAG_READY_WEAPON);
3413	change_abil (who, op);
3414	break;	3504	break;
3415		3505
3416	case ARMOUR:	3506	case ARMOUR:
3417	case HELMET:	3507	case HELMET:
3418	case SHIELD:	3508	case SHIELD:
…		…
3427	who->statusmsg (format ("You wear %s.", query_name (op)));	3517	who->statusmsg (format ("You wear %s.", query_name (op)));
3428	change_abil (who, op);	3518	change_abil (who, op);
3429	break;	3519	break;
3430		3520
3431	case SKILL_TOOL:	3521	case SKILL_TOOL:
3432	// applying a skill tool also readies the skill	3522	// applying a skill tool does not ready the skill
		3523	// if something needs the skill, it has to ready it itself
		3524	//TODO: unapplying should unapply the skill, though
3433	SET_FLAG (op, FLAG_APPLIED);	3525	SET_FLAG (op, FLAG_APPLIED);
		3526	break;
3434		3527
		3528	case SKILL:
3435	if (!(aflags & AP_NO_READY))	3529	if (!(aflags & AP_NO_SLOT))
3436	{	3530	{
3437	skop = find_skill_by_name (who, op->skill);	3531	// skill is used on it's own, as opposed to being a chosen_skill
3438	if (!skop->flag [FLAG_APPLIED])
3439	apply_special (who, skop, AP_APPLY);
3440	}
3441	break;
3442		3532
3443	case SKILL:	3533	if (skill_flags [op->subtype] & (SF_NEED_ITEM | SF_MANA))
3444	if (player *pl = who->contr)
3445	{
3446	if (IS_COMBAT_SKILL (op->subtype))
3447	{	3534	{
3448	if (skill_flags [op->subtype] & SF_NEED_WEAPON)
3449	{
3450	for (object *item = who->inv; item; item = item->below)
3451	if (item->type == WEAPON && item->flag [FLAG_APPLIED])
3452	{
3453	if (item->skill == op->skill)
3454	{
3455	who->change_weapon (pl->combat_ob = item);
3456	goto found_weapon;
3457	}
3458	}
3459
3460	who->failmsg (format (	3535	who->failmsg (format (
3461	"You need to apply a '%s' melee weapon before readying this skill. "	3536	"You feel as if you wanted to do something funny, but you can't remember what. "
3462	"H<Some skills need an item, in this case a melee weapon, to function.>",	3537	"H<The %s skill needs something else to function, for example a tool, weapon, rod, or spell. "
3463	&op->skill	3538	"It cannot be used on its own.>",
3464	));
3465	return 1;
3466
3467	found_weapon:;
3468	}
3469	else
3470	who->change_weapon (pl->combat_ob = op);
3471	}
3472	else if (IS_RANGED_SKILL (op->subtype))
3473	{
3474	if (skill_flags [op->subtype] & SF_NEED_BOW)
3475	{
3476	for (object *item = who->inv; item; item = item->below)
3477	if (item->type == BOW && item->flag [FLAG_APPLIED])
3478	{
3479	//TODO: bows should/must all have skill missile weapon right now
3480	who->change_weapon (pl->ranged_ob = item);
3481	goto found_bow;
3482	}
3483
3484	who->failmsg (
3485	"You need to apply a missile weapon before readying this skill. "
3486	"H<Some skills need an item, in this case a missile weapon, to function.>"
3487	);
3488	return 1;
3489
3490	found_bow:;
3491	}
3492	else
3493	who->change_weapon (pl->ranged_ob = op);
3494	}
3495
3496	if (!op->invisible)
3497	{
3498	who->statusmsg (format (
3499	"You ready %s."
3500	"You can now use the skill: %s.",
3501	query_name (op),
3502	&op->skill	3539	&op->skill
3503	));	3540	));
		3541	if (tmp) who->insert (tmp);
		3542	return 1;
3504	}	3543	}
		3544
		3545	if (skill_flags [op->subtype] & SF_AUTARK
		3546	|| !(skill_flags [op->subtype] & (SF_COMBAT | SF_RANGED)))
		3547	{
		3548	if (skill_flags [op->subtype] & SF_USE)
		3549	who->failmsg (format (
		3550	"You feel as if you wanted to do something funny, but you can't remember what. "
		3551	"H<The %s skill cannot be readied, instead, try C<use_skill %s>.>",
		3552	&op->skill, &op->skill
		3553	));
3505	else	3554	else
3506	who->statusmsg (format ("Readied skill: %s.", op->skill ? &op->skill : &op->name));	3555	who->failmsg (format (
		3556	"You feel as if you wanted to do something funny, but you can't remember what. "
		3557	"H<The %s skill cannot be readied or used, it is always active.>",
		3558	&op->skill, &op->skill
		3559	));
		3560
		3561	if (tmp) who->insert (tmp);
		3562	return 1;
		3563	}
		3564
		3565	if (who->contr)
		3566	who->statusmsg (format (
		3567	op->invisible ? "You can now use the %s skill." : "You ready %s.",
		3568	query_name (op),
		3569	&op->skill
		3570	));
3507	}	3571	}
3508	else	3572
3509	{
3510	SET_FLAG (op, FLAG_APPLIED);
3511	change_abil (who, op);
3512	who->chosen_skill = op;
3513	SET_FLAG (who, FLAG_READY_SKILL);	3573	SET_FLAG (who, FLAG_READY_SKILL);
3514	}	3574	SET_FLAG (op, FLAG_APPLIED);
3515		3575	change_abil (who, op);
3516	break;	3576	break;
3517		3577
3518	case BOW:	3578	case BOW:
3519	if (op->level && !op->name.starts_with (who->name))	3579	if (op->level && (!op->name.starts_with (who->name) || op->name [who->name.length ()] != '\''))
3520	{	3580	{
3521	who->failmsg ("The weapon does not recognize you as its owner. "	3581	who->failmsg ("The weapon does not recognize you as its owner. "
3522	"H<Its name indicates that it belongs to somebody else.>");	3582	"H<Its name indicates that it belongs to somebody else.>");
3523	if (tmp)	3583	if (tmp) who->insert (tmp);
3524	insert_ob_in_ob (tmp, who);
3525
3526	return 1;	3584	return 1;
3527	}	3585	}
		3586
		3587	if (player *pl = who->contr)
		3588	{
		3589	op->flag [FLAG_APPLIED] = true;
		3590	who->statusmsg (format ("You wield the %s.", query_name (op)));
		3591	change_abil (who, op);
		3592	}
		3593	break;
		3594
		3595	case RANGED:
		3596	if (player *pl = who->contr)
		3597	{
		3598	op->flag [FLAG_APPLIED] = true;
		3599	who->statusmsg (format ("You applied the %s.", query_name (op)));
		3600	}
		3601	break;
		3602
		3603	case SPELL:
		3604	if (player *pl = who->contr)
		3605	{
		3606	op->flag [FLAG_APPLIED] = true;
		3607	who->statusmsg (format ("You ready the spell %s.", query_name (op)));
		3608	}
		3609	break;
3528		3610
3529	/*FALLTHROUGH*/	3611	/*FALLTHROUGH*/
3530	case WAND:	3612	case WAND:
3531	case ROD:	3613	case ROD:
3532	case HORN:	3614	case HORN:
3533	/* check for skill, alter player status */	3615	/* check for skill, alter player status */
3534		3616
3535	if (!skop)	3617	if (!skop)
3536	{	3618	{
3537	who->failmsg (format ("The %s is broken, please report this to the dungeon master!", query_name (op)));//TODO	3619	who->failmsg (format ("The %s is broken, please report this to the dungeon master!", query_name (op)));//TODO
		3620	if (tmp) who->insert (tmp);
3538	return 1;	3621	return 1;
3539	}	3622	}
3540		3623
3541	SET_FLAG (op, FLAG_APPLIED);	3624	op->flag [FLAG_APPLIED] = true;
3542	who->change_skill (skop);
3543		3625
3544	if (who->contr)	3626	if (player *pl = who->contr)
3545	{	3627	{
3546	who->contr->ranged_ob = op;
3547
3548	who->statusmsg (format ("You ready %s.", query_name (op)));	3628	who->statusmsg (format ("You ready %s.", query_name (op)));
3549		3629
3550	if (op->type == BOW)	3630	if (op->type == BOW)
3551	{
3552	who->current_weapon = op;
3553	change_abil (who, op);
3554	who->statusmsg (format ("You will now fire %s with %s.", op->race ? &op->race : "nothing", query_name (op)));	3631	who->statusmsg (format ("You will now fire %s with %s.", op->race ? &op->race : "nothing", query_name (op)));
3555	}	3632
		3633	change_abil (who, op);
3556	}	3634	}
3557	else	3635	else
3558	{	3636	{
		3637	who->change_skill (skop);
		3638
3559	if (op->type == BOW)	3639	if (op->type == BOW)
3560	SET_FLAG (who, FLAG_READY_BOW);	3640	op->flag [FLAG_READY_BOW ] = true;
3561	else	3641	else
3562	SET_FLAG (who, FLAG_READY_RANGE);	3642	op->flag [FLAG_READY_RANGE] = true;
3563	}	3643	}
3564		3644
3565	break;	3645	break;
3566		3646
3567	case BUILDER:	3647	case BUILDER:
3568	if (who->type == PLAYER)	3648	if (player *pl = who->contr)
3569	{	3649	{
3570	//TODO: wtf does this do? shouldn't this be managed automatically (slots?)
3571	if (who->contr->ranged_ob && who->contr->ranged_ob->type == BUILDER)
3572	unapply_special (who, who->contr->ranged_ob, 0);
3573
3574	who->statusmsg (format ("You ready your %s.", query_name (op)));	3650	who->statusmsg (format ("You ready your %s.", query_name (op)));
3575		3651	//TODO: change_abil?
3576	who->contr->ranged_ob = op;
3577	}	3652	}
3578	break;	3653	break;
3579		3654
3580	default:	3655	default:
3581	who->statusmsg (format ("You apply %s.", query_name (op)));	3656	who->statusmsg (format ("You apply %s.", query_name (op)));
3582	}	3657	}
3583		3658
3584	SET_FLAG (op, FLAG_APPLIED);	3659	SET_FLAG (op, FLAG_APPLIED);
3585		3660
3586	if (tmp)
3587	who->insert (tmp);	3661	if (tmp) who->insert (tmp);
3588		3662
3589	who->update_stats ();	3663	who->update_stats ();
3590		3664
3591	/* We exclude spell casting objects. The fire code will set the	3665	/* We exclude spell casting objects. The fire code will set the
3592	* been applied flag when they are used - until that point,	3666	* been applied flag when they are used - until that point,
…		…
3607		3681
3608	if (object *pl = op->visible_to ())	3682	if (object *pl = op->visible_to ())
3609	esrv_send_item (pl, op);	3683	esrv_send_item (pl, op);
3610		3684
3611	return 0;	3685	return 0;
3612	}
3613
3614	int
3615	monster_apply_special (object *who, object *op, int aflags)
3616	{
3617	if (QUERY_FLAG (op, FLAG_UNPAID) && !QUERY_FLAG (op, FLAG_APPLIED))
3618	return 1;
3619
3620	return apply_special (who, op, aflags);
3621	}	3686	}
3622		3687
3623	/**	3688	/**
3624	* Map was just loaded, handle op's initialisation.	3689	* Map was just loaded, handle op's initialisation.
3625	*	3690	*
…		…
3732	* treasure again for this object	3797	* treasure again for this object
3733	*/	3798	*/
3734	invtmp->randomitems = NULL;	3799	invtmp->randomitems = NULL;
3735	}	3800	}
3736	}	3801	}
		3802
3737	/* This is really temporary - the code at the bottom will	3803	/* This is really temporary - the code at the bottom will
3738	* also set randomitems to null. The problem is there are bunches	3804	* also set randomitems to null. The problem is there are bunches
3739	* of maps/players already out there with items that have spells	3805	* of maps/players already out there with items that have spells
3740	* which haven't had the randomitems set to null yet.	3806	* which haven't had the randomitems set to null yet.
3741	* MSW 2004-05-13	3807	* MSW 2004-05-13
…		…
3745	* Ryo 2004-08-16	3811	* Ryo 2004-08-16
3746	*/	3812	*/
3747	if (tmp->type == WAND || tmp->type == ROD || tmp->type == SCROLL	3813	if (tmp->type == WAND || tmp->type == ROD || tmp->type == SCROLL
3748	|| tmp->type == HORN || tmp->type == FIREWALL || tmp->type == POTION || tmp->type == ALTAR || tmp->type == SPELLBOOK)	3814	|| tmp->type == HORN || tmp->type == FIREWALL || tmp->type == POTION || tmp->type == ALTAR || tmp->type == SPELLBOOK)
3749	tmp->randomitems = NULL;	3815	tmp->randomitems = NULL;
3750
3751	}	3816	}
3752		3817
3753	if (QUERY_FLAG (tmp, FLAG_AUTO_APPLY))	3818	if (QUERY_FLAG (tmp, FLAG_AUTO_APPLY))
3754	auto_apply (tmp);	3819	auto_apply (tmp);
3755	else if ((tmp->type == TREASURE || (tmp->type == CONTAINER)) && tmp->has_random_items ())	3820	else if ((tmp->type == TREASURE || (tmp->type == CONTAINER)) && tmp->has_random_items ())
…		…
3812	/* bigger morsel of food = longer effect time */	3877	/* bigger morsel of food = longer effect time */
3813	int duration = TIME2TICK (food->stats.food);	3878	int duration = TIME2TICK (food->stats.food);
3814		3879
3815	if (force = who->force_find (key))	3880	if (force = who->force_find (key))
3816	{	3881	{
3817	if (duration > abs (force->speed_left / force->speed))	3882	if (duration > fabs (force->speed_left / force->speed))
3818	{	3883	{
3819	new_draw_info_format (NDI_UNIQUE, 0, who, "More magical force spreads through you. H<The effect will last for about %.10g more seconds.>", TICK2TIME (duration));	3884	new_draw_info_format (NDI_UNIQUE, 0, who, "More magical force spreads through you. H<The effect will last for about %.10g more seconds.>", TICK2TIME (duration));
3820	force->force_set_timer (duration);	3885	force->force_set_timer (duration);
3821	}	3886	}
3822	else	3887	else
…		…
3894	/* place limit on max sp from food? */	3959	/* place limit on max sp from food? */
3895	}	3960	}
3896	}	3961	}
3897		3962
3898	who->update_stats ();	3963	who->update_stats ();
3899	}
3900
3901	/**
3902	* op made some mistake with a scroll, this takes care of punishment.
3903	* scroll_failure()- hacked directly from spell_failure
3904	*/
3905	void
3906	scroll_failure (object *op, int failure, int power)
3907	{
3908	if (abs (failure / 4) > power)
3909	power = abs (failure / 4); /* set minimum effect */
3910
3911	if (failure <= -1 && failure > -15)
3912	{ /* wonder */
3913	object *tmp;
3914
3915	op->failmsg ("Your spell warps!");
3916	tmp = get_archetype (SPELL_WONDER);
3917	cast_wonder (op, op, 0, tmp);
3918	tmp->destroy ();
3919	}
3920	else if (failure <= -15 && failure > -35)
3921	{ /* drain mana */
3922	op->failmsg ("Your mana is drained!");
3923	op->stats.sp -= random_roll (0, power - 1, op, PREFER_LOW);
3924	if (op->stats.sp < 0)
3925	op->stats.sp = 0;
3926	}
3927	else if (settings.spell_failure_effects == TRUE)
3928	{
3929	if (failure <= -35 && failure > -60)
3930	{ /* confusion */
3931	op->failmsg ("The magic recoils on you!");
3932	confuse_player (op, op, power);
3933	}
3934	else if (failure <= -60 && failure > -70)
3935	{ /* paralysis */
3936	op->failmsg ("The magic recoils and paralyzes you!");
3937	paralyze_player (op, op, power);
3938	}
3939	else if (failure <= -70 && failure > -80)
3940	{ /* blind */
3941	op->failmsg ("The magic recoils on you!");
3942	blind_player (op, op, power);
3943	}
3944	else if (failure <= -80)
3945	{ /* blast the immediate area */
3946	object *tmp = get_archetype (LOOSE_MANA);
3947	cast_magic_storm (op, tmp, power);
3948	op->failmsg ("You unleash uncontrolled mana!");
3949	tmp->destroy ();
3950	}
3951	}
3952	}	3964	}
3953		3965
3954	void	3966	void
3955	apply_changes_to_player (object *pl, object *change)	3967	apply_changes_to_player (object *pl, object *change)
3956	{	3968	{
…		…
4033	break;	4045	break;
4034	}	4046	}
4035	}	4047	}
4036	}	4048	}
4037		4049
4038	/**
4039	* This handles items of type 'transformer'.
4040	* Basically those items, used with a marked item, transform both items into something
4041	* else.
4042	* "Transformer" item has food decreased by 1, removed if 0 (0 at start means illimited)..
4043	* Change information is contained in the 'slaying' field of the marked item.
4044	* The format is as follow: transformer:[number ]yield[;transformer:...].
4045	* This way an item can be transformed in many things, and/or many objects.
4046	* The 'slaying' field for transformer is used as verb for the action.
4047	*/
4048	void
4049	apply_item_transformer (object *pl, object *transformer)
4050	{
4051	object *marked;
4052	object *new_item;
4053	char *find;
4054	char *separator;
4055	int yield;
4056	char got[MAX_BUF];
4057	int len;
4058
4059	if (!pl || !transformer)
4060	return;
4061
4062	marked = find_marked_object (pl);
4063
4064	if (!marked)
4065	{
4066	pl->failmsg (format ("Use the %s with what item?", query_name (transformer)));
4067	return;
4068	}
4069
4070	if (!marked->slaying)
4071	{
4072	pl->failmsg (format ("You can't use the %s with your %s!", query_name (transformer), query_name (marked)));
4073	return;
4074	}
4075
4076	/* check whether they are compatible or not */
4077	find = strstr (&marked->slaying, transformer->arch->archname);
4078	if (!find || (*(find + strlen (transformer->arch->archname)) != ':'))
4079	{
4080	pl->failmsg (format ("You can't use the %s with your %s!", query_name (transformer), query_name (marked)));
4081	return;
4082	}
4083
4084	find += strlen (transformer->arch->archname) + 1;
4085	/* Item can be used, now find how many and what it yields */
4086	if (isdigit (*(find)))
4087	{
4088	yield = atoi (find);
4089	if (yield < 1)
4090	{
4091	LOG (llevDebug, "apply_item_transformer: item %s has slaying-yield %d.", query_base_name (marked, 0), yield);
4092	yield = 1;
4093	}
4094	}
4095	else
4096	yield = 1;
4097
4098	while (isdigit (*find))
4099	find++;
4100
4101	while (*find == ' ')
4102	find++;
4103
4104	memset (got, 0, MAX_BUF);
4105
4106	if ((separator = strchr (find, ';')) != NULL)
4107	len = separator - find;
4108	else
4109	len = strlen (find);
4110
4111	if (len > MAX_BUF - 1)
4112	len = MAX_BUF - 1;
4113
4114	strcpy (got, find);
4115	got[len] = '\0';
4116
4117	/* Now create new item, remove used ones when required. */
4118	new_item = get_archetype (got);
4119	if (!new_item)
4120	{
4121	pl->failmsg (format ("This %s is strange, better to not use it.", query_base_name (marked, 0)));
4122	return;
4123	}
4124
4125	new_item->nrof = yield;
4126
4127	pl->statusmsg (format ("You %s the %s.", &transformer->slaying, query_base_name (marked, 0)));
4128
4129	pl->insert (new_item);
4130	/* Eat up one item */
4131	marked->decrease ();
4132
4133	/* Eat one transformer if needed */
4134	if (transformer->stats.food)
4135	if (--transformer->stats.food == 0)
4136	transformer->decrease ();
4137	}
4138

Diff Legend

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