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.67 by root, Thu Feb 8 03:09:32 2007 UTC vs.
Revision 1.97 by root, Tue May 15 19:07:15 2007 UTC

1	/*	1	/*
2	* CrossFire, A Multiplayer game for X-windows	2	* CrossFire, A Multiplayer game
3	*	3	*
4	* Copyright (C) 2005, 2006, 2007 Marc Lehmann & Crossfire+ Development Team	4	* Copyright (C) 2005, 2006, 2007 Marc Lehmann & Crossfire+ Development Team
5	* Copyright (C) 2001 Mark Wedel & Crossfire Development Team	5	* Copyright (C) 2001 Mark Wedel & Crossfire Development Team
6	* Copyright (C) 1992 Frank Tore Johansen	6	* Copyright (C) 1992 Frank Tore Johansen
7	*	7	*
…		…
20	* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.	20	* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
21	*	21	*
22	* The authors can be reached via e-mail to <crossfire@schmorp.de>	22	* The authors can be reached via e-mail to <crossfire@schmorp.de>
23	*/	23	*/
24		24
		25	#include <cmath>
		26
25	#include <global.h>	27	#include <global.h>
26	#include <living.h>	28	#include <living.h>
27	#include <spells.h>	29	#include <spells.h>
28	#include <skills.h>	30	#include <skills.h>
29	#include <tod.h>	31	#include <tod.h>
30		32
31	#include <sproto.h>	33	#include <sproto.h>
32		34
33	/* Want this regardless of rplay. */	35	/* Want this regardless of rplay. */
34	#include <sounds.h>	36	#include <sounds.h>
35
36	/* need math lib for double-precision and pow() in dragon_eat_flesh() */
37	#include <math.h>
38		37
39	/**	38	/**
40	* Check if op should abort moving victim because of it's race or slaying.	39	* 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.	40	* Returns 1 if it should abort, returns 0 if it should continue.
42	*/	41	*/
…		…
233	depl = present_arch_in_ob (at, op);	232	depl = present_arch_in_ob (at, op);
234		233
235	if (depl)	234	if (depl)
236	{	235	{
237	for (i = 0; i < NUM_STATS; i++)	236	for (i = 0; i < NUM_STATS; i++)
238	if (get_attr_value (&depl->stats, i))	237	if (depl->stats.stat (i))
239	new_draw_info (NDI_UNIQUE, 0, op, restore_msg[i]);	238	new_draw_info (NDI_UNIQUE, 0, op, restore_msg[i]);
240		239
241	depl->destroy ();	240	depl->destroy ();
242	op->update_stats ();	241	op->update_stats ();
243	}	242	}
…		…
375	force->stats.food *= 10;	374	force->stats.food *= 10;
376	for (i = 0; i < NROFATTACKS; i++)	375	for (i = 0; i < NROFATTACKS; i++)
377	if (force->resist[i] > 0)	376	if (force->resist[i] > 0)
378	force->resist[i] = -force->resist[i]; /* prot => vuln */	377	force->resist[i] = -force->resist[i]; /* prot => vuln */
379	}	378	}
		379
380	force->speed_left = -1;	380	force->speed_left = -1;
381	force = insert_ob_in_ob (force, op);	381	force = insert_ob_in_ob (force, op);
382	CLEAR_FLAG (tmp, FLAG_APPLIED);	382	CLEAR_FLAG (tmp, FLAG_APPLIED);
383	SET_FLAG (force, FLAG_APPLIED);	383	SET_FLAG (force, FLAG_APPLIED);
384	change_abil (op, force);	384	change_abil (op, force);
…		…
765	{	765	{
766	object *otmp;	766	object *otmp;
767		767
768	if (op->type != PLAYER)	768	if (op->type != PLAYER)
769	return 0;	769	return 0;
		770
770	if (!QUERY_FLAG (op, FLAG_WIZCAST) && (get_map_flags (op->map, NULL, op->x, op->y, NULL, NULL) & P_NO_MAGIC))	771	if (!QUERY_FLAG (op, FLAG_WIZCAST) && (get_map_flags (op->map, NULL, op->x, op->y, NULL, NULL) & P_NO_MAGIC))
771	{	772	{
772	new_draw_info (NDI_UNIQUE, 0, op, "Something blocks the magic of the scroll.");	773	new_draw_info (NDI_UNIQUE, 0, op, "Something blocks the magic of the scroll.");
773	return 0;	774	return 0;
774	}	775	}
		776
775	otmp = find_marked_object (op);	777	otmp = find_marked_object (op);
776	if (!otmp)	778	if (!otmp)
777	{	779	{
778	new_draw_info (NDI_UNIQUE, 0, op, "You need to mark a weapon object.");	780	new_draw_info (NDI_UNIQUE, 0, op, "You need to mark a weapon object.");
779	return 0;	781	return 0;
780	}	782	}
		783
781	if (otmp->type != WEAPON && otmp->type != BOW)	784	if (otmp->type != WEAPON && otmp->type != BOW)
782	{	785	{
783	new_draw_info (NDI_UNIQUE, 0, op, "Marked item is not a weapon or bow");	786	new_draw_info (NDI_UNIQUE, 0, op, "Marked item is not a weapon or bow");
784	return 0;	787	return 0;
785	}	788	}
		789
786	new_draw_info (NDI_UNIQUE, 0, op, "Applied weapon builder.");	790	new_draw_info (NDI_UNIQUE, 0, op, "Applied weapon builder.");
787	improve_weapon (op, tmp, otmp);	791	improve_weapon (op, tmp, otmp);
788	esrv_send_item (op, otmp);	792	esrv_send_item (op, otmp);
789	return 1;	793	return 1;
790	}	794	}
…		…
1015	* Handle apply on containers.	1019	* Handle apply on containers.
1016	* By Eneq(@csd.uu.se).	1020	* By Eneq(@csd.uu.se).
1017	* Moved to own function and added many features [Tero.Haatanen@lut.fi]	1021	* Moved to own function and added many features [Tero.Haatanen@lut.fi]
1018	* added the alchemical cauldron to the code -b.t.	1022	* added the alchemical cauldron to the code -b.t.
1019	*/	1023	*/
1020
1021	int	1024	int
1022	apply_container (object *op, object *sack)	1025	apply_container (object *op, object *sack)
1023	{	1026	{
1024	char buf[MAX_BUF];	1027	if (op->type != PLAYER || !op->contr->ns)
1025	object *tmp;
1026
1027	if (op->type != PLAYER)
1028	return 0; /* This might change */	1028	return 0; /* This might change */
1029		1029
1030	if (sack == NULL || sack->type != CONTAINER)	1030	if (!sack || sack->type != CONTAINER)
1031	{	1031	{
1032	LOG (llevError, "apply_container: %s is not container!\n", sack ? &sack->name : "[nullobject]");	1032	LOG (llevError, "apply_container: %s is not container!\n", sack ? &sack->name : "[nullobject]");
1033	return 0;	1033	return 0;
1034	}	1034	}
1035		1035
1036	op->contr->last_used = 0;	1036	op->contr->last_used = 0;
1037		1037
1038	if (sack->env != op)	1038	if (sack->env && sack->env != op)
		1039	{
		1040	new_draw_info (NDI_UNIQUE, 0, op, "You must put it onto the floor or into your inventory first.");
		1041	return 1;
1039	{	1042	}
1040	if (sack->other_arch == NULL || sack->env != NULL)	1043
		1044	// already applied == open on ground, or open in inv, or active in inv
		1045	if (sack->flag [FLAG_APPLIED])
		1046	{
		1047	if (op->container == sack)
1041	{	1048	{
1042	new_draw_info (NDI_UNIQUE, 0, op, "You must get it first.");	1049	// open on ground or inv, so close
		1050	op->close_container ();
1043	return 1;	1051	return 1;
1044	}	1052	}
1045		1053	else if (!sack->env)
1046	/* It's on the ground, the problems begin */
1047	if (op->container != sack)
1048	{
1049	/* it's closed OR some player has opened it */
1050	if (QUERY_FLAG (sack, FLAG_APPLIED))
1051	{	1054	{
1052	for (tmp = GET_MAP_OB (sack->map, sack->x, sack->y); tmp && tmp->container != sack; tmp = tmp->above);	1055	// active, but not ours: some other player has opened it
1053	if (tmp)
1054	{
1055	/* some other player have opened it */
1056	new_draw_info_format (NDI_UNIQUE, 0, op, "%s is already occupied.", query_name (sack));	1056	new_draw_info_format (NDI_UNIQUE, 0, op, "%s is already occupied.", query_name (sack));
1057	return 1;	1057	return 1;
1058	}
1059	}
1060	}
1061	if (QUERY_FLAG (sack, FLAG_APPLIED))
1062	{	1058	}
1063	if (op->container == NULL)
1064	{
1065	tmp = arch_to_object (sack->other_arch);
1066	/* not good, but insert_ob_in_ob() is too smart */
1067	CLEAR_FLAG (tmp, FLAG_REMOVED);
1068	tmp->x = tmp->y = 0;
1069	tmp->map = NULL;
1070	tmp->env = sack;
1071	if (sack->inv)
1072	sack->inv->above = tmp;
1073	tmp->below = sack->inv;
1074	tmp->above = NULL;
1075	sack->inv = tmp;
1076	sack->move_off = MOVE_ALL; /* trying force closing it */
1077	}
1078	else
1079	{
1080	sack->move_off = 0;
1081	tmp = sack->inv;
1082		1059
1083	if (tmp && tmp->type == CLOSE_CON)	1060	// fall through to opening it (active in inv)
1084	tmp->destroy ();
1085	}
1086	}
1087	}
1088
1089	if (QUERY_FLAG (sack, FLAG_APPLIED))
1090	{	1061	}
		1062	else if (sack->env)
		1063	{
		1064	// it is in our env, so activate it, do not open yet
1091	if (op->container)	1065	op->close_container ();
1092	{	1066	sack->flag [FLAG_APPLIED] = 1;
1093	if (op->container != sack)	1067	esrv_update_item (UPD_FLAGS, op, sack);
1094	{	1068	new_draw_info_format (NDI_UNIQUE, 0, op, "You ready %s.", query_name (sack));
1095	tmp = op->container;	1069	return 1;
1096	apply_container (op, tmp);	1070	}
1097	sprintf (buf, "You close %s and open ", query_name (tmp));	1071
1098	op->container = sack;	1072	// it's locked?
1099	strcat (buf, query_name (sack));	1073	if (sack->slaying)
1100	strcat (buf, ".");	1074	{
1101	}	1075	if (object *tmp = find_key (op, op, sack))
1102	else	1076	new_draw_info_format (NDI_UNIQUE, 0, op, "You unlock %s with %s.", query_name (sack), query_name (tmp));
1103	{
1104	CLEAR_FLAG (sack, FLAG_APPLIED);
1105	op->container = NULL;
1106	sprintf (buf, "You close %s.", query_name (sack));
1107	}
1108	}
1109	else	1077	else
1110	{	1078	{
1111	CLEAR_FLAG (sack, FLAG_APPLIED);
1112	sprintf (buf, "You open %s.", query_name (sack));
1113	SET_FLAG (sack, FLAG_APPLIED);
1114	op->container = sack;
1115	}
1116	}
1117	else
1118	{ /* not applied */
1119	if (sack->slaying)
1120	{ /* it's locked */
1121	tmp = find_key (op, op, sack);
1122	if (tmp)
1123	{
1124	sprintf (buf, "You unlock %s with %s.", query_name (sack), query_name (tmp));
1125	SET_FLAG (sack, FLAG_APPLIED);
1126
1127	if (sack->env == NULL)
1128	{ /* if it's on ground,open it also */
1129	new_draw_info (NDI_UNIQUE, 0, op, buf);
1130	apply_container (op, sack);
1131	return 1;
1132	}
1133	}
1134	else
1135	sprintf (buf, "You don't have the key to unlock %s.", query_name (sack));	1079	new_draw_info_format (NDI_UNIQUE, 0, op, "You don't have the key to unlock %s.", query_name (sack));
1136	}
1137	else
1138	{
1139	sprintf (buf, "You readied %s.", query_name (sack));
1140	SET_FLAG (sack, FLAG_APPLIED);
1141
1142	if (sack->env == NULL)
1143	{ /* if it's on ground,open it also */
1144	new_draw_info (NDI_UNIQUE, 0, op, buf);
1145	apply_container (op, sack);
1146	return 1;	1080	return 1;
1147	}	1081	}
1148	}
1149	}	1082	}
1150		1083
1151	new_draw_info (NDI_UNIQUE, 0, op, buf);	1084	op->open_container (sack);
1152
1153	if (op->contr)
1154	op->contr->ns->floorbox_update ();
1155		1085
1156	return 1;	1086	return 1;
1157	}	1087	}
1158
1159	/**
1160	* Eneq(@csd.uu.se): Handle apply on containers. This is for containers
1161	* the player has in their inventory, eg, sacks, luggages, etc.
1162	*
1163	* Moved to own function and added many features [Tero.Haatanen@lut.fi]
1164	* This version is for client/server mode.
1165	* op is the player, sack is the container the player is opening or closing.
1166	* return 1 if an object is apllied somehow or another, 0 if error/no apply
1167	*
1168	* Reminder - there are three states for any container - closed (non applied),
1169	* applied (not open, but objects that match get tossed into it), and open
1170	* (applied flag set, and op->container points to the open container)
1171	*/
1172
1173	int
1174	esrv_apply_container (object *op, object *sack)
1175	{
1176	object *tmp = op->container;
1177
1178	if (op->type != PLAYER)
1179	return 0; /* This might change */
1180
1181	if (sack == NULL || sack->type != CONTAINER)
1182	{
1183	LOG (llevError, "esrv_apply_container: %s is not container!\n", sack ? &sack->name : "[nullobject]");
1184	return 0;
1185	}
1186
1187	/* If we have a currently open container, then it needs to be closed in all cases
1188	* if we are opening this one up. We then fall through if appropriate for
1189	* openening the new container.
1190	*/
1191
1192	if (op->container && QUERY_FLAG (sack, FLAG_APPLIED))
1193	{
1194	if (op->container->env != op)
1195	{ /* if container is on the ground */
1196	op->container->move_off = 0;
1197	}
1198
1199	if (INVOKE_OBJECT (CLOSE, tmp, ARG_OBJECT (op)))
1200	return 1;
1201
1202	new_draw_info_format (NDI_UNIQUE, 0, op, "You close %s.", query_name (op->container));
1203	CLEAR_FLAG (op->container, FLAG_APPLIED);
1204	op->container = NULL;
1205	esrv_update_item (UPD_FLAGS, op, tmp);
1206	if (tmp == sack)
1207	return 1;
1208	}
1209
1210
1211	/* If the player is trying to open it (which he must be doing if we got here),
1212	* and it is locked, check to see if player has the equipment to open it.
1213	*/
1214
1215	if (sack->slaying)
1216	{ /* it's locked */
1217	tmp = find_key (op, op, sack);
1218	if (tmp)
1219	{
1220	new_draw_info_format (NDI_UNIQUE, 0, op, "You unlock %s with %s.", query_name (sack), query_name (tmp));
1221	}
1222	else
1223	{
1224	new_draw_info_format (NDI_UNIQUE, 0, op, "You don't have the key to unlock %s.", query_name (sack));
1225	return 0;
1226	}
1227	}
1228
1229	/* By the time we get here, we have made sure any other container has been closed and
1230	* if this is a locked container, the player they key to open it.
1231	*/
1232
1233	/* There are really two cases - the sack is either on the ground, or the sack is
1234	* part of the players inventory. If on the ground, we assume that the player is
1235	* opening it, since if it was being closed, that would have been taken care of above.
1236	*/
1237
1238
1239	if (sack->env != op)
1240	{
1241	/* Hypothetical case - the player is trying to open a sack that belong to someone
1242	* else. This normally should not happen, but a misbehaving client/player could
1243	* try to do it, so lets handle it gracefully.
1244	*/
1245	if (sack->env)
1246	{
1247	new_draw_info_format (NDI_UNIQUE, 0, op, "You can't open %s", query_name (sack));
1248	return 0;
1249	}
1250	/* set these so when the player walks off, we can unapply the sack */
1251	sack->move_off = MOVE_ALL; /* trying force closing it */
1252
1253	CLEAR_FLAG (sack, FLAG_APPLIED);
1254	new_draw_info_format (NDI_UNIQUE, 0, op, "You open %s.", query_name (sack));
1255	SET_FLAG (sack, FLAG_APPLIED);
1256	op->container = sack;
1257	esrv_update_item (UPD_FLAGS, op, sack);
1258	esrv_send_inventory (op, sack);
1259
1260	}
1261	else
1262	{ /* sack is in players inventory */
1263	if (QUERY_FLAG (sack, FLAG_APPLIED))
1264	{ /* readied sack becoming open */
1265	CLEAR_FLAG (sack, FLAG_APPLIED);
1266	new_draw_info_format (NDI_UNIQUE, 0, op, "You open %s.", query_name (sack));
1267	SET_FLAG (sack, FLAG_APPLIED);
1268	op->container = sack;
1269	esrv_update_item (UPD_FLAGS, op, sack);
1270	esrv_send_inventory (op, sack);
1271	}
1272	else
1273	{
1274	CLEAR_FLAG (sack, FLAG_APPLIED);
1275	new_draw_info_format (NDI_UNIQUE, 0, op, "You readied %s.", query_name (sack));
1276	SET_FLAG (sack, FLAG_APPLIED);
1277	esrv_update_item (UPD_FLAGS, op, sack);
1278	}
1279	}
1280	return 1;
1281	}
1282
1283		1088
1284	/**	1089	/**
1285	* Handles dropping things on altar.	1090	* Handles dropping things on altar.
1286	* Returns true if sacrifice was accepted.	1091	* Returns true if sacrifice was accepted.
1287	*/	1092	*/
…		…
1533		1338
1534	/* Just put in some sanity check. I think there is a bug in the	1339	/* Just put in some sanity check. I think there is a bug in the
1535	* above with some objects have zero speed, and thus the player	1340	* above with some objects have zero speed, and thus the player
1536	* getting permanently paralyzed.	1341	* getting permanently paralyzed.
1537	*/	1342	*/
1538	if (victim->speed_left < -50.0)	1343	if (victim->speed_left < -50.f)
1539	victim->speed_left = -50.0;	1344	victim->speed_left = -50.f;
1540	/* LOG(llevDebug, "apply, playermove, player speed_left=%f\n", victim->speed_left); */	1345	/* LOG(llevDebug, "apply, playermove, player speed_left=%f\n", victim->speed_left); */
1541	}	1346	}
1542	goto leave;	1347	goto leave;
1543		1348
1544	case SPINNER:	1349	case SPINNER:
…		…
1700		1505
1701	apply_sign (victim, trap, 1);	1506	apply_sign (victim, trap, 1);
1702	goto leave;	1507	goto leave;
1703		1508
1704	case CONTAINER:	1509	case CONTAINER:
1705	if (victim->type == PLAYER)
1706	(void) esrv_apply_container (victim, trap);
1707	else
1708	(void) apply_container (victim, trap);	1510	apply_container (victim, trap);
1709	goto leave;	1511	goto leave;
1710		1512
1711	case RUNE:	1513	case RUNE:
1712	case TRAP:	1514	case TRAP:
1713	if (trap->level && QUERY_FLAG (victim, FLAG_ALIVE))	1515	if (trap->level && QUERY_FLAG (victim, FLAG_ALIVE))
…		…
1773		1575
1774	readable_message_type *msgType = get_readable_message_type (tmp);	1576	readable_message_type *msgType = get_readable_message_type (tmp);
1775		1577
1776	draw_ext_info_format (NDI_UNIQUE | NDI_NAVY, 0, op,	1578	draw_ext_info_format (NDI_UNIQUE | NDI_NAVY, 0, op,
1777	msgType->message_type, msgType->message_subtype,	1579	msgType->message_type, msgType->message_subtype,
1778	"You open the %s and start reading.\n%s", "%s\n%s", long_desc (tmp, op), &tmp->msg);	1580	"You open the %s and start reading.\n%s", (char *)"%s\n%s",
		1581	long_desc (tmp, op), &tmp->msg);
