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.203 by sf-marcmagus, Thu Oct 15 16:00:38 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
…		…
1008	}	1004	}
1009		1005
1010	// already applied == open on ground, or open in inv, or active in inv	1006	// already applied == open on ground, or open in inv, or active in inv
1011	if (sack->flag [FLAG_APPLIED])	1007	if (sack->flag [FLAG_APPLIED])
1012	{	1008	{
1013	if (op->container == sack)	1009	if (op->container_ () == sack)
1014	{	1010	{
1015	// open on ground or inv, so close	1011	// open on ground or inv, so close
1016	op->close_container ();	1012	op->close_container ();
1017	return 1;	1013	return 1;
1018	}	1014	}
…		…
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."
…		…
1325	return;	1321	return;
1326		1322
1327	/* move_apply() is the most likely candidate for causing unwanted and	1323	/* move_apply() is the most likely candidate for causing unwanted and
1328	* possibly unlimited recursion.	1324	* possibly unlimited recursion.
1329	*/	1325	*/
1330	/* The following was changed because it was causing perfeclty correct	1326	/* The following was changed because it was causing perfectly correct
1331	* maps to fail. 1) it's not an error to recurse:	1327	* maps to fail. 1) it's not an error to recurse:
1332	* rune detonates, summoning monster. monster lands on nearby rune.	1328	* rune detonates, summoning monster. monster lands on nearby rune.
1333	* nearby rune detonates. This sort of recursion is expected and	1329	* nearby rune detonates. This sort of recursion is expected and
1334	* proper. This code was causing needless crashes.	1330	* proper. This code was causing needless crashes.
1335	*/	1331	*/
…		…
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	*/
…		…
1384	}	1380	}
1385	break;	1381	break;
1386		1382
1387	case BUTTON:	1383	case BUTTON:
1388	case PEDESTAL:	1384	case PEDESTAL:
		1385	case T_MATCH:
1389	update_button (trap, originator);	1386	update_button (trap, originator);
1390	break;	1387	break;
1391		1388
1392	case ALTAR:	1389	case ALTAR:
1393	/* sacrifice victim on trap */	1390	/* sacrifice victim on trap */
…		…
1404	* 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.
1405	* 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
1406	* 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
1407	* action, we avoid hits here	1404	* action, we avoid hits here
1408	*/	1405	*/
1409	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)
1410	hit_with_arrow (trap, victim);	1408	hit_with_arrow (trap, victim);
1411	break;	1409	break;
1412		1410
1413	case SPELL_EFFECT:	1411	case SPELL_EFFECT:
1414	apply_spell_effect (trap, victim);	1412	apply_spell_effect (trap, victim);
…		…
1487	if (victim->type == PLAYER && EXIT_PATH (trap))	1485	if (victim->type == PLAYER && EXIT_PATH (trap))
1488	{	1486	{
1489	/* Basically, don't show exits leading to random maps the	1487	/* Basically, don't show exits leading to random maps the
1490	* players output.	1488	* players output.
1491	*/	1489	*/
1492	if (trap->msg && !EXIT_PATH (trap).starts_with ("/!"))	1490	if (trap->msg && EXIT_PATH (trap) != shstr_random_map_exit)
1493	victim->statusmsg (trap->msg, NDI_NAVY);	1491	victim->statusmsg (trap->msg, NDI_NAVY);
1494		1492
1495	trap->play_sound (trap->sound);	1493	trap->play_sound (trap->sound);
1496	victim->enter_exit (trap);	1494	victim->enter_exit (trap);
1497	}	1495	}
…		…
1575	: lev_diff < 15 ? "This book is way beyond your comprehension."	1573	: lev_diff < 15 ? "This book is way beyond your comprehension."
1576	: "This book is totally beyond your comprehension.");	1574	: "This book is totally beyond your comprehension.");
1577	return;	1575	return;
1578	}	1576	}
1579		1577
		1578	// we currently don't use the message types for anything.
