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.77 by root, Mon Apr 30 04:43:45 2007 UTC vs.
Revision 1.113 by root, Tue Jul 10 05:51:38 2007 UTC

1	/*	1	/*
2	* CrossFire, A Multiplayer game for X-windows	2	* This file is part of Crossfire TRT, the Roguelike Realtime MORPG.
3	*	3	*
4	* Copyright (C) 2005, 2006, 2007 Marc Lehmann & Crossfire+ Development Team	4	* Copyright (©) 2005,2006,2007 Marc Alexander Lehmann / Robin Redeker / the Crossfire TRT team
5	* Copyright (C) 2001 Mark Wedel & Crossfire Development Team	5	* Copyright (©) 2001,2007 Mark Wedel & Crossfire Development Team
6	* Copyright (C) 1992 Frank Tore Johansen	6	* Copyright (©) 1992,2007 Frank Tore Johansen
7	*	7	*
8	* This program is free software; you can redistribute it and/or modify	8	* Crossfire TRT is free software: you can redistribute it and/or modify
9	* it under the terms of the GNU General Public License as published by	9	* it under the terms of the GNU General Public License as published by
10	* the Free Software Foundation; either version 2 of the License, or	10	* the Free Software Foundation, either version 3 of the License, or
11	* (at your option) any later version.	11	* (at your option) any later version.
12	*	12	*
13	* This program is distributed in the hope that it will be useful,	13	* This program is distributed in the hope that it will be useful,
14	* but WITHOUT ANY WARRANTY; without even the implied warranty of	14	* but WITHOUT ANY WARRANTY; without even the implied warranty of
15	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the	15	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16	* GNU General Public License for more details.	16	* GNU General Public License for more details.
17	*	17	*
18	* You should have received a copy of the GNU General Public License	18	* You should have received a copy of the GNU General Public License
19	* along with this program; if not, write to the Free Software	19	* along with this program. If not, see <http://www.gnu.org/licenses/>.
20	* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
21	*	20	*
22	* The authors can be reached via e-mail to <crossfire@schmorp.de>	21	* The authors can be reached via e-mail to <crossfire@schmorp.de>
23	*/	22	*/
		23
		24	#include <cmath>
24		25
25	#include <global.h>	26	#include <global.h>
26	#include <living.h>	27	#include <living.h>
27	#include <spells.h>	28	#include <spells.h>
28	#include <skills.h>	29	#include <skills.h>
…		…
30		31
31	#include <sproto.h>	32	#include <sproto.h>
32		33
33	/* Want this regardless of rplay. */	34	/* Want this regardless of rplay. */
34	#include <sounds.h>	35	#include <sounds.h>
35
36	/* need math lib for double-precision and pow() in dragon_eat_flesh() */
37	#include <math.h>
38		36
39	/**	37	/**
40	* Check if op should abort moving victim because of it's race or slaying.	38	* Check if op should abort moving victim because of it's race or slaying.
41	* Returns 1 if it should abort, returns 0 if it should continue.	39	* Returns 1 if it should abort, returns 0 if it should continue.
42	*/	40	*/
…		…
70		68
71	/* If the director has race set, only affect objects with a arch,	69	/* If the director has race set, only affect objects with a arch,
72	* name or race that matches.	70	* name or race that matches.
73	*/	71	*/
74	if ((op->race) &&	72	if ((op->race) &&
75	((!(victim->arch && arch_flag && victim->arch->name) || op->race != victim->arch->name)) &&	73	((!(victim->arch && arch_flag && victim->arch->archname) || op->race != victim->arch->archname)) &&
76	((!(victim->name && name_flag) || op->race != victim->name)) &&	74	((!(victim->name && name_flag) || op->race != victim->name)) &&
77	((!(victim->race && race_flag) || op->race != victim->race)))	75	((!(victim->race && race_flag) || op->race != victim->race)))
78	return 1;	76	return 1;
79		77
80	/* If the director has slaying set, only affect objects where none	78	/* If the director has slaying set, only affect objects where none
81	* of arch, name, or race match.	79	* of arch, name, or race match.
82	*/	80	*/
83	if ((op->slaying) && (((victim->arch && arch_flag && victim->arch->name && op->slaying == victim->arch->name))) ||	81	if ((op->slaying) && (((victim->arch && arch_flag && victim->arch->archname && op->slaying == victim->arch->archname))) ||
84	((victim->name && name_flag && op->slaying == victim->name)) ||	82	((victim->name && name_flag && op->slaying == victim->name)) ||
85	((victim->race && race_flag && op->slaying == victim->race)))	83	((victim->race && race_flag && op->slaying == victim->race)))
86	return 1;	84	return 1;
87		85
88	return 0;	86	return 0;
…		…
233	depl = present_arch_in_ob (at, op);	231	depl = present_arch_in_ob (at, op);
234		232
235	if (depl)	233	if (depl)
236	{	234	{
237	for (i = 0; i < NUM_STATS; i++)	235	for (i = 0; i < NUM_STATS; i++)
238	if (get_attr_value (&depl->stats, i))	236	if (depl->stats.stat (i))
239	new_draw_info (NDI_UNIQUE, 0, op, restore_msg[i]);	237	new_draw_info (NDI_UNIQUE, 0, op, restore_msg[i]);
240		238
241	depl->destroy ();	239	depl->destroy ();
242	op->update_stats ();	240	op->update_stats ();
243	}	241	}
…		…
375	force->stats.food *= 10;	373	force->stats.food *= 10;
376	for (i = 0; i < NROFATTACKS; i++)	374	for (i = 0; i < NROFATTACKS; i++)
377	if (force->resist[i] > 0)	375	if (force->resist[i] > 0)
378	force->resist[i] = -force->resist[i]; /* prot => vuln */	376	force->resist[i] = -force->resist[i]; /* prot => vuln */
379	}	377	}
		378
