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.169 by root, Sun Sep 7 21:31:23 2008 UTC vs.
Revision 1.200 by root, Sun Oct 11 18:18:04 2009 UTC

…		…
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, see <http://www.gnu.org/licenses/>.	19	* along with this program. If not, see <http://www.gnu.org/licenses/>.
20	*	20	*
21	* The authors can be reached via e-mail to <support@deliantra.net>	21	* The authors can be reached via e-mail to <support@deliantra.net>
22	*/	22	*/
23		23
24	#include <cmath>	24	#include <cmath>
25		25
…		…
92	* Return value: 1 if money was destroyed, 0 if not.	92	* Return value: 1 if money was destroyed, 0 if not.
93	*/	93	*/
94	static int	94	static int
95	apply_id_altar (object *money, object *altar, object *pl)	95	apply_id_altar (object *money, object *altar, object *pl)
96	{	96	{
97	dynbuf_text buf;	97	dynbuf_text &buf = msg_dynbuf; buf.clear ();
98		98
99	if (!pl || pl->type != PLAYER)	99	if (!pl || pl->type != PLAYER)
100	return 0;	100	return 0;
101		101
102	/* Check for MONEY type is a special hack - it prevents 'nothing needs	102	/* Check for MONEY type is a special hack - it prevents 'nothing needs
103	* identifying' from being printed out more than it needs to be.	103	* identifying' from being printed out more than it needs to be.
104	*/	104	*/
105	if (!check_altar_sacrifice (altar, money) || money->type != MONEY)	105	if (!check_altar_sacrifice (altar, money, pl) || money->type != MONEY)
106	return 0;	106	return 0;
107		107
108	/* if the player has a marked item, identify that if it needs to be	108	/* if the player has a marked item, identify that if it needs to be
109	* identified. If it doesn't, then go through the player inventory.	109	* identified. If it doesn't, then go through the player inventory.
110	*/	110	*/
111	if (object *marked = find_marked_object (pl))	111	if (object *marked = find_marked_object (pl))
112	if (!QUERY_FLAG (marked, FLAG_IDENTIFIED) && need_identify (marked))	112	if (!QUERY_FLAG (marked, FLAG_IDENTIFIED) && need_identify (marked))
113	{	113	{
114	if (operate_altar (altar, &money))	114	if (operate_altar (altar, &money, pl))
115	{	115	{
116	identify (marked);	116	identify (marked);
117		117
118	buf.printf ("You have %s.\r", long_desc (marked, pl));	118	buf.printf ("You have %s.\r", long_desc (marked, pl));
119	if (marked->msg)	119	if (marked->msg)
…		…
125		125
126	for (object *id = pl->inv; id; id = id->below)	126	for (object *id = pl->inv; id; id = id->below)
127	{	127	{
128	if (!QUERY_FLAG (id, FLAG_IDENTIFIED) && !id->invisible && need_identify (id))	128	if (!QUERY_FLAG (id, FLAG_IDENTIFIED) && !id->invisible && need_identify (id))
129	{	129	{
130	if (operate_altar (altar, &money))	130	if (operate_altar (altar, &money, pl))
131	{	131	{
132	identify (id);	132	identify (id);
133		133
134	buf.printf ("You have %s.\r", long_desc (id, pl));	134	buf.printf ("You have %s.\r", long_desc (id, pl));
135	if (id->msg)	135	if (id->msg)
…		…
160	* matching item.	160	* matching item.
161	**/	161	**/
162	void	162	void
163	handle_apply_yield (object *tmp)	163	handle_apply_yield (object *tmp)
164	{	164	{
165	if (shstr yield = tmp->kv (shstr_on_use_yield))	165	if (shstr_tmp yield = tmp->kv (shstr_on_use_yield))
166	archetype::get (yield)->insert_at (tmp, tmp, INS_BELOW_ORIGINATOR);	166	archetype::get (yield)->insert_at (tmp, tmp, INS_BELOW_ORIGINATOR);
167	}	167	}
168		168
169	/**	169	/**
170	* Handles applying a potion.	170	* Handles applying a potion.
…		…
315	*/	315	*/
316	if (tmp->inv)	316	if (tmp->inv)
317	{	317	{
318	if (QUERY_FLAG (tmp, FLAG_CURSED) || QUERY_FLAG (tmp, FLAG_DAMNED))	318	if (QUERY_FLAG (tmp, FLAG_CURSED) || QUERY_FLAG (tmp, FLAG_DAMNED))
319	{	319	{
320	object *fball;
321
322	op->failmsg ("Yech! Your lungs are on fire!");	320	op->failmsg ("Yech! Your lungs are on fire!");
323		321	create_exploding_ball_at (op, op->level);
324	/* Explodes a fireball centered at player */
325	fball = get_archetype (EXPLODING_FIREBALL);
326	fball->dam_modifier = random_roll (1, op->level, op, PREFER_LOW) / 5 + 1;
327	fball->stats.maxhp = random_roll (1, op->level, op, PREFER_LOW) / 10 + 2;
328	fball->x = op->x;
329	fball->y = op->y;
330	insert_ob_in_map (fball, op->map, NULL, 0);
331	}	322	}
332	else	323	else
333	cast_spell (op, tmp, op->facing, tmp->inv, NULL);	324	cast_spell (op, tmp, op->facing, tmp->inv, NULL);
334		325
335	tmp->decrease ();	326	tmp->decrease ();
…		…
378	}	369	}
379		370
380	/* Only thing left are the stat potions */	371	/* Only thing left are the stat potions */
381	if (op->type == PLAYER)	372	if (op->type == PLAYER)
382	{ /* only for players */	373	{ /* only for players */
383	if ((QUERY_FLAG (tmp, FLAG_CURSED) || QUERY_FLAG (tmp, FLAG_DAMNED)) && tmp->value != 0)	374	if ((QUERY_FLAG (tmp, FLAG_CURSED)
		375	|| QUERY_FLAG (tmp, FLAG_DAMNED))
		376	&& tmp->value != 0)
384	CLEAR_FLAG (tmp, FLAG_APPLIED);	377	CLEAR_FLAG (tmp, FLAG_APPLIED);
385	else	378	else
386	SET_FLAG (tmp, FLAG_APPLIED);	379	SET_FLAG (tmp, FLAG_APPLIED);
387		380
388	if (!change_abil (op, tmp))	381	if (!change_abil (op, tmp))
…		…
403	/****************************************************************************	396	/****************************************************************************
404	* Weapon improvement code follows	397	* Weapon improvement code follows
405	****************************************************************************/	398	****************************************************************************/
406		399
407	/**	400	/**
		401	* This function just checks whether who can handle equipping an item
		402	* with item_power.
		403	*/
		404
		405	bool
		406	check_item_power (object *who, int item_power)
		407	{
		408	if (who->type == PLAYER
		409	&& item_power
		410	&& item_power + who->contr->item_power > settings.item_power_factor * who->level)
		411	return false;
		412	else
		413	return true;
		414	}
		415
		416	/**
408	* This returns the sum of nrof of item (arch name).	417	* This returns the sum of nrof of item (arch name).
409	*/	418	*/
410	static int	419	static int
411	check_item (object *op, const char *item)	420	check_item (object *op, shstr_cmp item)
412	{	421	{
413	int count = 0;	422	int count = 0;
414		423
415	if (!item)	424	if (!item)
416	return 0;	425	return 0;
417		426
418	for (op = op->below; op; op = op->below)	427	for (op = op->below; op; op = op->below)
419	{
420	if (strcmp (op->arch->archname, item) == 0)	428	if (op->arch->archname == item)
421	{
422	if (!QUERY_FLAG (op, FLAG_CURSED) && !QUERY_FLAG (op, FLAG_DAMNED)	429	if (!QUERY_FLAG (op, FLAG_CURSED) && !QUERY_FLAG (op, FLAG_DAMNED)
423	/* Loophole bug? -FD- */ && !QUERY_FLAG (op, FLAG_UNPAID))	430	&& /* Loophole bug? -FD- */ !QUERY_FLAG (op, FLAG_UNPAID))
424	{
425	if (op->nrof == 0) /* this is necessary for artifact sacrifices --FD-- */
426	count++;
427	else
428	count += op->nrof;	431	count += op->number_of ();
429	}
430	}
431	}
432		432
433	return count;	433	return count;
434	}	434	}
435		435
436	/**	436	/**
…		…
438	* op is typically the player, which is only	438	* op is typically the player, which is only
439	* really used to determine what space to look at.	439	* really used to determine what space to look at.
440	* Modified to only eat 'nrof' of objects.	440	* Modified to only eat 'nrof' of objects.
441	*/	441	*/
442	static void	442	static void
443	eat_item (object *op, const char *item, uint32 nrof)	443	eat_item (object *op, shstr_cmp item, uint32 nrof)
444	{	444	{
445	object *prev;	445	object *prev;
446		446
447	prev = op;	447	prev = op;
448	op = op->below;	448	op = op->below;
449		449
450	while (op)	450	while (op)
451	{	451	{
452	if (strcmp (op->arch->archname, item) == 0)	452	if (op->arch->archname == item)
453	{	453	{
454	if (op->nrof >= nrof)	454	if (op->nrof >= nrof)
455	{	455	{
456	op->decrease (nrof);	456	op->decrease (nrof);
457	return;	457	return;
…		…
466	}	466	}
467		467
468	prev = op;	468	prev = op;
469	op = op->below;	469	op = op->below;
470	}	470	}
471	}
472
473	/**
474	* This checks to see of the player (who) is sufficient level to use a weapon
475	* with improvs improvements (typically last_eat). We take an int here
476	* instead of the object so that the improvement code can pass along the
477	* increased value to see if the object is usuable.
478	* we return 1 (true) if the player can use the weapon.
479	*/
480	static int
481	check_weapon_power (const object *who, int improvs)
482	{
483	/* Old code is below (commented out). Basically, since weapons are the only
484	* object players really have any control to improve, it's a bit harsh to
485	* require high level in some combat skill, so we just use overall level.
486	*/
487	#if 1
488	if (((who->level / 5) + 5) >= improvs)
489	return 1;
490	else
491	return 0;
492
493	#else
494	int level = 0;
495
496	/* The skill system hands out wc and dam bonuses to fighters
497	* more generously than the old system (see fix_player). Thus
498	* we need to curtail the power of player enchanted weapons.
499	* I changed this to 1 improvement per "fighter" level/5 -b.t.
500	* Note: Nothing should break by allowing this ratio to be different or
501	* using normal level - it is just a matter of play balance.
502	*/
503	if (who->type == PLAYER)
504	{
505	object *wc_obj = NULL;
506
507	for (wc_obj = who->inv; wc_obj; wc_obj = wc_obj->below)
508	if (wc_obj->type == SKILL && IS_COMBAT_SKILL (wc_obj->subtype) && wc_obj->level > level)
509	level = wc_obj->level;
510
511	if (!level)
512	{
513	LOG (llevError, "Error: Player: %s lacks wc experience object\n", who->name);
514	level = who->level;
515	}
516	}
517	else
518	level = who->level;
519
520	return (improvs <= ((level / 5) + 5));
521	#endif
522	}	471	}
523		472
524	/**	473	/**
525	* Returns how many items of type improver->slaying there are under op.	474	* Returns how many items of type improver->slaying there are under op.
526	* Will display a message if none found, and 1 if improver->slaying is NULL.	475	* Will display a message if none found, and 1 if improver->slaying is NULL.
…		…
655	if (improver->stats.sp == IMPROVE_PREPARE)	604	if (improver->stats.sp == IMPROVE_PREPARE)
656	return prepare_weapon (op, improver, weapon);	605	return prepare_weapon (op, improver, weapon);
657		606
658	if (weapon->level == 0)	607	if (weapon->level == 0)
659	{	608	{
660	op->failmsg ("This weapon has not been prepared. H<You first ahve to prepare a weapon with a prepare weapon scroll.>");	609	op->failmsg (
		610	"This weapon has not been prepared."
		611	" H<You first have to prepare a weapon with a prepare weapon scroll.>");
661	return 0;	612	return 0;
662	}	613	}
663		614
664	if (weapon->level == weapon->last_eat && weapon->item_power >= 100)	615	if (weapon->last_eat >= weapon->level // improvements used up
		616	|| weapon->item_power >= 100) // or item_power >= arbitrary limit of 100
665	{	617	{
666	op->failmsg ("This weapon cannot be improved any more.");	618	op->failmsg ("This weapon cannot be improved any more.");
667	return 0;	619	return 0;
668	}	620	}
669		621
670	if (QUERY_FLAG (weapon, FLAG_APPLIED) && !check_weapon_power (op, weapon->last_eat + 1))	622	if (QUERY_FLAG (weapon, FLAG_APPLIED)
		623	&& !check_item_power (op, weapon->item_power + 1))
671	{	624	{
672	op->failmsg ("Improving the weapon will make it too "	625	op->failmsg ("Improving the weapon will make it too "
673	"powerful for you to use. Unready it if you "	626	"powerful for you to use. Unready it if you "
674	"really want to improve it.");	627	"really want to improve it.");
675	return 0;	628	return 0;
…		…
904	* Takes one type of items and makes another.	857	* Takes one type of items and makes another.
905	* converter is the object that is doing the conversion.	858	* converter is the object that is doing the conversion.
906	* item is the object that triggered the converter - if it is not	859	* item is the object that triggered the converter - if it is not
907	* what the converter wants, this will not do anything.	860	* what the converter wants, this will not do anything.
908	*/	861	*/
909	static int	862	int
910	convert_item (object *item, object *converter)	863	convert_item (object *item, object *converter)
911	{	864	{
912	sint64 nr, price_in;	865	sint64 nr, price_in;
913		866
914	if (item->flag [FLAG_UNPAID])	867	if (item->flag [FLAG_UNPAID])
…		…
995	item->nrof = give;	948	item->nrof = give;
996		949
997	if (nr)	950	if (nr)
998	item->nrof *= nr;	951	item->nrof *= nr;
999		952
1000	if (is_in_shop (converter))	953	if (converter->flag [FLAG_PRECIOUS])
1001	SET_FLAG (item, FLAG_UNPAID);	954	SET_FLAG (item, FLAG_UNPAID);
		955
		956	if (is_in_shop (converter))
		957	{
		958	// converters on shop floors don't work anymore, bug lets check for it
		959	// and report in case someone still does it.
		960	LOG (llevDebug, "ITEMBUG: broken converter, converters on shop floor don't work: %s\n",
		961	converter->debug_desc ());
		962	SET_FLAG (item, FLAG_UNPAID);
		963	}
1002	else if (price_in < sint64 (item->nrof) * item->value)	964	else if (price_in < sint64 (item->nrof) * item->value)
1003	{	965	{
1004	LOG (llevDebug, "converter output price higher than input: %s at %s (%d, %d) in value %d, out value %d for %s\n",	966	LOG (llevDebug, "converter output price higher than input: %s at %s (%d, %d) in value %d, out value %d for %s\n",
1005	&converter->name, &converter->map->path, converter->x, converter->y, price_in, item->nrof * item->value, &item->name);	967	&converter->name, &converter->map->path, converter->x, converter->y, price_in, item->nrof * item->value, &item->name);
1006	/**	968	/**
…		…
1098	{	1060	{
1099	/* Only players can make sacrifices on spell casting altars. */	1061	/* Only players can make sacrifices on spell casting altars. */
1100	if (altar->inv && (!originator || originator->type != PLAYER))	1062	if (altar->inv && (!originator || originator->type != PLAYER))
1101	return 0;	1063	return 0;
1102		1064
1103	if (operate_altar (altar, &sacrifice))	1065	if (operate_altar (altar, &sacrifice, originator))
1104	{	1066	{
1105	/* Simple check. Unfortunately, it means you can't cast magic bullet	1067	/* Simple check. Unfortunately, it means you can't cast magic bullet
1106	* with an altar. We call it a Potion - altars are stationary - it	1068	* with an altar. We call it a Potion - altars are stationary - it
1107	* is up to map designers to use them properly.	1069	* is up to map designers to use them properly.
1108	*/	1070	*/
…		…
1117	/* push_button (altar);*/	1079	/* push_button (altar);*/
1118	}	1080	}
1119	else	1081	else
1120	{	1082	{
1121	altar->value = 1; /* works only once */	1083	altar->value = 1; /* works only once */
1122	push_button (altar);	1084	push_button (altar, originator);
1123	}	1085	}
1124		1086
1125	return !sacrifice;	1087	return !sacrifice;
1126	}	1088	}
1127	else	1089	else
…		…
1144		1106
1145	SET_FLAG (op, FLAG_NO_APPLY); /* prevent loops */	1107	SET_FLAG (op, FLAG_NO_APPLY); /* prevent loops */
1146		1108
1147	bool has_unpaid = false;	1109	bool has_unpaid = false;
1148		1110
1149	// quite inefficient to do this here twice, but the api doesn'T lend itself to	1111	// quite inefficient to do this here twice, but the api doesn't lend itself to
1150	// a quick and small change :(	1112	// a quick and small change :(
1151	for (object::depth_iterator item = op->begin (); item != op->end (); ++item)	1113	for (object::depth_iterator item = op->begin (); item != op->end (); ++item)
1152	if (item->flag [FLAG_UNPAID])	1114	if (item->flag [FLAG_UNPAID])
1153	{	1115	{
1154	has_unpaid = true;	1116	has_unpaid = true;
1155	break;	1117	break;
1156	}	1118	}
1157		1119
1158	if (op->type != PLAYER)	1120	if (!op->is_player ())
1159	{	1121	{
1160	/* Remove all the unpaid objects that may be carried here.	1122	/* Remove all the unpaid objects that may be carried here.
1161	* This could be pets or monsters that are somehow in	1123	* This could be pets or monsters that are somehow in
1162	* the shop.	1124	* the shop.
1163	*/	1125	*/
…		…
1167		1129
1168	if (QUERY_FLAG (tmp, FLAG_UNPAID))	1130	if (QUERY_FLAG (tmp, FLAG_UNPAID))
1169	{	1131	{
1170	int i = find_free_spot (tmp, op->map, op->x, op->y, 1, 9);	1132	int i = find_free_spot (tmp, op->map, op->x, op->y, 1, 9);
1171		1133
		1134	if (i >= 0)
1172	tmp->remove ();	1135	tmp->move (i);
1173
1174	if (i == -1)
1175	i = 0;
1176
1177	tmp->map = op->map;
1178	tmp->x = op->x + freearr_x[i];
1179	tmp->y = op->y + freearr_y[i];
1180	insert_ob_in_map (tmp, op->map, op, 0);
1181	}	1136	}
1182	}	1137	}
1183		1138
1184	/* Don't teleport things like spell effects */	1139	/* Don't teleport things like spell effects */
1185	if (QUERY_FLAG (op, FLAG_NO_PICK))	1140	if (QUERY_FLAG (op, FLAG_NO_PICK))
…		…
1196	if (i != -1)	1151	if (i != -1)
1197	rv = transfer_ob (op, op->x + freearr_x[i], op->y + freearr_y[i], 0, shop_mat);	1152	rv = transfer_ob (op, op->x + freearr_x[i], op->y + freearr_y[i], 0, shop_mat);
1198		1153
1199	return 0;	1154	return 0;
1200	}	1155	}
		1156
1201	/* Removed code that checked for multipart objects - it appears that	1157	/* Removed code that checked for multipart objects - it appears that
1202	* the teleport function should be able to handle this just fine.	1158	* the teleport function should be able to handle this just fine.
1203	*/	1159	*/
1204	rv = teleport (shop_mat, SHOP_MAT, op);	1160	rv = teleport (shop_mat, SHOP_MAT, op);
1205	}	1161	}
…		…
1260	* Handles applying a sign.	1216	* Handles applying a sign.
1261	*/	1217	*/
1262	static void	1218	static void
1263	apply_sign (object *op, object *sign, int autoapply)	1219	apply_sign (object *op, object *sign, int autoapply)
1264	{	1220	{
		1221	if (!op->is_player())
		1222	return;
		1223
1265	if (sign->has_dialogue ())	1224	if (sign->has_dialogue ())
1266	{	1225	{
1267	op->statusmsg (form ("Maybe you should I<talk> to the %s instead?", &sign->name));	1226	op->statusmsg (format ("Maybe you should I<talk> to the %s instead?", &sign->name));
1268	return;	1227	return;
1269	}	1228	}
1270		1229
1271	if (!sign->msg)	1230	if (!sign->msg)
1272	{	1231	{
1273	op->statusmsg ("Nothing is written on it.");	1232	op->contr->infobox (MSG_CHANNEL ("examine"),
		1233	format ("T<%s>\n\n Nothing %sis written on it.",
		1234	&sign->name,
		1235	sign->name == sign->arch->name ? "" : "else "));
1274	return;	1236	return;
1275	}	1237	}
1276		1238
1277	if (sign->stats.food)	1239	if (sign->stats.food)
1278	{	1240	{
1279	if (sign->last_eat >= sign->stats.food)	1241	if (sign->last_eat >= sign->stats.food)
1280	{	1242	{
1281	if (!sign->move_on)	1243	if (!sign->move_on)
1282	op->statusmsg ("You cannot read it anymore.");	1244	op->failmsg ("You cannot read it anymore.");
1283		1245
1284	return;	1246	return;
1285	}	1247	}
1286		1248
1287	if (!QUERY_FLAG (op, FLAG_WIZPASS))	1249	if (!QUERY_FLAG (op, FLAG_WIZPASS))
…		…
1305	if (sign->sound)	1267	if (sign->sound)
1306	ns->play_sound (sign->sound);	1268	ns->play_sound (sign->sound);
1307	else if (autoapply)	1269	else if (autoapply)
1308	ns->play_sound (sound_find ("msg_voice"));	1270	ns->play_sound (sound_find ("msg_voice"));
1309		1271
1310	if (ns->can_msg)
1311	op->contr->infobox (MSG_CHANNEL ("examine"), format ("T<%s>\n\n\n\n%s", &sign->name, &sign->msg));	1272	op->contr->infobox (MSG_CHANNEL ("examine"), format ("T<%s>\n\n%s", &sign->name, &sign->msg));
1312	else
1313	{
1314	readable_message_type *msgType = get_readable_message_type (sign);
1315	const char *somemsg = format ("%u %s", autoapply ? 1 : 0, &sign->msg);
1316	draw_ext_info (NDI_UNIQUE | NDI_NAVY, 0, op, msgType->message_type, msgType->message_subtype, somemsg, &sign->msg);
1317	}
1318	}	1273	}
1319	}	1274	}
1320		1275
1321	static void	1276	static void
1322	move_apply_hole (object *trap, object *victim)	1277	move_apply_hole (object *trap, object *victim)
…		…
1386		1341
1387	recursion_depth++;	1342	recursion_depth++;
1388	if (trap->head)	1343	if (trap->head)
1389	trap = trap->head;	1344	trap = trap->head;
1390		1345
1391	if (INVOKE_OBJECT (MOVE_TRIGGER, trap, ARG_OBJECT (victim), ARG_OBJECT (originator)))	1346	if (!INVOKE_OBJECT (MOVE_TRIGGER, trap, ARG_OBJECT (victim), ARG_OBJECT (originator)))
1392	goto leave;
1393
1394	switch (trap->type)	1347	switch (trap->type)
1395	{	1348	{
1396	case PLAYERMOVER:	1349	case PLAYERMOVER:
1397	if (trap->attacktype && (trap->level || victim->type != PLAYER) && !should_director_abort (trap, victim))	1350	if (trap->attacktype && (trap->level || victim->type != PLAYER) && !should_director_abort (trap, victim))
		1351	{
		1352	if (!trap->stats.maxsp)
		1353	trap->stats.maxsp = 2;
		1354
		1355	/* Is this correct? From the docs, it doesn't look like it
		1356	* should be divided by trap->speed
		1357	*/
		1358	victim->speed_left = -FABS (trap->stats.maxsp * victim->speed / trap->speed);
		1359
		1360	/* Just put in some sanity check. I think there is a bug in the
		1361	* above with some objects have zero speed, and thus the player
		1362	* getting permanently paralyzed.
		1363	*/
		1364	if (victim->speed_left < -50.f)
		1365	victim->speed_left = -50.f;
		1366	/* LOG(llevDebug, "apply, playermove, player speed_left=%f\n", victim->speed_left); */
		1367	}
		1368	break;
		1369
		1370	case SPINNER:
		1371	if (victim->direction)
		1372	{
		1373	victim->direction = absdir (victim->direction - trap->stats.sp);
		1374	update_turn_face (victim);
		1375	}
		1376	break;
		1377
		1378	case DIRECTOR:
		1379	if (victim->direction && !should_director_abort (trap, victim))
		1380	{
		1381	victim->direction = trap->stats.sp;
		1382	update_turn_face (victim);
		1383	}
		1384	break;
		1385
		1386	case BUTTON:
		1387	case PEDESTAL:
		1388	update_button (trap, originator);
		1389	break;
		1390
		1391	case ALTAR:
		1392	/* sacrifice victim on trap */
		1393	apply_altar (trap, victim, originator);
		1394	break;
		1395
		1396	case THROWN_OBJ:
		1397	if (trap->inv == NULL)
		1398	break;
		1399	/* fallthrough */
		1400
		1401	case ARROW:
		1402	/* bad bug: monster throw a object, make a step forwards, step on object ,
		1403	* trigger this here and get hit by own missile - and will be own enemy.
		1404	* Victim then is his own enemy and will start to kill herself (this is
		1405	* removed) but we have not synced victim and his missile. To avoid senseless
		1406	* action, we avoid hits here
		1407	*/
		1408	if ((QUERY_FLAG (victim, FLAG_ALIVE) && trap->speed) && trap->owner != victim)
		1409	hit_with_arrow (trap, victim);
		1410	break;
		1411
		1412	case SPELL_EFFECT:
		1413	apply_spell_effect (trap, victim);
		1414	break;
		1415
		1416	case TRAPDOOR:
1398	{	1417	{
		1418	int max, sound_was_played;
		1419	object *ab, *ab_next;
		1420
1399	if (!trap->stats.maxsp)	1421	if (!trap->value)
1400	trap->stats.maxsp = 2;	1422	{
		1423	int tot;
1401		1424
1402	/* Is this correct? From the docs, it doesn't look like it	1425	for (ab = trap->above, tot = 0; ab; ab = ab->above)
1403	* should be divided by trap->speed	1426	if ((ab->move_type && trap->move_on) || ab->move_type == 0)
		1427	tot += ab->head_ ()->total_weight ();
		1428
		1429	if (!(trap->value = (tot > trap->weight) ? 1 : 0))
		1430	break;
		1431
		1432	SET_ANIMATION (trap, trap->value);
		1433	update_object (trap, UP_OBJ_FACE);
		1434	}
		1435
		1436	for (ab = trap->above, max = 100, sound_was_played = 0; --max && ab; ab = ab_next)
		1437	{
		1438	/* need to set this up, since if we do transfer the object,
		1439	* ab->above would be bogus
1404	*/	1440	*/
1405	victim->speed_left = -FABS (trap->stats.maxsp * victim->speed / trap->speed);	1441	ab_next = ab->above;
1406		1442
1407	/* Just put in some sanity check. I think there is a bug in the	1443	if ((ab->move_type && trap->move_on) || ab->move_type == 0)
1408	* above with some objects have zero speed, and thus the player	1444	{
1409	* getting permanently paralyzed.	1445	if (!sound_was_played)
		1446	{
		1447	trap->play_sound (trap->sound ? trap->sound : sound_find ("fall_hole"));
		1448	sound_was_played = 1;
		1449	}
		1450
		1451	ab->statusmsg ("You fall into a trapdoor!", NDI_RED);
		1452	transfer_ob (ab, EXIT_X (trap), EXIT_Y (trap), 0, ab);
		1453	}
1410	*/	1454	}
1411	if (victim->speed_left < -50.f)	1455	break;
1412	victim->speed_left = -50.f;
1413	/* LOG(llevDebug, "apply, playermove, player speed_left=%f\n", victim->speed_left); */
1414	}	1456	}
1415	goto leave;
1416		1457
1417	case SPINNER:	1458	case CONVERTER:
1418	if (victim->direction)	1459	if (convert_item (victim, trap) < 0)
1419	{
1420	victim->direction = absdir (victim->direction - trap->stats.sp);
1421	update_turn_face (victim);
1422	}
1423	goto leave;
1424
1425	case DIRECTOR:
1426	if (victim->direction && !should_director_abort (trap, victim))
1427	{
1428	victim->direction = trap->stats.sp;
1429	update_turn_face (victim);
1430	}
1431	goto leave;
1432
1433	case BUTTON:
1434	case PEDESTAL:
1435	update_button (trap);
1436	goto leave;
1437
1438	case ALTAR:
1439	/* sacrifice victim on trap */
1440	apply_altar (trap, victim, originator);
1441	goto leave;
1442
1443	case THROWN_OBJ:
1444	if (trap->inv == NULL)
1445	goto leave;
1446	/* fallthrough */
1447
1448	case ARROW:
1449	/* bad bug: monster throw a object, make a step forwards, step on object ,
1450	* trigger this here and get hit by own missile - and will be own enemy.
1451	* Victim then is his own enemy and will start to kill herself (this is
1452	* removed) but we have not synced victim and his missile. To avoid senseless
1453	* action, we avoid hits here
1454	*/
1455	if ((QUERY_FLAG (victim, FLAG_ALIVE) && trap->speed) && trap->owner != victim)
1456	hit_with_arrow (trap, victim);
1457	goto leave;
1458
1459	case SPELL_EFFECT:
1460	apply_spell_effect (trap, victim);
1461	goto leave;
1462
1463	case TRAPDOOR:
1464	{
1465	int max, sound_was_played;
1466	object *ab, *ab_next;
1467
1468	if (!trap->value)
1469	{	1460	{
1470	int tot;	1461	originator->failmsg (format ("The %s seems to be broken!", query_name (trap)));
1471		1462	archetype::get (shstr_burnout)->insert_at (trap, trap);
1472	for (ab = trap->above, tot = 0; ab; ab = ab->above)
1473	if ((ab->move_type && trap->move_on) || ab->move_type == 0)
1474	tot += ab->head_ ()->total_weight ();
1475
1476	if (!(trap->value = (tot > trap->weight) ? 1 : 0))
1477	goto leave;
1478
1479	SET_ANIMATION (trap, trap->value);
1480	update_object (trap, UP_OBJ_FACE);
1481	}	1463	}
1482		1464
1483	for (ab = trap->above, max = 100, sound_was_played = 0; --max && ab; ab = ab_next)	1465	break;
		1466
		1467	case TRIGGER_BUTTON:
		1468	case TRIGGER_PEDESTAL:
		1469	case TRIGGER_ALTAR:
		1470	check_trigger (trap, victim, originator);
		1471	break;
		1472
		1473	case DEEP_SWAMP:
		1474	walk_on_deep_swamp (trap, victim);
		1475	break;
		1476
		1477	case CHECK_INV:
		1478	check_inv (victim, trap);
		1479	break;
		1480
		1481	case HOLE:
		1482	move_apply_hole (trap, victim);
		1483	break;
		1484
		1485	case EXIT:
		1486	if (victim->type == PLAYER && EXIT_PATH (trap))
1484	{	1487	{
1485	/* need to set this up, since if we do transfer the object,	1488	/* Basically, don't show exits leading to random maps the
1486	* ab->above would be bogus	1489	* players output.
1487	*/	1490	*/
1488	ab_next = ab->above;	1491	if (trap->msg && !EXIT_PATH (trap).starts_with ("/!"))
		1492	victim->statusmsg (trap->msg, NDI_NAVY);
1489		1493
1490	if ((ab->move_type && trap->move_on) || ab->move_type == 0)	1494	trap->play_sound (trap->sound);
1491	{	1495	victim->enter_exit (trap);
1492	if (!sound_was_played)
1493	{
1494	trap->play_sound (trap->sound ? trap->sound : sound_find ("fall_hole"));
1495	sound_was_played = 1;
1496	}
1497
1498	ab->statusmsg ("You fall into a trapdoor!", NDI_RED);
1499	transfer_ob (ab, EXIT_X (trap), EXIT_Y (trap), 0, ab);
1500	}
1501	}	1496	}
1502	goto leave;	1497	break;
1503	}
1504		1498
1505	case CONVERTER:
1506	if (convert_item (victim, trap) < 0)
1507	{
1508	originator->failmsg (format ("The %s seems to be broken!", query_name (trap)));
1509	archetype::get (shstr_burnout)->insert_at (trap, trap);
1510	}
1511
1512	goto leave;
1513
1514	case TRIGGER_BUTTON:
1515	case TRIGGER_PEDESTAL:
1516	case TRIGGER_ALTAR:
1517	check_trigger (trap, victim);
1518	goto leave;
1519
1520	case DEEP_SWAMP:
1521	walk_on_deep_swamp (trap, victim);
1522	goto leave;
1523
1524	case CHECK_INV:
1525	check_inv (victim, trap);
1526	goto leave;
1527
1528	case HOLE:
1529	move_apply_hole (trap, victim);
1530	goto leave;
1531
1532	case EXIT:
1533	if (victim->type == PLAYER && EXIT_PATH (trap))
1534	{
1535	/* Basically, don't show exits leading to random maps the
1536	* players output.
1537	*/
1538	if (trap->msg && strncmp (EXIT_PATH (trap), "/!", 2))
1539	victim->statusmsg (trap->msg, NDI_NAVY);
1540
1541	trap->play_sound (trap->sound);
1542	victim->enter_exit (trap);
1543	}
1544	goto leave;
1545
1546	case ENCOUNTER:	1499	case ENCOUNTER:
1547	/* may be some leftovers on this */	1500	/* may be some leftovers on this */
1548	goto leave;	1501	break;
1549		1502
1550	case SHOP_MAT:	1503	case SHOP_MAT:
1551	apply_shop_mat (trap, victim);	1504	apply_shop_mat (trap, victim);
1552	goto leave;	1505	break;
1553		1506
1554	/* Drop a certain amount of gold, and have one item identified */	1507	/* Drop a certain amount of gold, and have one item identified */
1555	case IDENTIFY_ALTAR:	1508	case IDENTIFY_ALTAR:
1556	apply_id_altar (victim, trap, originator);	1509	apply_id_altar (victim, trap, originator);
1557	goto leave;	1510	break;
1558		1511
1559	case SIGN:	1512	case SIGN:
1560	if (victim->type != PLAYER && trap->stats.food > 0)	1513	if (victim->type != PLAYER && trap->stats.food > 0)
1561	goto leave; /* monsters musn't apply magic_mouths with counters */	1514	break; /* monsters musn't apply magic_mouths with counters */
1562		1515
1563	apply_sign (victim, trap, 1);	1516	apply_sign (victim, trap, 1);
1564	goto leave;	1517	break;
1565		1518
1566	case CONTAINER:	1519	case CONTAINER:
1567	apply_container (victim, trap);	1520	apply_container (victim, trap);
1568	goto leave;	1521	break;
1569		1522
1570	case RUNE:	1523	case RUNE:
1571	case TRAP:	1524	case TRAP:
1572	if (trap->level && QUERY_FLAG (victim, FLAG_ALIVE))	1525	if (trap->level && QUERY_FLAG (victim, FLAG_ALIVE))
1573	spring_trap (trap, victim);	1526	spring_trap (trap, victim);
1574	goto leave;	1527	break;
1575		1528
1576	default:	1529	default:
1577	LOG (llevDebug, "name %s, arch %s, type %d with fly/walk on/off not "	1530	LOG (llevDebug, "name %s, arch %s, type %d with fly/walk on/off not "
1578	"handled in move_apply()\n", &trap->name, &trap->arch->archname, trap->type);	1531	"handled in move_apply()\n", &trap->name, &trap->arch->archname, trap->type);
1579	goto leave;	1532	break;
1580	}	1533	}
1581		1534
1582	leave:
1583	recursion_depth--;	1535	recursion_depth--;
1584	}	1536	}
1585		1537
1586	/**	1538	/**
1587	* Handles reading a regular (ie not containing a spell) book.	1539	* Handles reading a regular (ie not containing a spell) book.
…		…
1626		1578
1627	readable_message_type *msgType = get_readable_message_type (tmp);	1579	readable_message_type *msgType = get_readable_message_type (tmp);
1628		1580
1629	if (player *pl = op->contr)	1581	if (player *pl = op->contr)
1630	if (client *ns = pl->ns)	1582	if (client *ns = pl->ns)
1631	if (ns->can_msg)
1632	pl->infobox (MSG_CHANNEL ("book"), format ("T<%s>\n\n\n\n%s", (char *)long_desc (tmp, op), &tmp->msg));	1583	pl->infobox (MSG_CHANNEL ("book"), format ("T<%s>\n\n%s", (char *)long_desc (tmp, op), &tmp->msg));
1633	else
1634	draw_ext_info_format (NDI_UNIQUE | NDI_NAVY, 0, op,
1635	msgType->message_type, msgType->message_subtype,
1636	"You open the %s and start reading.\n%s", (char *)"%s\n%s",
1637	long_desc (tmp, op), &tmp->msg);
1638		1584
1639	/* gain xp from reading */	1585	/* gain xp from reading */
1640	if (!QUERY_FLAG (tmp, FLAG_NO_SKILL_IDENT))	1586	if (!QUERY_FLAG (tmp, FLAG_NO_SKILL_IDENT))
1641	{ /* only if not read before */	1587	{ /* only if not read before */
1642	int exp_gain = calc_skill_exp (op, tmp, skill_ob);	1588	int exp_gain = calc_skill_exp (op, tmp, skill_ob);
…		…
1796	LOG (llevError, "apply_spellbook: Book %s has no spell in it!\n", &tmp->name);	1742	LOG (llevError, "apply_spellbook: Book %s has no spell in it!\n", &tmp->name);
1797	op->failmsg ("The spellbook symbols make no sense. This is a bug, please report!");	1743	op->failmsg ("The spellbook symbols make no sense. This is a bug, please report!");
1798	return;	1744	return;
1799	}	1745	}
1800		1746
1801	if (skop->level < int (sqrtf (spell->level) * 1.5f))	1747	int learn_level = sqrtf (spell->level) * 1.5f;
		1748	if (skop->level < learn_level)
1802	{	1749	{
1803	op->failmsg (format ("You are unable to decipher the strange symbols. H<Your %s level is too low.>", &tmp->skill));	1750	op->failmsg (format ("You are unable to decipher the strange symbols. H<Your %s level is too low, it must be at least %d.>",
		1751	&tmp->skill, learn_level));
1804	return;	1752	return;
1805	}	1753	}
1806		1754
1807	op->statusmsg (format ("The spellbook contains the %s level spell %s.", get_levelnumber (spell->level), &spell->name));	1755	op->statusmsg (format ("The spellbook contains the %s level spell %s.", get_levelnumber (spell->level), &spell->name));
1808		1756
…		…
1965	if (op->destroyed () || tmp->destroyed ())	1913	if (op->destroyed () || tmp->destroyed ())
1966	break;	1914	break;
1967	}	1915	}
1968		1916
1969	if (!tmp->destroyed () && !tmp->inv)	1917	if (!tmp->destroyed () && !tmp->inv)
1970	tmp->decrease ();	1918	tmp->decrease (true);
1971	}	1919	}
1972		1920
1973	/**	1921	/**
1974	* op eats food.	1922	* op eats food.
1975	* If player, takes care of messages and dragon special food.	1923	* If player, takes care of messages and dragon special food.
…		…
2170	op->statusmsg (buf);	2118	op->statusmsg (buf);
2171		2119
2172	/* now choose a winner if we have any */	2120	/* now choose a winner if we have any */
2173	i = -1;	2121	i = -1;
2174	if (winners > 0)	2122	if (winners > 0)
2175	i = atnr_winner[RANDOM () % winners];	2123	i = atnr_winner [rndm (winners)];
2176		2124
2177	if (i >= 0 && i < NROFATTACKS && skin->resist[i] < 95)	2125	if (i >= 0 && i < NROFATTACKS && skin->resist[i] < 95)
2178	{	2126	{
2179	/* resistance increased! */	2127	/* resistance increased! */
2180	skin->resist[i]++;	2128	skin->resist[i]++;
…		…
2355		2303
2356	return 0;	2304	return 0;
2357	}	2305	}
2358		2306
2359	/**	2307	/**
		2308	* This function will try to apply a lighter and in case no lighter
		2309	* is specified it will try to find a lighter in the players inventory,
		2310	* and inform him about this requirement.
		2311	*
		2312	* who - the player
		2313	* op - the item we want to light
		2314	* lighter - the lighter or 0 if a lighter has yet to be found
		2315	*/
		2316	static object *
		2317	auto_apply_lighter (object *who, object *op, object *lighter)
		2318	{
		2319	if (lighter == 0)
		2320	{
		2321	for (object *tmp = who->inv; tmp; tmp = tmp->below)
		2322	{
		2323	if (tmp->type == LIGHTER)
		2324	{
		2325	lighter = tmp;
		2326	break;
		2327	}
		2328	}
		2329
		2330	if (!lighter)
		2331	{
		2332	who->failmsg (format (
		2333	"You can't light up the %s with your bare hands! "
		2334	"H<You need a lighter in your inventory, for example a flint and steel.>",
		2335	&op->name));
		2336	return 0;
		2337	}
		2338	}
		2339
		2340	// last_eat == 0 means the lighter is not being used up!
		2341	if (lighter->last_eat && lighter->stats.food)
		2342	{
		2343	/* lighter gets used up */
		2344	lighter = lighter->split ();
		2345	lighter->stats.food--;
		2346	who->insert (lighter);
		2347	}
		2348	else if (lighter->last_eat)
		2349	{
		2350	/* no charges left in lighter */
		2351	who->failmsg (format (
		2352	"You attempt to light the %s with a used up %s.",
		2353	&op->name, &lighter->name));
		2354	return 0;
		2355	}
		2356
		2357	return lighter;
		2358	}
		2359
		2360	/**
		2361	* Designed primarily to light torches/lanterns/etc.
		2362	* Also burns up burnable material too. First object in the inventory is
		2363	* the selected object to "burn". -b.t.
		2364	*/
		2365	void
		2366	apply_lighter (object *who, object *lighter)
		2367	{
		2368	object *item;
		2369	int is_player_env = 0;
		2370
		2371	item = find_marked_object (who);
		2372	if (item)
		2373	{
		2374	if (!auto_apply_lighter (who, item, lighter))
		2375	return;
		2376
		2377	/* Perhaps we should split what we are trying to light on fire?
		2378	* I can't see many times when you would want to light multiple
		2379	* objects at once.
		2380	*/
		2381
		2382	save_throw_object (item, AT_FIRE, who);
		2383
		2384	if (item->destroyed ()
		2385	|| ((item->type == LAMP || item->type == TORCH)
		2386	&& item->glow_radius > 0))
		2387	who->statusmsg (format (
		2388	"You light the %s with the %s.",
		2389	&item->name, &lighter->name));
		2390	else
		2391	who->failmsg (format (
		2392	"You attempt to light the %s with the %s and fail.",
		2393	&item->name, &lighter->name));
		2394	}
		2395	else
		2396	who->failmsg ("You need to mark a lightable object.");
		2397	}
		2398
		2399	/**
		2400	* This function generates a cursed effect for cursed lamps and torches.
		2401	*/
		2402	void player_apply_lamp_cursed_effect (object *who, object *op)
		2403	{
		2404	if (op->level)
		2405	{
		2406	who->failmsg (format (
		2407	"The %s was cursed, it explodes in a big fireball!",
		2408	&op->name));
		2409	create_exploding_ball_at (who, op->level);
		2410	}
		2411	else
		2412	{
		2413	who->failmsg (format (
		2414	"The %s was cursed, it crumbles to dust, at least it didn't explode.!",
		2415	&op->name));
		2416	}
		2417
		2418	op->destroy ();
		2419	}
		2420
		2421	/**
		2422	* Apply for players and lamps
		2423	*
		2424	* who - the player
		2425	* op - the lamp
		2426	*/
		2427	void player_apply_lamp (object *who, object *op)
		2428	{
		2429	bool switch_on = op->glow_radius ? false : true;
		2430
		2431	if (switch_on)
		2432	{
		2433	object *lighter = 0;
		2434
		2435	if (op->flag [FLAG_IS_LIGHTABLE]
		2436	&& !(lighter = auto_apply_lighter (who, op, 0)))
		2437	return;
		2438
		2439	if (op->stats.food < 1)
		2440	{
		2441	if (op->type == LAMP)
		2442	who->failmsg (format (
		2443	"The %s is out of fuel! "
		2444	"H<Lamps and similar items need fuel. They cannot be refilled.>",
		2445	&op->name));
		2446	else
		2447	who->failmsg (format (
		2448	"The %s is burnt out! "
		2449	"H<Torches and similar items burn out and become worthless.>",
		2450	&op->name));
		2451	return;
		2452	}
		2453
		2454	if (op->flag [FLAG_CURSED])
		2455	{
		2456	player_apply_lamp_cursed_effect (who, op);
		2457	return;
		2458	}
		2459
		2460	if (lighter)
		2461	who->statusmsg (format (
		2462	"You light up the %s with the %s.", &op->name, &lighter->name));
		2463	else
		2464	who->statusmsg (format ("You light up the %s.", &op->name));
		2465	}
		2466	else
		2467	{
		2468	if (op->flag [FLAG_CURSED])
		2469	{
		2470	player_apply_lamp_cursed_effect (who, op);
		2471	return;
		2472	}
		2473
		2474	if (op->type == TORCH)
		2475	{
		2476	if (!op->flag [FLAG_IS_LIGHTABLE])
		2477	{
		2478	who->statusmsg (format (
		2479	"You put out the %s. "
		2480	"H<The %s can't be used anymore, as it can't be lighted up again.>",
		2481	&op->name, &op->name));
		2482	}
		2483	else
		2484	who->statusmsg (format (
		2485	"You put out the %s."
		2486	"H<Torches wear out if you put them out.>",
		2487	&op->name));
		2488	}
		2489	else
		2490	who->statusmsg (format ("You turn off the %s.", &op->name));
		2491	}
		2492
		2493	apply_lamp (op, switch_on);
		2494	}
		2495
		2496	void get_animation_from_arch (object *op, arch_ptr a)
		2497	{
		2498	op->animation_id = a->animation_id;
		2499	op->flag [FLAG_IS_TURNABLE] = a->flag [FLAG_IS_TURNABLE];
		2500	op->flag [FLAG_ANIMATE] = a->flag [FLAG_ANIMATE];
		2501	op->anim_speed = a->anim_speed;
		2502	op->last_anim = 0;
		2503	op->state = 0;
		2504	op->face = a->face;
		2505
		2506	if (NUM_ANIMATIONS(op) > 1)
		2507	{
		2508	SET_ANIMATION(op, 0);
		2509	animate_object (op, op->direction);
		2510	}
		2511	else
		2512	update_object (op, UP_OBJ_FACE);
		2513	}
		2514
		2515	/**
		2516	* Apply for LAMPs and TORCHes.
		2517	*
		2518	* op - the lamp
		2519	* switch_on - a flag which says whether the lamp should be switched on or off
		2520	*/
		2521	void apply_lamp (object *op, bool switch_on)
		2522	{
		2523	op->set_glow_radius (switch_on ? op->range : 0);
		2524	op->set_speed (switch_on ? op->arch->speed : 0);
		2525
		2526	// torches wear out if you put them out
		2527	if (op->type == TORCH && !switch_on)
		2528	{
		2529	if (op->flag [FLAG_IS_LIGHTABLE])
		2530	{
		2531	op->stats.food -= (double) op->arch->stats.food / 15;
		2532	if (op->stats.food < 0)
		2533	op->stats.food = 0;
		2534	}
		2535	else
		2536	op->stats.food = 0;
		2537	}
		2538
		2539	// lamps and torched get worthless when used up
		2540	if (op->stats.food <= 0)
		2541	op->value = 0;
		2542
		2543	// FIXME: This is a hack to make the more sane torches and lamps
		2544	// still animated ;-/
		2545	if (op->other_arch)
		2546	get_animation_from_arch (op, switch_on ? op->other_arch : op->arch);
		2547
		2548	if (object *pl = op->visible_to ())
		2549	esrv_update_item (UPD_ANIM | UPD_FACE | UPD_NAME, pl, op);
		2550	}
		2551
		2552	/**
2360	* Main apply handler.	2553	* Main apply handler.
2361	*	2554	*
2362	* Checks for unpaid items before applying.	2555	* Checks for unpaid items before applying.
2363	*	2556	*
2364	* Return value:	2557	* Return value:
2365	* 0: player or monster can't apply objects of that type	2558	* 0: player or monster can't apply objects of that type
2366	* 1: has been applied, or there was an error applying the object	2559	* 1: has been applied, or there was an error applying the object
2367	* 2: objects of that type can't be applied if not in inventory	2560	* 2: objects of that type can't be applied if not in inventory
2368	*	2561	*
2369	* op is the object that is causing object to be applied, tmp is the object	2562	* who is the object that is causing object to be applied, op is the object
2370	* being applied.	2563	* being applied.
2371	*	2564	*
2372	* aflag is special (always apply/unapply) flags. Nothing is done with	2565	* aflag is special (always apply/unapply) flags. Nothing is done with
2373	* them in this function - they are passed to apply_special	2566	* them in this function - they are passed to apply_special
2374	*/	2567	*/
2375	int	2568	int
2376	manual_apply (object *op, object *tmp, int aflag)	2569	manual_apply (object *who, object *op, int aflag)
2377	{	2570	{
2378	tmp = tmp->head_ ();	2571	op = op->head_ ();
2379		2572
2380	if (QUERY_FLAG (tmp, FLAG_UNPAID) && !QUERY_FLAG (tmp, FLAG_APPLIED))	2573	if (QUERY_FLAG (op, FLAG_UNPAID) && !QUERY_FLAG (op, FLAG_APPLIED))
2381	{	2574	{
2382	if (op->type == PLAYER)	2575	if (who->type == PLAYER)
2383	{	2576	{
		2577	examine (who, op);
2384	op->failmsg ("You should pay for it first! H<You cannot use items marked as unpaid.>");	2578	//who->failmsg ("You should pay for it first! H<You cannot use items marked as unpaid.>");//TODO remove
2385	return 1;	2579	return 1;
2386	}	2580	}
2387	else	2581	else
2388	return 0; /* monsters just skip unpaid items */	2582	return 0; /* monsters just skip unpaid items */
2389	}	2583	}
2390		2584
2391	if (INVOKE_OBJECT (APPLY, tmp, ARG_OBJECT (op)))	2585	if (INVOKE_OBJECT (APPLY, op, ARG_OBJECT (who)))
2392	return RESULT_INT (0);	2586	return RESULT_INT (0);
2393		2587
2394	switch (tmp->type)	2588	switch (op->type)
2395	{	2589	{
2396	case CF_HANDLE:	2590	case CF_HANDLE:
2397	op->play_sound (sound_find ("turn_handle"));	2591	who->play_sound (sound_find ("turn_handle"));
2398	op->statusmsg ("You turn the handle.");	2592	who->statusmsg ("You turn the handle.");
2399	tmp->value = tmp->value ? 0 : 1;	2593	op->value = op->value ? 0 : 1;
2400	SET_ANIMATION (tmp, tmp->value);	2594	SET_ANIMATION (op, op->value);
2401	update_object (tmp, UP_OBJ_FACE);	2595	update_object (op, UP_OBJ_FACE);
2402	push_button (tmp);	2596	push_button (op, who);
2403	return 1;	2597	return 1;
2404		2598
2405	case TRIGGER:	2599	case TRIGGER:
2406	if (check_trigger (tmp, op))	2600	if (check_trigger (op, who, who))
2407	{	2601	{
2408	op->statusmsg ("You turn the handle.");	2602	who->statusmsg ("You turn the handle.");
2409	op->play_sound (sound_find ("turn_handle"));	2603	who->play_sound (sound_find ("turn_handle"));
2410	}	2604	}
2411	else	2605	else
2412	op->failmsg ("The handle doesn't move.");	2606	who->failmsg ("The handle doesn't move.");
2413		2607
2414	return 1;	2608	return 1;
2415		2609
2416	case EXIT:	2610	case EXIT:
2417	if (op->type != PLAYER)	2611	if (who->type != PLAYER)
2418	return 0;	2612	return 0;
2419		2613
2420	if (!EXIT_PATH (tmp) || !is_legal_2ways_exit (op, tmp))	2614	if (!EXIT_PATH (op) || !is_legal_2ways_exit (who, op))
2421	op->failmsg (format ("The %s is closed.", query_name (tmp)));	2615	who->failmsg (format ("The %s is closed. H<And will stay closed, until somebody fires up the map editor and adds it.>", query_name (op)));
2422	else	2616	else
2423	{	2617	{
2424	/* Don't display messages for random maps. */	2618	/* Don't display messages for random maps. */
2425	if (tmp->msg && strncmp (EXIT_PATH (tmp), "/!", 2))	2619	if (op->msg && !EXIT_PATH (op).starts_with ("/!"))
2426	op->statusmsg (tmp->msg, NDI_NAVY);	2620	who->statusmsg (op->msg, NDI_NAVY);
2427		2621
2428	op->enter_exit (tmp);	2622	who->enter_exit (op);
2429	}	2623	}
2430		2624
2431	return 1;	2625	return 1;
2432		2626
2433	case INSCRIBABLE:	2627	case INSCRIBABLE:
2434	op->statusmsg (tmp->msg);	2628	who->statusmsg (op->msg);
2435	// maybe show a spell menu to chose from or something like that	2629	// maybe show a spell menu to chose from or something like that
2436	return 1;	2630	return 1;
2437		2631
2438	case SIGN:	2632	case SIGN:
2439	apply_sign (op, tmp, 0);	2633	apply_sign (who, op, 0);
2440	return 1;	2634	return 1;
2441		2635
2442	case BOOK:	2636	case BOOK:
2443	if (op->type == PLAYER)	2637	if (who->type == PLAYER)
2444	{	2638	{
2445	apply_book (op, tmp);	2639	apply_book (who, op);
2446	return 1;	2640	return 1;
2447	}	2641	}
2448	else	2642	else
2449	return 0;	2643	return 0;
2450		2644
2451	case SKILLSCROLL:	2645	case SKILLSCROLL:
2452	if (op->type == PLAYER)	2646	if (who->type == PLAYER)
2453	{	2647	{
2454	apply_skillscroll (op, tmp);	2648	apply_skillscroll (who, op);
2455	return 1;	2649	return 1;
2456	}	2650	}
2457	else	2651	else
2458	return 0;	2652	return 0;
2459		2653
2460	case SPELLBOOK:	2654	case SPELLBOOK:
2461	if (op->type == PLAYER)	2655	if (who->type == PLAYER)
2462	{	2656	{
2463	apply_spellbook (op, tmp);	2657	apply_spellbook (who, op);
2464	return 1;	2658	return 1;
2465	}	2659	}
2466	else	2660	else
2467	return 0;	2661	return 0;
2468		2662
2469	case SCROLL:	2663	case SCROLL:
2470	apply_scroll (op, tmp, 0);	2664	apply_scroll (who, op, 0);
2471	return 1;	2665	return 1;
2472		2666
2473	case POTION:	2667	case POTION:
2474	apply_potion (op, tmp);	2668	apply_potion (who, op);
2475	return 1;	2669	return 1;
2476		2670
2477	/* Eneq(@csd.uu.se): Handle apply on containers. */	2671	/* Eneq(@csd.uu.se): Handle apply on containers. */
2478	//TODO: remove, as it is unsed?	2672	//TODO: remove, as it is unsed?
2479	case CLOSE_CON:	2673	case CLOSE_CON:
2480	apply_container (op, tmp->env);	2674	apply_container (who, op->env);
2481	return 1;	2675	return 1;
2482		2676
2483	case CONTAINER:	2677	case CONTAINER:
2484	apply_container (op, tmp);	2678	apply_container (who, op);
2485	return 1;	2679	return 1;
2486		2680
2487	case TREASURE:	2681	case TREASURE:
2488	if (op->type == PLAYER)	2682	if (who->type == PLAYER)
2489	{	2683	{
2490	apply_treasure (op, tmp);	2684	apply_treasure (who, op);
2491	return 1;	2685	return 1;
2492	}	2686	}
2493	else	2687	else
2494	return 0;	2688	return 0;
		2689
		2690	case LAMP:
		2691	case TORCH:
		2692	player_apply_lamp (who, op);
		2693	return 1;
2495		2694
2496	case WEAPON:	2695	case WEAPON:
2497	case ARMOUR:	2696	case ARMOUR:
2498	case BOOTS:	2697	case BOOTS:
2499	case GLOVES:	2698	case GLOVES:
…		…
2507	case WAND:	2706	case WAND:
2508	case ROD:	2707	case ROD:
2509	case HORN:	2708	case HORN:
2510	case SKILL:	2709	case SKILL:
2511	case BOW:	2710	case BOW:
2512	case LAMP:
2513	case BUILDER:	2711	case BUILDER:
2514	case SKILL_TOOL:	2712	case SKILL_TOOL:
2515	if (tmp->env != op)	2713	if (op->env != who)
2516	return 2; /* not in inventory */	2714	return 2; /* not in inventory */
2517		2715
2518	apply_special (op, tmp, aflag);	2716	apply_special (who, op, aflag);
2519	return 1;	2717	return 1;
2520		2718
2521	case DRINK:	2719	case DRINK:
2522	case FOOD:	2720	case FOOD:
2523	case FLESH:	2721	case FLESH:
2524	apply_food (op, tmp);	2722	apply_food (who, op);
2525	return 1;	2723	return 1;
2526		2724
2527	case POISON:	2725	case POISON:
2528	apply_poison (op, tmp);	2726	apply_poison (who, op);
2529	return 1;	2727	return 1;
2530		2728
2531	case SAVEBED:	2729	case SAVEBED:
2532	return 1;	2730	return 1;
2533		2731
2534	case ARMOUR_IMPROVER:	2732	case ARMOUR_IMPROVER:
2535	if (op->type == PLAYER)	2733	if (who->type == PLAYER)
2536	{	2734	{
2537	apply_armour_improver (op, tmp);	2735	apply_armour_improver (who, op);
2538	return 1;	2736	return 1;
2539	}	2737	}
2540	else	2738	else
2541	return 0;	2739	return 0;
2542		2740
2543	case WEAPON_IMPROVER:	2741	case WEAPON_IMPROVER:
2544	check_improve_weapon (op, tmp);	2742	check_improve_weapon (who, op);
2545	return 1;	2743	return 1;
2546		2744
2547	case CLOCK:	2745	case CLOCK:
2548	if (op->type == PLAYER)	2746	if (who->type == PLAYER)
2549	{	2747	{
2550	char buf[MAX_BUF];	2748	char buf[MAX_BUF];
2551	timeofday_t tod;	2749	timeofday_t tod;
2552		2750
2553	get_tod (&tod);	2751	get_tod (&tod);
2554	op->play_sound (sound_find ("sound_clock"));	2752	who->play_sound (sound_find ("sound_clock"));
2555	op->statusmsg (format (	2753	who->statusmsg (format (
2556	"It is %d minute%s past %d o'clock %s",	2754	"It is %d minute%s past %d o'clock %s",
2557	tod.minute + 1, ((tod.minute + 1 < 2) ? "" : "s"),	2755	tod.minute + 1, ((tod.minute + 1 < 2) ? "" : "s"),
2558	((tod.hour % 14 == 0) ? 14 : ((tod.hour) % 14)), ((tod.hour >= 14) ? "pm" : "am")	2756	((tod.hour % 14 == 0) ? 14 : ((tod.hour) % 14)), ((tod.hour >= 14) ? "pm" : "am")
2559	));	2757	));
2560	return 1;	2758	return 1;
2561	}	2759	}
2562	else	2760	else
2563	return 0;	2761	return 0;
2564		2762
2565	case MENU:	2763	case MENU:
2566	if (op->type == PLAYER)	2764	if (who->type == PLAYER)
2567	{	2765	{
2568	shop_listing (tmp, op);	2766	shop_listing (op, who);
2569	return 1;	2767	return 1;
2570	}	2768	}
2571	else	2769	else
2572	return 0;	2770	return 0;
2573		2771
2574	case POWER_CRYSTAL:	2772	case POWER_CRYSTAL:
2575	apply_power_crystal (op, tmp); /* see egoitem.c */	2773	apply_power_crystal (who, op); /* see egoitem.c */
2576	return 1;	2774	return 1;
2577		2775
2578	case LIGHTER: /* for lighting torches/lanterns/etc */	2776	case LIGHTER: /* for lighting torches/lanterns/etc */
2579	if (op->type == PLAYER)	2777	if (who->type == PLAYER)
2580	{	2778	{
2581	apply_lighter (op, tmp);	2779	apply_lighter (who, op);
2582	return 1;	2780	return 1;
2583	}	2781	}
2584	else	2782	else
2585	return 0;	2783	return 0;
2586		2784
2587	case ITEM_TRANSFORMER:	2785	case ITEM_TRANSFORMER:
2588	apply_item_transformer (op, tmp);	2786	apply_item_transformer (who, op);
2589	return 1;	2787	return 1;
2590		2788
2591	default:	2789	default:
2592	return 0;	2790	return 0;
2593	}	2791	}
…		…
2660	* person moving on it, also activate. Added code to make it	2858	* person moving on it, also activate. Added code to make it
2661	* so that at least one of players movement types be that which	2859	* so that at least one of players movement types be that which
2662	* the item needs.	2860	* the item needs.
2663	*/	2861	*/
2664	if (!tmp->invisible || (tmp->move_on & pl->move_type))	2862	if (!tmp->invisible || (tmp->move_on & pl->move_type))
2665	{
2666	if (player_apply (pl, tmp, 0, 1) == 1)	2863	if (player_apply (pl, tmp, 0, 1) == 1)
2667	return;	2864	return;
2668	}	2865
2669	if (floors >= 2)	2866	if (floors >= 2)
2670	return; /* process at most two floor objects */	2867	return; /* process at most two floor objects */
2671	}	2868	}
2672	}	2869	}
2673		2870
…		…
2745	case BRACERS:	2942	case BRACERS:
2746	case CLOAK:	2943	case CLOAK:
2747	who->statusmsg (format ("You unwear %s.", query_name (op)));	2944	who->statusmsg (format ("You unwear %s.", query_name (op)));
2748	change_abil (who, op);	2945	change_abil (who, op);
2749	break;	2946	break;
2750
2751	case LAMP:
2752	{
2753	who->statusmsg (format ("You turn off your %s.", &op->name));
2754
2755	object *tmp2 = arch_to_object (op->other_arch);
2756	tmp2->x = op->x;
2757	tmp2->y = op->y;
2758	tmp2->map = op->map;
2759	tmp2->below = op->below;
2760	tmp2->above = op->above;
2761	tmp2->stats.food = op->stats.food;
2762	CLEAR_FLAG (tmp2, FLAG_APPLIED);
2763
2764	if (QUERY_FLAG (op, FLAG_INV_LOCKED))
2765	SET_FLAG (tmp2, FLAG_INV_LOCKED);
2766
2767	op->destroy ();
2768	who->insert (tmp2);
2769	who->update_stats ();
2770
2771	if (who->contr)
2772	{
2773	if (QUERY_FLAG (op, FLAG_CURSED) || QUERY_FLAG (op, FLAG_DAMNED))
2774	{
2775	who->failmsg ("Oops, it feels deadly cold!");
2776	SET_FLAG (tmp2, FLAG_KNOWN_CURSED);
2777	}
2778	}
2779	}
2780
2781	return 1; /* otherwise, an attempt to drop causes problems */
2782		2947
2783	case BOW:	2948	case BOW:
2784	case WAND:	2949	case WAND:
2785	case ROD:	2950	case ROD:
2786	case HORN:	2951	case HORN:
…		…
3194	* skill so that the dam and wc get updated	3359	* skill so that the dam and wc get updated
3195	*/	3360	*/
3196	who->change_skill (skop);	3361	who->change_skill (skop);
3197	}	3362	}
3198		3363
3199	if (who->type == PLAYER	3364	if (!check_item_power (who, op->item_power))
3200	&& op->item_power
3201	&& op->item_power + who->contr->item_power > settings.item_power_factor * who->level)
3202	{	3365	{
3203	who->failmsg ("Equipping that combined with other items would consume your soul!" LACK_ITEM_POWER);	3366	who->failmsg ("Equipping that combined with other items would consume your soul!" LACK_ITEM_POWER);
3204	return 1;	3367	return 1;
3205	}	3368	}
3206		3369
…		…
3214	return RESULT_INT (0);	3377	return RESULT_INT (0);
3215		3378
3216	switch (op->type)	3379	switch (op->type)
3217	{	3380	{
3218	case WEAPON:	3381	case WEAPON:
3219	if (!check_weapon_power (who, op->last_eat))
3220	{
3221	op->failmsg ("This weapon is too powerful for you to use. It would consume your soul!" LACK_ITEM_POWER);
3222
3223	if (tmp)
3224	insert_ob_in_ob (tmp, who);
3225
3226	return 1;
3227	}
3228
3229	//TODO: this obviously fails for players using a shorter prefix	3382	//TODO: this obviously fails for players using a shorter prefix
3230	// i.e. "R" can use Ragnarok's sword.	3383	// i.e. "R" can use Ragnarok's sword.
3231	if (op->level && (strncmp (op->name, who->name, strlen (who->name))))	3384	if (op->level && !op->name.starts_with (who->name))
3232	{	3385	{
3233	/* if the weapon does not have the name as the character, can't use it. */	3386	/* if the weapon does not have the name as the character, can't use it. */
3234	/* (Ragnarok's sword attempted to be used by Foo: won't work) */	3387	/* (Ragnarok's sword attempted to be used by Foo: won't work) */
3235	who->failmsg ("The weapon does not recognize you as its owner. H<Its name indicates that it belongs to somebody else.>");	3388	who->failmsg ("The weapon does not recognize you as its owner. H<Its name indicates that it belongs to somebody else.>");
3236		3389
…		…
3270	case AMULET:	3423	case AMULET:
3271	SET_FLAG (op, FLAG_APPLIED);	3424	SET_FLAG (op, FLAG_APPLIED);
3272	who->statusmsg (format ("You wear %s.", query_name (op)));	3425	who->statusmsg (format ("You wear %s.", query_name (op)));
3273	change_abil (who, op);	3426	change_abil (who, op);
3274	break;	3427	break;
3275
3276	case LAMP:
3277	if (op->stats.food < 1)
3278	{
3279	who->failmsg (format (
3280	"Your %s is out of fuel! "
3281	"H<Lamps and similar items need fuel. They cannot be refilled.>",
3282	&op->name
3283	));
3284	return 1;
3285	}
3286
3287	who->statusmsg (format ("You turn on your %s.", &op->name));
3288
3289	tmp2 = arch_to_object (op->other_arch);
3290	tmp2->stats.food = op->stats.food;
3291	SET_FLAG (tmp2, FLAG_APPLIED);
3292
3293	if (QUERY_FLAG (op, FLAG_INV_LOCKED))
3294	SET_FLAG (tmp2, FLAG_INV_LOCKED);
3295
3296	who->insert (tmp2);
3297
3298	/* Remove the old lantern */
3299	op->destroy ();
3300
3301	/* insert the portion that was split off */
3302	if (tmp)
3303	who->insert (tmp);
3304
3305	who->update_stats ();
3306
3307	if (QUERY_FLAG (op, FLAG_CURSED) || QUERY_FLAG (op, FLAG_DAMNED))
3308	if (who->type == PLAYER)
3309	{
3310	who->failmsg ("Oops, it feels deadly cold! H<Maybe it wasn't such a bright idea to apply this cursed/damned item.>");
3311	SET_FLAG (tmp2, FLAG_KNOWN_CURSED);
3312	}
3313
3314	return 0;
3315		3428
3316	case SKILL_TOOL:	3429	case SKILL_TOOL:
3317	// applying a skill tool also readies the skill	3430	// applying a skill tool also readies the skill
3318	SET_FLAG (op, FLAG_APPLIED);	3431	SET_FLAG (op, FLAG_APPLIED);
3319		3432
…		…
3399	}	3512	}
3400		3513
3401	break;	3514	break;
3402		3515
3403	case BOW:	3516	case BOW:
3404	if (!check_weapon_power (who, op->last_eat))	3517	if (op->level && !op->name.starts_with (who->name))
3405	{
3406	who->failmsg ("That weapon is too powerful for you to use. It would consume your soul!" LACK_ITEM_POWER);
3407
3408	if (tmp)
3409	insert_ob_in_ob (tmp, who);
3410
3411	return 1;
3412	}
3413
3414	if (op->level && (strncmp (op->name, who->name, strlen (who->name))))
3415	{	3518	{
3416	who->failmsg ("The weapon does not recognize you as its owner. "	3519	who->failmsg ("The weapon does not recognize you as its owner. "
3417	"H<Its name indicates that it belongs to somebody else.>");	3520	"H<Its name indicates that it belongs to somebody else.>");
3418	if (tmp)	3521	if (tmp)
3419	insert_ob_in_ob (tmp, who);	3522	insert_ob_in_ob (tmp, who);
…		…
3493	if (QUERY_FLAG (op, FLAG_CURSED) || QUERY_FLAG (op, FLAG_DAMNED))	3596	if (QUERY_FLAG (op, FLAG_CURSED) || QUERY_FLAG (op, FLAG_DAMNED))
3494	if (who->type == PLAYER)	3597	if (who->type == PLAYER)
3495	{	3598	{
3496	who->failmsg (	3599	who->failmsg (
3497	"Oops, it feels deadly cold! "	3600	"Oops, it feels deadly cold! "
3498	"H<Maybe it wasn't such a bright idea to apply this cursed/damned item.>"	3601	"H<Maybe it wasn't such a bright idea to apply this cursed or damned item.>"
3499	);	3602	);
3500	SET_FLAG (op, FLAG_KNOWN_CURSED);	3603	SET_FLAG (op, FLAG_KNOWN_CURSED);
3501	}	3604	}
3502		3605
3503	if (object *pl = op->visible_to ())	3606	if (object *pl = op->visible_to ())
…		…
3572	/* If we generated an object and put it in this object inventory,	3675	/* If we generated an object and put it in this object inventory,
3573	* move it to the parent object as the current object is about	3676	* move it to the parent object as the current object is about
3574	* to disappear. An example of this item is the random_* stuff	3677	* to disappear. An example of this item is the random_* stuff
3575	* that is put inside other objects.	3678	* that is put inside other objects.
3576	*/	3679	*/
3577	for (tmp = op->inv; tmp; tmp = tmp2)
3578	{
3579	tmp2 = tmp->below;
3580	tmp->remove ();
3581
3582	if (op->env)	3680	if (op->env)
3583	insert_ob_in_ob (tmp, op->env);	3681	while (op->inv)
3584	else	3682	op->env->insert (op->inv);
3585	tmp->destroy ();
3586	}
3587		3683
3588	op->destroy ();	3684	op->destroy ();
3589	break;	3685	break;
3590	}	3686	}
3591		3687
…		…
3690	}	3786	}
3691		3787
3692	for (mapspace *ms = spaces + size (); ms-- > spaces; )	3788	for (mapspace *ms = spaces + size (); ms-- > spaces; )
3693	for (object *tmp = ms->bot; tmp; tmp = tmp->above)	3789	for (object *tmp = ms->bot; tmp; tmp = tmp->above)
3694	if (tmp->above && (tmp->type == TRIGGER_BUTTON || tmp->type == TRIGGER_PEDESTAL))	3790	if (tmp->above && (tmp->type == TRIGGER_BUTTON || tmp->type == TRIGGER_PEDESTAL))
3695	check_trigger (tmp, tmp->above);	3791	check_trigger (tmp, tmp->above, tmp->above);
3696	}	3792	}
3697		3793
3698	/**	3794	/**
3699	* Handles player eating food that temporarily changes status (resistances, stats).	3795	* Handles player eating food that temporarily changes status (resistances, stats).
3700	* This used to call cast_change_attr(), but	3796	* This used to call cast_change_attr(), but
…		…
3705	eat_special_food (object *who, object *food)	3801	eat_special_food (object *who, object *food)
3706	{	3802	{
3707	object *force;	3803	object *force;
3708	int i, did_one = 0;	3804	int i, did_one = 0;
3709		3805
3710	force = get_archetype (FORCE_NAME);	3806	char buf[64];
		3807	snprintf (buf, sizeof(buf), "sp_food_%s", &food->title);
		3808	shstr key (buf);
3711		3809
3712	for (i = 0; i < NUM_STATS; i++)
3713	if (sint8 k = food->stats.stat (i))
3714	{
3715	force->stats.stat (i) = k;
3716	did_one = 1;
3717	}
3718
3719	/* check if we can protect the eater */
3720	for (i = 0; i < NROFATTACKS; i++)
3721	{
3722	if (food->resist[i] > 0)
3723	{
3724	force->resist[i] = food->resist[i] / 2;
3725	did_one = 1;
3726	}
3727	}
3728
3729	if (did_one)
3730	{
3731	force->set_speed (0.1);
3732	/* bigger morsel of food = longer effect time */	3810	/* bigger morsel of food = longer effect time */
3733	force->duration = food->stats.food / 5;	3811	int duration = TIME2TICK (food->stats.food);
3734	SET_FLAG (force, FLAG_APPLIED);	3812
3735	change_abil (who, force);	3813	if (force = who->force_find (key))
3736	insert_ob_in_ob (force, who);	3814	{
		3815	if (duration > abs (force->speed_left / force->speed))
		3816	{
		3817	new_draw_info_format (NDI_UNIQUE, 0, who, "More magical force spreads through you. H<The effect will last for about %.10g more seconds.>", TICK2TIME (duration));
		3818	force->force_set_timer (duration);
		3819	}
		3820	else
		3821	new_draw_info (NDI_UNIQUE, 0, who, "It had no additional effect.");
		3822
		3823	return;
3737	}	3824	}
3738	else	3825	else
		3826	{
		3827	force = who->force_add (key, duration);
		3828	force->name = key;
		3829
		3830	/* check if the food affects a stat */
		3831	for (i = 0; i < NUM_STATS; i++)
		3832	if (sint8 k = food->stats.stat (i))
		3833	{
		3834	force->stats.stat (i) = k;
		3835	did_one = 1;
		3836	}
		3837
		3838	/* check if we can protect the eater */
		3839	for (i = 0; i < NROFATTACKS; i++)
		3840	{
		3841	if (food->resist[i] > 0)
		3842	{
		3843	force->resist[i] = food->resist[i];
		3844	did_one = 1;
		3845	}
		3846	}
		3847
		3848	if (did_one)
		3849	{
		3850	new_draw_info_format (NDI_UNIQUE, 0, who, "You are suffused with magical force. H<The effect will last for about %.10g seconds.>", TICK2TIME (duration));
		3851
		3852	/* make the force take effect and report effects to user */
		3853	change_abil (who, force);
		3854	}
		3855	else
3739	force->destroy ();	3856	force->destroy ();
		3857	}
3740		3858
3741	/* check for hp, sp change */	3859	/* check for hp, sp change */
3742	if (food->stats.hp != 0)	3860	if (food->stats.hp != 0)
3743	{	3861	{
3744	if (QUERY_FLAG (food, FLAG_CURSED))	3862	if (QUERY_FLAG (food, FLAG_CURSED))
…		…
3776	}	3894	}
3777		3895
3778	who->update_stats ();	3896	who->update_stats ();
3779	}	3897	}
3780		3898
3781	/**
3782	* Designed primarily to light torches/lanterns/etc.
3783	* Also burns up burnable material too. First object in the inventory is
3784	* the selected object to "burn". -b.t.
3785	*/
3786	void
3787	apply_lighter (object *who, object *lighter)
3788	{
3789	object *item;
3790	int is_player_env = 0;
3791
3792	item = find_marked_object (who);
3793	if (item)
3794	{
3795	if (lighter->last_eat && lighter->stats.food)
3796	{ /* lighter gets used up */
3797	object *oneLighter = lighter->split ();
3798	oneLighter->stats.food--;
3799	who->insert (oneLighter);
3800	}
3801	else if (lighter->last_eat)
3802	{
3803	/* no charges left in lighter */
3804	who->failmsg (format ("You attempt to light the %s with a used up %s.", &item->name, &lighter->name));
3805	return;
3806	}
3807
3808	/* Perhaps we should split what we are trying to light on fire?
3809	* I can't see many times when you would want to light multiple
3810	* objects at once.
3811	*/
3812
3813	if (who == item->in_player ())
3814	is_player_env = 1;
3815
3816	save_throw_object (item, AT_FIRE, who);
3817
3818	if (item->destroyed ())
3819	{
3820	who->statusmsg (format ("You light the %s with the %s.", &item->name, &lighter->name));
3821	/* Need to update the player so that the players glow radius
3822	* gets changed.
3823	*/
3824	if (is_player_env)
3825	who->update_stats ();
3826	}
3827	else
3828	who->failmsg (format ("You attempt to light the %s with the %s and fail.", &item->name, &lighter->name));
3829	}
3830	else
3831	who->failmsg ("You need to mark a lightable object.");
3832	}
3833		3899
3834	/**	3900	/**
3835	* op made some mistake with a scroll, this takes care of punishment.	3901	* op made some mistake with a scroll, this takes care of punishment.
3836	* scroll_failure()- hacked directly from spell_failure	3902	* scroll_failure()- hacked directly from spell_failure
3837	*/	3903	*/
…		…
3937	}	4003	}
3938		4004
3939	/* insert the randomitems from the change's treasurelist into	4005	/* insert the randomitems from the change's treasurelist into
3940	* the player ref: player.c	4006	* the player ref: player.c
3941	*/	4007	*/
3942	if (change->randomitems != NULL)	4008	if (change->randomitems)
3943	give_initial_items (pl, change->randomitems);	4009	give_initial_items (pl, change->randomitems);
3944		4010
3945	/* set up the face, for some races. */	4011	/* set up the face, for some races. */
3946		4012
3947	/* first, look for the force object banning	4013	/* first, look for the force object banning
3948	* changing the face. Certain races never change face with class.	4014	* changing the face. Certain races never change face with class.
3949	*/	4015	*/
3950	for (walk = pl->inv; walk != NULL; walk = walk->below)	4016	for (walk = pl->inv; walk; walk = walk->below)
3951	if (!strcmp (walk->name, "NOCLASSFACECHANGE"))	4017	if (walk->name == shstr_NOCLASSFACECHANGE)
3952	flag_change_face = 0;	4018	flag_change_face = 0;
3953		4019
3954	if (flag_change_face)	4020	if (flag_change_face)
3955	{	4021	{
3956	pl->face = change->face;	4022	pl->face = change->face;
…		…
3958	pl->flag [FLAG_ANIMATE] = change->flag [FLAG_ANIMATE];	4024	pl->flag [FLAG_ANIMATE] = change->flag [FLAG_ANIMATE];
3959	}	4025	}
3960		4026
3961	/* check the special case of can't use weapons */	4027	/* check the special case of can't use weapons */
3962	/*if(QUERY_FLAG(change,FLAG_USE_WEAPON)) CLEAR_FLAG(pl,FLAG_USE_WEAPON); */	4028	/*if(QUERY_FLAG(change,FLAG_USE_WEAPON)) CLEAR_FLAG(pl,FLAG_USE_WEAPON); */
3963	if (!strcmp (change->name, "monk"))	4029	if (change->name == shstr_monk)
3964	CLEAR_FLAG (pl, FLAG_USE_WEAPON);	4030	CLEAR_FLAG (pl, FLAG_USE_WEAPON);
3965		4031
3966	break;	4032	break;
3967	}	4033	}
3968	}	4034	}
…		…
4005	pl->failmsg (format ("You can't use the %s with your %s!", query_name (transformer), query_name (marked)));	4071	pl->failmsg (format ("You can't use the %s with your %s!", query_name (transformer), query_name (marked)));
4006	return;	4072	return;
4007	}	4073	}
4008		4074
4009	/* check whether they are compatible or not */	4075	/* check whether they are compatible or not */
4010	find = strstr (marked->slaying, transformer->arch->archname);	4076	find = strstr (&marked->slaying, transformer->arch->archname);
4011	if (!find || (*(find + strlen (transformer->arch->archname)) != ':'))	4077	if (!find || (*(find + strlen (transformer->arch->archname)) != ':'))
4012	{	4078	{
4013	pl->failmsg (format ("You can't use the %s with your %s!", query_name (transformer), query_name (marked)));	4079	pl->failmsg (format ("You can't use the %s with your %s!", query_name (transformer), query_name (marked)));
4014	return;	4080	return;
4015	}	4081	}

Diff Legend

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