1580	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"));
1581		1582
1582	if (player *pl = op->contr)	1583	if (player *pl = op->contr)
1583	if (client *ns = pl->ns)	1584	if (client *ns = pl->ns)
1584	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));
1585		1586
…		…
1597	esrv_update_item (UPD_FLAGS | UPD_NAME, pl, tmp);	1598	esrv_update_item (UPD_FLAGS | UPD_NAME, pl, tmp);
1598	}	1599	}
1599		1600
1600	change_exp (op, exp_gain, skill_ob->skill, 0);	1601	change_exp (op, exp_gain, skill_ob->skill, 0);
1601	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	}
1602	}	1656	}
1603	}	1657	}
1604		1658
1605	/**	1659	/**
1606	* Handles the applying of a skill scroll, calling learn_skill straight.	1660	* Handles the applying of a skill scroll, calling learn_skill straight.
…		…
1685	LOG (llevError, "BUG: do_forget_spell(): spell not known\n");	1739	LOG (llevError, "BUG: do_forget_spell(): spell not known\n");
1686	return;	1740	return;
1687	}	1741	}
1688		1742
1689	op->failmsg (format ("You lose knowledge of %s.", spell));	1743	op->failmsg (format ("You lose knowledge of %s.", spell));
1690	player_unready_range_ob (op->contr, spob);
1691	esrv_remove_spell (op->contr, spob);	1744	esrv_remove_spell (op->contr, spob);
1692	spob->destroy ();	1745	spob->destroy ();
1693	}	1746	}
1694		1747
1695	/**	1748	/**
…		…
1712	* instead of having their spell stored in stats.sp. These are	1765	* instead of having their spell stored in stats.sp. These are
1713	* legacy spellbooks	1766	* legacy spellbooks
1714	*/	1767	*/
1715	if (tmp->slaying)	1768	if (tmp->slaying)
1716	{	1769	{
1717	spell = arch_to_object (find_archetype_by_object_name (tmp->slaying));	1770	spell = find_archetype_by_object_name (tmp->slaying)->instance ();
		1771
1718	if (!spell)	1772	if (!spell)
1719	{	1773	{
1720	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));
1721	return;	1775	return;
1722	}	1776	}
…		…
1751	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.>",
1752	&tmp->skill, learn_level));	1806	&tmp->skill, learn_level));
1753	return;	1807	return;
1754	}	1808	}
1755		1809
1756	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));
1757		1811
1758	if (!QUERY_FLAG (tmp, FLAG_IDENTIFIED))	1812	if (!QUERY_FLAG (tmp, FLAG_IDENTIFIED))
1759	identify (tmp);	1813	identify (tmp);
1760		1814
1761	/* 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
…		…
1773	{	1827	{
1774	spell_skill = find_skill_by_name (op, spell->skill);	1828	spell_skill = find_skill_by_name (op, spell->skill);
1775		1829
1776	if (!spell_skill)	1830	if (!spell_skill)
1777	{	1831	{
1778	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));
1779	return;	1833	return;
1780	}	1834	}
1781		1835
1782	if (spell_skill->level < spell->level)	1836	if (spell_skill->level < spell->level)
1783	{	1837	{
…		…
1799	* literacy rate very useful! -b.t.	1853	* literacy rate very useful! -b.t.
1800	*/	1854	*/
1801	if (QUERY_FLAG (op, FLAG_CONFUSED))	1855	if (QUERY_FLAG (op, FLAG_CONFUSED))
1802	{	1856	{
1803	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!");
1804	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));
1805	}	1859	}
1806	else if (QUERY_FLAG (tmp, FLAG_STARTEQUIP) ||	1860	else if (QUERY_FLAG (tmp, FLAG_STARTEQUIP) ||
1807	(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])
1808	{	1862	{
1809	op->statusmsg ("You succeed in learning the spell!", NDI_GREEN);	1863	op->statusmsg ("You succeed in learning the spell!", NDI_GREEN);
…		…
1915	break;	1969	break;
1916	}	1970	}
1917		1971
1918	if (!tmp->destroyed () && !tmp->inv)	1972	if (!tmp->destroyed () && !tmp->inv)
1919	tmp->decrease (true);	1973	tmp->decrease (true);
1920	}
1921
1922	/**
1923	* op eats food.
1924	* If player, takes care of messages and dragon special food.
1925	*/
1926	static void
1927	apply_food (object *op, object *tmp)
1928	{
1929	int capacity_remaining;
1930
1931	if (op->type != PLAYER)
1932	op->stats.hp = op->stats.maxhp;
1933	else
1934	{
1935	/* check if this is a dragon (player), eating some flesh */
1936	if (tmp->type == FLESH && is_dragon_pl (op) && dragon_eat_flesh (op, tmp))
1937	;
1938	else
1939	{
1940	/* usual case - no dragon meal: */
1941	if (op->stats.food + tmp->stats.food > 999)
1942	{
1943	if (tmp->type == FOOD || tmp->type == FLESH)
1944	op->failmsg ("You feel full, but what a waste of food!");
1945	else
1946	op->statusmsg ("Most of the drink goes down your face not your throat!");
1947	}
1948
1949	tmp->play_sound (
1950	tmp->sound
1951	? tmp->sound
1952	: tmp->type == DRINK
1953	? sound_find ("eat_drink")
1954	: sound_find ("eat_food")
1955	);
1956
1957	if (!QUERY_FLAG (tmp, FLAG_CURSED))
1958	{
1959	const char *buf;
1960
1961	if (!is_dragon_pl (op))
1962	{
1963	/* eating message for normal players */
1964	if (tmp->type == DRINK)
1965	buf = format ("Ahhh...that %s tasted good.", &tmp->name);
1966	else
1967	buf = format ("The %s tasted %s", &tmp->name, tmp->type == FLESH ? "terrible!" : "good.");
1968	}
1969	else
1970	/* eating message for dragon players */
1971	buf = format ("The %s tasted terrible!", &tmp->name);
1972
1973	op->statusmsg (buf);
1974
1975	capacity_remaining = 999 - op->stats.food;
1976	op->stats.food += tmp->stats.food;
1977	if (capacity_remaining < tmp->stats.food)
1978	op->stats.hp += capacity_remaining / 50;
1979	else
1980	op->stats.hp += tmp->stats.food / 50;
1981
1982	if (op->stats.hp > op->stats.maxhp)
1983	op->stats.hp = op->stats.maxhp;
1984	if (op->stats.food > 999)
1985	op->stats.food = 999;
1986	}
1987
1988	/* special food hack -b.t. */
1989	if (tmp->title || QUERY_FLAG (tmp, FLAG_CURSED))
1990	eat_special_food (op, tmp);
1991	}
1992	}
1993
1994	handle_apply_yield (tmp);
1995	tmp->decrease ();
1996	}	1974	}
1997		1975
1998	/**	1976	/**
1999	* A dragon is eating some flesh. If the flesh contains resistances,	1977	* A dragon is eating some flesh. If the flesh contains resistances,
2000	* 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.
…		…
2003	* object *op the object (dragon player) eating the flesh	1981	* object *op the object (dragon player) eating the flesh
2004	* object *meal the flesh item, getting chewed in dragon's mouth	1982	* object *meal the flesh item, getting chewed in dragon's mouth
2005	* return:	1983	* return:
2006	* int 1 if eating successful, 0 if it doesn't work	1984	* int 1 if eating successful, 0 if it doesn't work
2007	*/	1985	*/
2008	int	1986	static int
2009	dragon_eat_flesh (object *op, object *meal)	1987	dragon_eat_flesh (object *op, object *meal)
2010	{	1988	{
2011	object *skin = NULL; /* pointer to dragon skin force */	1989	object *skin = NULL; /* pointer to dragon skin force */
2012	object *abil = NULL; /* pointer to dragon ability force */	1990	object *abil = NULL; /* pointer to dragon ability force */
2013	object *tmp = NULL; /* tmp. object */	1991	object *tmp = NULL; /* tmp. object */
…		…
2019	int atnr_winner[NROFATTACKS]; /* winning candidates for resistance improvement */	1997	int atnr_winner[NROFATTACKS]; /* winning candidates for resistance improvement */
2020	int winners = 0; /* number of winners */	1998	int winners = 0; /* number of winners */
2021	int i; /* index */	1999	int i; /* index */
2022		2000
2023	/* let's make sure and doublecheck the parameters */	2001	/* let's make sure and doublecheck the parameters */
2024	if (meal->type != FLESH || !is_dragon_pl (op))	2002	if (meal->type != FLESH || !op->is_dragon ())
2025	return 0;	2003	return 0;
2026		2004
2027	/* now grab the 'dragon_skin'- and 'dragon_ability'-forces	2005	/* now grab the 'dragon_skin'- and 'dragon_ability'-forces
2028	from the player's inventory */	2006	from the player's inventory */
2029	for (tmp = op->inv; tmp; tmp = tmp->below)	2007	for (tmp = op->inv; tmp; tmp = tmp->below)
…		…
2037	which is not to be considered a dragon -> bail out */	2015	which is not to be considered a dragon -> bail out */
2038	if (skin == NULL || abil == NULL)	2016	if (skin == NULL || abil == NULL)
2039	return 0;	2017	return 0;
2040		2018
2041	/* now start by filling stomache and health, according to food-value */	2019	/* now start by filling stomache and health, according to food-value */
2042	if ((999 - op->stats.food) < meal->stats.food)	2020	if ((MAX_FOOD - op->stats.food) < meal->stats.food)
2043	op->stats.hp += (999 - op->stats.food) / 50;	2021	op->stats.hp += (MAX_FOOD - op->stats.food) / 50;
2044	else	2022	else
2045	op->stats.hp += meal->stats.food / 50;	2023	op->stats.hp += meal->stats.food / 50;
2046		2024
2047	if (op->stats.hp > op->stats.maxhp)	2025	min_it (op->stats.hp, op->stats.maxhp);
2048	op->stats.hp = op->stats.maxhp;
2049
2050	op->stats.food = MIN (999, op->stats.food + meal->stats.food);	2026	op->stats.food = min (MAX_FOOD, op->stats.food + meal->stats.food);
2051		2027
2052	/*LOG(llevDebug, "-> player: %d, flesh: %d\n", op->level, meal->level); */	2028	/*LOG(llevDebug, "-> player: %d, flesh: %d\n", op->level, meal->level); */
2053		2029
2054	/* on to the interesting part: chances for adding resistance */	2030	/* on to the interesting part: chances for adding resistance */
2055	for (i = 0; i < NROFATTACKS; i++)	2031	for (i = 0; i < NROFATTACKS; i++)
…		…
2065		2041
2066	/* monster bonus increases with level, because high-level	2042	/* monster bonus increases with level, because high-level
2067	flesh is too rare */	2043	flesh is too rare */
2068	mbonus = op->level * 20. / ((double) settings.max_level);	2044	mbonus = op->level * 20. / ((double) settings.max_level);
2069		2045
2070	chance = (((double) MIN (op->level + bonus, meal->level + bonus + mbonus)) * 100. /	2046	chance = (((double)min (op->level + bonus, meal->level + bonus + mbonus)) * 100. /
2071	((double) settings.max_level)) - skin->resist[i];	2047	((double)settings.max_level)) - skin->resist[i];
2072		2048
2073	if (chance >= 0.)	2049	if (chance >= 0.)
2074	chance += 1.;	2050	chance += 1.;
2075	else	2051	else
2076	chance = (chance < -12) ? 0. : 1. / pow (2., -chance);	2052	chance = (chance < -12) ? 0. : 1. / pow (2., -chance);
2077		2053
2078	/* chance is proportional to amount of resistance (max. 50) */	2054	/* chance is proportional to amount of resistance (max. 50) */
2079	chance *= ((double) (MIN (meal->resist[i], 50))) / 50.;	2055	chance *= ((double)(min (meal->resist[i], 50))) / 50.;
2080		2056
2081	/* doubled chance for resistance of ability-focus */	2057	/* doubled chance for resistance of ability-focus */
2082	if (i == abil->stats.exp)	2058	if (i == abil->stats.exp)
2083	chance = MIN (100., chance * 2.);	2059	chance = min (100., chance * 2.);
2084		2060
2085	/* 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!) */
2086	if (rndm (10000) < (unsigned int) (chance * 100))	2062	if (rndm (10000) < (unsigned int)(chance * 100))
2087	{	2063	{
2088	atnr_winner[winners] = i;	2064	atnr_winner[winners] = i;
2089	winners++;	2065	winners++;
2090	}	2066	}
2091		2067
…		…
2154		2130
2155	return 1;	2131	return 1;
2156	}	2132	}
2157		2133
2158	/**	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	/**
2159	* Handles applying an improve armor scroll.	2209	* Handles applying an improve armor scroll.
2160	* Does some sanity checks, then calls improve_armour.	2210	* Does some sanity checks, then calls improve_armour.
2161	*/	2211	*/
2162	static void	2212	static void
2163	apply_armour_improver (object *op, object *tmp)	2213	apply_armour_improver (object *op, object *tmp)
…		…
2211	hit_player (op, poison->stats.hp, tmp, AT_POISON, 1);	2261	hit_player (op, poison->stats.hp, tmp, AT_POISON, 1);
2212	}	2262	}
2213		2263
2214	op->stats.food -= op->stats.food / 4;	2264	op->stats.food -= op->stats.food / 4;
2215	poison->destroy ();	2265	poison->destroy ();
2216	}
2217
2218	/**
2219	* This function return true if the exit is not a 2 ways one or it is 2 ways, valid exit.
2220	* A valid 2 way exit means:
2221	* -You can come back (there is another exit at the other side)
2222	* -You are
2223	* ° the owner of the exit
2224	* ° or in the same party as the owner
2225	*
2226	* Note: a owner in a 2 way exit is saved as the owner's name
2227	* in the field exit->name cause the field exit->owner doesn't
2228	* survive in the swapping (in fact the whole exit doesn't survive).
2229	*/
2230	int
2231	is_legal_2ways_exit (object *op, object *exit)
2232	{
2233	if (exit->stats.exp != 1)
2234	return 1; /*This is not a 2 way, so it is legal */
2235
2236	#if 0 //TODO
2237	if (!has_been_loaded (EXIT_PATH (exit)) && exit->race)
2238	return 0; /* This is a reset town portal */
2239	#endif
2240
2241	LOG (llevError | logBacktrace, "sync map load due to %s\n", exit->debug_desc ());
2242
2243	maptile *exitmap = maptile::find_sync (EXIT_PATH (exit), exit->map);
2244
2245	if (exitmap)
2246	{
2247	exitmap->load_sync ();
2248
2249	object *tmp = exitmap->at (EXIT_X (exit), EXIT_Y (exit)).bot;
2250
2251	if (!tmp)
2252	return 0;
2253
2254	for (; tmp; tmp = tmp->above)
2255	{
2256	if (tmp->type != EXIT)
2257	continue; /*Not an exit */
2258
2259	if (!EXIT_PATH (tmp))
2260	continue; /*Not a valid exit */
2261
2262	if ((EXIT_X (tmp) != exit->x) || (EXIT_Y (tmp) != exit->y))
2263	continue; /*Not in the same place */
2264
2265	if (exit->map->path != EXIT_PATH (tmp))
2266	continue; /*Not in the same map */
2267
2268	/* From here we have found the exit is valid. However we do
2269	* here the check of the exit owner. It is important for the
2270	* town portals to prevent strangers from visiting your appartments
2271	*/
2272	if (!exit->race)
2273	return 1; /*No owner, free for all! */
2274
2275	object *exit_owner = 0;
2276
2277	for_all_players (pp)
2278	{
2279	if (!pp->ob)
2280	continue;
2281
2282	if (pp->ob->name != exit->race)
2283	continue;
2284
2285	exit_owner = pp->ob; /*We found a player which correspond to the player name */
2286	break;
2287	}
2288
2289	if (!exit_owner)
2290	return 0; /* No more owner */
2291
2292	if (exit_owner->contr == op->contr)
2293	return 1; /*It is your exit */
2294
2295	if (exit_owner && /*There is a owner */
2296	(op->contr) && /*A player tries to pass */
2297	((exit_owner->contr->party == NULL) || /*No pass if controller has no party */
2298	(exit_owner->contr->party != op->contr->party))) /* Or not the same as op */
2299	return 0;
2300
2301	return 1;
2302	}
2303	}
2304
2305	return 0;
2306	}	2266	}
2307		2267
2308	/**	2268	/**
2309	* 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
2310	* 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,
…		…
2361	/**	2321	/**
2362	* Designed primarily to light torches/lanterns/etc.	2322	* Designed primarily to light torches/lanterns/etc.
2363	* 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
2364	* the selected object to "burn". -b.t.	2324	* the selected object to "burn". -b.t.
2365	*/	2325	*/
2366	void	2326	static void
2367	apply_lighter (object *who, object *lighter)	2327	apply_lighter (object *who, object *lighter)
2368	{	2328	{
2369	object *item;	2329	object *item;
2370	int is_player_env = 0;	2330	int is_player_env = 0;
2371		2331
…		…
2398	}	2358	}
2399		2359
2400	/**	2360	/**
2401	* This function generates a cursed effect for cursed lamps and torches.	2361	* This function generates a cursed effect for cursed lamps and torches.
2402	*/	2362	*/
		2363	static void