1779		1582
1780	/* gain xp from reading */	1583	/* gain xp from reading */
1781	if (!QUERY_FLAG (tmp, FLAG_NO_SKILL_IDENT))	1584	if (!QUERY_FLAG (tmp, FLAG_NO_SKILL_IDENT))
1782	{ /* only if not read before */	1585	{ /* only if not read before */
1783	int exp_gain = calc_skill_exp (op, tmp, skill_ob);	1586	int exp_gain = calc_skill_exp (op, tmp, skill_ob);
…		…
1939	return;	1742	return;
1940	}	1743	}
1941		1744
1942	if (skop->level < int (sqrtf (spell->level) * 1.5f))	1745	if (skop->level < int (sqrtf (spell->level) * 1.5f))
1943	{	1746	{
1944	new_draw_info (NDI_UNIQUE, 0, op, "It is too hard to read at your level: You are unable to decipher the strange symbols.");	1747	new_draw_info (NDI_UNIQUE, 0, op, "You are unable to decipher the strange symbols. [Your literacy level is too low]");
1945	return;	1748	return;
1946	}	1749	}
1947		1750
1948	new_draw_info_format (NDI_UNIQUE, 0, op, "The spellbook contains the %s level spell %s.", get_levelnumber (spell->level), &spell->name);	1751	new_draw_info_format (NDI_UNIQUE, 0, op, "The spellbook contains the %s level spell %s.", get_levelnumber (spell->level), &spell->name);
1949		1752
…		…
1972	{	1775	{
1973	spell_skill = find_skill_by_name (op, spell->skill);	1776	spell_skill = find_skill_by_name (op, spell->skill);
1974		1777
1975	if (!spell_skill)	1778	if (!spell_skill)
1976	{	1779	{
1977	new_draw_info_format (NDI_UNIQUE, 0, op, "You lack the skill %s to use this spell", &spell->skill);	1780	new_draw_info_format (NDI_UNIQUE, 0, op, "You lack the skill %s to use this spell.", &spell->skill);
1978	return;	1781	return;
1979	}	1782	}
1980		1783
1981	if (spell_skill->level < spell->level)	1784	if (spell_skill->level < spell->level)
1982	{	1785	{
…		…
2016	else	1819	else
2017	{	1820	{
2018	play_sound_player_only (op->contr, SOUND_FUMBLE_SPELL, 0, 0);	1821	play_sound_player_only (op->contr, SOUND_FUMBLE_SPELL, 0, 0);
2019	new_draw_info (NDI_UNIQUE, 0, op, "You fail to learn the spell.\n");	1822	new_draw_info (NDI_UNIQUE, 0, op, "You fail to learn the spell.\n");
2020	}	1823	}
		1824
2021	decrease_ob (tmp);	1825	decrease_ob (tmp);
2022	}	1826	}
2023		1827
2024	/**	1828	/**
2025	* Handles applying a spell scroll.	1829	* Handles applying a spell scroll.
…		…
2280	/* doubled chance for resistance of ability-focus */	2084	/* doubled chance for resistance of ability-focus */
2281	if (i == abil->stats.exp)	2085	if (i == abil->stats.exp)
2282	chance = MIN (100., chance * 2.);	2086	chance = MIN (100., chance * 2.);
2283		2087
2284	/* now make the throw and save all winners (Don't insert luck bonus here!) */	2088	/* now make the throw and save all winners (Don't insert luck bonus here!) */
2285	if (rndm (10000) < (int) (chance * 100))	2089	if (rndm (10000) < (unsigned int) (chance * 100))
2286	{	2090	{
2287	atnr_winner[winners] = i;	2091	atnr_winner[winners] = i;
2288	winners++;	2092	winners++;
2289	}	2093	}
2290		2094
…		…
2492	}	2296	}
2493		2297
2494	return 0;	2298	return 0;
2495	}	2299	}
2496		2300
2497
2498	/**	2301	/**
2499	* Main apply handler.	2302	* Main apply handler.
2500	*	2303	*
2501	* Checks for unpaid items before applying.	2304	* Checks for unpaid items before applying.
2502	*	2305	*
…		…
2509	* being applied.	2312	* being applied.
2510	*	2313	*
2511	* aflag is special (always apply/unapply) flags. Nothing is done with	2314	* aflag is special (always apply/unapply) flags. Nothing is done with
2512	* them in this function - they are passed to apply_special	2315	* them in this function - they are passed to apply_special
2513	*/	2316	*/
2514
2515	int	2317	int
2516	manual_apply (object *op, object *tmp, int aflag)	2318	manual_apply (object *op, object *tmp, int aflag)
2517	{	2319	{
2518	if (tmp->head)	2320	if (tmp->head)
2519	tmp = tmp->head;	2321	tmp = tmp->head;
…		…
2557	case EXIT:	2359	case EXIT:
2558	if (op->type != PLAYER)	2360	if (op->type != PLAYER)
2559	return 0;	2361	return 0;
2560		2362
2561	if (!EXIT_PATH (tmp) || !is_legal_2ways_exit (op, tmp))	2363	if (!EXIT_PATH (tmp) || !is_legal_2ways_exit (op, tmp))
2562	{
2563	new_draw_info_format (NDI_UNIQUE, 0, op, "The %s is closed.", query_name (tmp));	2364	new_draw_info_format (NDI_UNIQUE, 0, op, "The %s is closed.", query_name (tmp));
2564	}
2565	else	2365	else
2566	{	2366	{
2567	/* Don't display messages for random maps. */	2367	/* Don't display messages for random maps. */
2568	if (tmp->msg && strncmp (EXIT_PATH (tmp), "/!", 2))	2368	if (tmp->msg && strncmp (EXIT_PATH (tmp), "/!", 2))
2569	new_draw_info (NDI_NAVY, 0, op, tmp->msg);	2369	new_draw_info (NDI_NAVY, 0, op, tmp->msg);
2570		2370
2571	op->enter_exit (tmp);	2371	op->enter_exit (tmp);
2572	}	2372	}
		2373
2573	return 1;	2374	return 1;
2574		2375
2575	case SIGN:	2376	case SIGN:
2576	apply_sign (op, tmp, 0);	2377	apply_sign (op, tmp, 0);
2577	return 1;	2378	return 1;
…		…
2581	{	2382	{
2582	apply_book (op, tmp);	2383	apply_book (op, tmp);
2583	return 1;	2384	return 1;
2584	}	2385	}
2585	else	2386	else
2586	{
2587	return 0;	2387	return 0;
2588	}
2589		2388
2590	case SKILLSCROLL:	2389	case SKILLSCROLL:
2591	if (op->type == PLAYER)	2390	if (op->type == PLAYER)
2592	{	2391	{
2593	apply_skillscroll (op, tmp);	2392	apply_skillscroll (op, tmp);
2594	return 1;	2393	return 1;
2595	}	2394	}
		2395	else
2596	return 0;	2396	return 0;
2597		2397
2598	case SPELLBOOK:	2398	case SPELLBOOK:
2599	if (op->type == PLAYER)	2399	if (op->type == PLAYER)
2600	{	2400	{
2601	apply_spellbook (op, tmp);	2401	apply_spellbook (op, tmp);
2602	return 1;	2402	return 1;
2603	}	2403	}
		2404	else
2604	return 0;	2405	return 0;
2605		2406
2606	case SCROLL:	2407	case SCROLL:
2607	apply_scroll (op, tmp, 0);	2408	apply_scroll (op, tmp, 0);
2608	return 1;	2409	return 1;
2609		2410
2610	case POTION:	2411	case POTION:
2611	(void) apply_potion (op, tmp);	2412	apply_potion (op, tmp);
2612	return 1;	2413	return 1;
2613		2414
2614	/* Eneq(@csd.uu.se): Handle apply on containers. */	2415	/* Eneq(@csd.uu.se): Handle apply on containers. */
		2416	//TODO: remove, as it is unsed?
2615	case CLOSE_CON:	2417	case CLOSE_CON:
2616	if (op->type == PLAYER)
2617	(void) esrv_apply_container (op, tmp->env);
2618	else
2619	(void) apply_container (op, tmp->env);	2418	apply_container (op, tmp->env);
2620	return 1;	2419	return 1;
2621		2420
2622	case CONTAINER:	2421	case CONTAINER:
2623	if (op->type == PLAYER)
2624	(void) esrv_apply_container (op, tmp);
2625	else
2626	(void) apply_container (op, tmp);	2422	apply_container (op, tmp);
2627	return 1;	2423	return 1;
2628		2424
2629	case TREASURE:	2425	case TREASURE:
2630	if (op->type == PLAYER)	2426	if (op->type == PLAYER)
2631	{	2427	{
2632	apply_treasure (op, tmp);	2428	apply_treasure (op, tmp);
2633	return 1;	2429	return 1;
2634	}	2430	}
2635	else	2431	else
2636	{
2637	return 0;	2432	return 0;
2638	}
2639		2433
2640	case WEAPON:	2434	case WEAPON:
2641	case ARMOUR:	2435	case ARMOUR:
2642	case BOOTS:	2436	case BOOTS:
2643	case GLOVES:	2437	case GLOVES:
…		…
2656	case LAMP:	2450	case LAMP:
2657	case BUILDER:	2451	case BUILDER:
2658	case SKILL_TOOL:	2452	case SKILL_TOOL:
2659	if (tmp->env != op)	2453	if (tmp->env != op)
2660	return 2; /* not in inventory */	2454	return 2; /* not in inventory */
		2455
2661	(void) apply_special (op, tmp, aflag);	2456	apply_special (op, tmp, aflag);
2662	return 1;	2457	return 1;
2663		2458
2664	case DRINK:	2459	case DRINK:
2665	case FOOD:	2460	case FOOD:
2666	case FLESH:	2461	case FLESH:
…		…
2682	}	2477	}
2683	else	2478	else
2684	return 0;	2479	return 0;
2685		2480
2686	case WEAPON_IMPROVER:	2481	case WEAPON_IMPROVER:
2687	(void) check_improve_weapon (op, tmp);	2482	check_improve_weapon (op, tmp);
2688	return 1;	2483	return 1;
2689		2484
2690	case CLOCK:	2485	case CLOCK:
2691	if (op->type == PLAYER)	2486	if (op->type == PLAYER)
2692	{	2487	{
…		…
2700	play_sound_player_only (op->contr, SOUND_CLOCK, 0, 0);	2495	play_sound_player_only (op->contr, SOUND_CLOCK, 0, 0);
2701	new_draw_info (NDI_UNIQUE, 0, op, buf);	2496	new_draw_info (NDI_UNIQUE, 0, op, buf);
2702	return 1;	2497	return 1;
2703	}	2498	}
2704	else	2499	else
2705	{
2706	return 0;	2500	return 0;
2707	}
2708		2501
2709	case MENU:	2502	case MENU:
2710	if (op->type == PLAYER)	2503	if (op->type == PLAYER)
2711	{	2504	{
2712	shop_listing (op);	2505	shop_listing (tmp, op);
2713	return 1;	2506	return 1;
2714	}	2507	}
2715	else	2508	else
2716	{
2717	return 0;	2509	return 0;
2718	}
2719		2510
2720	case POWER_CRYSTAL:	2511	case POWER_CRYSTAL:
2721	apply_power_crystal (op, tmp); /* see egoitem.c */	2512	apply_power_crystal (op, tmp); /* see egoitem.c */
2722	return 1;	2513	return 1;
2723		2514
…		…
2726	{	2517	{
2727	apply_lighter (op, tmp);	2518	apply_lighter (op, tmp);
2728	return 1;	2519	return 1;
2729	}	2520	}
2730	else	2521	else
2731	{
2732	return 0;	2522	return 0;
2733	}
2734		2523
2735	case ITEM_TRANSFORMER:	2524	case ITEM_TRANSFORMER:
2736	apply_item_transformer (op, tmp);	2525	apply_item_transformer (op, tmp);
2737	return 1;	2526	return 1;
2738		2527
…		…
2791	/**	2580	/**
2792	* player_apply_below attempts to apply the object 'below' the player.	2581	* player_apply_below attempts to apply the object 'below' the player.
2793	* If the player has an open container, we use that for below, otherwise	2582	* If the player has an open container, we use that for below, otherwise
2794	* we use the ground.	2583	* we use the ground.
2795	*/	2584	*/
2796
2797	void	2585	void
2798	player_apply_below (object *pl)	2586	player_apply_below (object *pl)
2799	{	2587	{
2800	object *tmp, *next;
2801	int floors;	2588	int floors = 0;
2802		2589
2803	/* If using a container, set the starting item to be the top	2590	/* If using a container, set the starting item to be the top
2804	* item in the container. Otherwise, use the map.	2591	* item in the container. Otherwise, use the map.
2805	*/
2806	tmp = (pl->container != NULL) ? pl->container->inv : pl->below;
2807
2808	/* This is perhaps more complicated. However, I want to make sure that	2592	* This is perhaps more complicated. However, I want to make sure that
2809	* we don't use a corrupt pointer for the next object, so we get the	2593	* we don't use a corrupt pointer for the next object, so we get the
2810	* next object in the stack before applying. This is can only be a	2594	* next object in the stack before applying. This is can only be a
2811	* problem if player_apply() has a bug in that it uses the object but does	2595	* problem if player_apply() has a bug in that it uses the object but does
2812	* not return a proper value.	2596	* not return a proper value.
2813	*/	2597	*/
2814	for (floors = 0; tmp != NULL; tmp = next)	2598	for (object *next, *tmp = pl->container ? pl->container->inv : pl->below; tmp; tmp = next)
2815	{	2599	{
2816	next = tmp->below;	2600	next = tmp->below;
		2601
2817	if (QUERY_FLAG (tmp, FLAG_IS_FLOOR))	2602	if (QUERY_FLAG (tmp, FLAG_IS_FLOOR))
2818	floors++;	2603	floors++;
2819	else if (floors > 0)	2604	else if (floors > 0)
2820	return; /* process only floor objects after first floor object */	2605	return; /* process only floor objects after first floor object */
2821		2606
…		…
2841	* to keep the size of apply_special to a more managable size.	2626	* to keep the size of apply_special to a more managable size.
2842	*/	2627	*/
2843	static int	2628	static int
2844	unapply_special (object *who, object *op, int aflags)	2629	unapply_special (object *who, object *op, int aflags)
2845	{	2630	{
2846	if (INVOKE_OBJECT (BE_UNREADY, op, ARG_OBJECT (who), ARG_INT (aflags)) || INVOKE_OBJECT (UNREADY, who, ARG_OBJECT (op), ARG_INT (aflags)))	2631	if (INVOKE_OBJECT (BE_UNREADY, op, ARG_OBJECT (who), ARG_INT (aflags))
		2632	|| INVOKE_OBJECT (UNREADY, who, ARG_OBJECT (op), ARG_INT (aflags)))
2847	return RESULT_INT (0);	2633	return RESULT_INT (0);
2848		2634
2849	object *tmp2;	2635	object *tmp2;
2850		2636
2851	CLEAR_FLAG (op, FLAG_APPLIED);	2637	CLEAR_FLAG (op, FLAG_APPLIED);
		2638
		2639	if (player *pl = who->contr)
		2640	{
		2641	if (op == pl->ranged_ob) pl->ranged_ob = 0;
		2642	if (op == pl->combat_ob) pl->combat_ob = 0;
		2643	}
		2644
2852	switch (op->type)	2645	switch (op->type)
2853	{	2646	{
		2647	case SKILL_TOOL:
		2648	// unapplying a skill tool should also unapply the skill it governs
		2649	// but this is hard, as it shouldn't do so when the skill can
		2650	// be used for other reasons
		2651	for (object *tmp = who->inv; tmp; tmp = tmp->below)
		2652	if (tmp->skill == op->skill
		2653	&& tmp->type == SKILL
		2654	&& tmp->flag [FLAG_APPLIED]
		2655	&& !tmp->flag [FLAG_CAN_USE_SKILL])
		2656	unapply_special (who, tmp, 0);
		2657
		2658	change_abil (who, op);
		2659	break;
		2660
2854	case WEAPON:	2661	case WEAPON:
2855	new_draw_info_format (NDI_UNIQUE, 0, who, "You unwield %s.", query_name (op));	2662	new_draw_info_format (NDI_UNIQUE, 0, who, "You unwield %s.", query_name (op));
2856		2663
2857	(void) change_abil (who, op);	2664	change_abil (who, op);
2858	if (QUERY_FLAG (who, FLAG_READY_WEAPON))
2859	CLEAR_FLAG (who, FLAG_READY_WEAPON);	2665	CLEAR_FLAG (who, FLAG_READY_WEAPON);
2860	clear_skill (who);	2666	clear_skill (who);
2861	break;	2667	break;
2862		2668
2863	case SKILL: /* allows objects to impart skills */
2864	case SKILL_TOOL:	2669	case SKILL:
2865	if (op != who->chosen_skill)	2670	if (op != who->chosen_skill)
2866	{
2867	LOG (llevError, "BUG: apply_special(): applied skill is not a chosen skill\n");	2671	LOG (llevError, "BUG: apply_special(): applied skill is not a chosen skill\n");
		2672
		2673	if (who->contr)
2868	}	2674	{
2869	if (who->type == PLAYER)
2870	{
2871	if (who->contr->shoottype == range_skill)
2872	who->contr->shoottype = range_none;
2873	if (!op->invisible)	2675	if (!op->invisible)
2874	{
2875	new_draw_info_format (NDI_UNIQUE, 0, who, "You stop using the %s.", query_name (op));	2676	new_draw_info_format (NDI_UNIQUE, 0, who, "You stop using the %s.", query_name (op));
2876	}
2877	else	2677	else
2878	{
2879	new_draw_info_format (NDI_UNIQUE, 0, who, "You can no longer use the skill: %s.", &op->skill);	2678	new_draw_info_format (NDI_UNIQUE, 0, who, "You can no longer use the skill: %s.", &op->skill);
2880	}	2679	}
2881	}	2680
2882	(void) change_abil (who, op);	2681	change_abil (who, op);
2883	who->chosen_skill = NULL;	2682	who->chosen_skill = 0;
2884	CLEAR_FLAG (who, FLAG_READY_SKILL);	2683	CLEAR_FLAG (who, FLAG_READY_SKILL);
2885	break;	2684	break;
2886		2685
2887	case ARMOUR:	2686	case ARMOUR:
2888	case HELMET:	2687	case HELMET:
…		…
2893	case AMULET:	2692	case AMULET:
2894	case GIRDLE:	2693	case GIRDLE:
2895	case BRACERS:	2694	case BRACERS:
2896	case CLOAK:	2695	case CLOAK:
2897	new_draw_info_format (NDI_UNIQUE, 0, who, "You unwear %s.", query_name (op));	2696	new_draw_info_format (NDI_UNIQUE, 0, who, "You unwear %s.", query_name (op));
2898	(void) change_abil (who, op);	2697	change_abil (who, op);
2899	break;	2698	break;
		2699
2900	case LAMP:	2700	case LAMP:
2901	new_draw_info_format (NDI_UNIQUE, 0, who, "You turn off your %s.", &op->name);	2701	new_draw_info_format (NDI_UNIQUE, 0, who, "You turn off your %s.", &op->name);
2902	tmp2 = arch_to_object (op->other_arch);	2702	tmp2 = arch_to_object (op->other_arch);
2903	tmp2->x = op->x;	2703	tmp2->x = op->x;
2904	tmp2->y = op->y;	2704	tmp2->y = op->y;
…		…
2909	CLEAR_FLAG (tmp2, FLAG_APPLIED);	2709	CLEAR_FLAG (tmp2, FLAG_APPLIED);
2910		2710
2911	if (QUERY_FLAG (op, FLAG_INV_LOCKED))	2711	if (QUERY_FLAG (op, FLAG_INV_LOCKED))
2912	SET_FLAG (tmp2, FLAG_INV_LOCKED);	2712	SET_FLAG (tmp2, FLAG_INV_LOCKED);
2913		2713
2914	if (who->type == PLAYER)	2714	if (who->contr)
2915	esrv_del_item (who->contr, op->count);	2715	esrv_del_item (who->contr, op->count);
2916		2716
2917	op->destroy ();	2717	op->destroy ();
2918	insert_ob_in_ob (tmp2, who);	2718	insert_ob_in_ob (tmp2, who);
2919	who->update_stats ();	2719	who->update_stats ();
		2720
2920	if (QUERY_FLAG (op, FLAG_CURSED) || QUERY_FLAG (op, FLAG_DAMNED))	2721	if (QUERY_FLAG (op, FLAG_CURSED) || QUERY_FLAG (op, FLAG_DAMNED))
2921	{	2722	{
2922	if (who->type == PLAYER)	2723	if (who->contr)
2923	{	2724	{
2924	new_draw_info (NDI_UNIQUE, 0, who, "Oops, it feels deadly cold!");	2725	new_draw_info (NDI_UNIQUE, 0, who, "Oops, it feels deadly cold!");
2925	SET_FLAG (tmp2, FLAG_KNOWN_CURSED);	2726	SET_FLAG (tmp2, FLAG_KNOWN_CURSED);
2926	}	2727	}
2927	}	2728	}
2928	if (who->type == PLAYER)	2729
		2730	if (who->contr)
2929	esrv_send_item (who, tmp2);	2731	esrv_send_item (who, tmp2);
		2732
2930	return 1; /* otherwise, an attempt to drop causes problems */	2733	return 1; /* otherwise, an attempt to drop causes problems */
2931	break;	2734
2932	case BOW:	2735	case BOW:
2933	case WAND:	2736	case WAND:
2934	case ROD:	2737	case ROD:
2935	case HORN:	2738	case HORN:
2936	clear_skill (who);	2739	clear_skill (who);
		2740
		2741	if (who->contr)
		2742	{
2937	new_draw_info_format (NDI_UNIQUE, 0, who, "You unready %s.", query_name (op));	2743	new_draw_info_format (NDI_UNIQUE, 0, who, "You unready %s.", query_name (op));
2938	if (who->type == PLAYER)	2744
2939	{	2745	if (who->contr->ranged_ob == op)
2940	who->contr->shoottype = range_none;	2746	who->contr->ranged_ob = 0;
		2747
		2748	if (who->current_weapon == op)
		2749	who->current_weapon = 0;
2941	}	2750	}
2942	else	2751	else
2943	{	2752	{
2944	if (op->type == BOW)	2753	if (op->type == BOW)
2945	CLEAR_FLAG (who, FLAG_READY_BOW);	2754	CLEAR_FLAG (who, FLAG_READY_BOW);
2946	else	2755	else
2947	CLEAR_FLAG (who, FLAG_READY_RANGE);	2756	CLEAR_FLAG (who, FLAG_READY_RANGE);
2948	}	2757	}
		2758
2949	break;	2759	break;
2950		2760
2951	case BUILDER:	2761	case BUILDER:
		2762	if (who->contr)
		2763	{
2952	new_draw_info_format (NDI_UNIQUE, 0, who, "You unready %s.", query_name (op));	2764	new_draw_info_format (NDI_UNIQUE, 0, who, "You unready %s.", query_name (op));
2953	who->contr->shoottype = range_none;	2765
2954	who->contr->ranges[range_builder] = NULL;	2766	if (who->contr->ranged_ob == op)
		2767	who->contr->ranged_ob = 0;
		2768	}
2955	break;	2769	break;
2956		2770
2957	default:	2771	default:
2958	new_draw_info_format (NDI_UNIQUE, 0, who, "You unapply %s.", query_name (op));	2772	new_draw_info_format (NDI_UNIQUE, 0, who, "You unapply %s.", query_name (op));
2959	break;	2773	break;
…		…
2961		2775
2962	who->update_stats ();	2776	who->update_stats ();
2963		2777
2964	if (!(aflags & AP_NO_MERGE))	2778	if (!(aflags & AP_NO_MERGE))
2965	{	2779	{
2966	object *tmp;
2967
2968	tmp = merge_ob (op, NULL);	2780	object *tmp = merge_ob (op, 0);
2969	if (who->type == PLAYER)	2781
		2782	if (who->contr)
2970	{	2783	{
2971	if (tmp)	2784	if (tmp)
2972	{ /* it was merged */	2785	{ /* it was merged */
2973	esrv_del_item (who->contr, op->count);	2786	esrv_del_item (who->contr, op->count);
2974	op = tmp;	2787	op = tmp;
2975	}	2788	}
2976		2789
2977	esrv_send_item (who, op);	2790	esrv_send_item (who, op);
2978	}	2791	}
2979	}	2792	}
		2793
2980	return 0;	2794	return 0;
2981	}	2795	}
2982		2796
2983	/**	2797	/**
2984	* Returns the object that is using location 'loc'.	2798	* Returns the object that is using location 'loc'.
2985	* Note that 'start' is the first object to start examing - we	2799	* Note that 'start' is the first object to start examing - we
2986	* then go through the below of this. In this way, you can do	2800	* then go through the below of this. In this way, you can do
2987	* something like:	2801	* something like:
2988	* tmp = get_item_from_body_location(who->inv, 1);	2802	* tmp = get_next_item_from_body_location(who->inv, 1);
2989	* if (tmp) tmp1 = get_item_from_body_location(tmp->below, 1);	2803	* if (tmp) tmp1 = get_next_item_from_body_location(tmp->below, 1);
2990	* to find the second object that may use this location, etc.	2804	* to find the second object that may use this location, etc.
2991	* Returns NULL if no match is found.	2805	* Returns NULL if no match is found.
2992	* loc is the index into the array we are looking for a match.	2806	* loc is the index into the array we are looking for a match.
2993	* don't return invisible objects unless they are skill objects	2807	* don't return invisible objects unless they are skill objects
2994	* invisible other objects that use	2808	* invisible other objects that use
2995	* up body locations can be used as restrictions.	2809	* up body locations can be used as restrictions.
2996	*/	2810	*/
2997	object *	2811	static object *
2998	get_item_from_body_location (object *start, int loc)	2812	get_next_item_from_body_location (int loc, object *start)
2999	{	2813	{
3000	object *tmp;
3001
3002	if (!start)
3003	return NULL;
3004
3005	for (tmp = start; tmp; tmp = tmp->below)	2814	for (object *tmp = start; tmp; tmp = tmp->below)
3006	if (QUERY_FLAG (tmp, FLAG_APPLIED) && tmp->body_info[loc] && (!tmp->invisible || tmp->type == SKILL))	2815	if (tmp->flag [FLAG_APPLIED]
		2816	&& tmp->slot[loc].info
		2817	&& (!tmp->invisible || tmp->type == SKILL))
3007	return tmp;	2818	return tmp;
3008		2819
3009	return NULL;	2820	return 0;
3010	}	2821	}
3011
3012
3013		2822
3014	/**	2823	/**
3015	* 'op' wants to apply an object, but can't because of other equipment.	2824	* 'op' wants to apply an object, but can't because of other equipment.
3016	* This should only be called when it is known	2825	* This should only be called when it is known
3017	* that there are objects to unapply. This makes pretty heavy	2826	* that there are objects to unapply. This makes pretty heavy
…		…
3023	* another function that does just that.	2832	* another function that does just that.
3024	*/	2833	*/
3025	int	2834	int
3026	unapply_for_ob (object *who, object *op, int aflags)	2835	unapply_for_ob (object *who, object *op, int aflags)
3027	{	2836	{
3028	int i;	2837	if (op->is_range ())
3029	object *tmp = NULL, *last;
3030
3031	/* If we are applying a shield or weapon, unapply any equipped shield
3032	* or weapons first - only allowed to use one weapon/shield at a time.
3033	*/
3034	if (op->type == WEAPON || op->type == SHIELD)
3035	{
3036	for (tmp = who->inv; tmp; tmp = tmp->below)	2838	for (object *tmp = who->inv; tmp; tmp = tmp->below)
3037	{
3038	if (QUERY_FLAG (tmp, FLAG_APPLIED) && tmp->type == op->type)	2839	if (QUERY_FLAG (tmp, FLAG_APPLIED) && tmp->is_range ())
3039	{
3040	if ((aflags & AP_IGNORE_CURSE) || (aflags & AP_PRINT) || (!QUERY_FLAG (tmp, FLAG_CURSED) && !QUERY_FLAG (tmp, FLAG_DAMNED)))	2840	if ((aflags & AP_IGNORE_CURSE) || (aflags & AP_PRINT) || (!QUERY_FLAG (tmp, FLAG_CURSED) && !QUERY_FLAG (tmp, FLAG_DAMNED)))
3041	{	2841	{
3042	if (aflags & AP_PRINT)	2842	if (aflags & AP_PRINT)
3043	new_draw_info (NDI_UNIQUE, 0, who, query_name (tmp));	2843	new_draw_info (NDI_UNIQUE, 0, who, query_name (tmp));
3044	else	2844	else
3045	unapply_special (who, tmp, aflags);	2845	unapply_special (who, tmp, aflags);
3046	}	2846	}
3047	else	2847	else
3048	{	2848	{
3049	/* In this case, we want to try and remove a cursed item.	2849	/* In this case, we want to try and remove a cursed item.
3050	* While we know it won't work, we want unapply_special to	2850	* While we know it won't work, we want unapply_special to
3051	* at least generate the message.	2851	* at least generate the message.
3052	*/	2852	*/
3053	new_draw_info_format (NDI_UNIQUE, 0, who, "No matter how hard you try, you just can't\nremove %s.", query_name (tmp));	2853	new_draw_info_format (NDI_UNIQUE, 0, who, "No matter how hard you try, you just can't remove the %s.", query_name (tmp));
3054	return 1;	2854	return 1;
3055	}
3056
3057	}	2855	}
3058	}
3059	}
3060		2856
3061	for (i = 0; i < NUM_BODY_LOCATIONS; i++)	2857	for (int i = 0; i < NUM_BODY_LOCATIONS; i++)
3062	{	2858	{
3063	/* this used up a slot that we need to free */	2859	/* this used up a slot that we need to free */
3064	if (op->body_info[i])	2860	if (op->slot[i].info)
3065	{	2861	{
3066	last = who->inv;	2862	object *last = who->inv;
3067		2863
3068	/* We do a while loop - may need to remove several items in order	2864	/* We do a while loop - may need to remove several items in order
3069	* to free up enough slots.	2865	* to free up enough slots.
3070	*/	2866	*/
3071	while ((who->body_used[i] + op->body_info[i]) < 0)	2867	while ((who->slot[i].used + op->slot[i].info) < 0)
3072	{	2868	{
3073	tmp = get_item_from_body_location (last, i);	2869	object *tmp = get_next_item_from_body_location (i, last);
		2870
3074	if (!tmp)	2871	if (!tmp)
3075	{	2872	{
3076	#if 0	2873	#if 0
3077	/* Not a bug - we'll get this if the player has cursed items	2874	/* Not a bug - we'll get this if the player has cursed items
3078	* equipped.	2875	* equipped.
3079	*/	2876	*/
3080	LOG (llevError, "Can't find object using location %d (%s) on %s\n", i, body_locations[i].save_name, who->name);	2877	LOG (llevError, "Can't find object using location %d (%s) on %s\n", i, body_locations[i].save_name, who->name);
3081	#endif	2878	#endif
3082	return 1;	2879	return 1;
3083	}	2880	}
		2881
3084	/* If we are just printing, we don't care about cursed status */	2882	/* If we are just printing, we don't care about cursed status */
3085	if ((aflags & AP_IGNORE_CURSE) || (aflags & AP_PRINT) || (!(QUERY_FLAG (tmp, FLAG_CURSED) || QUERY_FLAG (tmp, FLAG_DAMNED))))	2883	if ((aflags & AP_IGNORE_CURSE) || (aflags & AP_PRINT) || (!(QUERY_FLAG (tmp, FLAG_CURSED) || QUERY_FLAG (tmp, FLAG_DAMNED))))
3086	{	2884	{
3087	if (aflags & AP_PRINT)	2885	if (aflags & AP_PRINT)
3088	new_draw_info (NDI_UNIQUE, 0, who, query_name (tmp));	2886	new_draw_info (NDI_UNIQUE, 0, who, query_name (tmp));
…		…
3096	* so it may not be critical (eg, putting on a ring and you have	2894	* so it may not be critical (eg, putting on a ring and you have
3097	* one cursed ring.)	2895	* one cursed ring.)
3098	*/	2896	*/
3099	new_draw_info_format (NDI_UNIQUE, 0, who, "The %s just won't come off", query_name (tmp));	2897	new_draw_info_format (NDI_UNIQUE, 0, who, "The %s just won't come off", query_name (tmp));
3100	}	2898	}
		2899
3101	last = tmp->below;	2900	last = tmp->below;
3102	}	2901	}
3103	/* if we got here, this slot is freed up - otherwise, if it wasn't freed up, the	2902	/* if we got here, this slot is freed up - otherwise, if it wasn't freed up, the
3104	* return in the !tmp would have kicked in.	2903	* return in the !tmp would have kicked in.
3105	*/	2904	*/
3106	} /* if op is using this body location */	2905	} /* if op is using this body location */
3107	} /* for body lcoations */	2906	} /* for body lcoations */
		2907
3108	return 0;	2908	return 0;
3109	}	2909	}
3110		2910
3111	/**	2911	/**
3112	* Checks to see if 'who' can apply object 'op'.	2912	* Checks to see if 'who' can apply object 'op'.
3113	* Returns 0 if apply can be done without anything special.	2913	* Returns 0 if apply can be done without anything special.
3114	* Otherwise returns a bitmask - potentially several of these may be	2914	* Otherwise returns a bitmask - potentially several of these may be
3115	* set, but largely depends on circumstance - in the future, processing	2915	* set, but largely depends on circumstance - in the future, processing
3116	* may be pruned once we know some status (eg, once CAN_APPLY_NEVER	2916	* may be pruned once we know some status (eg, once CAN_APPLY_NEVER
3117	* is set, do we really are what the other flags may be?)	2917	* is set, do we really care what the other flags may be?)
3118	*	2918	*
3119	* See include/define.h for detailed description of the meaning of	2919	* See include/define.h for detailed description of the meaning of
3120	* these return values.	2920	* these return values.
3121	*/	2921	*/
3122	int	2922	int
3123	can_apply_object (object *who, object *op)	2923	can_apply_object (object *who, object *op)
3124	{	2924	{
3125	if (INVOKE_OBJECT (CAN_BE_APPLIED, op, ARG_OBJECT (who)) || INVOKE_OBJECT (CAN_APPLY, who, ARG_OBJECT (op)))	2925	if (INVOKE_OBJECT (CAN_BE_APPLIED, op, ARG_OBJECT (who)) || INVOKE_OBJECT (CAN_APPLY, who, ARG_OBJECT (op)))
3126	return RESULT_INT (0);	2926	return RESULT_INT (0);
3127		2927
3128	int i, retval = 0;	2928	int retval = 0;
3129	object *tmp = NULL, *ws = NULL;	2929	object *tmp = 0, *ws = 0;
3130		2930
3131	/* Players have 2 'arm's, so they could in theory equip 2 shields or	2931	for (int i = 0; i < NUM_BODY_LOCATIONS; i++)
3132	* 2 weapons, but we don't want to let them do that. So if they are
3133	* trying to equip a weapon or shield, see if they already have one
3134	* in place and store that way.
3135	*/
3136	if (op->type == WEAPON || op->type == SHIELD)
3137	{	2932	{
3138	for (tmp = who->inv; tmp && !ws; tmp = tmp->below)	2933	if (op->slot[i].info)
3139	{	2934	{
3140	if (QUERY_FLAG (tmp, FLAG_APPLIED) && tmp->type == op->type)	2935	/* Item uses more slots than we have */
		2936	if (who->slot[i].info + op->slot [i].info < 0)
3141	{	2937	{
3142	retval = CAN_APPLY_UNAPPLY;
3143	ws = tmp;
3144	}
3145	}
3146	}
3147
3148
3149	for (i = 0; i < NUM_BODY_LOCATIONS; i++)
3150	{
3151	if (op->body_info[i])
3152	{
3153	/* Item uses more slots than we have */
3154	if (FABS (op->body_info[i]) > who->body_info[i])
3155	{
3156	/* Could return now for efficiently - rest of info below isn'	2938	/* Could return now for efficiency - rest of info below isn't
3157	* really needed.	2939	* really needed.
3158	*/	2940	*/
3159	retval |= CAN_APPLY_NEVER;	2941	retval |= CAN_APPLY_NEVER;
3160	}	2942	}
3161	else if ((who->body_used[i] + op->body_info[i]) < 0)	2943	else if (who->slot[i].used + op->slot[i].info < 0)
3162	{	2944	{
3163	/* in this case, equipping this would use more free spots than	2945	/* in this case, equipping this would use more free spots than
3164	* we have.	2946	* we have.
3165	*/	2947	*/
3166	object *tmp1;
3167
3168		2948
3169	/* if we have an applied weapon/shield, and unapply it would free	2949	/* if we have an applied weapon/shield, and unapply it would free
3170	* enough slots to equip the new item, then just set this can	2950	* enough slots to equip the new item, then just set "can
3171	* continue. We don't care about the logic below - if you have	2951	* apply unapply". We don't care about the logic below - if you have a
3172	* shield equipped and try to equip another shield, there is only	2952	* shield equipped and try to equip another shield, there is only
3173	* one choice. However, the check for the number of body locations	2953	* one choice. However, the check for the number of body locations
3174	* does take into the account cases where what is being applied	2954	* does take into the account cases where what is being applied
3175	* may be two handed for example.	2955	* may be two handed for example.
3176	*/	2956	*/
3177	if (ws)	2957	if (ws)
3178	{	2958	if ((who->slot[i].used - ws->slot[i].info + op->slot[i].info) >= 0)
3179	if ((who->body_used[i] - ws->body_info[i] + op->body_info[i]) >= 0)
3180	{	2959	{
3181	retval |= CAN_APPLY_UNAPPLY;	2960	retval |= CAN_APPLY_UNAPPLY;
3182	continue;	2961	continue;
3183	}	2962	}
3184	}
3185		2963
3186	tmp1 = get_item_from_body_location (who->inv, i);	2964	object *tmp1 = get_next_item_from_body_location (i, who->inv);
3187	if (!tmp1)	2965	if (!tmp1)
3188	{	2966	{
3189	#if 0	2967	#if 0
3190	/* This is sort of an error, but happens a lot when old players	2968	/* This is sort of an error, but happens a lot when old players
3191	* join in with more stuff equipped than they are now allowed.	2969	* join in with more stuff equipped than they are now allowed.
3192	*/	2970	*/
3193	LOG (llevError, "Can't find object using location %d on %s\n", i, who->name);	2971	LOG (llevError, "Can't find object using location %d on %s\n", i, who->name);
3194	#endif	2972	#endif
		2973	fprintf (stderr, "can apply never due to %d but %d - %d + %d\n",//D
		2974	i, who->slot[i].used,ws ? ws->slot[i].info :-77,op->slot[i].info);//D
3195	retval |= CAN_APPLY_NEVER;	2975	retval |= CAN_APPLY_NEVER;
3196	}	2976	}
3197	else	2977	else
3198	{	2978	{
3199	/* need to unapply something. However, if this something	2979	/* need to unapply something. However, if this something
3200	* is different than we had found before, it means they need	2980	* is different than we had found before, it means they need
3201	* to apply multiple objects	2981	* to apply multiple objects
3202	*/	2982	*/
3203	retval |= CAN_APPLY_UNAPPLY;	2983	retval |= CAN_APPLY_UNAPPLY;
		2984
3204	if (!tmp)	2985	if (!tmp)
3205	tmp = tmp1;	2986	tmp = tmp1;
3206	else if (tmp != tmp1)	2987	else if (tmp != tmp1)
3207	{
3208	retval |= CAN_APPLY_UNAPPLY_MULT;	2988	retval |= CAN_APPLY_UNAPPLY_MULT;
3209	}	2989
3210	/* This object isn't using up all the slots, so there must	2990	/* This object isn't using up all the slots, so there must
3211	* be another. If so, and it the new item doesn't need all	2991	* be another. If so, and it the new item doesn't need all
3212	* the slots, the player then has a choice.	2992	* the slots, the player then has a choice.
3213	*/	2993	*/
3214	if (((who->body_used[i] - tmp1->body_info[i]) != who->body_info[i]) && (FABS (op->body_info[i]) < who->body_info[i]))	2994	if ((who->slot[i].used - tmp1->slot[i].info != who->slot[i].info)
		2995	&& abs (op->slot[i].info) < who->slot[i].info)
3215	retval |= CAN_APPLY_UNAPPLY_CHOICE;	2996	retval |= CAN_APPLY_UNAPPLY_CHOICE;
3216		2997
3217	/* Does unequippint 'tmp1' free up enough slots for this to be	2998	/* Does unequippint 'tmp1' free up enough slots for this to be
3218	* equipped? If not, there must be something else to unapply.	2999	* equipped? If not, there must be something else to unapply.
3219	*/	3000	*/
3220	if ((who->body_used[i] + op->body_info[i] - tmp1->body_info[i]) < 0)	3001	if (who->slot[i].used + op->slot[i].info < tmp1->slot[i].info)
3221	retval |= CAN_APPLY_UNAPPLY_MULT;	3002	retval |= CAN_APPLY_UNAPPLY_MULT;
3222
3223	}	3003	}
3224	} /* if not enough free slots */	3004	} /* if not enough free slots */
3225	} /* if this object uses location i */	3005	} /* if this object uses location i */
3226	} /* for i -> num_body_locations loop */	3006	} /* for i -> num_body_locations loop */
3227		3007
…		…
3232	* and weapons all use the same slot. Similar for horn/rod/wand - they	3012	* and weapons all use the same slot. Similar for horn/rod/wand - they
3233	* all use the same location.	3013	* all use the same location.
3234	*/	3014	*/
3235	if (op->type == WEAPON && !QUERY_FLAG (who, FLAG_USE_WEAPON))	3015	if (op->type == WEAPON && !QUERY_FLAG (who, FLAG_USE_WEAPON))
3236	retval |= CAN_APPLY_RESTRICTION;	3016	retval |= CAN_APPLY_RESTRICTION;
		3017
3237	if (op->type == SHIELD && !QUERY_FLAG (who, FLAG_USE_SHIELD))	3018	if (op->type == SHIELD && !QUERY_FLAG (who, FLAG_USE_SHIELD))
3238	retval |= CAN_APPLY_RESTRICTION;	3019	retval |= CAN_APPLY_RESTRICTION;
3239		3020
3240
3241	if (who->type != PLAYER)	3021	if (who->type != PLAYER)
3242	{	3022	{
3243	if ((op->type == WAND || op->type == HORN || op->type == ROD) && !QUERY_FLAG (who, FLAG_USE_RANGE))	3023	if ((op->type == WAND || op->type == HORN || op->type == ROD) && !QUERY_FLAG (who, FLAG_USE_RANGE))
3244	retval |= CAN_APPLY_RESTRICTION;	3024	retval |= CAN_APPLY_RESTRICTION;
		3025
3245	if (op->type == BOW && !QUERY_FLAG (who, FLAG_USE_BOW))	3026	if (op->type == BOW && !QUERY_FLAG (who, FLAG_USE_BOW))
3246	retval |= CAN_APPLY_RESTRICTION;	3027	retval |= CAN_APPLY_RESTRICTION;
		3028
3247	if (op->type == RING && !QUERY_FLAG (who, FLAG_USE_RING))	3029	if (op->type == RING && !QUERY_FLAG (who, FLAG_USE_RING))
3248	retval |= CAN_APPLY_RESTRICTION;	3030	retval |= CAN_APPLY_RESTRICTION;
		3031
3249	if (op->type == BOW && !QUERY_FLAG (who, FLAG_USE_BOW))	3032	if (op->type == BOW && !QUERY_FLAG (who, FLAG_USE_BOW))
3250	retval |= CAN_APPLY_RESTRICTION;	3033	retval |= CAN_APPLY_RESTRICTION;
3251	}	3034	}
		3035
3252	return retval;	3036	return retval;
3253	}	3037	}
3254
3255
3256		3038
3257	/**	3039	/**
3258	* who is the object using the object. It can be a monster.	3040	* who is the object using the object. It can be a monster.
3259	* op is the object they are using. op is an equipment type item,	3041	* op is the object they are using. op is an equipment type item,
3260	* eg, one which you put on and keep on for a while, and not something	3042	* eg, one which you put on and keep on for a while, and not something
…		…
3279	int	3061	int
3280	apply_special (object *who, object *op, int aflags)	3062	apply_special (object *who, object *op, int aflags)
3281	{	3063	{
3282	int basic_flag = aflags & AP_BASIC_FLAGS;	3064	int basic_flag = aflags & AP_BASIC_FLAGS;
3283	object *tmp, *tmp2, *skop = NULL;	3065	object *tmp, *tmp2, *skop = NULL;
3284	int i;
3285		3066
3286	if (who == NULL)	3067	if (who == NULL)
3287	{	3068	{
3288	LOG (llevError, "apply_special() from object without environment.\n");	3069	LOG (llevError, "apply_special() from object without environment.\n");
3289	return 1;	3070	return 1;
…		…
3299	if (basic_flag == AP_APPLY)	3080	if (basic_flag == AP_APPLY)
3300	return 0;	3081	return 0;
3301		3082
3302	if (!(aflags & AP_IGNORE_CURSE) && (QUERY_FLAG (op, FLAG_CURSED) || QUERY_FLAG (op, FLAG_DAMNED)))	3083	if (!(aflags & AP_IGNORE_CURSE) && (QUERY_FLAG (op, FLAG_CURSED) || QUERY_FLAG (op, FLAG_DAMNED)))
3303	{	3084	{
3304	new_draw_info_format (NDI_UNIQUE, 0, who, "No matter how hard you try, you just can't\nremove %s.", query_name (op));	3085	new_draw_info_format (NDI_UNIQUE, 0, who, "No matter how hard you try, you just can't remove %s.", query_name (op));
3305	return 1;	3086	return 1;
3306	}	3087	}
		3088
3307	return unapply_special (who, op, aflags);	3089	return unapply_special (who, op, aflags);
3308	}	3090	}
3309		3091
3310	if (basic_flag == AP_UNAPPLY)	3092	if (basic_flag == AP_UNAPPLY)
3311	return 0;	3093	return 0;
3312		3094
3313	i = can_apply_object (who, op);	3095	// if the item is combat/ranged, wield the relevant slot first
		3096	// to resolve conflicts.
		3097	if (player *pl = who->contr)
		3098	switch (op->slottype ())
		3099	{
		3100	case slot_combat: who->change_weapon (pl->combat_ob); break;
		3101	case slot_ranged: who->change_weapon (pl->ranged_ob); break;
		3102	}
3314		3103
3315	/* 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 */
3316	if (i)	3105	if (int i = can_apply_object (who, op))
3317	{	3106	{
3318	if (i & CAN_APPLY_NEVER)	3107	if (i & CAN_APPLY_NEVER)
3319	{	3108	{
3320	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));
3321	return 1;	3110	return 1;
…		…
3323	else if (i & CAN_APPLY_RESTRICTION)	3112	else if (i & CAN_APPLY_RESTRICTION)
3324	{	3113	{
3325	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));
3326	return 1;	3115	return 1;
3327	}	3116	}
		3117
3328	if (who->type != PLAYER)	3118	if (who->type != PLAYER)
3329	{	3119	{
3330	/* Some error, so don't try to equip something more */	3120	/* Some error, so don't try to equip something more */
3331	if (unapply_for_ob (who, op, aflags))	3121	if (unapply_for_ob (who, op, aflags))
3332	return 1;	3122	return 1;
…		…
3338	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:");
3339	unapply_for_ob (who, op, AP_PRINT);	3129	unapply_for_ob (who, op, AP_PRINT);
3340	return 1;	3130	return 1;
3341	}	3131	}
3342	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))
3343	{
3344	i = unapply_for_ob (who, op, aflags);	3133	if (unapply_for_ob (who, op, aflags))
3345	if (i)
3346	return 1;	3134	return 1;
3347	}
3348	}	3135	}
3349	}	3136	}
3350		3137
3351	if (op->skill && op->type != SKILL && op->type != SKILL_TOOL)	3138	if (op->skill && op->type != SKILL && op->type != SKILL_TOOL)
3352	{	3139	{
3353	skop = find_skill_by_name (who, op->skill);	3140	skop = find_skill_by_name (who, op->skill);
		3141
3354	if (!skop)	3142	if (!skop)
3355	{	3143	{
3356	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);
3357	return 1;	3145	return 1;
3358	}	3146	}
3359	else	3147	else
3360	{
3361	/* While experience will be credited properly, we want to change the	3148	/* While experience will be credited properly, we want to change the
3362	* skill so that the dam and wc get updated	3149	* skill so that the dam and wc get updated
3363	*/	3150	*/
3364	change_skill (who, skop, 0);	3151	change_skill (who, skop, 0);
3365	}
3366	}
3367
3368	if (who->type == PLAYER && op->item_power && (op->item_power + who->contr->item_power) > (settings.item_power_factor * who->level))
3369	{	3152	}
3370	new_draw_info (NDI_UNIQUE, 0, who, "Equipping that combined with other items would consume your soul!");	3153
		3154	if (who->type == PLAYER
		3155	&& op->item_power
		3156	&& op->item_power + who->contr->item_power > settings.item_power_factor * who->level)
		3157	{
		3158	new_draw_info (NDI_UNIQUE, 0, who,
		3159	"Equipping that combined with other items would consume your soul! "
		3160	"[use the skills command to check your available item power]");
3371	return 1;	3161	return 1;
3372	}	3162	}
3373
3374		3163
3375	/* 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.
3376	* Note that we don't have the checks for can_use_...	3165	* Note that we don't have the checks for can_use_...
3377	* below - that is already taken care of by can_apply_object.	3166	* below - that is already taken care of by can_apply_object.
3378	*/	3167	*/
3379
3380
3381	if (op->nrof > 1)	3168	if (op->nrof > 1)
3382	tmp = get_split_ob (op, op->nrof - 1);	3169	tmp = get_split_ob (op, op->nrof - 1);
3383	else	3170	else
3384	tmp = NULL;	3171	tmp = 0;
3385		3172
3386	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)))
3387	return RESULT_INT (0);	3174	return RESULT_INT (0);
3388		3175
3389	switch (op->type)	3176	switch (op->type)
3390	{	3177	{
3391	case WEAPON:	3178	case WEAPON:
3392	if (!check_weapon_power (who, op->last_eat))	3179	if (!check_weapon_power (who, op->last_eat))
3393	{	3180	{
3394	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.\n"
3395	new_draw_info (NDI_UNIQUE, 0, who, "It would consume your soul!.");	3182	"It would consume your soul!.");
		3183
3396	if (tmp != NULL)	3184	if (tmp)
3397	(void) insert_ob_in_ob (tmp, who);	3185	insert_ob_in_ob (tmp, who);
		3186
3398	return 1;	3187	return 1;
3399	}	3188	}
3400		3189
3401	//TODO: this obviously fails for players using a shiorter prefix	3190	//TODO: this obviously fails for players using a shorter prefix
3402	// i.e. "R" can use Ragnarok's swors.	3191	// i.e. "R" can use Ragnarok's sword.
3403	if (op->level && (strncmp (op->name, who->name, strlen (who->name))))	3192	if (op->level && (strncmp (op->name, who->name, strlen (who->name))))
3404	{	3193	{
3405	/* 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. */
3406	/* (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) */
3407	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.");
…		…
3410	insert_ob_in_ob (tmp, who);	3199	insert_ob_in_ob (tmp, who);
3411		3200
3412	return 1;	3201	return 1;
3413	}	3202	}
3414		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
3415	SET_FLAG (op, FLAG_APPLIED);	3210	SET_FLAG (op, FLAG_APPLIED);
3416
3417	if (skop)
3418	change_skill (who, skop, 1);	3211	change_skill (who, skop, 1);
		3212
		3213	if (who->contr)
		3214	who->change_weapon (who->contr->combat_ob = op);
		3215
3419	if (!QUERY_FLAG (who, FLAG_READY_WEAPON))	3216	if (!QUERY_FLAG (who, FLAG_READY_WEAPON))
3420	SET_FLAG (who, FLAG_READY_WEAPON);	3217	SET_FLAG (who, FLAG_READY_WEAPON);
3421		3218
3422	new_draw_info_format (NDI_UNIQUE, 0, who, "You wield %s.", query_name (op));	3219	new_draw_info_format (NDI_UNIQUE, 0, who, "You wield %s.", query_name (op));
3423		3220
3424	(void) change_abil (who, op);	3221	change_abil (who, op);
3425	break;	3222	break;
3426		3223
3427	case ARMOUR:	3224	case ARMOUR:
3428	case HELMET:	3225	case HELMET:
3429	case SHIELD:	3226	case SHIELD:
…		…
3434	case CLOAK:	3231	case CLOAK:
3435	case RING:	3232	case RING:
3436	case AMULET:	3233	case AMULET:
3437	SET_FLAG (op, FLAG_APPLIED);	3234	SET_FLAG (op, FLAG_APPLIED);
3438	new_draw_info_format (NDI_UNIQUE, 0, who, "You wear %s.", query_name (op));	3235	new_draw_info_format (NDI_UNIQUE, 0, who, "You wear %s.", query_name (op));
3439	(void) change_abil (who, op);	3236	change_abil (who, op);
3440	break;	3237	break;
		3238
3441	case LAMP:	3239	case LAMP:
3442	if (op->stats.food < 1)	3240	if (op->stats.food < 1)
3443	{	3241	{
3444	new_draw_info_format (NDI_UNIQUE, 0, who, "Your %s is out of" " fuel!", &op->name);	3242	new_draw_info_format (NDI_UNIQUE, 0, who, "Your %s is out of fuel!", &op->name);
3445	return 1;	3243	return 1;
3446	}	3244	}
		3245
3447	new_draw_info_format (NDI_UNIQUE, 0, who, "You turn on your %s.", &op->name);	3246	new_draw_info_format (NDI_UNIQUE, 0, who, "You turn on your %s.", &op->name);
3448	tmp2 = arch_to_object (op->other_arch);	3247	tmp2 = arch_to_object (op->other_arch);
3449	tmp2->stats.food = op->stats.food;	3248	tmp2->stats.food = op->stats.food;
3450	SET_FLAG (tmp2, FLAG_APPLIED);	3249	SET_FLAG (tmp2, FLAG_APPLIED);
		3250
3451	if (QUERY_FLAG (op, FLAG_INV_LOCKED))	3251	if (QUERY_FLAG (op, FLAG_INV_LOCKED))
3452	SET_FLAG (tmp2, FLAG_INV_LOCKED);	3252	SET_FLAG (tmp2, FLAG_INV_LOCKED);
		3253
3453	insert_ob_in_ob (tmp2, who);	3254	insert_ob_in_ob (tmp2, who);
3454		3255
3455	/* Remove the old lantern */	3256	/* Remove the old lantern */
3456	if (who->type == PLAYER)	3257	if (who->type == PLAYER)
3457	esrv_del_item (who->contr, op->count);	3258	esrv_del_item (who->contr, op->count);
3458		3259
3459	op->destroy ();	3260	op->destroy ();
3460		3261
3461	/* insert the portion that was split off */	3262	/* insert the portion that was split off */
3462	if (tmp != NULL)	3263	if (tmp)
3463	{	3264	{
3464	(void) insert_ob_in_ob (tmp, who);	3265	insert_ob_in_ob (tmp, who);
3465	if (who->type == PLAYER)	3266	if (who->type == PLAYER)
3466	esrv_send_item (who, tmp);	3267	esrv_send_item (who, tmp);
3467	}	3268	}
		3269
3468	who->update_stats ();	3270	who->update_stats ();
		3271
3469	if (QUERY_FLAG (op, FLAG_CURSED) || QUERY_FLAG (op, FLAG_DAMNED))	3272	if (QUERY_FLAG (op, FLAG_CURSED) || QUERY_FLAG (op, FLAG_DAMNED))
3470	{
3471	if (who->type == PLAYER)	3273	if (who->type == PLAYER)
3472	{	3274	{
3473	new_draw_info (NDI_UNIQUE, 0, who, "Oops, it feels deadly cold!");	3275	new_draw_info (NDI_UNIQUE, 0, who, "Oops, it feels deadly cold!");
3474	SET_FLAG (tmp2, FLAG_KNOWN_CURSED);	3276	SET_FLAG (tmp2, FLAG_KNOWN_CURSED);
3475	}	3277	}
3476	}	3278
3477	if (who->type == PLAYER)	3279	if (who->type == PLAYER)
3478	esrv_send_item (who, tmp2);	3280	esrv_send_item (who, tmp2);
		3281
3479	return 0;	3282	return 0;
		3283
		3284	case SKILL_TOOL:
		3285	// applying a skill tool also readies the skill
		3286	SET_FLAG (op, FLAG_APPLIED);
		3287	skop = find_skill_by_name (who, op->skill);
		3288	if (!skop->flag [FLAG_APPLIED])
		3289	apply_special (who, skop, AP_APPLY);
3480	break;	3290	break;
3481		3291
3482	/* this part is needed for skill-tools */
3483	case SKILL:	3292	case SKILL:
3484	case SKILL_TOOL:
3485	if (who->chosen_skill)	3293	if (who->chosen_skill)
3486	{	3294	{
3487	LOG (llevError, "BUG: apply_special(): can't apply two skills\n");	3295	LOG (llevError, "BUG: apply_special(): can't apply two skills\n");
3488	return 1;	3296	return 1;
3489	}	3297	}
3490	if (who->type == PLAYER)	3298
		3299	if (player *pl = who->contr)
		3300	{
		3301	if (IS_COMBAT_SKILL (op->subtype))
3491	{	3302	{
3492	who->contr->shoottype = range_skill;	3303	if (skill_flags [op->subtype] & SF_NEED_WEAPON)
3493	who->contr->ranges[range_skill] = op;	3304	{
		3305	for (object *item = who->inv; item; item = item->below)
		3306	if (item->type == WEAPON && item->flag [FLAG_APPLIED])
		3307	{
		3308	who->change_weapon (pl->combat_ob = item);
		3309	goto found_weapon;
		3310	}
		3311
		3312	new_draw_info (NDI_UNIQUE, 0, who, "You need to apply a melee weapon before readying this skill");
		3313	return 1;
		3314
		3315	found_weapon:;
		3316	}
		3317	else
		3318	who->change_weapon (pl->combat_ob = op);
		3319	}
		3320	else if (IS_RANGED_SKILL (op->subtype))
		3321	{
		3322	if (skill_flags [op->subtype] & SF_NEED_BOW)
		3323	{
		3324	for (object *item = who->inv; item; item = item->below)
		3325	if (item->type == BOW && item->flag [FLAG_APPLIED])
		3326	{
		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 if (skill_flags [op->subtype] & SF_NEED_ITEM)
		3337	{
		3338	for (object *item = who->inv; item; item = item->below)
		3339	if (item->flag [FLAG_APPLIED]
		3340	&& (item->type == WAND || item->type == ROD || item->type == HORN))
		3341	{
		3342	who->change_weapon (pl->ranged_ob = item);
		3343	goto found_item;
		3344	}
		3345
		3346	new_draw_info (NDI_UNIQUE, 0, who, "You need to apply a magic item before readying this skill");
		3347	return 1;
		3348
		3349	found_item:;
		3350	}
		3351	else
		3352	who->change_weapon (pl->ranged_ob = op);
		3353	}
		3354
3494	if (!op->invisible)	3355	if (!op->invisible)
3495	{	3356	{
3496	new_draw_info_format (NDI_UNIQUE, 0, who, "You ready %s.", query_name (op));	3357	new_draw_info_format (NDI_UNIQUE, 0, who, "You ready %s.", query_name (op));
3497	new_draw_info_format (NDI_UNIQUE, 0, who, "You can now use the skill: %s.", &op->skill);	3358	new_draw_info_format (NDI_UNIQUE, 0, who, "You can now use the skill: %s.", &op->skill);
3498	}	3359	}
3499	else	3360	else
3500	{
3501	new_draw_info_format (NDI_UNIQUE, 0, who, "Readied skill: %s.", op->skill ? &op->skill : &op->name);	3361	new_draw_info_format (NDI_UNIQUE, 0, who, "Readied skill: %s.", op->skill ? &op->skill : &op->name);
3502	}	3362	}
3503	}	3363
3504	SET_FLAG (op, FLAG_APPLIED);	3364	SET_FLAG (op, FLAG_APPLIED);
3505	(void) change_abil (who, op);	3365	change_abil (who, op);
3506	who->chosen_skill = op;	3366	who->chosen_skill = op;
3507	SET_FLAG (who, FLAG_READY_SKILL);	3367	SET_FLAG (who, FLAG_READY_SKILL);
3508	break;	3368	break;
3509		3369
3510	case BOW:	3370	case BOW:
3511	if (!check_weapon_power (who, op->last_eat))	3371	if (!check_weapon_power (who, op->last_eat))
3512	{	3372	{
3513	new_draw_info (NDI_UNIQUE, 0, who, "That item is too powerful for you to use.");	3373	new_draw_info (NDI_UNIQUE, 0, who, "That weapon is too powerful for you to use.");
3514	new_draw_info (NDI_UNIQUE, 0, who, "It would consume your soul!.");	3374	new_draw_info (NDI_UNIQUE, 0, who, "It would consume your soul!.");
		3375
3515	if (tmp != NULL)	3376	if (tmp)
3516	(void) insert_ob_in_ob (tmp, who);	3377	insert_ob_in_ob (tmp, who);
		3378
3517	return 1;	3379	return 1;
3518	}	3380	}
		3381
3519	if (op->level && (strncmp (op->name, who->name, strlen (who->name))))	3382	if (op->level && (strncmp (op->name, who->name, strlen (who->name))))
3520	{	3383	{
3521	new_draw_info (NDI_UNIQUE, 0, who, "The weapon does not recognize you as its owner.");	3384	new_draw_info (NDI_UNIQUE, 0, who, "The weapon does not recognize you as its owner.");
3522	if (tmp != NULL)	3385	if (tmp)
3523	(void) insert_ob_in_ob (tmp, who);	3386	insert_ob_in_ob (tmp, who);
		3387
3524	return 1;	3388	return 1;
3525	}	3389	}
		3390
3526	/*FALLTHROUGH*/ case WAND:	3391	/*FALLTHROUGH*/
		3392	case WAND:
3527	case ROD:	3393	case ROD:
3528	case HORN:	3394	case HORN:
3529	/* check for skill, alter player status */	3395	/* check for skill, alter player status */
		3396
		3397	if (!skop)
		3398	{
		3399	new_draw_info_format (NDI_UNIQUE, 0, who, "The %s is broken, please report this to the dungeon master!", query_name (op));//TODO
		3400	return 1;
		3401	}
		3402
3530	SET_FLAG (op, FLAG_APPLIED);	3403	SET_FLAG (op, FLAG_APPLIED);
3531	if (skop)
3532	change_skill (who, skop, 0);	3404	change_skill (who, skop, 0);
		3405
		3406	if (who->contr)
		3407	{
		3408	who->contr->ranged_ob = op;
		3409
3533	new_draw_info_format (NDI_UNIQUE, 0, who, "You ready %s.", query_name (op));	3410	new_draw_info_format (NDI_UNIQUE, 0, who, "You ready %s.", query_name (op));
3534		3411
3535	if (who->type == PLAYER)
3536	{
3537	if (op->type == BOW)	3412	if (op->type == BOW)
3538	{	3413	{
		3414	who->current_weapon = op;
3539	(void) change_abil (who, op);	3415	change_abil (who, op);
3540	new_draw_info_format (NDI_UNIQUE, 0, who,	3416	new_draw_info_format (NDI_UNIQUE, 0, who,
3541	"You will now fire %s with %s.", op->race ? &op->race : "nothing", query_name (op));	3417	"You will now fire %s with %s.", op->race ? &op->race : "nothing", query_name (op));
3542	who->contr->shoottype = range_bow;
3543	}
3544	else
3545	{
3546	who->contr->shoottype = range_misc;
3547	}	3418	}
3548	}	3419	}
3549	else	3420	else
3550	{	3421	{
3551	if (op->type == BOW)	3422	if (op->type == BOW)
3552	SET_FLAG (who, FLAG_READY_BOW);	3423	SET_FLAG (who, FLAG_READY_BOW);
3553	else	3424	else
3554	SET_FLAG (who, FLAG_READY_RANGE);	3425	SET_FLAG (who, FLAG_READY_RANGE);
3555	}	3426	}
		3427
3556	break;	3428	break;
3557		3429
3558	case BUILDER:	3430	case BUILDER:
3559	if (who->contr->ranges[range_builder])	3431	if (who->type == PLAYER)
		3432	{
		3433	if (who->contr->ranged_ob && who->contr->ranged_ob->type == BUILDER)
3560	unapply_special (who, who->contr->ranges[range_builder], 0);	3434	unapply_special (who, who->contr->ranged_ob, 0);
3561	who->contr->shoottype = range_builder;	3435
3562	who->contr->ranges[range_builder] = op;
3563	new_draw_info_format (NDI_UNIQUE, 0, who, "You ready your %s.", query_name (op));	3436	new_draw_info_format (NDI_UNIQUE, 0, who, "You ready your %s.", query_name (op));
		3437
		3438	who->contr->ranged_ob = op;
		3439	}
3564	break;	3440	break;
3565		3441
3566	default:	3442	default:
3567	new_draw_info_format (NDI_UNIQUE, 0, who, "You apply %s.", query_name (op));	3443	new_draw_info_format (NDI_UNIQUE, 0, who, "You apply %s.", query_name (op));
3568	} /* end of switch op->type */	3444	} /* end of switch op->type */
3569		3445
3570	SET_FLAG (op, FLAG_APPLIED);	3446	SET_FLAG (op, FLAG_APPLIED);
3571		3447
3572	if (tmp != NULL)	3448	if (tmp)
3573	tmp = insert_ob_in_ob (tmp, who);	3449	tmp = insert_ob_in_ob (tmp, who);
3574		3450
3575	who->update_stats ();	3451	who->update_stats ();
3576		3452
3577	/* We exclude spell casting objects. The fire code will set the	3453	/* We exclude spell casting objects. The fire code will set the
…		…
3587	{	3463	{
3588	new_draw_info (NDI_UNIQUE, 0, who, "Oops, it feels deadly cold!");	3464	new_draw_info (NDI_UNIQUE, 0, who, "Oops, it feels deadly cold!");
3589	SET_FLAG (op, FLAG_KNOWN_CURSED);	3465	SET_FLAG (op, FLAG_KNOWN_CURSED);
3590	}	3466	}
3591	}	3467	}
		3468
3592	if (who->type == PLAYER)	3469	if (who->type == PLAYER)
3593	{	3470	{
3594	/* if multiple objects were applied, update both slots */	3471	/* if multiple objects were applied, update both slots */
3595	if (tmp)	3472	if (tmp)
3596	esrv_send_item (who, tmp);	3473	esrv_send_item (who, tmp);
		3474
3597	esrv_send_item (who, op);	3475	esrv_send_item (who, op);
3598	}	3476	}
		3477