380	force->speed_left = -1;	379	force->speed_left = -1;
381	force = insert_ob_in_ob (force, op);	380	force = insert_ob_in_ob (force, op);
382	CLEAR_FLAG (tmp, FLAG_APPLIED);	381	CLEAR_FLAG (tmp, FLAG_APPLIED);
383	SET_FLAG (force, FLAG_APPLIED);	382	SET_FLAG (force, FLAG_APPLIED);
384	change_abil (op, force);	383	change_abil (op, force);
…		…
425	return 0;	424	return 0;
426		425
427	op = op->below;	426	op = op->below;
428	while (op != NULL)	427	while (op != NULL)
429	{	428	{
430	if (strcmp (op->arch->name, item) == 0)	429	if (strcmp (op->arch->archname, item) == 0)
431	{	430	{
432	if (!QUERY_FLAG (op, FLAG_CURSED) && !QUERY_FLAG (op, FLAG_DAMNED)	431	if (!QUERY_FLAG (op, FLAG_CURSED) && !QUERY_FLAG (op, FLAG_DAMNED)
433	/* Loophole bug? -FD- */ && !QUERY_FLAG (op, FLAG_UNPAID))	432	/* Loophole bug? -FD- */ && !QUERY_FLAG (op, FLAG_UNPAID))
434	{	433	{
435	if (op->nrof == 0) /* this is necessary for artifact sacrifices --FD-- */	434	if (op->nrof == 0) /* this is necessary for artifact sacrifices --FD-- */
…		…
459	prev = op;	458	prev = op;
460	op = op->below;	459	op = op->below;
461		460
462	while (op != NULL)	461	while (op != NULL)
463	{	462	{
464	if (strcmp (op->arch->name, item) == 0)	463	if (strcmp (op->arch->archname, item) == 0)
465	{	464	{
466	if (op->nrof >= nrof)	465	if (op->nrof >= nrof)
467	{	466	{
468	decrease_ob_nr (op, nrof);	467	decrease_ob_nr (op, nrof);
469	return;	468	return;
…		…
855	{	854	{
856	base = base - (base * settings.armor_speed_improvement) / 100;	855	base = base - (base * settings.armor_speed_improvement) / 100;
857	pow++;	856	pow++;
858	}	857	}
859		858
860	ARMOUR_SPEED (armour) = (ARMOUR_SPEED (&armour->arch->clone) * base) / 100;	859	ARMOUR_SPEED (armour) = (ARMOUR_SPEED (armour->arch) * base) / 100;
861	}	860	}
862	else	861	else
863	ARMOUR_SPEED (armour) = (ARMOUR_SPEED (&armour->arch->clone) * (100 + armour->magic * settings.armor_speed_improvement)) / 100;	862	ARMOUR_SPEED (armour) = (ARMOUR_SPEED (armour->arch) * (100 + armour->magic * settings.armor_speed_improvement)) / 100;
864		863
865	if (!settings.armor_weight_linear)	864	if (!settings.armor_weight_linear)
866	{	865	{
867	int base = 100;	866	int base = 100;
868	int pow = 0;	867	int pow = 0;
…		…
871	{	870	{
872	base = base - (base * settings.armor_weight_reduction) / 100;	871	base = base - (base * settings.armor_weight_reduction) / 100;
873	pow++;	872	pow++;
874	}	873	}
875		874
876	armour->weight = (armour->arch->clone.weight * base) / 100;	875	armour->weight = (armour->arch->weight * base) / 100;
877	}	876	}
878	else	877	else
879	armour->weight = (armour->arch->clone.weight * (100 - armour->magic * settings.armor_weight_reduction)) / 100;	878	armour->weight = (armour->arch->weight * (100 - armour->magic * settings.armor_weight_reduction)) / 100;
880		879
881	if (armour->weight <= 0)	880	if (armour->weight <= 0)
882	{	881	{
883	LOG (llevInfo, "Warning: enchanted armours can have negative weight\n.");	882	LOG (llevInfo, "Warning: enchanted armours can have negative weight\n.");
884	armour->weight = 1;	883	armour->weight = 1;
885	}	884	}
886		885
887	armour->item_power = get_power_from_ench (armour->arch->clone.item_power + armour->magic);	886	armour->item_power = get_power_from_ench (armour->arch->item_power + armour->magic);
888		887
889	if (op->type == PLAYER)	888	if (op->type == PLAYER)
890	{	889	{
891	esrv_send_item (op, armour);	890	esrv_send_item (op, armour);
892	if (QUERY_FLAG (armour, FLAG_APPLIED))	891	if (QUERY_FLAG (armour, FLAG_APPLIED))
…		…
944		943
945	price_in = cost * item->value;	944	price_in = cost * item->value;
946	}	945	}
947	else	946	else
948	{	947	{
949	if (item->type == PLAYER || CONV_FROM (converter) != item->arch->name ||	948	if (item->type == PLAYER || CONV_FROM (converter) != item->arch->archname ||
950	(CONV_NEED (converter) && CONV_NEED (converter) > (uint16) item->nrof))	949	(CONV_NEED (converter) && CONV_NEED (converter) > (uint16) item->nrof))
951	return 0;	950	return 0;
952		951
953	if (CONV_NEED (converter))	952	if (CONV_NEED (converter))
954	{	953	{
…		…
1006	LOG (llevDebug, "converter output price higher than input: %s at %s (%d, %d) in value %d, out value %d for %s\n",	1005	LOG (llevDebug, "converter output price higher than input: %s at %s (%d, %d) in value %d, out value %d for %s\n",
1007	&converter->name, &converter->map->path, converter->x, converter->y, price_in, item->nrof * item->value, &item->name);	1006	&converter->name, &converter->map->path, converter->x, converter->y, price_in, item->nrof * item->value, &item->name);
1008		1007
1009	/**	1008	/**
1010	* elmex: we are going to let the game continue, as the mapcreator	1009	* elmex: we are going to let the game continue, as the mapcreator
1011	* propably had something in mind when doing this	1010	* probably had something in mind when doing this
1012	*/	1011	*/
1013	}	1012	}
1014	insert_ob_in_map_at (item, converter->map, converter, 0, converter->x, converter->y);	1013	insert_ob_in_map_at (item, converter->map, converter, 0, converter->x, converter->y);
1015	return 1;	1014	return 1;
1016	}	1015	}
…		…
1245	*/	1244	*/
1246	static void	1245	static void
1247	apply_sign (object *op, object *sign, int autoapply)	1246	apply_sign (object *op, object *sign, int autoapply)
1248	{	1247	{
1249	readable_message_type *msgType;	1248	readable_message_type *msgType;
1250	char newbuf[HUGE_BUF];
1251		1249
1252	if (sign->msg == NULL)	1250	if (sign->msg == NULL)
1253	{	1251	{
1254	new_draw_info (NDI_UNIQUE, 0, op, "Nothing is written on it.");	1252	new_draw_info (NDI_UNIQUE, 0, op, "Nothing is written on it.");
1255	return;	1253	return;
…		…
1276	if (QUERY_FLAG (op, FLAG_BLIND) && !QUERY_FLAG (op, FLAG_WIZ) && !sign->move_on)	1274	if (QUERY_FLAG (op, FLAG_BLIND) && !QUERY_FLAG (op, FLAG_WIZ) && !sign->move_on)
1277	{	1275	{
1278	new_draw_info (NDI_UNIQUE, 0, op, "You are unable to read while blind.");	1276	new_draw_info (NDI_UNIQUE, 0, op, "You are unable to read while blind.");
1279	return;	1277	return;
1280	}	1278	}
		1279
		1280	if (op->contr)
		1281	if (client *ns = op->contr->ns)
		1282	{
1281	msgType = get_readable_message_type (sign);	1283	msgType = get_readable_message_type (sign);
		1284
		1285	if (ns->can_msg)
		1286	ns->send_msg (NDI_NAVY, msgType->msgtype, &sign->msg);
		1287	else
		1288	{
		1289	char newbuf[HUGE_BUF];
1282	snprintf (newbuf, sizeof (newbuf), "%hhu %s", autoapply ? 1 : 0, &sign->msg);	1290	snprintf (newbuf, sizeof (newbuf), "%u %s", autoapply ? 1 : 0, &sign->msg);
1283	draw_ext_info (NDI_UNIQUE | NDI_NAVY, 0, op, msgType->message_type, msgType->message_subtype, newbuf, &sign->msg);	1291	draw_ext_info (NDI_UNIQUE | NDI_NAVY, 0, op, msgType->message_type, msgType->message_subtype, newbuf, &sign->msg);
		1292	}
		1293	}
1284	}	1294	}
1285		1295
1286	/**	1296	/**
1287	* 'victim' moves onto 'trap'	1297	* 'victim' moves onto 'trap'
1288	* 'victim' leaves 'trap'	1298	* 'victim' leaves 'trap'
…		…
1311	* proper. This code was causing needless crashes.	1321	* proper. This code was causing needless crashes.
1312	*/	1322	*/
1313	if (recursion_depth >= 500)	1323	if (recursion_depth >= 500)
1314	{	1324	{
1315	LOG (llevDebug, "WARNING: move_apply(): aborting recursion "	1325	LOG (llevDebug, "WARNING: move_apply(): aborting recursion "
1316	"[trap arch %s, name %s; victim arch %s, name %s]\n", &trap->arch->name, &trap->name, &victim->arch->name, &victim->name);	1326	"[trap arch %s, name %s; victim arch %s, name %s]\n", &trap->arch->archname, &trap->name, &victim->arch->archname, &victim->name);
1317	return;	1327	return;
1318	}	1328	}
		1329
1319	recursion_depth++;	1330	recursion_depth++;
1320	if (trap->head)	1331	if (trap->head)
1321	trap = trap->head;	1332	trap = trap->head;
1322		1333
1323	if (INVOKE_OBJECT (MOVE_TRIGGER, trap, ARG_OBJECT (victim), ARG_OBJECT (originator)))	1334	if (INVOKE_OBJECT (MOVE_TRIGGER, trap, ARG_OBJECT (victim), ARG_OBJECT (originator)))
…		…
1338		1349
1339	/* Just put in some sanity check. I think there is a bug in the	1350	/* Just put in some sanity check. I think there is a bug in the
1340	* above with some objects have zero speed, and thus the player	1351	* above with some objects have zero speed, and thus the player
1341	* getting permanently paralyzed.	1352	* getting permanently paralyzed.
1342	*/	1353	*/
1343	if (victim->speed_left < -50.0)	1354	if (victim->speed_left < -50.f)
1344	victim->speed_left = -50.0;	1355	victim->speed_left = -50.f;
1345	/* LOG(llevDebug, "apply, playermove, player speed_left=%f\n", victim->speed_left); */	1356	/* LOG(llevDebug, "apply, playermove, player speed_left=%f\n", victim->speed_left); */
1346	}	1357	}
1347	goto leave;	1358	goto leave;
1348		1359
1349	case SPINNER:	1360	case SPINNER:
…		…
1518	}	1529	}
1519	goto leave;	1530	goto leave;
1520		1531
1521	default:	1532	default:
1522	LOG (llevDebug, "name %s, arch %s, type %d with fly/walk on/off not "	1533	LOG (llevDebug, "name %s, arch %s, type %d with fly/walk on/off not "
1523	"handled in move_apply()\n", &trap->name, &trap->arch->name, trap->type);	1534	"handled in move_apply()\n", &trap->name, &trap->arch->archname, trap->type);
1524	goto leave;	1535	goto leave;
1525	}	1536	}
1526		1537
1527	leave:	1538	leave:
1528	recursion_depth--;	1539	recursion_depth--;
…		…
1540	if (QUERY_FLAG (op, FLAG_BLIND) && !QUERY_FLAG (op, FLAG_WIZ))	1551	if (QUERY_FLAG (op, FLAG_BLIND) && !QUERY_FLAG (op, FLAG_WIZ))
1541	{	1552	{
1542	new_draw_info (NDI_UNIQUE, 0, op, "You are unable to read while blind.");	1553	new_draw_info (NDI_UNIQUE, 0, op, "You are unable to read while blind.");
1543	return;	1554	return;
1544	}	1555	}
		1556
1545	if (tmp->msg == NULL)	1557	if (!tmp->msg)
1546	{	1558	{
1547	new_draw_info_format (NDI_UNIQUE, 0, op, "You open the %s and find it empty.", &tmp->name);	1559	new_draw_info_format (NDI_UNIQUE, 0, op, "You open the %s and find it empty.", &tmp->name);
1548	return;	1560	return;
1549	}	1561	}
1550		1562
…		…
1553	if (!skill_ob)	1565	if (!skill_ob)
1554	{	1566	{
1555	new_draw_info (NDI_UNIQUE, 0, op, "You are unable to decipher the strange symbols.");	1567	new_draw_info (NDI_UNIQUE, 0, op, "You are unable to decipher the strange symbols.");
1556	return;	1568	return;
1557	}	1569	}
		1570
1558	lev_diff = tmp->level - (skill_ob->level + 5);	1571	lev_diff = tmp->level - (skill_ob->level + 5);
1559	if (!QUERY_FLAG (op, FLAG_WIZ) && lev_diff > 0)	1572	if (!QUERY_FLAG (op, FLAG_WIZ) && lev_diff > 0)
1560	{	1573	{
1561	if (lev_diff < 2)	1574	if (lev_diff < 2)
1562	new_draw_info (NDI_UNIQUE, 0, op, "This book is just barely beyond your comprehension.");	1575	new_draw_info (NDI_UNIQUE, 0, op, "This book is just barely beyond your comprehension.");
…		…
1573	return;	1586	return;
1574	}	1587	}
1575		1588
1576	readable_message_type *msgType = get_readable_message_type (tmp);	1589	readable_message_type *msgType = get_readable_message_type (tmp);
1577		1590
		1591	if (player *pl = op->contr)
		1592	if (client *ns = pl->ns)
		1593	if (ns->can_msg)
		1594	{
		1595	dynbuf_text buf;
		1596	buf << long_desc (tmp, op)
		1597	<< "\n\n"
		1598	<< tmp->msg
		1599	<< '\0';
		1600	ns->send_msg (NDI_NAVY, msgType->msgtype, buf.linearise ());
		1601	}
		1602	else
1578	draw_ext_info_format (NDI_UNIQUE | NDI_NAVY, 0, op,	1603	draw_ext_info_format (NDI_UNIQUE | NDI_NAVY, 0, op,
1579	msgType->message_type, msgType->message_subtype,	1604	msgType->message_type, msgType->message_subtype,
1580	"You open the %s and start reading.\n%s", (char *)"%s\n%s",	1605	"You open the %s and start reading.\n%s", (char *)"%s\n%s",
1581	long_desc (tmp, op), &tmp->msg);	1606	long_desc (tmp, op), &tmp->msg);
1582		1607
1583	/* gain xp from reading */	1608	/* gain xp from reading */
1584	if (!QUERY_FLAG (tmp, FLAG_NO_SKILL_IDENT))	1609	if (!QUERY_FLAG (tmp, FLAG_NO_SKILL_IDENT))
1585	{ /* only if not read before */	1610	{ /* only if not read before */
1586	int exp_gain = calc_skill_exp (op, tmp, skill_ob);	1611	int exp_gain = calc_skill_exp (op, tmp, skill_ob);
…		…
1868	if (!QUERY_FLAG (tmp, FLAG_IDENTIFIED))	1893	if (!QUERY_FLAG (tmp, FLAG_IDENTIFIED))
1869	identify (tmp);	1894	identify (tmp);
1870		1895
1871	new_draw_info_format (NDI_BLACK, 0, op, "The scroll of %s turns to dust.", &tmp->inv->name);	1896	new_draw_info_format (NDI_BLACK, 0, op, "The scroll of %s turns to dust.", &tmp->inv->name);
1872		1897
1873
1874	cast_spell (op, tmp, dir, tmp->inv, NULL);	1898	cast_spell (op, tmp, dir, tmp->inv, NULL);
1875	decrease_ob (tmp);	1899	decrease_ob (tmp);
1876	}	1900	}
1877		1901
1878	/**	1902	/**
…		…
1881	* chest.	1905	* chest.
1882	*/	1906	*/
1883	static void	1907	static void
1884	apply_treasure (object *op, object *tmp)	1908	apply_treasure (object *op, object *tmp)
1885	{	1909	{
1886	object *treas;
1887
1888
1889	/* Nice side effect of new treasure creation method is that the treasure	1910	/* Nice side effect of new treasure creation method is that the treasure
1890	* for the chest is done when the chest is created, and put into the chest	1911	* for the chest is done when the chest is created, and put into the chest
1891	* inventory. So that when the chest burns up, the items still exist. Also	1912	* inventory. So that when the chest burns up, the items still exist. Also
1892	* prevents people fromt moving chests to more difficult maps to get better	1913	* prevents people fromt moving chests to more difficult maps to get better
1893	* treasure	1914	* treasure
1894	*/	1915	*/
1895
1896	treas = tmp->inv;	1916	object *treas = tmp->inv;
1897	if (treas == NULL)	1917
		1918	if (!treas)
1898	{	1919	{
1899	new_draw_info (NDI_UNIQUE, 0, op, "The chest was empty.");	1920	new_draw_info (NDI_UNIQUE, 0, op, "The chest was empty.");
1900	decrease_ob (tmp);	1921	decrease_ob (tmp);
1901	return;	1922	return;
1902	}	1923	}
		1924
1903	while (tmp->inv)	1925	while (tmp->inv)
1904	{	1926	{
1905	treas = tmp->inv;	1927	treas = tmp->inv;
1906		1928
1907	treas->remove ();	1929	treas->remove ();
…		…
2025	if (meal->type != FLESH || !is_dragon_pl (op))	2047	if (meal->type != FLESH || !is_dragon_pl (op))
2026	return 0;	2048	return 0;
2027		2049
2028	/* now grab the 'dragon_skin'- and 'dragon_ability'-forces	2050	/* now grab the 'dragon_skin'- and 'dragon_ability'-forces
2029	from the player's inventory */	2051	from the player's inventory */
2030	shstr_cmp dragon_ability_force ("dragon_ability_force");
2031	shstr_cmp dragon_skin_force ("dragon_skin_force");
2032
2033	for (tmp = op->inv; tmp; tmp = tmp->below)	2052	for (tmp = op->inv; tmp; tmp = tmp->below)
2034	if (tmp->type == FORCE)	2053	if (tmp->type == FORCE)
2035	if (tmp->arch->name == dragon_skin_force)	2054	if (tmp->arch->archname == shstr_dragon_skin_force)
2036	skin = tmp;	2055	skin = tmp;
2037	else if (tmp->arch->name == dragon_ability_force)	2056	else if (tmp->arch->archname == shstr_dragon_ability_force)
2038	abil = tmp;	2057	abil = tmp;
2039		2058
2040	/* if either skin or ability are missing, this is an old player	2059	/* if either skin or ability are missing, this is an old player
2041	which is not to be considered a dragon -> bail out */	2060	which is not to be considered a dragon -> bail out */
2042	if (skin == NULL || abil == NULL)	2061	if (skin == NULL || abil == NULL)
…		…
2296	}	2315	}
2297		2316
2298	return 0;	2317	return 0;
2299	}	2318	}
2300		2319
2301
2302	/**	2320	/**
2303	* Main apply handler.	2321	* Main apply handler.
2304	*	2322	*
2305	* Checks for unpaid items before applying.	2323	* Checks for unpaid items before applying.
2306	*	2324	*
…		…
2313	* being applied.	2331	* being applied.
2314	*	2332	*
2315	* aflag is special (always apply/unapply) flags. Nothing is done with	2333	* aflag is special (always apply/unapply) flags. Nothing is done with
2316	* them in this function - they are passed to apply_special	2334	* them in this function - they are passed to apply_special
2317	*/	2335	*/
2318
2319	int	2336	int
2320	manual_apply (object *op, object *tmp, int aflag)	2337	manual_apply (object *op, object *tmp, int aflag)
2321	{	2338	{
2322	if (tmp->head)	2339	if (tmp->head)
2323	tmp = tmp->head;	2340	tmp = tmp->head;
…		…
2361	case EXIT:	2378	case EXIT:
2362	if (op->type != PLAYER)	2379	if (op->type != PLAYER)
2363	return 0;	2380	return 0;
2364		2381
2365	if (!EXIT_PATH (tmp) || !is_legal_2ways_exit (op, tmp))	2382	if (!EXIT_PATH (tmp) || !is_legal_2ways_exit (op, tmp))
2366	{
2367	new_draw_info_format (NDI_UNIQUE, 0, op, "The %s is closed.", query_name (tmp));	2383	new_draw_info_format (NDI_UNIQUE, 0, op, "The %s is closed.", query_name (tmp));
2368	}
2369	else	2384	else
2370	{	2385	{
2371	/* Don't display messages for random maps. */	2386	/* Don't display messages for random maps. */
2372	if (tmp->msg && strncmp (EXIT_PATH (tmp), "/!", 2))	2387	if (tmp->msg && strncmp (EXIT_PATH (tmp), "/!", 2))
2373	new_draw_info (NDI_NAVY, 0, op, tmp->msg);	2388	new_draw_info (NDI_NAVY, 0, op, tmp->msg);
2374		2389
2375	op->enter_exit (tmp);	2390	op->enter_exit (tmp);
2376	}	2391	}
		2392
2377	return 1;	2393	return 1;
2378		2394
2379	case SIGN:	2395	case SIGN:
2380	apply_sign (op, tmp, 0);	2396	apply_sign (op, tmp, 0);
2381	return 1;	2397	return 1;
…		…
2385	{	2401	{
2386	apply_book (op, tmp);	2402	apply_book (op, tmp);
2387	return 1;	2403	return 1;
2388	}	2404	}
2389	else	2405	else
2390	{
2391	return 0;	2406	return 0;
2392	}
2393		2407
2394	case SKILLSCROLL:	2408	case SKILLSCROLL:
2395	if (op->type == PLAYER)	2409	if (op->type == PLAYER)
2396	{	2410	{
2397	apply_skillscroll (op, tmp);	2411	apply_skillscroll (op, tmp);
2398	return 1;	2412	return 1;
2399	}	2413	}
		2414	else
2400	return 0;	2415	return 0;
2401		2416
2402	case SPELLBOOK:	2417	case SPELLBOOK:
2403	if (op->type == PLAYER)	2418	if (op->type == PLAYER)
2404	{	2419	{
2405	apply_spellbook (op, tmp);	2420	apply_spellbook (op, tmp);
2406	return 1;	2421	return 1;
2407	}	2422	}
		2423	else
2408	return 0;	2424	return 0;
2409		2425
2410	case SCROLL:	2426	case SCROLL:
2411	apply_scroll (op, tmp, 0);	2427	apply_scroll (op, tmp, 0);
2412	return 1;	2428	return 1;
2413		2429
2414	case POTION:	2430	case POTION:
2415	(void) apply_potion (op, tmp);	2431	apply_potion (op, tmp);
2416	return 1;	2432	return 1;
2417		2433
2418	/* Eneq(@csd.uu.se): Handle apply on containers. */	2434	/* Eneq(@csd.uu.se): Handle apply on containers. */
2419	//TODO: remove, as it is unsed?	2435	//TODO: remove, as it is unsed?
2420	case CLOSE_CON:	2436	case CLOSE_CON:
…		…
2453	case LAMP:	2469	case LAMP:
2454	case BUILDER:	2470	case BUILDER:
2455	case SKILL_TOOL:	2471	case SKILL_TOOL:
2456	if (tmp->env != op)	2472	if (tmp->env != op)
2457	return 2; /* not in inventory */	2473	return 2; /* not in inventory */
		2474
2458	(void) apply_special (op, tmp, aflag);	2475	apply_special (op, tmp, aflag);
2459	return 1;	2476	return 1;
2460		2477
2461	case DRINK:	2478	case DRINK:
2462	case FOOD:	2479	case FOOD:
2463	case FLESH:	2480	case FLESH:
…		…
2479	}	2496	}
2480	else	2497	else
2481	return 0;	2498	return 0;
2482		2499
2483	case WEAPON_IMPROVER:	2500	case WEAPON_IMPROVER:
2484	(void) check_improve_weapon (op, tmp);	2501	check_improve_weapon (op, tmp);
2485	return 1;	2502	return 1;
2486		2503
2487	case CLOCK:	2504	case CLOCK:
2488	if (op->type == PLAYER)	2505	if (op->type == PLAYER)
2489	{	2506	{
…		…
2497	play_sound_player_only (op->contr, SOUND_CLOCK, 0, 0);	2514	play_sound_player_only (op->contr, SOUND_CLOCK, 0, 0);
2498	new_draw_info (NDI_UNIQUE, 0, op, buf);	2515	new_draw_info (NDI_UNIQUE, 0, op, buf);
2499	return 1;	2516	return 1;
2500	}	2517	}
2501	else	2518	else
2502	{
2503	return 0;	2519	return 0;
2504	}
2505		2520
2506	case MENU:	2521	case MENU:
2507	if (op->type == PLAYER)	2522	if (op->type == PLAYER)
2508	{	2523	{
2509	shop_listing (tmp, op);	2524	shop_listing (tmp, op);
2510	return 1;	2525	return 1;
2511	}	2526	}
2512	else	2527	else
2513	{
2514	return 0;	2528	return 0;
2515	}
2516		2529
2517	case POWER_CRYSTAL:	2530	case POWER_CRYSTAL:
2518	apply_power_crystal (op, tmp); /* see egoitem.c */	2531	apply_power_crystal (op, tmp); /* see egoitem.c */
2519	return 1;	2532	return 1;
2520		2533
…		…
2523	{	2536	{
2524	apply_lighter (op, tmp);	2537	apply_lighter (op, tmp);
2525	return 1;	2538	return 1;
2526	}	2539	}
2527	else	2540	else
2528	{
2529	return 0;	2541	return 0;
2530	}
2531		2542
2532	case ITEM_TRANSFORMER:	2543	case ITEM_TRANSFORMER:
2533	apply_item_transformer (op, tmp);	2544	apply_item_transformer (op, tmp);
2534	return 1;	2545	return 1;
2535		2546
…		…
2558	new_draw_info (NDI_UNIQUE, 0, pl, "But you are floating high " "above the ground!");	2569	new_draw_info (NDI_UNIQUE, 0, pl, "But you are floating high " "above the ground!");
2559	return 0;	2570	return 0;
2560	}	2571	}
2561	}	2572	}
2562		2573
2563	/* Check for PLAYER to avoid a DM to disappear in a puff of smoke if
2564	* applied.
2565	*/
2566	if (op->type != PLAYER && QUERY_FLAG (op, FLAG_WAS_WIZ) && !QUERY_FLAG (pl, FLAG_WAS_WIZ))
2567	{
2568	play_sound_map (pl->map, pl->x, pl->y, SOUND_OB_EVAPORATE);
2569	new_draw_info (NDI_UNIQUE, 0, pl, "The object disappears in a puff " "of smoke!");
2570	new_draw_info (NDI_UNIQUE, 0, pl, "It must have been an illusion.");
2571	op->destroy ();
2572	return 1;
2573	}
2574
2575	pl->contr->last_used = op;	2574	pl->contr->last_used = op;
2576		2575
2577	tmp = manual_apply (pl, op, aflag);	2576	tmp = manual_apply (pl, op, aflag);
2578	if (!quiet)	2577	if (!quiet)
2579	{	2578	{
…		…
2588	/**	2587	/**
2589	* player_apply_below attempts to apply the object 'below' the player.	2588	* player_apply_below attempts to apply the object 'below' the player.
2590	* If the player has an open container, we use that for below, otherwise	2589	* If the player has an open container, we use that for below, otherwise
2591	* we use the ground.	2590	* we use the ground.
2592	*/	2591	*/
2593
2594	void	2592	void
2595	player_apply_below (object *pl)	2593	player_apply_below (object *pl)
2596	{	2594	{
2597	int floors = 0;	2595	int floors = 0;
2598		2596
…		…
2635	* to keep the size of apply_special to a more managable size.	2633	* to keep the size of apply_special to a more managable size.
2636	*/	2634	*/
2637	static int	2635	static int
2638	unapply_special (object *who, object *op, int aflags)	2636	unapply_special (object *who, object *op, int aflags)
2639	{	2637	{
2640	if (INVOKE_OBJECT (BE_UNREADY, op, ARG_OBJECT (who), ARG_INT (aflags)) || INVOKE_OBJECT (UNREADY, who, ARG_OBJECT (op), ARG_INT (aflags)))	2638	if (INVOKE_OBJECT (BE_UNREADY, op, ARG_OBJECT (who), ARG_INT (aflags))
		2639	|| INVOKE_OBJECT (UNREADY, who, ARG_OBJECT (op), ARG_INT (aflags)))
2641	return RESULT_INT (0);	2640	return RESULT_INT (0);
2642		2641
2643	object *tmp2;
2644
2645	CLEAR_FLAG (op, FLAG_APPLIED);	2642	CLEAR_FLAG (op, FLAG_APPLIED);
2646		2643
2647	switch (op->type)	2644	switch (op->type)
2648	{	2645	{
		2646	case SKILL_TOOL:
		2647	// unapplying a skill tool should also unapply the skill it governs
		2648	// but this is hard, as it shouldn't do so when the skill can
		2649	// be used for other reasons
		2650	for (object *tmp = who->inv; tmp; tmp = tmp->below)
		2651	if (tmp->skill == op->skill
		2652	&& tmp->type == SKILL
		2653	&& tmp->flag [FLAG_APPLIED]
		2654	&& !tmp->flag [FLAG_CAN_USE_SKILL])
		2655	unapply_special (who, tmp, 0);
		2656
		2657	change_abil (who, op);
		2658	break;
		2659
2649	case WEAPON:	2660	case WEAPON:
		2661	if (player *pl = who->contr)
		2662	if (op == pl->combat_ob)
		2663	{
		2664	pl->combat_ob = 0;
		2665	who->change_weapon (pl->ranged_ob);
		2666	}
		2667
2650	new_draw_info_format (NDI_UNIQUE, 0, who, "You unwield %s.", query_name (op));	2668	new_draw_info_format (NDI_UNIQUE, 0, who, "You unwield %s.", query_name (op));
2651		2669
2652	(void) change_abil (who, op);	2670	change_abil (who, op);
2653	if (QUERY_FLAG (who, FLAG_READY_WEAPON))
2654	CLEAR_FLAG (who, FLAG_READY_WEAPON);	2671	CLEAR_FLAG (who, FLAG_READY_WEAPON);
2655	clear_skill (who);
2656	break;	2672	break;
2657		2673
2658	case SKILL: /* allows objects to impart skills */
2659	case SKILL_TOOL:	2674	case SKILL:
2660	if (op != who->chosen_skill)	2675	if (who->contr)
2661	LOG (llevError, "BUG: apply_special(): applied skill is not a chosen skill\n");
2662
2663	if (who->type == PLAYER)
2664	{
2665	if (who->contr->ranged_ob == op)
2666	{	2676	{
2667	who->contr->ranged_skill = 0;
2668	who->contr->ranged_ob = 0;
2669	}
2670
2671	if (!op->invisible)	2677	if (!op->invisible)
2672	new_draw_info_format (NDI_UNIQUE, 0, who, "You stop using the %s.", query_name (op));	2678	new_draw_info_format (NDI_UNIQUE, 0, who, "You stop using the %s.", query_name (op));
2673	else	2679	else
2674	new_draw_info_format (NDI_UNIQUE, 0, who, "You can no longer use the skill: %s.", &op->skill);	2680	new_draw_info_format (NDI_UNIQUE, 0, who, "You can no longer use the skill: %s.", &op->skill);
2675	}	2681	}
2676		2682
2677	change_abil (who, op);	2683	change_abil (who, op);
2678	who->chosen_skill = 0;
2679	CLEAR_FLAG (who, FLAG_READY_SKILL);	2684	CLEAR_FLAG (who, FLAG_READY_SKILL);
2680	break;	2685	break;
2681		2686
2682	case ARMOUR:	2687	case ARMOUR:
2683	case HELMET:	2688	case HELMET:
…		…
2688	case AMULET:	2693	case AMULET:
2689	case GIRDLE:	2694	case GIRDLE:
2690	case BRACERS:	2695	case BRACERS:
2691	case CLOAK:	2696	case CLOAK:
2692	new_draw_info_format (NDI_UNIQUE, 0, who, "You unwear %s.", query_name (op));	2697	new_draw_info_format (NDI_UNIQUE, 0, who, "You unwear %s.", query_name (op));
2693	(void) change_abil (who, op);	2698	change_abil (who, op);
2694	break;	2699	break;
		2700
2695	case LAMP:	2701	case LAMP:
		2702	{
2696	new_draw_info_format (NDI_UNIQUE, 0, who, "You turn off your %s.", &op->name);	2703	new_draw_info_format (NDI_UNIQUE, 0, who, "You turn off your %s.", &op->name);
		2704
2697	tmp2 = arch_to_object (op->other_arch);	2705	object *tmp2 = arch_to_object (op->other_arch);
2698	tmp2->x = op->x;	2706	tmp2->x = op->x;
2699	tmp2->y = op->y;	2707	tmp2->y = op->y;
2700	tmp2->map = op->map;	2708	tmp2->map = op->map;
2701	tmp2->below = op->below;	2709	tmp2->below = op->below;
2702	tmp2->above = op->above;	2710	tmp2->above = op->above;
2703	tmp2->stats.food = op->stats.food;	2711	tmp2->stats.food = op->stats.food;
2704	CLEAR_FLAG (tmp2, FLAG_APPLIED);	2712	CLEAR_FLAG (tmp2, FLAG_APPLIED);
2705		2713
2706	if (QUERY_FLAG (op, FLAG_INV_LOCKED))	2714	if (QUERY_FLAG (op, FLAG_INV_LOCKED))
2707	SET_FLAG (tmp2, FLAG_INV_LOCKED);	2715	SET_FLAG (tmp2, FLAG_INV_LOCKED);
2708		2716
2709	if (who->type == PLAYER)	2717	if (who->contr)
2710	esrv_del_item (who->contr, op->count);	2718	esrv_del_item (who->contr, op->count);
2711		2719
2712	op->destroy ();	2720	op->destroy ();
2713	insert_ob_in_ob (tmp2, who);	2721	insert_ob_in_ob (tmp2, who);
2714	who->update_stats ();	2722	who->update_stats ();
		2723
2715	if (QUERY_FLAG (op, FLAG_CURSED) || QUERY_FLAG (op, FLAG_DAMNED))	2724	if (QUERY_FLAG (op, FLAG_CURSED) || QUERY_FLAG (op, FLAG_DAMNED))
2716	{	2725	{
2717	if (who->type == PLAYER)	2726	if (who->contr)
2718	{	2727	{
2719	new_draw_info (NDI_UNIQUE, 0, who, "Oops, it feels deadly cold!");	2728	new_draw_info (NDI_UNIQUE, 0, who, "Oops, it feels deadly cold!");
2720	SET_FLAG (tmp2, FLAG_KNOWN_CURSED);	2729	SET_FLAG (tmp2, FLAG_KNOWN_CURSED);
2721	}	2730	}
2722	}	2731	}
2723	if (who->type == PLAYER)	2732
		2733	if (who->contr)
2724	esrv_send_item (who, tmp2);	2734	esrv_send_item (who, tmp2);
		2735	}
		2736
2725	return 1; /* otherwise, an attempt to drop causes problems */	2737	return 1; /* otherwise, an attempt to drop causes problems */
2726	break;
2727		2738
2728	case BOW:	2739	case BOW:
2729	case WAND:	2740	case WAND:
2730	case ROD:	2741	case ROD:
2731	case HORN:	2742	case HORN:
2732	clear_skill (who);	2743	if (player *pl = who->contr)
2733	if (who->type == PLAYER)	2744	{
		2745	if (op == pl->ranged_ob)
2734	{	2746	{
		2747	pl->ranged_ob = 0;
		2748	who->change_weapon (pl->combat_ob);
		2749	}
		2750
2735	new_draw_info_format (NDI_UNIQUE, 0, who, "You unready %s.", query_name (op));	2751	new_draw_info_format (NDI_UNIQUE, 0, who, "You unready %s.", query_name (op));
2736
2737	who->contr->ranged_skill = 0;
2738	who->contr->ranged_ob = 0;
2739	}	2752	}
2740	else	2753	else
2741	{	2754	{
		2755	who->change_skill (0);
		2756
2742	if (op->type == BOW)	2757	if (op->type == BOW)
2743	CLEAR_FLAG (who, FLAG_READY_BOW);	2758	CLEAR_FLAG (who, FLAG_READY_BOW);
2744	else	2759	else
2745	CLEAR_FLAG (who, FLAG_READY_RANGE);	2760	CLEAR_FLAG (who, FLAG_READY_RANGE);
2746	}	2761	}
2747		2762
2748	break;	2763	break;
2749		2764
2750	case BUILDER:	2765	case BUILDER:
2751	if (who->type == PLAYER)	2766	if (who->contr)
2752	{
2753	new_draw_info_format (NDI_UNIQUE, 0, who, "You unready %s.", query_name (op));	2767	new_draw_info_format (NDI_UNIQUE, 0, who, "You unready %s.", query_name (op));
2754
2755	who->contr->ranged_skill = 0;
2756	who->contr->ranged_ob = 0;
2757	}
2758	break;	2768	break;
2759		2769
2760	default:	2770	default:
2761	new_draw_info_format (NDI_UNIQUE, 0, who, "You unapply %s.", query_name (op));	2771	new_draw_info_format (NDI_UNIQUE, 0, who, "You unapply %s.", query_name (op));
2762	break;	2772	break;
…		…
2764		2774
2765	who->update_stats ();	2775	who->update_stats ();
2766		2776
2767	if (!(aflags & AP_NO_MERGE))	2777	if (!(aflags & AP_NO_MERGE))
2768	{	2778	{
2769	object *tmp;
2770
2771	tmp = merge_ob (op, NULL);	2779	object *tmp = merge_ob (op, 0);
2772	if (who->type == PLAYER)	2780
		2781	if (who->contr)
2773	{	2782	{
2774	if (tmp)	2783	if (tmp)
2775	{ /* it was merged */	2784	{ /* it was merged */
2776	esrv_del_item (who->contr, op->count);	2785	esrv_del_item (who->contr, op->count);
2777	op = tmp;	2786	op = tmp;
2778	}	2787	}
2779		2788
2780	esrv_send_item (who, op);	2789	esrv_send_item (who, op);
2781	}	2790	}
2782	}	2791	}
		2792
2783	return 0;	2793	return 0;
2784	}	2794	}
2785		2795
2786	/**	2796	/**
2787	* Returns the object that is using location 'loc'.	2797	* Returns the object that is using location 'loc'.
2788	* Note that 'start' is the first object to start examing - we	2798	* Note that 'start' is the first object to start examing - we
2789	* then go through the below of this. In this way, you can do	2799	* then go through the below of this. In this way, you can do
2790	* something like:	2800	* something like:
2791	* tmp = get_item_from_body_location(who->inv, 1);	2801	* tmp = get_next_item_from_body_location(who->inv, 1);
2792	* if (tmp) tmp1 = get_item_from_body_location(tmp->below, 1);	2802	* if (tmp) tmp1 = get_next_item_from_body_location(tmp->below, 1);
2793	* to find the second object that may use this location, etc.	2803	* to find the second object that may use this location, etc.
2794	* Returns NULL if no match is found.	2804	* Returns NULL if no match is found.
2795	* loc is the index into the array we are looking for a match.	2805	* loc is the index into the array we are looking for a match.
2796	* don't return invisible objects unless they are skill objects	2806	* don't return invisible objects unless they are skill objects
2797	* invisible other objects that use	2807	* invisible other objects that use
2798	* up body locations can be used as restrictions.	2808	* up body locations can be used as restrictions.
2799	*/	2809	*/
2800	object *	2810	static object *
2801	get_item_from_body_location (object *start, int loc)	2811	get_next_item_from_body_location (int loc, object *start)
2802	{	2812	{
2803	object *tmp;
2804
2805	if (!start)
2806	return NULL;
2807
2808	for (tmp = start; tmp; tmp = tmp->below)	2813	for (object *tmp = start; tmp; tmp = tmp->below)
2809	if (QUERY_FLAG (tmp, FLAG_APPLIED) && tmp->body_info[loc] && (!tmp->invisible || tmp->type == SKILL))	2814	if (tmp->flag [FLAG_APPLIED]
		2815	&& tmp->slot[loc].info
		2816	&& (!tmp->invisible || tmp->type == SKILL))
2810	return tmp;	2817	return tmp;
2811		2818
2812	return NULL;	2819	return 0;
2813	}	2820	}
2814
2815
2816		2821
2817	/**	2822	/**
2818	* 'op' wants to apply an object, but can't because of other equipment.	2823	* 'op' wants to apply an object, but can't because of other equipment.
2819	* This should only be called when it is known	2824	* This should only be called when it is known
2820	* that there are objects to unapply. This makes pretty heavy	2825	* that there are objects to unapply. This makes pretty heavy
…		…
2826	* another function that does just that.	2831	* another function that does just that.
2827	*/	2832	*/
2828	int	2833	int
2829	unapply_for_ob (object *who, object *op, int aflags)	2834	unapply_for_ob (object *who, object *op, int aflags)
2830	{	2835	{
2831	int i;	2836	if (op->is_range ())
2832	object *tmp = NULL, *last;
2833
2834	/* If we are applying a shield or weapon, unapply any equipped shield
2835	* or weapons first - only allowed to use one weapon/shield at a time.
2836	*/
2837	if (op->type == WEAPON || op->type == SHIELD)
2838	{
2839	for (tmp = who->inv; tmp; tmp = tmp->below)	2837	for (object *tmp = who->inv; tmp; tmp = tmp->below)
2840	{
2841	if (QUERY_FLAG (tmp, FLAG_APPLIED) && tmp->type == op->type)	2838	if (QUERY_FLAG (tmp, FLAG_APPLIED) && tmp->is_range ())
2842	{
2843	if ((aflags & AP_IGNORE_CURSE) || (aflags & AP_PRINT) || (!QUERY_FLAG (tmp, FLAG_CURSED) && !QUERY_FLAG (tmp, FLAG_DAMNED)))	2839	if ((aflags & AP_IGNORE_CURSE) || (aflags & AP_PRINT) || (!QUERY_FLAG (tmp, FLAG_CURSED) && !QUERY_FLAG (tmp, FLAG_DAMNED)))
2844	{	2840	{
2845	if (aflags & AP_PRINT)	2841	if (aflags & AP_PRINT)
2846	new_draw_info (NDI_UNIQUE, 0, who, query_name (tmp));	2842	new_draw_info (NDI_UNIQUE, 0, who, query_name (tmp));
2847	else	2843	else
2848	unapply_special (who, tmp, aflags);	2844	unapply_special (who, tmp, aflags);
2849	}	2845	}
2850	else	2846	else
2851	{	2847	{
2852	/* In this case, we want to try and remove a cursed item.	2848	/* In this case, we want to try and remove a cursed item.
2853	* While we know it won't work, we want unapply_special to	2849	* While we know it won't work, we want unapply_special to
2854	* at least generate the message.	2850	* at least generate the message.
2855	*/	2851	*/
2856	new_draw_info_format (NDI_UNIQUE, 0, who, "No matter how hard you try, you just can't\nremove %s.", query_name (tmp));	2852	new_draw_info_format (NDI_UNIQUE, 0, who, "No matter how hard you try, you just can't remove the %s.", query_name (tmp));
2857	return 1;	2853	return 1;
2858	}
2859
2860	}	2854	}
2861	}
2862	}
2863		2855
2864	for (i = 0; i < NUM_BODY_LOCATIONS; i++)	2856	for (int i = 0; i < NUM_BODY_LOCATIONS; i++)
2865	{	2857	{
2866	/* this used up a slot that we need to free */	2858	/* this used up a slot that we need to free */
2867	if (op->body_info[i])	2859	if (op->slot[i].info)
2868	{	2860	{
2869	last = who->inv;	2861	object *last = who->inv;
2870		2862
2871	/* We do a while loop - may need to remove several items in order	2863	/* We do a while loop - may need to remove several items in order
2872	* to free up enough slots.	2864	* to free up enough slots.
2873	*/	2865	*/
2874	while ((who->body_used[i] + op->body_info[i]) < 0)	2866	while ((who->slot[i].used + op->slot[i].info) < 0)
2875	{	2867	{
2876	tmp = get_item_from_body_location (last, i);	2868	object *tmp = get_next_item_from_body_location (i, last);
		2869
2877	if (!tmp)	2870	if (!tmp)
2878	{	2871	{
2879	#if 0	2872	#if 0
2880	/* Not a bug - we'll get this if the player has cursed items	2873	/* Not a bug - we'll get this if the player has cursed items
2881	* equipped.	2874	* equipped.
2882	*/	2875	*/
2883	LOG (llevError, "Can't find object using location %d (%s) on %s\n", i, body_locations[i].save_name, who->name);	2876	LOG (llevError, "Can't find object using location %d (%s) on %s\n", i, body_locations[i].save_name, who->name);
2884	#endif	2877	#endif
2885	return 1;	2878	return 1;
2886	}	2879	}
		2880
2887	/* If we are just printing, we don't care about cursed status */	2881	/* If we are just printing, we don't care about cursed status */
2888	if ((aflags & AP_IGNORE_CURSE) || (aflags & AP_PRINT) || (!(QUERY_FLAG (tmp, FLAG_CURSED) || QUERY_FLAG (tmp, FLAG_DAMNED))))	2882	if ((aflags & AP_IGNORE_CURSE) || (aflags & AP_PRINT) || (!(QUERY_FLAG (tmp, FLAG_CURSED) || QUERY_FLAG (tmp, FLAG_DAMNED))))
2889	{	2883	{
2890	if (aflags & AP_PRINT)	2884	if (aflags & AP_PRINT)
2891	new_draw_info (NDI_UNIQUE, 0, who, query_name (tmp));	2885	new_draw_info (NDI_UNIQUE, 0, who, query_name (tmp));
…		…
2899	* so it may not be critical (eg, putting on a ring and you have	2893	* so it may not be critical (eg, putting on a ring and you have
2900	* one cursed ring.)	2894	* one cursed ring.)
2901	*/	2895	*/
2902	new_draw_info_format (NDI_UNIQUE, 0, who, "The %s just won't come off", query_name (tmp));	2896	new_draw_info_format (NDI_UNIQUE, 0, who, "The %s just won't come off", query_name (tmp));
2903	}	2897	}
		2898
2904	last = tmp->below;	2899	last = tmp->below;
2905	}	2900	}
2906	/* if we got here, this slot is freed up - otherwise, if it wasn't freed up, the	2901	/* if we got here, this slot is freed up - otherwise, if it wasn't freed up, the
2907	* return in the !tmp would have kicked in.	2902	* return in the !tmp would have kicked in.
2908	*/	2903	*/
2909	} /* if op is using this body location */	2904	} /* if op is using this body location */
2910	} /* for body lcoations */	2905	} /* for body lcoations */
		2906
2911	return 0;	2907	return 0;
2912	}	2908	}
2913		2909
2914	/**	2910	/**
2915	* Checks to see if 'who' can apply object 'op'.	2911	* Checks to see if 'who' can apply object 'op'.
2916	* Returns 0 if apply can be done without anything special.	2912	* Returns 0 if apply can be done without anything special.
2917	* Otherwise returns a bitmask - potentially several of these may be	2913	* Otherwise returns a bitmask - potentially several of these may be
2918	* set, but largely depends on circumstance - in the future, processing	2914	* set, but largely depends on circumstance - in the future, processing
2919	* may be pruned once we know some status (eg, once CAN_APPLY_NEVER	2915	* may be pruned once we know some status (eg, once CAN_APPLY_NEVER
2920	* is set, do we really are what the other flags may be?)	2916	* is set, do we really care what the other flags may be?)
2921	*	2917	*
2922	* See include/define.h for detailed description of the meaning of	2918	* See include/define.h for detailed description of the meaning of
2923	* these return values.	2919	* these return values.
2924	*/	2920	*/
2925	int	2921	int
2926	can_apply_object (object *who, object *op)	2922	can_apply_object (object *who, object *op)
2927	{	2923	{
2928	if (INVOKE_OBJECT (CAN_BE_APPLIED, op, ARG_OBJECT (who)) || INVOKE_OBJECT (CAN_APPLY, who, ARG_OBJECT (op)))	2924	if (INVOKE_OBJECT (CAN_BE_APPLIED, op, ARG_OBJECT (who)) || INVOKE_OBJECT (CAN_APPLY, who, ARG_OBJECT (op)))
2929	return RESULT_INT (0);	2925	return RESULT_INT (0);
2930		2926
2931	int i, retval = 0;	2927	int retval = 0;
2932	object *tmp = NULL, *ws = NULL;	2928	object *tmp = 0, *ws = 0;
2933		2929
2934	/* Players have 2 'arm's, so they could in theory equip 2 shields or	2930	for (int i = 0; i < NUM_BODY_LOCATIONS; i++)
2935	* 2 weapons, but we don't want to let them do that. So if they are
2936	* trying to equip a weapon or shield, see if they already have one
2937	* in place and store that way.
2938	*/
2939	if (op->type == WEAPON || op->type == SHIELD)
2940	{	2931	{
2941	for (tmp = who->inv; tmp && !ws; tmp = tmp->below)	2932	if (op->slot[i].info)
2942	{	2933	{
2943	if (QUERY_FLAG (tmp, FLAG_APPLIED) && tmp->type == op->type)	2934	/* Item uses more slots than we have */
		2935	if (who->slot[i].info + op->slot [i].info < 0)
2944	{	2936	{
2945	retval = CAN_APPLY_UNAPPLY;
2946	ws = tmp;
2947	}
2948	}
2949	}
2950
2951	for (i = 0; i < NUM_BODY_LOCATIONS; i++)
2952	{
2953	if (op->body_info[i])
2954	{
2955	/* Item uses more slots than we have */
2956	if (FABS (op->body_info[i]) > who->body_info[i])
2957	{
2958	/* Could return now for efficiently - rest of info below isn'	2937	/* Could return now for efficiency - rest of info below isn't
2959	* really needed.	2938	* really needed.
2960	*/	2939	*/
2961	retval |= CAN_APPLY_NEVER;	2940	retval |= CAN_APPLY_NEVER;
2962	}	2941	}
2963	else if ((who->body_used[i] + op->body_info[i]) < 0)	2942	else if (who->slot[i].used + op->slot[i].info < 0)
2964	{	2943	{
2965	/* in this case, equipping this would use more free spots than	2944	/* in this case, equipping this would use more free spots than
2966	* we have.	2945	* we have.
2967	*/	2946	*/
2968	object *tmp1;
2969
2970		2947
2971	/* if we have an applied weapon/shield, and unapply it would free	2948	/* if we have an applied weapon/shield, and unapply it would free
2972	* enough slots to equip the new item, then just set this can	2949	* enough slots to equip the new item, then just set "can
2973	* continue. We don't care about the logic below - if you have	2950	* apply unapply". We don't care about the logic below - if you have a
2974	* shield equipped and try to equip another shield, there is only	2951	* shield equipped and try to equip another shield, there is only
2975	* one choice. However, the check for the number of body locations	2952	* one choice. However, the check for the number of body locations
2976	* does take into the account cases where what is being applied	2953	* does take into the account cases where what is being applied
2977	* may be two handed for example.	2954	* may be two handed for example.
2978	*/	2955	*/
2979	if (ws)	2956	if (ws)
2980	{	2957	if ((who->slot[i].used - ws->slot[i].info + op->slot[i].info) >= 0)
2981	if ((who->body_used[i] - ws->body_info[i] + op->body_info[i]) >= 0)
2982	{	2958	{
2983	retval |= CAN_APPLY_UNAPPLY;	2959	retval |= CAN_APPLY_UNAPPLY;
2984	continue;	2960	continue;
2985	}	2961	}
2986	}
2987		2962
2988	tmp1 = get_item_from_body_location (who->inv, i);	2963	object *tmp1 = get_next_item_from_body_location (i, who->inv);
2989	if (!tmp1)	2964	if (!tmp1)
2990	{	2965	{
2991	#if 0	2966	#if 0
2992	/* This is sort of an error, but happens a lot when old players	2967	/* This is sort of an error, but happens a lot when old players
2993	* join in with more stuff equipped than they are now allowed.	2968	* join in with more stuff equipped than they are now allowed.
…		…
3001	/* need to unapply something. However, if this something	2976	/* need to unapply something. However, if this something
3002	* is different than we had found before, it means they need	2977	* is different than we had found before, it means they need
3003	* to apply multiple objects	2978	* to apply multiple objects
3004	*/	2979	*/
3005	retval |= CAN_APPLY_UNAPPLY;	2980	retval |= CAN_APPLY_UNAPPLY;
		2981
3006	if (!tmp)	2982	if (!tmp)
3007	tmp = tmp1;	2983	tmp = tmp1;
3008	else if (tmp != tmp1)	2984	else if (tmp != tmp1)
3009	{
3010	retval |= CAN_APPLY_UNAPPLY_MULT;	2985	retval |= CAN_APPLY_UNAPPLY_MULT;
3011	}	2986
3012	/* This object isn't using up all the slots, so there must	2987	/* This object isn't using up all the slots, so there must
3013	* be another. If so, and it the new item doesn't need all	2988	* be another. If so, and it the new item doesn't need all
3014	* the slots, the player then has a choice.	2989	* the slots, the player then has a choice.
3015	*/	2990	*/
3016	if (((who->body_used[i] - tmp1->body_info[i]) != who->body_info[i]) && (FABS (op->body_info[i]) < who->body_info[i]))	2991	if ((who->slot[i].used - tmp1->slot[i].info != who->slot[i].info)
		2992	&& abs (op->slot[i].info) < who->slot[i].info)
3017	retval |= CAN_APPLY_UNAPPLY_CHOICE;	2993	retval |= CAN_APPLY_UNAPPLY_CHOICE;
3018		2994
3019	/* Does unequippint 'tmp1' free up enough slots for this to be	2995	/* Does unequippint 'tmp1' free up enough slots for this to be
3020	* equipped? If not, there must be something else to unapply.	2996	* equipped? If not, there must be something else to unapply.
3021	*/	2997	*/
3022	if ((who->body_used[i] + op->body_info[i] - tmp1->body_info[i]) < 0)	2998	if (who->slot[i].used + op->slot[i].info < tmp1->slot[i].info)
3023	retval |= CAN_APPLY_UNAPPLY_MULT;	2999	retval |= CAN_APPLY_UNAPPLY_MULT;
3024
3025	}	3000	}
3026	} /* if not enough free slots */	3001	} /* if not enough free slots */
3027	} /* if this object uses location i */	3002	} /* if this object uses location i */
3028	} /* for i -> num_body_locations loop */	3003	} /* for i -> num_body_locations loop */
3029		3004
…		…
3042		3017
3043	if (who->type != PLAYER)	3018	if (who->type != PLAYER)
3044	{	3019	{
3045	if ((op->type == WAND || op->type == HORN || op->type == ROD) && !QUERY_FLAG (who, FLAG_USE_RANGE))	3020	if ((op->type == WAND || op->type == HORN || op->type == ROD) && !QUERY_FLAG (who, FLAG_USE_RANGE))
3046	retval |= CAN_APPLY_RESTRICTION;	3021	retval |= CAN_APPLY_RESTRICTION;
		3022
3047	if (op->type == BOW && !QUERY_FLAG (who, FLAG_USE_BOW))	3023	if (op->type == BOW && !QUERY_FLAG (who, FLAG_USE_BOW))
3048	retval |= CAN_APPLY_RESTRICTION;	3024	retval |= CAN_APPLY_RESTRICTION;
		3025
3049	if (op->type == RING && !QUERY_FLAG (who, FLAG_USE_RING))	3026	if (op->type == RING && !QUERY_FLAG (who, FLAG_USE_RING))
3050	retval |= CAN_APPLY_RESTRICTION;	3027	retval |= CAN_APPLY_RESTRICTION;
		3028
3051	if (op->type == BOW && !QUERY_FLAG (who, FLAG_USE_BOW))	3029	if (op->type == BOW && !QUERY_FLAG (who, FLAG_USE_BOW))
3052	retval |= CAN_APPLY_RESTRICTION;	3030	retval |= CAN_APPLY_RESTRICTION;
3053	}	3031	}
3054		3032
3055	return retval;	3033	return retval;
…		…
3070	* AP_UNAPPLY=always unapply).	3048	* AP_UNAPPLY=always unapply).
3071	*	3049	*
3072	* Optional flags:	3050	* Optional flags:
3073	* AP_NO_MERGE: don't merge an unapplied object with other objects	3051	* AP_NO_MERGE: don't merge an unapplied object with other objects
3074	* AP_IGNORE_CURSE: unapply cursed items	3052	* AP_IGNORE_CURSE: unapply cursed items
		3053	* AP_NO_READY: do not ready skills when applying skill tools
3075	*	3054	*
3076	* Usage example: apply_special (who, op, AP_UNAPPLY | AP_IGNORE_CURSE)	3055	* Usage example: apply_special (who, op, AP_UNAPPLY | AP_IGNORE_CURSE)
3077	*	3056	*
3078	* apply_special() doesn't check for unpaid items.	3057	* apply_special() doesn't check for unpaid items.
3079	*/	3058	*/
3080	int	3059	int
3081	apply_special (object *who, object *op, int aflags)	3060	apply_special (object *who, object *op, int aflags)
3082	{	3061	{
3083	int basic_flag = aflags & AP_BASIC_FLAGS;	3062	int basic_flag = aflags & AP_BASIC_FLAGS;
3084	object *tmp, *tmp2, *skop = NULL;	3063	object *tmp, *tmp2, *skop = NULL;
3085	int i;
3086		3064
3087	if (who == NULL)	3065	if (who == NULL)
3088	{	3066	{
3089	LOG (llevError, "apply_special() from object without environment.\n");	3067	LOG (llevError, "apply_special() from object without environment.\n");
3090	return 1;	3068	return 1;
…		…
3100	if (basic_flag == AP_APPLY)	3078	if (basic_flag == AP_APPLY)
3101	return 0;	3079	return 0;
3102		3080
3103	if (!(aflags & AP_IGNORE_CURSE) && (QUERY_FLAG (op, FLAG_CURSED) || QUERY_FLAG (op, FLAG_DAMNED)))	3081	if (!(aflags & AP_IGNORE_CURSE) && (QUERY_FLAG (op, FLAG_CURSED) || QUERY_FLAG (op, FLAG_DAMNED)))
3104	{	3082	{
3105	new_draw_info_format (NDI_UNIQUE, 0, who, "No matter how hard you try, you just can't\nremove %s.", query_name (op));	3083	new_draw_info_format (NDI_UNIQUE, 0, who, "No matter how hard you try, you just can't remove %s.", query_name (op));
3106	return 1;	3084	return 1;
3107	}	3085	}
		3086
3108	return unapply_special (who, op, aflags);	3087	return unapply_special (who, op, aflags);
3109	}	3088	}
3110		3089
3111	if (basic_flag == AP_UNAPPLY)	3090	if (basic_flag == AP_UNAPPLY)
3112	return 0;	3091	return 0;
3113		3092
3114	i = can_apply_object (who, op);	3093	// if the item is combat/ranged, wield the relevant slot first
		3094	// to resolve conflicts.
		3095	if (player *pl = who->contr)
		3096	switch (op->slottype ())
		3097	{
		3098	case slot_combat: who->change_weapon (pl->combat_ob); break;
		3099	case slot_ranged: who->change_weapon (pl->ranged_ob); break;
		3100	}
		3101
		3102	splay (op);
3115		3103
3116	/* Can't just apply this object. Lets see what not and what to do */	3104	/* Can't just apply this object. Lets see what not and what to do */
3117	if (i)	3105	if (int i = can_apply_object (who, op))
3118	{	3106	{
3119	if (i & CAN_APPLY_NEVER)	3107	if (i & CAN_APPLY_NEVER)
3120	{	3108	{
3121	new_draw_info_format (NDI_UNIQUE, 0, who, "You don't have the body to use a %s\n", query_name (op));	3109	new_draw_info_format (NDI_UNIQUE, 0, who, "You don't have the body to use a %s\n", query_name (op));
3122	return 1;	3110	return 1;
…		…
3124	else if (i & CAN_APPLY_RESTRICTION)	3112	else if (i & CAN_APPLY_RESTRICTION)
3125	{	3113	{
3126	new_draw_info_format (NDI_UNIQUE, 0, who, "You have a prohibition against using a %s\n", query_name (op));	3114	new_draw_info_format (NDI_UNIQUE, 0, who, "You have a prohibition against using a %s\n", query_name (op));
3127	return 1;	3115	return 1;
3128	}	3116	}
		3117
3129	if (who->type != PLAYER)	3118	if (who->type != PLAYER)
3130	{	3119	{
3131	/* Some error, so don't try to equip something more */	3120	/* Some error, so don't try to equip something more */
3132	if (unapply_for_ob (who, op, aflags))	3121	if (unapply_for_ob (who, op, aflags))
3133	return 1;	3122	return 1;
…		…
3139	new_draw_info (NDI_UNIQUE, 0, who, "You need to unapply some of the following item(s) or change your applymode:");	3128	new_draw_info (NDI_UNIQUE, 0, who, "You need to unapply some of the following item(s) or change your applymode:");
3140	unapply_for_ob (who, op, AP_PRINT);	3129	unapply_for_ob (who, op, AP_PRINT);
3141	return 1;	3130	return 1;
3142	}	3131	}
3143	else if (who->contr->unapply == unapply_always || !(i & CAN_APPLY_UNAPPLY_CHOICE))	3132	else if (who->contr->unapply == unapply_always || !(i & CAN_APPLY_UNAPPLY_CHOICE))
3144	{
3145	i = unapply_for_ob (who, op, aflags);	3133	if (unapply_for_ob (who, op, aflags))
3146	if (i)
3147	return 1;	3134	return 1;
3148	}
3149	}	3135	}
3150	}	3136	}
3151		3137
3152	if (op->skill && op->type != SKILL && op->type != SKILL_TOOL)	3138	if (op->skill && op->type != SKILL && op->type != SKILL_TOOL)
3153	{	3139	{
3154	skop = find_skill_by_name (who, op->skill);	3140	skop = find_skill_by_name (who, op->skill);
		3141
3155	if (!skop)	3142	if (!skop)
3156	{	3143	{
3157	new_draw_info_format (NDI_UNIQUE, 0, who, "You need the %s skill to use this item!", &op->skill);	3144	new_draw_info_format (NDI_UNIQUE, 0, who, "You need the %s skill to use this item!", &op->skill);
3158	return 1;	3145	return 1;
3159	}	3146	}
3160	else	3147	else
3161	/* While experience will be credited properly, we want to change the	3148	/* While experience will be credited properly, we want to change the
3162	* skill so that the dam and wc get updated	3149	* skill so that the dam and wc get updated
3163	*/	3150	*/
3164	change_skill (who, skop, 0);	3151	who->change_skill (skop);
3165	}	3152	}
3166		3153
		3154	if (who->type == PLAYER
		3155	&& op->item_power
3167	if (who->type == PLAYER && op->item_power && (op->item_power + who->contr->item_power) > (settings.item_power_factor * who->level))	3156	&& op->item_power + who->contr->item_power > settings.item_power_factor * who->level)
3168	{	3157	{
3169	new_draw_info (NDI_UNIQUE, 0, who,	3158	new_draw_info (NDI_UNIQUE, 0, who,
3170	"Equipping that combined with other items would consume your soul! "	3159	"Equipping that combined with other items would consume your soul! "
3171	"[use the skills command to check your available item power]");	3160	"[use the skills command to check your available item power]");
3172	return 1;	3161	return 1;
3173	}	3162	}
3174		3163
3175
3176	/* Ok. We are now at the state where we can apply the new object.	3164	/* Ok. We are now at the state where we can apply the new object.
3177	* Note that we don't have the checks for can_use_...	3165	* Note that we don't have the checks for can_use_...
3178	* below - that is already taken care of by can_apply_object.	3166	* below - that is already taken care of by can_apply_object.
3179	*/	3167	*/
3180
3181	if (op->nrof > 1)	3168	if (op->nrof > 1)
3182	tmp = get_split_ob (op, op->nrof - 1);	3169	tmp = get_split_ob (op, op->nrof - 1);
3183	else	3170	else
3184	tmp = NULL;	3171	tmp = 0;
3185		3172
3186	if (INVOKE_OBJECT (BE_READY, op, ARG_OBJECT (who)) || INVOKE_OBJECT (READY, who, ARG_OBJECT (op)))	3173	if (INVOKE_OBJECT (BE_READY, op, ARG_OBJECT (who)) || INVOKE_OBJECT (READY, who, ARG_OBJECT (op)))
3187	return RESULT_INT (0);	3174	return RESULT_INT (0);
3188		3175
3189	switch (op->type)	3176	switch (op->type)
3190	{	3177	{
3191	case WEAPON:	3178	case WEAPON:
3192	if (!check_weapon_power (who, op->last_eat))	3179	if (!check_weapon_power (who, op->last_eat))
3193	{	3180	{
3194	new_draw_info (NDI_UNIQUE, 0, who, "That weapon is too powerful for you to use.");	3181	new_draw_info (NDI_UNIQUE, 0, who, "This weapon is too powerful for you to use. "
3195	new_draw_info (NDI_UNIQUE, 0, who, "It would consume your soul!.");	3182	"It would consume your soul!.");
		3183
3196	if (tmp != NULL)	3184	if (tmp)
3197	(void) insert_ob_in_ob (tmp, who);	3185	insert_ob_in_ob (tmp, who);
		3186
3198	return 1;	3187	return 1;
3199	}	3188	}
3200		3189
3201	//TODO: this obviously fails for players using a shiorter prefix	3190	//TODO: this obviously fails for players using a shorter prefix
3202	// i.e. "R" can use Ragnarok's swors.	3191	// i.e. "R" can use Ragnarok's sword.
3203	if (op->level && (strncmp (op->name, who->name, strlen (who->name))))	3192	if (op->level && (strncmp (op->name, who->name, strlen (who->name))))
3204	{	3193	{
3205	/* if the weapon does not have the name as the character, can't use it. */	3194	/* if the weapon does not have the name as the character, can't use it. */
3206	/* (Ragnarok's sword attempted to be used by Foo: won't work) */	3195	/* (Ragnarok's sword attempted to be used by Foo: won't work) */
3207	new_draw_info (NDI_UNIQUE, 0, who, "The weapon does not recognize you as its owner.");	3196	new_draw_info (NDI_UNIQUE, 0, who, "The weapon does not recognize you as its owner.");
…		…
3210	insert_ob_in_ob (tmp, who);	3199	insert_ob_in_ob (tmp, who);
3211		3200
3212	return 1;	3201	return 1;
3213	}	3202	}
3214		3203
		3204	if (!skop)
		3205	{
		3206	new_draw_info_format (NDI_UNIQUE, 0, who, "The %s is broken, please report this to the dungeon master!", query_name (op));//TODO
		3207	return 1;
		3208	}
		3209
3215	SET_FLAG (op, FLAG_APPLIED);	3210	SET_FLAG (op, FLAG_APPLIED);
3216
3217	if (skop)
3218	change_skill (who, skop, 1);	3211	who->change_skill (skop);
3219		3212
3220	if (!QUERY_FLAG (who, FLAG_READY_WEAPON))	3213	if (who->contr)
3221	SET_FLAG (who, FLAG_READY_WEAPON);	3214	who->change_weapon (who->contr->combat_ob = op);
3222		3215
3223	new_draw_info_format (NDI_UNIQUE, 0, who, "You wield %s.", query_name (op));	3216	new_draw_info_format (NDI_UNIQUE, 0, who, "You wield %s.", query_name (op));
3224		3217
		3218	SET_FLAG (who, FLAG_READY_WEAPON);
3225	change_abil (who, op);	3219	change_abil (who, op);
3226	break;	3220	break;
3227		3221
3228	case ARMOUR:	3222	case ARMOUR:
3229	case HELMET:	3223	case HELMET:
…		…
3241	break;	3235	break;
3242		3236
3243	case LAMP:	3237	case LAMP:
3244	if (op->stats.food < 1)	3238	if (op->stats.food < 1)
3245	{	3239	{
3246	new_draw_info_format (NDI_UNIQUE, 0, who, "Your %s is out of" " fuel!", &op->name);	3240	new_draw_info_format (NDI_UNIQUE, 0, who, "Your %s is out of fuel!", &op->name);
3247	return 1;	3241	return 1;
3248	}	3242	}
3249		3243
3250	new_draw_info_format (NDI_UNIQUE, 0, who, "You turn on your %s.", &op->name);	3244	new_draw_info_format (NDI_UNIQUE, 0, who, "You turn on your %s.", &op->name);
3251	tmp2 = arch_to_object (op->other_arch);	3245	tmp2 = arch_to_object (op->other_arch);
…		…
3272	}	3266	}
3273		3267
3274	who->update_stats ();	3268	who->update_stats ();
3275		3269
3276	if (QUERY_FLAG (op, FLAG_CURSED) || QUERY_FLAG (op, FLAG_DAMNED))	3270	if (QUERY_FLAG (op, FLAG_CURSED) || QUERY_FLAG (op, FLAG_DAMNED))
3277	{
3278	if (who->type == PLAYER)	3271	if (who->type == PLAYER)
3279	{	3272	{
3280	new_draw_info (NDI_UNIQUE, 0, who, "Oops, it feels deadly cold!");	3273	new_draw_info (NDI_UNIQUE, 0, who, "Oops, it feels deadly cold!");
3281	SET_FLAG (tmp2, FLAG_KNOWN_CURSED);	3274	SET_FLAG (tmp2, FLAG_KNOWN_CURSED);
3282	}	3275	}
3283	}
3284		3276
3285	if (who->type == PLAYER)	3277	if (who->type == PLAYER)
3286	esrv_send_item (who, tmp2);	3278	esrv_send_item (who, tmp2);
3287		3279
3288	return 0;	3280	return 0;
3289		3281
3290	/* this part is needed for skill-tools */	3282	case SKILL_TOOL:
		3283	// applying a skill tool also readies the skill
		3284	SET_FLAG (op, FLAG_APPLIED);
		3285
		3286	if (!(aflags & AP_NO_READY))
		3287	{
		3288	skop = find_skill_by_name (who, op->skill);
		3289	if (!skop->flag [FLAG_APPLIED])
		3290	apply_special (who, skop, AP_APPLY);
		3291	}
		3292	break;
		3293
3291	case SKILL:	3294	case SKILL:
3292	case SKILL_TOOL:	3295	if (player *pl = who->contr)
3293	if (who->chosen_skill)
3294	{
3295	LOG (llevError, "BUG: apply_special(): can't apply two skills\n");
3296	return 1;
3297	}	3296	{
3298		3297	if (IS_COMBAT_SKILL (op->subtype))
3299	if (who->type == PLAYER)
3300	{	3298	{
3301	who->contr->ranged_skill = who;	3299	if (skill_flags [op->subtype] & SF_NEED_WEAPON)
3302	who->contr->ranged_ob = op;	3300	{
		3301	for (object *item = who->inv; item; item = item->below)
		3302	if (item->type == WEAPON && item->flag [FLAG_APPLIED])
		3303	{
		3304	if (item->skill == op->skill)
		3305	{
		3306	who->change_weapon (pl->combat_ob = item);
		3307	goto found_weapon;
		3308	}
		3309	}
		3310
		3311	new_draw_info_format (NDI_UNIQUE, 0, who, "You need to apply a '%s' melee weapon before readying this skill", &op->skill);
		3312	return 1;
		3313
		3314	found_weapon:;
		3315	}
		3316	else
		3317	who->change_weapon (pl->combat_ob = op);
		3318	}
		3319	else if (IS_RANGED_SKILL (op->subtype))
		3320	{
		3321	if (skill_flags [op->subtype] & SF_NEED_BOW)
		3322	{
		3323	for (object *item = who->inv; item; item = item->below)
		3324	if (item->type == BOW && item->flag [FLAG_APPLIED])
		3325	{
		3326	//TODO: bows should/must all have skill missile weapon right now
		3327	who->change_weapon (pl->ranged_ob = item);
		3328	goto found_bow;
		3329	}
		3330
		3331	new_draw_info (NDI_UNIQUE, 0, who, "You need to apply a missile weapon before readying this skill");
		3332	return 1;
		3333
		3334	found_bow:;
		3335	}
		3336	else
		3337	who->change_weapon (pl->ranged_ob = op);
		3338	}
3303		3339
3304	if (!op->invisible)	3340	if (!op->invisible)
3305	{	3341	{
3306	new_draw_info_format (NDI_UNIQUE, 0, who, "You ready %s.", query_name (op));	3342	new_draw_info_format (NDI_UNIQUE, 0, who, "You ready %s.", query_name (op));
3307	new_draw_info_format (NDI_UNIQUE, 0, who, "You can now use the skill: %s.", &op->skill);	3343	new_draw_info_format (NDI_UNIQUE, 0, who, "You can now use the skill: %s.", &op->skill);
3308	}	3344	}
3309	else	3345	else
3310	new_draw_info_format (NDI_UNIQUE, 0, who, "Readied skill: %s.", op->skill ? &op->skill : &op->name);	3346	new_draw_info_format (NDI_UNIQUE, 0, who, "Readied skill: %s.", op->skill ? &op->skill : &op->name);
3311	}	3347	}
3312		3348	else
		3349	{
3313	SET_FLAG (op, FLAG_APPLIED);	3350	SET_FLAG (op, FLAG_APPLIED);
3314	change_abil (who, op);	3351	change_abil (who, op);
3315	who->chosen_skill = op;	3352	who->chosen_skill = op;
3316	SET_FLAG (who, FLAG_READY_SKILL);	3353	SET_FLAG (who, FLAG_READY_SKILL);
		3354	}
		3355
3317	break;	3356	break;
3318		3357
3319	case BOW:	3358	case BOW:
3320	if (!check_weapon_power (who, op->last_eat))	3359	if (!check_weapon_power (who, op->last_eat))
3321	{	3360	{
3322	new_draw_info (NDI_UNIQUE, 0, who, "That item is too powerful for you to use.");	3361	new_draw_info (NDI_UNIQUE, 0, who, "That weapon is too powerful for you to use.");
3323	new_draw_info (NDI_UNIQUE, 0, who, "It would consume your soul!.");	3362	new_draw_info (NDI_UNIQUE, 0, who, "It would consume your soul!.");
3324		3363
3325	if (tmp)	3364	if (tmp)
3326	insert_ob_in_ob (tmp, who);	3365	insert_ob_in_ob (tmp, who);
3327		3366
…		…
3329	}	3368	}
3330		3369
3331	if (op->level && (strncmp (op->name, who->name, strlen (who->name))))	3370	if (op->level && (strncmp (op->name, who->name, strlen (who->name))))
3332	{	3371	{
3333	new_draw_info (NDI_UNIQUE, 0, who, "The weapon does not recognize you as its owner.");	3372	new_draw_info (NDI_UNIQUE, 0, who, "The weapon does not recognize you as its owner.");
3334	if (tmp != NULL)	3373	if (tmp)
3335	insert_ob_in_ob (tmp, who);	3374	insert_ob_in_ob (tmp, who);
3336		3375
3337	return 1;	3376	return 1;
3338	}	3377	}
3339		3378
3340	/*FALLTHROUGH*/	3379	/*FALLTHROUGH*/
3341	case WAND:	3380	case WAND:
3342	case ROD:	3381	case ROD:
3343	case HORN:	3382	case HORN:
3344	/* check for skill, alter player status */	3383	/* check for skill, alter player status */
		3384
		3385	if (!skop)
		3386	{
		3387	new_draw_info_format (NDI_UNIQUE, 0, who, "The %s is broken, please report this to the dungeon master!", query_name (op));//TODO
		3388	return 1;
		3389	}
		3390
3345	SET_FLAG (op, FLAG_APPLIED);	3391	SET_FLAG (op, FLAG_APPLIED);
3346	if (skop)
3347	change_skill (who, skop, 0);	3392	who->change_skill (skop);
3348		3393
3349	if (who->type == PLAYER)	3394	if (who->contr)
3350	{	3395	{
		3396	who->contr->ranged_ob = op;
		3397
3351	new_draw_info_format (NDI_UNIQUE, 0, who, "You ready %s.", query_name (op));	3398	new_draw_info_format (NDI_UNIQUE, 0, who, "You ready %s.", query_name (op));
3352		3399
3353	if (op->type == BOW)	3400	if (op->type == BOW)
3354	{	3401	{
		3402	who->current_weapon = op;
3355	change_abil (who, op);	3403	change_abil (who, op);
3356	new_draw_info_format (NDI_UNIQUE, 0, who,	3404	new_draw_info_format (NDI_UNIQUE, 0, who,
3357	"You will now fire %s with %s.", op->race ? &op->race : "nothing", query_name (op));	3405	"You will now fire %s with %s.", op->race ? &op->race : "nothing", query_name (op));
3358	}	3406	}
3359
3360	who->contr->ranged_skill = find_skill_by_name (who, op->skill);//TODO
3361	who->contr->ranged_ob = op;
3362	}	3407	}
3363	else	3408	else
3364	{	3409	{
3365	if (op->type == BOW)	3410	if (op->type == BOW)
3366	SET_FLAG (who, FLAG_READY_BOW);	3411	SET_FLAG (who, FLAG_READY_BOW);
…		…
3371	break;	3416	break;
3372		3417
3373	case BUILDER:	3418	case BUILDER:
3374	if (who->type == PLAYER)	3419	if (who->type == PLAYER)
3375	{	3420	{
		3421	//TODO: wtf does this do? shouldn't this be managed automatically (slots?)
3376	if (who->contr->ranged_ob && who->contr->ranged_ob->type == BUILDER)	3422	if (who->contr->ranged_ob && who->contr->ranged_ob->type == BUILDER)
3377	unapply_special (who, who->contr->ranged_ob, 0);	3423	unapply_special (who, who->contr->ranged_ob, 0);
3378		3424
3379	new_draw_info_format (NDI_UNIQUE, 0, who, "You ready your %s.", query_name (op));	3425	new_draw_info_format (NDI_UNIQUE, 0, who, "You ready your %s.", query_name (op));
3380		3426
3381	who->contr->ranged_skill = who;
3382	who->contr->ranged_ob = op;	3427	who->contr->ranged_ob = op;
3383	}	3428	}
3384	break;	3429	break;
3385		3430
3386	default:	3431	default:
3387	new_draw_info_format (NDI_UNIQUE, 0, who, "You apply %s.", query_name (op));	3432	new_draw_info_format (NDI_UNIQUE, 0, who, "You apply %s.", query_name (op));
3388	} /* end of switch op->type */	3433	} /* end of switch op->type */
3389		3434
3390	SET_FLAG (op, FLAG_APPLIED);	3435	SET_FLAG (op, FLAG_APPLIED);
3391		3436
3392	if (tmp != NULL)	3437	if (tmp)
3393	tmp = insert_ob_in_ob (tmp, who);	3438	tmp = insert_ob_in_ob (tmp, who);
3394		3439
3395	who->update_stats ();	3440	who->update_stats ();
3396		3441
3397	/* We exclude spell casting objects. The fire code will set the	3442	/* We exclude spell casting objects. The fire code will set the
…		…
3587	&& tmp->type != PLAYER_CHANGER && tmp->type != CLASS && tmp->has_random_items ())	3632	&& tmp->type != PLAYER_CHANGER && tmp->type != CLASS && tmp->has_random_items ())
3588	{	3633	{
3589	create_treasure (tmp->randomitems, tmp, GT_APPLY, difficulty, 0);	3634	create_treasure (tmp->randomitems, tmp, GT_APPLY, difficulty, 0);
3590	tmp->randomitems = NULL;	3635	tmp->randomitems = NULL;
3591	}	3636	}
		3637
3592	// close all containers	3638	// close all containers
3593	else if (tmp->type == CONTAINER)	3639	else if (tmp->type == CONTAINER)
3594	tmp->flag [FLAG_APPLIED] = 0;	3640	tmp->flag [FLAG_APPLIED] = 0;
3595		3641
3596	tmp = above;	3642	tmp = above;
…		…
3606	* Handles player eating food that temporarily changes status (resistances, stats).	3652	* Handles player eating food that temporarily changes status (resistances, stats).
3607	* This used to call cast_change_attr(), but	3653	* This used to call cast_change_attr(), but
3608	* that doesn't work with the new spell code. Since we know what	3654	* that doesn't work with the new spell code. Since we know what
3609	* the food changes, just grab a force and use that instead.	3655	* the food changes, just grab a force and use that instead.
3610	*/	3656	*/
3611
3612	void	3657	void
3613	eat_special_food (object *who, object *food)	3658	eat_special_food (object *who, object *food)
3614	{	3659	{
3615	object *force;	3660	object *force;
3616	int i, did_one = 0;	3661	int i, did_one = 0;
3617	sint8 k;
3618		3662
3619	force = get_archetype (FORCE_NAME);	3663	force = get_archetype (FORCE_NAME);
3620		3664
3621	for (i = 0; i < NUM_STATS; i++)	3665	for (i = 0; i < NUM_STATS; i++)
3622	{	3666	if (sint8 k = food->stats.stat (i))
3623	k = get_attr_value (&food->stats, i);
3624	if (k)
3625	{	3667	{
3626	set_attr_value (&force->stats, i, k);	3668	force->stats.stat (i) = k;
3627	did_one = 1;	3669	did_one = 1;
3628	}	3670	}
3629	}
3630		3671
3631	/* check if we can protect the eater */	3672	/* check if we can protect the eater */
3632	for (i = 0; i < NROFATTACKS; i++)	3673	for (i = 0; i < NROFATTACKS; i++)
3633	{	3674	{
3634	if (food->resist[i] > 0)	3675	if (food->resist[i] > 0)
…		…
3795	new_draw_info (NDI_UNIQUE, 0, op, "The magic recoils on you!");	3836	new_draw_info (NDI_UNIQUE, 0, op, "The magic recoils on you!");
3796	blind_player (op, op, power);	3837	blind_player (op, op, power);
3797	}	3838	}
3798	else if (failure <= -80)	3839	else if (failure <= -80)
3799	{ /* blast the immediate area */	3840	{ /* blast the immediate area */
3800	object *tmp;
3801
3802	tmp = get_archetype (LOOSE_MANA);	3841	object *tmp = get_archetype (LOOSE_MANA);
3803	cast_magic_storm (op, tmp, power);	3842	cast_magic_storm (op, tmp, power);
3804	new_draw_info (NDI_UNIQUE, 0, op, "You unlease uncontrolled mana!");	3843	new_draw_info (NDI_UNIQUE, 0, op, "You unleash uncontrolled mana!");
3805	tmp->destroy ();	3844	tmp->destroy ();
3806	}	3845	}
3807	}	3846	}
3808	}	3847	}
3809		3848
…		…
3829	*/	3868	*/
3830	int i, j;	3869	int i, j;
3831		3870
3832	for (i = 0; i < NUM_STATS; i++)	3871	for (i = 0; i < NUM_STATS; i++)
3833	{	3872	{
3834	sint8 stat = get_attr_value (stats, i);	3873	int race_bonus = pl->arch->stats.stat (i);
3835	int race_bonus = get_attr_value (&(pl->arch->clone.stats), i);	3874	sint8 stat = stats->stat (i) + ns->stat (i);
3836		3875
3837	stat += get_attr_value (ns, i);
3838	if (stat > 20 + race_bonus)	3876	if (stat > 20 + race_bonus)
3839	{	3877	{
3840	excess_stat++;	3878	excess_stat++;
3841	stat = 20 + race_bonus;	3879	stat = 20 + race_bonus;
3842	}	3880	}
3843	set_attr_value (stats, i, stat);	3881
		3882	stats->stat (i) = stat;
3844	}	3883	}
3845		3884
3846	for (j = 0; excess_stat > 0 && j < 100; j++)	3885	for (j = 0; excess_stat > 0 && j < 100; j++)
3847	{ /* try 100 times to assign excess stats */	3886	{ /* try 100 times to assign excess stats */
3848	int i = rndm (0, 6);	3887	int i = rndm (0, 6);
3849	int stat = get_attr_value (stats, i);
3850	int race_bonus = get_attr_value (&(pl->arch->clone.stats), i);
3851		3888
3852	if (i == CHA)	3889	if (i == CHA)
3853	continue; /* exclude cha from this */	3890	continue; /* exclude cha from this */
		3891
		3892	int stat = stats->stat (i);
		3893	int race_bonus = pl->arch->stats.stat (i);
3854	if (stat < 20 + race_bonus)	3894	if (stat < 20 + race_bonus)
3855	{	3895	{
3856	change_attr_value (stats, i, 1);	3896	change_attr_value (stats, i, 1);
3857	excess_stat--;	3897	excess_stat--;
3858	}	3898	}
…		…
3861	/* insert the randomitems from the change's treasurelist into	3901	/* insert the randomitems from the change's treasurelist into
3862	* the player ref: player.c	3902	* the player ref: player.c
3863	*/	3903	*/
3864	if (change->randomitems != NULL)	3904	if (change->randomitems != NULL)
3865	give_initial_items (pl, change->randomitems);	3905	give_initial_items (pl, change->randomitems);
3866
3867		3906
3868	/* set up the face, for some races. */	3907	/* set up the face, for some races. */
3869		3908
3870	/* first, look for the force object banning	3909	/* first, look for the force object banning
3871	* changing the face. Certain races never change face with class.	3910	* changing the face. Certain races never change face with class.
…		…
3928	{	3967	{
3929	new_draw_info_format (NDI_UNIQUE, 0, pl, "You can't use the %s with your %s!", query_name (transformer), query_name (marked));	3968	new_draw_info_format (NDI_UNIQUE, 0, pl, "You can't use the %s with your %s!", query_name (transformer), query_name (marked));
3930	return;	3969	return;
3931	}	3970	}
3932	/* check whether they are compatible or not */	3971	/* check whether they are compatible or not */
3933	find = strstr (marked->slaying, transformer->arch->name);	3972	find = strstr (marked->slaying, transformer->arch->archname);
3934	if (!find || (*(find + strlen (transformer->arch->name)) != ':'))	3973	if (!find || (*(find + strlen (transformer->arch->archname)) != ':'))
3935	{	3974	{
3936	new_draw_info_format (NDI_UNIQUE, 0, pl, "You can't use the %s with your %s!", query_name (transformer), query_name (marked));	3975	new_draw_info_format (NDI_UNIQUE, 0, pl, "You can't use the %s with your %s!", query_name (transformer), query_name (marked));
3937	return;	3976	return;
3938	}	3977	}
3939	find += strlen (transformer->arch->name) + 1;	3978	find += strlen (transformer->arch->archname) + 1;
3940	/* Item can be used, now find how many and what it yields */	3979	/* Item can be used, now find how many and what it yields */
3941	if (isdigit (*(find)))	3980	if (isdigit (*(find)))
3942	{	3981	{
3943	yield = atoi (find);	3982	yield = atoi (find);
3944	if (yield < 1)	3983	if (yield < 1)

Diff Legend

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