2403	void player_apply_lamp_cursed_effect (object *who, object *op)	2364	player_apply_lamp_cursed_effect (object *who, object *op)
2404	{	2365	{
2405	if (op->level)	2366	if (op->level)
2406	{	2367	{
2407	who->failmsg (format (	2368	who->failmsg (format (
2408	"The %s was cursed, it explodes in a big fireball!",	2369	"The %s was cursed, it explodes in a big fireball!",
…		…
2423	* Apply for players and lamps	2384	* Apply for players and lamps
2424	*	2385	*
2425	* who - the player	2386	* who - the player
2426	* op - the lamp	2387	* op - the lamp
2427	*/	2388	*/
		2389	static void
2428	void player_apply_lamp (object *who, object *op)	2390	player_apply_lamp (object *who, object *op)
2429	{	2391	{
2430	bool switch_on = op->glow_radius ? false : true;	2392	bool switch_on = op->glow_radius ? false : true;
2431		2393
2432	if (switch_on)	2394	if (switch_on)
2433	{	2395	{
…		…
2546	if (op->other_arch)	2508	if (op->other_arch)
2547	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);
2548		2510
2549	if (object *pl = op->visible_to ())	2511	if (object *pl = op->visible_to ())
2550	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 ();
2551	}	2613	}
2552		2614
2553	/**	2615	/**
2554	* Main apply handler.	2616	* Main apply handler.
2555	*	2617	*
…		…
2564	* being applied.	2626	* being applied.
2565	*	2627	*
2566	* aflag is special (always apply/unapply) flags. Nothing is done with	2628	* aflag is special (always apply/unapply) flags. Nothing is done with
2567	* them in this function - they are passed to apply_special	2629	* them in this function - they are passed to apply_special
2568	*/	2630	*/
2569	int	2631	static int
2570	manual_apply (object *who, object *op, int aflag)	2632	manual_apply (object *who, object *op, int aflag)
2571	{	2633	{
2572	op = op->head_ ();	2634	op = op->head_ ();
2573		2635
2574	if (QUERY_FLAG (op, FLAG_UNPAID) && !QUERY_FLAG (op, FLAG_APPLIED))	2636	if (op->flag [FLAG_UNPAID] && !op->flag [FLAG_APPLIED])
2575	{	2637	{
2576	if (who->type == PLAYER)	2638	if (who->type == PLAYER)
2577	{	2639	{
2578	examine (who, op);	2640	examine (who, op);
2579	//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
…		…
2610		2672
2611	case EXIT:	2673	case EXIT:
2612	if (who->type != PLAYER)	2674	if (who->type != PLAYER)
2613	return 0;	2675	return 0;
2614		2676
2615	if (!EXIT_PATH (op) || !is_legal_2ways_exit (who, op))	2677	if (!EXIT_PATH (op))
2616	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)));
2617	else	2679	else
2618	{	2680	{
2619	/* Don't display messages for random maps. */	2681	/* Don't display messages for random maps. */
2620	if (op->msg && !EXIT_PATH (op).starts_with ("/!"))	2682	if (op->msg && EXIT_PATH (op) != shstr_random_map_exit)
2621	who->statusmsg (op->msg, NDI_NAVY);	2683	who->statusmsg (op->msg, NDI_NAVY);
2622		2684
2623	who->enter_exit (op);	2685	who->enter_exit (op);
2624	}	2686	}
2625		2687
…		…
2706	case CLOAK:	2768	case CLOAK:
2707	case WAND:	2769	case WAND:
2708	case ROD:	2770	case ROD:
2709	case HORN:	2771	case HORN:
2710	case SKILL:	2772	case SKILL:
		2773	case SPELL:
2711	case BOW:	2774	case BOW:
		2775	case RANGED:
2712	case BUILDER:	2776	case BUILDER:
2713	case SKILL_TOOL:	2777	case SKILL_TOOL:
2714	if (op->env != who)	2778	if (op->env != who)
2715	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)));
2716		2780	else
2717	apply_special (who, op, aflag);	2781	apply_special (who, op, aflag);
		2782
2718	return 1;	2783	return 1;
2719		2784
2720	case DRINK:	2785	case DRINK:
2721	case FOOD:	2786	case FOOD:
2722	case FLESH:	2787	case FLESH:
…		…
2786	case ITEM_TRANSFORMER:	2851	case ITEM_TRANSFORMER:
2787	apply_item_transformer (who, op);	2852	apply_item_transformer (who, op);
2788	return 1;	2853	return 1;
2789		2854
2790	default:	2855	default:
		2856	who->statusmsg (format ("I don't know how to apply the %s.", query_name (op)));
2791	return 0;	2857	return 0;
2792	}	2858	}
2793	}	2859	}
2794		2860
2795	/* quiet suppresses the "don't know how to apply" and "you must get it first"	2861	/*
2796	* messages as needed by player_apply_below(). But there can still be
2797	* "but you are floating high above the ground" messages.
2798	*
2799	* Same return value as apply() function.	2862	* Same return value as apply() function.
2800	*/	2863	*/
2801	int	2864	bool
2802	player_apply (object *pl, object *op, int aflag, int quiet)	2865	player_apply (object *pl, object *op, int aflag)
2803	{	2866	{
2804	if (!op->env && (pl->move_type & MOVE_FLYING))	2867	if (!op->env && (pl->move_type & MOVE_FLYING))
2805	{	2868	{
2806	/* player is flying and applying object not in inventory */	2869	/* player is flying and applying object not in inventory */
2807	if (!QUERY_FLAG (pl, FLAG_WIZ) && !(op->move_type & MOVE_FLYING))	2870	if (!QUERY_FLAG (pl, FLAG_WIZ) && !(op->move_type & MOVE_FLYING))
…		…
2813	}	2876	}
2814	}	2877	}
2815		2878
2816	pl->contr->last_used = op;	2879	pl->contr->last_used = op;
2817		2880
2818	int tmp = manual_apply (pl, op, aflag);	2881	return pl->apply (op, aflag);
2819
2820	if (!quiet)
2821	{
2822	if (tmp == 0)
2823	pl->statusmsg (format ("I don't know how to apply the %s.", query_name (op)));
2824	else if (tmp == 2)
2825	pl->failmsg ("You must get it first!\n");
2826	}
2827
2828	return tmp;
2829	}	2882	}
2830		2883
2831	/**	2884	/**
2832	* player_apply_below attempts to apply the object 'below' the player.	2885	* player_apply_below attempts to apply the object 'below' the player.
2833	* 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
…		…
2844	* 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
2845	* 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
2846	* 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
2847	* not return a proper value.	2900	* not return a proper value.
2848	*/	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?
2849	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)
2850	{	2905	{
2851	next = tmp->below;	2906	next = tmp->below;
2852		2907
2853	if (QUERY_FLAG (tmp, FLAG_IS_FLOOR))
2854	floors++;
2855	else if (floors > 0)
2856	return; /* process only floor objects after first floor object */
2857
2858	/* If it is visible, player can apply it. If it is applied by	2908	/* If it is visible, player can apply it.
2859	* person moving on it, also activate. Added code to make it
2860	* so that at least one of players movement types be that which
2861	* the item needs.
2862	*/	2909	*/
2863	if (!tmp->invisible || (tmp->move_on & pl->move_type))	2910	if (!tmp->invisible)
2864	if (player_apply (pl, tmp, 0, 1) == 1)	2911	if (player_apply (pl, tmp, 0))
2865	return;	2912	break;
2866		2913
2867	if (floors >= 2)	2914	break;
2868	return; /* process at most two floor objects */
2869	}	2915	}
2870	}	2916	}
2871		2917
2872	/**	2918	/**
2873	* Unapplies specified item.	2919	* Unapplies specified item.
…		…
2880	{	2926	{
2881	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))
2882	|| INVOKE_OBJECT (UNREADY, who, ARG_OBJECT (op), ARG_INT (aflags)))	2928	|| INVOKE_OBJECT (UNREADY, who, ARG_OBJECT (op), ARG_INT (aflags)))
2883	return RESULT_INT (0);	2929	return RESULT_INT (0);
2884		2930
2885	CLEAR_FLAG (op, FLAG_APPLIED);	2931	if (who->current_weapon == op)
		2932	who->current_weapon = 0;
		2933
		2934	op->flag [FLAG_APPLIED] = false;
2886		2935
2887	switch (op->type)	2936	switch (op->type)
2888	{	2937	{
2889	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
2890	// 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
2891	// 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
2892	// be used for other reasons	2956	// be used for other reasons
2893	for (object *tmp = who->inv; tmp; tmp = tmp->below)	2957	if (who->chosen_skill)
2894	if (tmp->skill == op->skill	2958	if (!who->chosen_skill->flag [FLAG_CAN_USE_SKILL])
2895	&& tmp->type == SKILL
2896	&& tmp->flag [FLAG_APPLIED]
2897	&& !tmp->flag [FLAG_CAN_USE_SKILL])
2898	unapply_special (who, tmp, 0);	2959	unapply_special (who, op, 0);
2899		2960
2900	change_abil (who, op);
2901	break;	2961	break;
2902		2962
		2963	case BOW:
2903	case WEAPON:	2964	case WAND:
		2965	case ROD:
		2966	case HORN:
		2967	case RANGED:
2904	if (player *pl = who->contr)	2968	if (player *pl = who->contr)
2905	if (op == pl->combat_ob)
2906	{
2907	pl->combat_ob = 0;
2908	who->change_weapon (pl->ranged_ob);
2909	}
2910
2911	who->statusmsg (format ("You unwield %s.", query_name (op)));
2912
2913	change_abil (who, op);
2914	CLEAR_FLAG (who, FLAG_READY_WEAPON);
2915	break;
2916
2917	case SKILL:
2918	if (who->contr)
2919	{	2969	{
2920	if (IS_COMBAT_SKILL (op->subtype))	2970	who->statusmsg (format ("You unready %s.", query_name (op)));
2921	who->change_weapon (who->contr->combat_ob = 0);	2971	change_abil (who, op);
2922	else if (IS_RANGED_SKILL (op->subtype))	2972	}
2923	who->change_weapon (who->contr->ranged_ob = 0);	2973	else
		2974	{
		2975	who->change_skill (0);
2924		2976
2925	if (op->invisible)	2977	if (op->type == BOW)
2926	who->statusmsg (format ("You can no longer use the skill: %s.", &op->skill));	2978	op->flag [FLAG_READY_BOW ] = false;
2927	else	2979	else
2928	who->statusmsg (format ("You stop using the %s.", query_name (op)));	2980	op->flag [FLAG_READY_RANGE] = false;
2929	}	2981	}
2930		2982
2931	change_abil (who, op);
2932	CLEAR_FLAG (who, FLAG_READY_SKILL);
2933	break;	2983	break;
2934		2984
2935	case ARMOUR:	2985	case ARMOUR:
2936	case HELMET:	2986	case HELMET:
2937	case SHIELD:	2987	case SHIELD:
…		…
2944	case CLOAK:	2994	case CLOAK:
2945	who->statusmsg (format ("You unwear %s.", query_name (op)));	2995	who->statusmsg (format ("You unwear %s.", query_name (op)));
2946	change_abil (who, op);	2996	change_abil (who, op);
2947	break;	2997	break;
2948		2998
		2999	case SPELL:
2949	case BOW:	3000	case BUILDER:
2950	case WAND:
2951	case ROD:
2952	case HORN:
2953	if (player *pl = who->contr)
2954	{
2955	if (op == pl->ranged_ob)
2956	{
2957	pl->ranged_ob = 0;
2958	who->change_weapon (pl->combat_ob);
2959	}
2960
2961	who->statusmsg (format ("You unready %s.", query_name (op)));	3001	who->statusmsg (format ("You unready %s.", query_name (op)));
2962	}
2963	else
2964	{
2965	who->change_skill (0);
2966
2967	if (op->type == BOW)
2968	CLEAR_FLAG (who, FLAG_READY_BOW);
2969	else
2970	CLEAR_FLAG (who, FLAG_READY_RANGE);
2971	}
2972
2973	break;	3002	break;
2974		3003
2975	case BUILDER:	3004	//case SKILL_TOOL://TODO
2976	if (who->contr)
2977	who->statusmsg (format ("You unready %s.", query_name (op)));
2978	break;
2979
2980	default:	3005	default:
2981	who->statusmsg (format ("You unapply %s.", query_name (op)));	3006	who->statusmsg (format ("You unapply %s.", query_name (op)));
2982	break;	3007	break;
2983	}	3008	}
2984		3009
…		…
3008	static object *	3033	static object *
3009	get_next_item_from_body_location (int loc, object *start)	3034	get_next_item_from_body_location (int loc, object *start)
3010	{	3035	{
3011	for (object *tmp = start; tmp; tmp = tmp->below)	3036	for (object *tmp = start; tmp; tmp = tmp->below)
3012	if (tmp->flag [FLAG_APPLIED]	3037	if (tmp->flag [FLAG_APPLIED]
3013	&& tmp->slot[loc].info	3038	&& tmp->slot [loc].info
3014	&& (!tmp->invisible || tmp->type == SKILL))	3039	&& (!tmp->invisible || tmp->type == SKILL || tmp->type == SPELL))
3015	return tmp;	3040	return tmp;
3016		3041
3017	return 0;	3042	return 0;
3018	}	3043	}
3019		3044
…		…
3032	#define CANNOT_REMOVE_CURSED \	3057	#define CANNOT_REMOVE_CURSED \
3033	"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. " \
3034	"Praying over an altar, scrolls of remove curse/damnation, " \	3059	"Praying over an altar, scrolls of remove curse/damnation, " \
3035	"priests or even other players might help.>"	3060	"priests or even other players might help.>"
3036		3061
3037	int	3062	static int
3038	unapply_for_ob (object *who, object *op, int aflags)	3063	unapply_for_ob (object *who, object *op, int aflags)
3039	{	3064	{
3040	if (op->is_range ())	3065	if (op->is_range ())
3041	for (object *tmp = who->inv; tmp; tmp = tmp->below)	3066	for (object *tmp = who->inv; tmp; tmp = tmp->below)
3042	if (QUERY_FLAG (tmp, FLAG_APPLIED) && tmp->is_range ())	3067	if (QUERY_FLAG (tmp, FLAG_APPLIED) && tmp->is_range ())
…		…
3164	continue;	3189	continue;
3165	}	3190	}
3166		3191
3167	object *tmp1 = get_next_item_from_body_location (i, who->inv);	3192	object *tmp1 = get_next_item_from_body_location (i, who->inv);
3168	if (!tmp1)	3193	if (!tmp1)
3169	{
3170	#if 0
3171	/* This is sort of an error, but happens a lot when old players
3172	* join in with more stuff equipped than they are now allowed.
3173	*/
3174	LOG (llevError, "Can't find object using location %d on %s\n", i, who->name);
3175	#endif
3176	retval |= CAN_APPLY_NEVER;	3194	retval |= CAN_APPLY_NEVER;
3177	}
3178	else	3195	else
3179	{	3196	{
3180	/* need to unapply something. However, if this something	3197	/* need to unapply something. However, if this something
3181	* is different than we had found before, it means they need	3198	* is different than we had found before, it means they need
3182	* to apply multiple objects	3199	* to apply multiple objects
…		…
3233	if (op->type == BOW && !QUERY_FLAG (who, FLAG_USE_BOW))	3250	if (op->type == BOW && !QUERY_FLAG (who, FLAG_USE_BOW))
3234	retval |= CAN_APPLY_RESTRICTION;	3251	retval |= CAN_APPLY_RESTRICTION;
3235	}	3252	}
3236		3253
3237	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;
3238	}	3344	}
3239		3345
3240	/**	3346	/**
3241	* 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.
3242	* 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,
…		…
3265	" 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.>"
3266		3372
3267	int	3373	int
3268	apply_special (object *who, object *op, int aflags)	3374	apply_special (object *who, object *op, int aflags)
3269	{	3375	{
3270	int basic_flag = aflags & AP_BASIC_FLAGS;	3376	int basic_flag = aflags & AP_MODE;
3271	object *tmp, *tmp2, *skop = NULL;	3377	object *tmp, *tmp2, *skop = NULL;
3272		3378
3273	if (who == NULL)	3379	if (who == NULL)
3274	{	3380	{
3275	LOG (llevError, "apply_special() from object without environment.\n");	3381	LOG (llevError, "apply_special() from object without environment.\n");
…		…
3294		3400
3295	return unapply_special (who, op, aflags);	3401	return unapply_special (who, op, aflags);
3296	}	3402	}
3297	else if (basic_flag == AP_UNAPPLY)	3403	else if (basic_flag == AP_UNAPPLY)
3298	return 0;	3404	return 0;
3299
3300	// if the item is combat/ranged, wield the relevant slot first
3301	// to resolve conflicts.
3302	if (player *pl = who->contr)
3303	switch (op->slottype ())
3304	{
3305	case slot_combat: who->change_weapon (pl->combat_ob); break;
3306	case slot_ranged: who->change_weapon (pl->ranged_ob); break;
3307	}
3308		3405
3309	splay (op);	3406	splay (op);
3310		3407
3311	/* 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 */
3312	if (int i = can_apply_object (who, op))	3409	if (int i = can_apply_object (who, op))
…		…
3346	}	3443	}
3347	}	3444	}
3348		3445
3349	if (op->skill && op->type != SKILL && op->type != SKILL_TOOL)	3446	if (op->skill && op->type != SKILL && op->type != SKILL_TOOL)
3350	{	3447	{
		3448	// try to ready attached skill first
3351	skop = find_skill_by_name (who, op->skill);	3449	skop = find_skill_by_name (who, op->skill);
3352		3450
3353	if (!skop)	3451	if (!skop)
3354	{	3452	{
3355	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));
3356	return 1;	3454	return 1;
3357	}	3455	}
3358	else	3456	else if (!who->apply (skop, AP_APPLY | AP_NO_SLOT))
3359	/* While experience will be credited properly, we want to change the
3360	* skill so that the dam and wc get updated
3361	*/	3457	{
3362	who->change_skill (skop);	3458	who->failmsg (format ("You can't use the required %s skill!", &op->skill));
		3459	return 1;
		3460	}