3599	return 0;	3478	return 0;
3600	}	3479	}
3601
3602		3480
3603	int	3481	int
3604	monster_apply_special (object *who, object *op, int aflags)	3482	monster_apply_special (object *who, object *op, int aflags)
3605	{	3483	{
3606	if (QUERY_FLAG (op, FLAG_UNPAID) && !QUERY_FLAG (op, FLAG_APPLIED))	3484	if (QUERY_FLAG (op, FLAG_UNPAID) && !QUERY_FLAG (op, FLAG_APPLIED))
…		…
3677	}	3555	}
3678	return tmp ? 1 : 0;	3556	return tmp ? 1 : 0;
3679	}	3557	}
3680		3558
3681	/**	3559	/**
3682	* fix_auto_apply goes through the entire map (only the first time	3560	* fix_auto_apply goes through the entire map every time a map
3683	* when an original map is loaded) and performs special actions for	3561	* is loaded or swapped in and performs special actions for
3684	* certain objects (most initialization of chests and creation of	3562	* certain objects (most initialization of chests and creation of
3685	* treasures and stuff). Calls auto_apply if appropriate.	3563	* treasures and stuff). Calls auto_apply if appropriate.
3686	*/	3564	*/
3687	void	3565	void
3688	maptile::fix_auto_apply ()	3566	maptile::fix_auto_apply ()
…		…
3766	{	3644	{
3767	create_treasure (tmp->randomitems, tmp, GT_APPLY, difficulty, 0);	3645	create_treasure (tmp->randomitems, tmp, GT_APPLY, difficulty, 0);
3768	tmp->randomitems = NULL;	3646	tmp->randomitems = NULL;
3769	}	3647	}
3770		3648
		3649	// close all containers
		3650	else if (tmp->type == CONTAINER)
		3651	tmp->flag [FLAG_APPLIED] = 0;
		3652