3363	}	3461	}
3364		3462
3365	if (!check_item_power (who, op->item_power))	3463	if (!check_item_power (who, op->item_power))
3366	{	3464	{
3367	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);
…		…
3370		3468
3371	/* 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.
3372	* Note that we don't have the checks for can_use_...	3470	* Note that we don't have the checks for can_use_...
3373	* below - that is already taken care of by can_apply_object.	3471	* below - that is already taken care of by can_apply_object.
3374	*/	3472	*/
		3473
		3474	// split away all the other items from the stack, so only one item is left
3375	tmp = op->nrof > 1 ? op->split (op->nrof - 1) : 0;	3475	tmp = op->nrof > 1 ? op->split (op->nrof - 1) : 0;
3376		3476
3377	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)))
3378	return RESULT_INT (0);	3478	return RESULT_INT (0);
3379		3479
3380	switch (op->type)	3480	switch (op->type)
3381	{	3481	{
3382	case WEAPON:	3482	case WEAPON:
3383	//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 ()] != '\''))
3384	// i.e. "R" can use Ragnarok's sword.
3385	if (op->level && !op->name.starts_with (who->name))
3386	{	3484	{
3387	/* 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. */
3388	/* (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) */
3389	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. "
3390		3488	"H<Its name indicates that it belongs to somebody else.>");
3391	if (tmp)	3489	if (tmp) who->insert (tmp);
3392	insert_ob_in_ob (tmp, who);
3393
3394	return 1;	3490	return 1;
3395	}	3491	}
3396		3492
3397	if (!skop)	3493	op->flag [FLAG_APPLIED] = true;
		3494
		3495	if (player *pl = who->contr)
3398	{	3496	{
3399	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)));
3400	return 1;	3498	change_abil (who, op);
3401	}	3499	}
3402		3500	else
3403	SET_FLAG (op, FLAG_APPLIED);
3404	who->change_skill (skop);	3501	who->change_skill (skop);
3405		3502
3406	if (who->contr)	3503	op->flag [FLAG_READY_WEAPON] = true;
3407	who->change_weapon (who->contr->combat_ob = op);
3408
3409	who->statusmsg (format ("You wield %s.", query_name (op)));
3410
3411	SET_FLAG (who, FLAG_READY_WEAPON);
3412	change_abil (who, op);
3413	break;	3504	break;
3414		3505
3415	case ARMOUR:	3506	case ARMOUR:
3416	case HELMET:	3507	case HELMET:
3417	case SHIELD:	3508	case SHIELD:
…		…
3426	who->statusmsg (format ("You wear %s.", query_name (op)));	3517	who->statusmsg (format ("You wear %s.", query_name (op)));
3427	change_abil (who, op);	3518	change_abil (who, op);
3428	break;	3519	break;
3429		3520
3430	case SKILL_TOOL:	3521	case SKILL_TOOL:
3431	// 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
3432	SET_FLAG (op, FLAG_APPLIED);	3525	SET_FLAG (op, FLAG_APPLIED);
		3526	break;
3433		3527
		3528	case SKILL:
3434	if (!(aflags & AP_NO_READY))	3529	if (!(aflags & AP_NO_SLOT))
3435	{	3530	{
3436	skop = find_skill_by_name (who, op->skill);	3531	// skill is used on it's own, as opposed to being a chosen_skill
3437	if (!skop->flag [FLAG_APPLIED])
3438	apply_special (who, skop, AP_APPLY);
3439	}
3440	break;
3441		3532
3442	case SKILL:	3533	if (skill_flags [op->subtype] & (SF_NEED_ITEM | SF_MANA))
3443	if (player *pl = who->contr)
3444	{
3445	if (IS_COMBAT_SKILL (op->subtype))
3446	{	3534	{
3447	if (skill_flags [op->subtype] & SF_NEED_WEAPON)
3448	{
3449	for (object *item = who->inv; item; item = item->below)
3450	if (item->type == WEAPON && item->flag [FLAG_APPLIED])
3451	{
3452	if (item->skill == op->skill)
3453	{
3454	who->change_weapon (pl->combat_ob = item);
3455	goto found_weapon;
3456	}
3457	}
3458
3459	who->failmsg (format (	3535	who->failmsg (format (
3460	"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. "
3461	"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. "
3462	&op->skill	3538	"It cannot be used on its own.>",
3463	));
3464	return 1;
3465
3466	found_weapon:;
3467	}
3468	else
3469	who->change_weapon (pl->combat_ob = op);
3470	}
3471	else if (IS_RANGED_SKILL (op->subtype))
3472	{
3473	if (skill_flags [op->subtype] & SF_NEED_BOW)
3474	{
3475	for (object *item = who->inv; item; item = item->below)
3476	if (item->type == BOW && item->flag [FLAG_APPLIED])
3477	{
3478	//TODO: bows should/must all have skill missile weapon right now
3479	who->change_weapon (pl->ranged_ob = item);
3480	goto found_bow;
3481	}
3482
3483	who->failmsg (
3484	"You need to apply a missile weapon before readying this skill. "
3485	"H<Some skills need an item, in this case a missile weapon, to function.>"
3486	);
3487	return 1;
3488
3489	found_bow:;
3490	}
3491	else
3492	who->change_weapon (pl->ranged_ob = op);
3493	}
3494
3495	if (!op->invisible)
3496	{
3497	who->statusmsg (format (
3498	"You ready %s."
3499	"You can now use the skill: %s.",
3500	query_name (op),
3501	&op->skill	3539	&op->skill
3502	));	3540	));
		3541	if (tmp) who->insert (tmp);
		3542	return 1;
3503	}	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	));
3504	else	3554	else
3505	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	));
3506	}	3571	}
3507	else	3572
3508	{
3509	SET_FLAG (op, FLAG_APPLIED);
3510	change_abil (who, op);
3511	who->chosen_skill = op;
3512	SET_FLAG (who, FLAG_READY_SKILL);	3573	SET_FLAG (who, FLAG_READY_SKILL);
3513	}	3574	SET_FLAG (op, FLAG_APPLIED);
3514		3575	change_abil (who, op);
3515	break;	3576	break;
3516		3577
3517	case BOW:	3578	case BOW:
3518	if (op->level && !op->name.starts_with (who->name))	3579	if (op->level && (!op->name.starts_with (who->name) || op->name [who->name.length ()] != '\''))
3519	{	3580	{
3520	who->failmsg ("The weapon does not recognize you as its owner. "	3581	who->failmsg ("The weapon does not recognize you as its owner. "
3521	"H<Its name indicates that it belongs to somebody else.>");	3582	"H<Its name indicates that it belongs to somebody else.>");
3522	if (tmp)	3583	if (tmp) who->insert (tmp);
3523	insert_ob_in_ob (tmp, who);
3524
3525	return 1;	3584	return 1;
3526	}	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;
3527		3610
3528	/*FALLTHROUGH*/	3611	/*FALLTHROUGH*/
3529	case WAND:	3612	case WAND:
3530	case ROD:	3613	case ROD:
3531	case HORN:	3614	case HORN:
3532	/* check for skill, alter player status */	3615	/* check for skill, alter player status */
3533		3616
3534	if (!skop)	3617	if (!skop)
3535	{	3618	{
3536	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);
3537	return 1;	3621	return 1;
3538	}	3622	}
3539		3623
3540	SET_FLAG (op, FLAG_APPLIED);	3624	op->flag [FLAG_APPLIED] = true;
3541	who->change_skill (skop);
3542		3625
3543	if (who->contr)	3626	if (player *pl = who->contr)
3544	{	3627	{
3545	who->contr->ranged_ob = op;
3546
3547	who->statusmsg (format ("You ready %s.", query_name (op)));	3628	who->statusmsg (format ("You ready %s.", query_name (op)));
3548		3629
3549	if (op->type == BOW)	3630	if (op->type == BOW)
3550	{
3551	who->current_weapon = op;
3552	change_abil (who, op);
3553	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)));
3554	}	3632
		3633	change_abil (who, op);