3771	tmp = above;	3653	tmp = above;
3772	}	3654	}
3773		3655
3774	for (mapspace *ms = spaces + size (); ms-- > spaces; )	3656	for (mapspace *ms = spaces + size (); ms-- > spaces; )
3775	for (object *tmp = ms->bot; tmp; tmp = tmp->above)	3657	for (object *tmp = ms->bot; tmp; tmp = tmp->above)
…		…
3781	* Handles player eating food that temporarily changes status (resistances, stats).	3663	* Handles player eating food that temporarily changes status (resistances, stats).
3782	* This used to call cast_change_attr(), but	3664	* This used to call cast_change_attr(), but
3783	* that doesn't work with the new spell code. Since we know what	3665	* that doesn't work with the new spell code. Since we know what
3784	* the food changes, just grab a force and use that instead.	3666	* the food changes, just grab a force and use that instead.
3785	*/	3667	*/
3786
3787	void	3668	void
3788	eat_special_food (object *who, object *food)	3669	eat_special_food (object *who, object *food)
3789	{	3670	{
3790	object *force;	3671	object *force;
3791	int i, did_one = 0;	3672	int i, did_one = 0;
3792	sint8 k;
3793		3673
3794	force = get_archetype (FORCE_NAME);	3674	force = get_archetype (FORCE_NAME);
3795		3675
3796	for (i = 0; i < NUM_STATS; i++)	3676	for (i = 0; i < NUM_STATS; i++)
3797	{	3677	if (sint8 k = food->stats.stat (i))
3798	k = get_attr_value (&food->stats, i);
3799	if (k)
3800	{	3678	{
3801	set_attr_value (&force->stats, i, k);	3679	force->stats.stat (i) = k;
3802	did_one = 1;	3680	did_one = 1;
3803	}	3681	}
3804	}
3805		3682
3806	/* check if we can protect the eater */	3683	/* check if we can protect the eater */
3807	for (i = 0; i < NROFATTACKS; i++)	3684	for (i = 0; i < NROFATTACKS; i++)
3808	{	3685	{
3809	if (food->resist[i] > 0)	3686	if (food->resist[i] > 0)
…		…
3970	new_draw_info (NDI_UNIQUE, 0, op, "The magic recoils on you!");	3847	new_draw_info (NDI_UNIQUE, 0, op, "The magic recoils on you!");
3971	blind_player (op, op, power);	3848	blind_player (op, op, power);
3972	}	3849	}
3973	else if (failure <= -80)	3850	else if (failure <= -80)
3974	{ /* blast the immediate area */	3851	{ /* blast the immediate area */
3975	object *tmp;
3976
3977	tmp = get_archetype (LOOSE_MANA);	3852	object *tmp = get_archetype (LOOSE_MANA);
3978	cast_magic_storm (op, tmp, power);	3853	cast_magic_storm (op, tmp, power);
3979	new_draw_info (NDI_UNIQUE, 0, op, "You unlease uncontrolled mana!");	3854	new_draw_info (NDI_UNIQUE, 0, op, "You unleash uncontrolled mana!");
3980	tmp->destroy ();	3855	tmp->destroy ();
3981	}	3856	}
3982	}	3857	}
3983	}	3858	}
3984		3859
…		…
4004	*/	3879	*/
4005	int i, j;	3880	int i, j;
4006		3881
4007	for (i = 0; i < NUM_STATS; i++)	3882	for (i = 0; i < NUM_STATS; i++)
4008	{	3883	{
4009	sint8 stat = get_attr_value (stats, i);
4010	int race_bonus = get_attr_value (&(pl->arch->clone.stats), i);	3884	int race_bonus = pl->arch->clone.stats.stat (i);
		3885	sint8 stat = stats->stat (i) + ns->stat (i);
4011		3886
4012	stat += get_attr_value (ns, i);
4013	if (stat > 20 + race_bonus)	3887	if (stat > 20 + race_bonus)
4014	{	3888	{
4015	excess_stat++;	3889	excess_stat++;
4016	stat = 20 + race_bonus;	3890	stat = 20 + race_bonus;
4017	}	3891	}
4018	set_attr_value (stats, i, stat);	3892
		3893	stats->stat (i) = stat;
4019	}	3894	}
4020		3895
4021	for (j = 0; excess_stat > 0 && j < 100; j++)	3896	for (j = 0; excess_stat > 0 && j < 100; j++)
4022	{ /* try 100 times to assign excess stats */	3897	{ /* try 100 times to assign excess stats */
4023	int i = rndm (0, 6);	3898	int i = rndm (0, 6);
4024	int stat = get_attr_value (stats, i);
4025	int race_bonus = get_attr_value (&(pl->arch->clone.stats), i);
4026		3899
4027	if (i == CHA)	3900	if (i == CHA)
4028	continue; /* exclude cha from this */	3901	continue; /* exclude cha from this */
		3902
		3903	int stat = stats->stat (i);
		3904	int race_bonus = pl->arch->clone.stats.stat (i);
4029	if (stat < 20 + race_bonus)	3905	if (stat < 20 + race_bonus)
4030	{	3906	{
4031	change_attr_value (stats, i, 1);	3907	change_attr_value (stats, i, 1);
4032	excess_stat--;	3908	excess_stat--;
4033	}	3909	}
…		…
4036	/* insert the randomitems from the change's treasurelist into	3912	/* insert the randomitems from the change's treasurelist into
4037	* the player ref: player.c	3913	* the player ref: player.c
4038	*/	3914	*/
4039	if (change->randomitems != NULL)	3915	if (change->randomitems != NULL)
4040	give_initial_items (pl, change->randomitems);	3916	give_initial_items (pl, change->randomitems);
4041
4042		3917
4043	/* set up the face, for some races. */	3918	/* set up the face, for some races. */
4044		3919
4045	/* first, look for the force object banning	3920	/* first, look for the force object banning
4046	* changing the face. Certain races never change face with class.	3921	* changing the face. Certain races never change face with class.

Diff Legend

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