3555	}	3634	}
3556	else	3635	else
3557	{	3636	{
		3637	who->change_skill (skop);
		3638
3558	if (op->type == BOW)	3639	if (op->type == BOW)
3559	SET_FLAG (who, FLAG_READY_BOW);	3640	op->flag [FLAG_READY_BOW ] = true;
3560	else	3641	else
3561	SET_FLAG (who, FLAG_READY_RANGE);	3642	op->flag [FLAG_READY_RANGE] = true;
3562	}	3643	}
3563		3644
3564	break;	3645	break;
3565		3646
3566	case BUILDER:	3647	case BUILDER:
3567	if (who->type == PLAYER)	3648	if (player *pl = who->contr)
3568	{	3649	{
3569	//TODO: wtf does this do? shouldn't this be managed automatically (slots?)
3570	if (who->contr->ranged_ob && who->contr->ranged_ob->type == BUILDER)
3571	unapply_special (who, who->contr->ranged_ob, 0);
3572
3573	who->statusmsg (format ("You ready your %s.", query_name (op)));	3650	who->statusmsg (format ("You ready your %s.", query_name (op)));
3574		3651	//TODO: change_abil?
3575	who->contr->ranged_ob = op;
3576	}	3652	}
3577	break;	3653	break;
3578		3654
3579	default:	3655	default:
3580	who->statusmsg (format ("You apply %s.", query_name (op)));	3656	who->statusmsg (format ("You apply %s.", query_name (op)));
3581	}	3657	}
3582		3658
3583	SET_FLAG (op, FLAG_APPLIED);	3659	SET_FLAG (op, FLAG_APPLIED);
3584		3660
3585	if (tmp)
3586	who->insert (tmp);	3661	if (tmp) who->insert (tmp);
3587		3662
3588	who->update_stats ();	3663	who->update_stats ();
3589		3664
3590	/* We exclude spell casting objects. The fire code will set the	3665	/* We exclude spell casting objects. The fire code will set the
3591	* been applied flag when they are used - until that point,	3666	* been applied flag when they are used - until that point,
…		…
3606		3681
3607	if (object *pl = op->visible_to ())	3682	if (object *pl = op->visible_to ())
3608	esrv_send_item (pl, op);	3683	esrv_send_item (pl, op);
3609		3684
3610	return 0;	3685	return 0;
3611	}
3612
3613	int
3614	monster_apply_special (object *who, object *op, int aflags)
3615	{
3616	if (QUERY_FLAG (op, FLAG_UNPAID) && !QUERY_FLAG (op, FLAG_APPLIED))
3617	return 1;
3618
3619	return apply_special (who, op, aflags);
3620	}	3686	}
3621		3687
3622	/**	3688	/**
3623	* Map was just loaded, handle op's initialisation.	3689	* Map was just loaded, handle op's initialisation.
3624	*	3690	*
…		…
3731	* treasure again for this object	3797	* treasure again for this object
3732	*/	3798	*/
3733	invtmp->randomitems = NULL;	3799	invtmp->randomitems = NULL;
3734	}	3800	}
3735	}	3801	}
		3802
3736	/* This is really temporary - the code at the bottom will	3803	/* This is really temporary - the code at the bottom will
3737	* also set randomitems to null. The problem is there are bunches	3804	* also set randomitems to null. The problem is there are bunches
3738	* of maps/players already out there with items that have spells	3805	* of maps/players already out there with items that have spells
3739	* which haven't had the randomitems set to null yet.	3806	* which haven't had the randomitems set to null yet.
3740	* MSW 2004-05-13	3807	* MSW 2004-05-13
…		…
3744	* Ryo 2004-08-16	3811	* Ryo 2004-08-16
3745	*/	3812	*/
3746	if (tmp->type == WAND || tmp->type == ROD || tmp->type == SCROLL	3813	if (tmp->type == WAND || tmp->type == ROD || tmp->type == SCROLL
3747	|| 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)
3748	tmp->randomitems = NULL;	3815	tmp->randomitems = NULL;
3749
3750	}	3816	}
3751		3817
3752	if (QUERY_FLAG (tmp, FLAG_AUTO_APPLY))	3818	if (QUERY_FLAG (tmp, FLAG_AUTO_APPLY))
3753	auto_apply (tmp);	3819	auto_apply (tmp);
3754	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 ())
…		…
3811	/* bigger morsel of food = longer effect time */	3877	/* bigger morsel of food = longer effect time */
3812	int duration = TIME2TICK (food->stats.food);	3878	int duration = TIME2TICK (food->stats.food);
3813		3879
3814	if (force = who->force_find (key))	3880	if (force = who->force_find (key))
3815	{	3881	{
3816	if (duration > abs (force->speed_left / force->speed))	3882	if (duration > fabs (force->speed_left / force->speed))
3817	{	3883	{
3818	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));
3819	force->force_set_timer (duration);	3885	force->force_set_timer (duration);
3820	}	3886	}
3821	else	3887	else
…		…
3893	/* place limit on max sp from food? */	3959	/* place limit on max sp from food? */
3894	}	3960	}
3895	}	3961	}
3896		3962
3897	who->update_stats ();	3963	who->update_stats ();
3898	}
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