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.178 by root, Sun Dec 28 15:28:47 2008 UTC vs.
Revision 1.209 by root, Fri Nov 6 12:49:19 2009 UTC

…		…
3	*	3	*
4	* Copyright (©) 2005,2006,2007,2008 Marc Alexander Lehmann / Robin Redeker / the Deliantra team	4	* Copyright (©) 2005,2006,2007,2008 Marc Alexander Lehmann / Robin Redeker / the Deliantra team
5	* Copyright (©) 2001,2007 Mark Wedel & Crossfire Development Team	5	* Copyright (©) 2001,2007 Mark Wedel & Crossfire Development Team
6	* Copyright (©) 1992,2007 Frank Tore Johansen	6	* Copyright (©) 1992,2007 Frank Tore Johansen
7	*	7	*
8	* Deliantra is free software: you can redistribute it and/or modify	8	* Deliantra is free software: you can redistribute it and/or modify it under
9	* it under the terms of the GNU General Public License as published by	9	* the terms of the Affero GNU General Public License as published by the
10	* the Free Software Foundation, either version 3 of the License, or	10	* Free Software Foundation, either version 3 of the License, or (at your
11	* (at your option) any later version.	11	* option) any later version.
12	*	12	*
13	* This program is distributed in the hope that it will be useful,	13	* This program is distributed in the hope that it will be useful,
14	* but WITHOUT ANY WARRANTY; without even the implied warranty of	14	* but WITHOUT ANY WARRANTY; without even the implied warranty of
15	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the	15	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16	* GNU General Public License for more details.	16	* GNU General Public License for more details.
17	*	17	*
18	* You should have received a copy of the GNU General Public License	18	* You should have received a copy of the Affero GNU General Public License
19	* along with this program. If not, see <http://www.gnu.org/licenses/>.	19	* and the GNU General Public License along with this program. If not, see
		20	* <http://www.gnu.org/licenses/>.
20	*	21	*
21	* The authors can be reached via e-mail to <support@deliantra.net>	22	* The authors can be reached via e-mail to <support@deliantra.net>
22	*/	23	*/
23		24
24	#include <cmath>	25	#include <cmath>
…		…
92	* Return value: 1 if money was destroyed, 0 if not.	93	* Return value: 1 if money was destroyed, 0 if not.
93	*/	94	*/
94	static int	95	static int
95	apply_id_altar (object *money, object *altar, object *pl)	96	apply_id_altar (object *money, object *altar, object *pl)
96	{	97	{
97	dynbuf_text buf;	98	dynbuf_text &buf = msg_dynbuf; buf.clear ();
98		99
99	if (!pl || pl->type != PLAYER)	100	if (!pl || pl->type != PLAYER)
100	return 0;	101	return 0;
101		102
102	/* Check for MONEY type is a special hack - it prevents 'nothing needs	103	/* Check for MONEY type is a special hack - it prevents 'nothing needs
103	* identifying' from being printed out more than it needs to be.	104	* identifying' from being printed out more than it needs to be.
104	*/	105	*/
105	if (!check_altar_sacrifice (altar, money) || money->type != MONEY)	106	if (!check_altar_sacrifice (altar, money, pl) || money->type != MONEY)
106	return 0;	107	return 0;
107		108
108	/* if the player has a marked item, identify that if it needs to be	109	/* 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.	110	* identified. If it doesn't, then go through the player inventory.
110	*/	111	*/
111	if (object *marked = find_marked_object (pl))	112	if (object *marked = find_marked_object (pl))
112	if (!QUERY_FLAG (marked, FLAG_IDENTIFIED) && need_identify (marked))	113	if (!QUERY_FLAG (marked, FLAG_IDENTIFIED) && need_identify (marked))
113	{	114	{
114	if (operate_altar (altar, &money))	115	if (operate_altar (altar, &money, pl))
115	{	116	{
116	identify (marked);	117	identify (marked);
117		118
118	buf.printf ("You have %s.\r", long_desc (marked, pl));	119	buf.printf ("You have %s.\r", long_desc (marked, pl));
119	if (marked->msg)	120	if (marked->msg)
…		…
125		126
126	for (object *id = pl->inv; id; id = id->below)	127	for (object *id = pl->inv; id; id = id->below)
127	{	128	{
128	if (!QUERY_FLAG (id, FLAG_IDENTIFIED) && !id->invisible && need_identify (id))	129	if (!QUERY_FLAG (id, FLAG_IDENTIFIED) && !id->invisible && need_identify (id))
129	{	130	{
130	if (operate_altar (altar, &money))	131	if (operate_altar (altar, &money, pl))
131	{	132	{
132	identify (id);	133	identify (id);
133		134
134	buf.printf ("You have %s.\r", long_desc (id, pl));	135	buf.printf ("You have %s.\r", long_desc (id, pl));
135	if (id->msg)	136	if (id->msg)
…		…
160	* matching item.	161	* matching item.
161	**/	162	**/
162	void	163	void
163	handle_apply_yield (object *tmp)	164	handle_apply_yield (object *tmp)
164	{	165	{
165	if (shstr yield = tmp->kv (shstr_on_use_yield))	166	if (shstr_tmp yield = tmp->kv (shstr_on_use_yield))
166	archetype::get (yield)->insert_at (tmp, tmp, INS_BELOW_ORIGINATOR);	167	archetype::get (yield)->insert_at (tmp, tmp, INS_BELOW_ORIGINATOR);
167	}	168	}
168		169
169	/**	170	/**
170	* Handles applying a potion.	171	* Handles applying a potion.
…		…
315	*/	316	*/
316	if (tmp->inv)	317	if (tmp->inv)
317	{	318	{
318	if (QUERY_FLAG (tmp, FLAG_CURSED) || QUERY_FLAG (tmp, FLAG_DAMNED))	319	if (QUERY_FLAG (tmp, FLAG_CURSED) || QUERY_FLAG (tmp, FLAG_DAMNED))
319	{	320	{
320	object *fball;
321
322	op->failmsg ("Yech! Your lungs are on fire!");	321	op->failmsg ("Yech! Your lungs are on fire!");
323		322	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	}	323	}
332	else	324	else
333	cast_spell (op, tmp, op->facing, tmp->inv, NULL);	325	cast_spell (op, tmp, op->facing, tmp->inv, NULL);
334		326
335	tmp->decrease ();	327	tmp->decrease ();
…		…
378	}	370	}
379		371
380	/* Only thing left are the stat potions */	372	/* Only thing left are the stat potions */
381	if (op->type == PLAYER)	373	if (op->type == PLAYER)
382	{ /* only for players */	374	{ /* only for players */
383	if ((QUERY_FLAG (tmp, FLAG_CURSED) || QUERY_FLAG (tmp, FLAG_DAMNED)) && tmp->value != 0)	375	if ((QUERY_FLAG (tmp, FLAG_CURSED)
		376	|| QUERY_FLAG (tmp, FLAG_DAMNED))
		377	&& tmp->value != 0)
384	CLEAR_FLAG (tmp, FLAG_APPLIED);	378	CLEAR_FLAG (tmp, FLAG_APPLIED);
385	else	379	else
386	SET_FLAG (tmp, FLAG_APPLIED);	380	SET_FLAG (tmp, FLAG_APPLIED);
387		381
388	if (!change_abil (op, tmp))	382	if (!change_abil (op, tmp))
…		…
403	/****************************************************************************	397	/****************************************************************************
404	* Weapon improvement code follows	398	* Weapon improvement code follows
405	****************************************************************************/	399	****************************************************************************/
406		400
407	/**	401	/**
		402	* This function just checks whether who can handle equipping an item
		403	* with item_power.
		404	*/
		405	static 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;
…		…
753	/**	706	/**
754	* Handles the applying of improve/prepare/enchant weapon scroll.	707	* Handles the applying of improve/prepare/enchant weapon scroll.
755	* Checks a few things (not on a non-magic square, marked weapon, ...),	708	* Checks a few things (not on a non-magic square, marked weapon, ...),
756	* then calls improve_weapon to do the dirty work.	709	* then calls improve_weapon to do the dirty work.
757	*/	710	*/
758	int	711	static int
759	check_improve_weapon (object *op, object *tmp)	712	check_improve_weapon (object *op, object *tmp)
760	{	713	{
761	object *otmp;	714	object *otmp;
762		715
763	if (op->type != PLAYER)	716	if (op->type != PLAYER)
…		…
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])
…		…
1031	* Handle apply on containers.	984	* Handle apply on containers.
1032	* By Eneq(@csd.uu.se).	985	* By Eneq(@csd.uu.se).
1033	* Moved to own function and added many features [Tero.Haatanen@lut.fi]	986	* Moved to own function and added many features [Tero.Haatanen@lut.fi]
1034	* added the alchemical cauldron to the code -b.t.	987	* added the alchemical cauldron to the code -b.t.
1035	*/	988	*/
1036	int	989	static int
1037	apply_container (object *op, object *sack)	990	apply_container (object *op, object *sack)
1038	{	991	{
1039	if (op->type != PLAYER || !op->contr->ns)	992	if (op->type != PLAYER || !op->contr->ns)
1040	return 0; /* This might change */	993	return 0; /* This might change */
1041		994
…		…
1054	}	1007	}
1055		1008
1056	// already applied == open on ground, or open in inv, or active in inv	1009	// already applied == open on ground, or open in inv, or active in inv
1057	if (sack->flag [FLAG_APPLIED])	1010	if (sack->flag [FLAG_APPLIED])
1058	{	1011	{
1059	if (op->container == sack)	1012	if (op->container_ () == sack)
1060	{	1013	{
1061	// open on ground or inv, so close	1014	// open on ground or inv, so close
1062	op->close_container ();	1015	op->close_container ();
1063	return 1;	1016	return 1;
1064	}	1017	}
…		…
1107	{	1060	{
1108	/* Only players can make sacrifices on spell casting altars. */	1061	/* Only players can make sacrifices on spell casting altars. */
1109	if (altar->inv && (!originator || originator->type != PLAYER))	1062	if (altar->inv && (!originator || originator->type != PLAYER))
1110	return 0;	1063	return 0;
1111		1064
1112	if (operate_altar (altar, &sacrifice))	1065	if (operate_altar (altar, &sacrifice, originator))
1113	{	1066	{
1114	/* Simple check. Unfortunately, it means you can't cast magic bullet	1067	/* Simple check. Unfortunately, it means you can't cast magic bullet
1115	* 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
1116	* is up to map designers to use them properly.	1069	* is up to map designers to use them properly.
1117	*/	1070	*/
…		…
1126	/* push_button (altar);*/	1079	/* push_button (altar);*/
1127	}	1080	}
1128	else	1081	else
1129	{	1082	{
1130	altar->value = 1; /* works only once */	1083	altar->value = 1; /* works only once */
1131	push_button (altar);	1084	push_button (altar, originator);
1132	}	1085	}
1133		1086
1134	return !sacrifice;	1087	return !sacrifice;
1135	}	1088	}
1136	else	1089	else
…		…
1153		1106
1154	SET_FLAG (op, FLAG_NO_APPLY); /* prevent loops */	1107	SET_FLAG (op, FLAG_NO_APPLY); /* prevent loops */
1155		1108
1156	bool has_unpaid = false;	1109	bool has_unpaid = false;
1157		1110
1158	// 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
1159	// a quick and small change :(	1112	// a quick and small change :(
1160	for (object::depth_iterator item = op->begin (); item != op->end (); ++item)	1113	for (object::depth_iterator item = op->begin (); item != op->end (); ++item)
1161	if (item->flag [FLAG_UNPAID])	1114	if (item->flag [FLAG_UNPAID])
1162	{	1115	{
1163	has_unpaid = true;	1116	has_unpaid = true;
…		…
1263	* Handles applying a sign.	1216	* Handles applying a sign.
1264	*/	1217	*/
1265	static void	1218	static void
1266	apply_sign (object *op, object *sign, int autoapply)	1219	apply_sign (object *op, object *sign, int autoapply)
1267	{	1220	{
		1221	if (!op->is_player())
		1222	return;
		1223
1268	if (sign->has_dialogue ())	1224	if (sign->has_dialogue ())
1269	{	1225	{
1270	op->statusmsg (format ("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));
1271	return;	1227	return;
1272	}	1228	}
…		…
1368	return;	1324	return;
1369		1325
1370	/* move_apply() is the most likely candidate for causing unwanted and	1326	/* move_apply() is the most likely candidate for causing unwanted and
1371	* possibly unlimited recursion.	1327	* possibly unlimited recursion.
1372	*/	1328	*/
1373	/* The following was changed because it was causing perfeclty correct	1329	/* The following was changed because it was causing perfectly correct
1374	* maps to fail. 1) it's not an error to recurse:	1330	* maps to fail. 1) it's not an error to recurse:
1375	* rune detonates, summoning monster. monster lands on nearby rune.	1331	* rune detonates, summoning monster. monster lands on nearby rune.
1376	* nearby rune detonates. This sort of recursion is expected and	1332	* nearby rune detonates. This sort of recursion is expected and
1377	* proper. This code was causing needless crashes.	1333	* proper. This code was causing needless crashes.
1378	*/	1334	*/
…		…
1385		1341
1386	recursion_depth++;	1342	recursion_depth++;
1387	if (trap->head)	1343	if (trap->head)
1388	trap = trap->head;	1344	trap = trap->head;
1389		1345
1390	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)))
1391	goto leave;
1392
1393	switch (trap->type)	1347	switch (trap->type)
1394	{	1348	{
1395	case PLAYERMOVER:	1349	case PLAYERMOVER:
1396	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	case T_MATCH:
		1389	update_button (trap, originator);
		1390	break;
		1391
		1392	case ALTAR:
		1393	/* sacrifice victim on trap */
		1394	apply_altar (trap, victim, originator);
		1395	break;
		1396
		1397	case THROWN_OBJ:
		1398	if (trap->inv == NULL)
		1399	break;
		1400	/* fallthrough */
		1401
		1402	case ARROW:
		1403	/* bad bug: monster throw a object, make a step forwards, step on object ,
		1404	* trigger this here and get hit by own missile - and will be own enemy.
		1405	* Victim then is his own enemy and will start to kill herself (this is
		1406	* removed) but we have not synced victim and his missile. To avoid senseless
		1407	* action, we avoid hits here
		1408	*/
		1409	if ((QUERY_FLAG (victim, FLAG_ALIVE) && trap->speed) && trap->owner != victim)
		1410	hit_with_arrow (trap, victim);
		1411	break;
		1412
		1413	case SPELL_EFFECT:
		1414	apply_spell_effect (trap, victim);
		1415	break;
		1416
		1417	case TRAPDOOR:
1397	{	1418	{
		1419	int max, sound_was_played;
		1420	object *ab, *ab_next;
		1421
1398	if (!trap->stats.maxsp)	1422	if (!trap->value)
1399	trap->stats.maxsp = 2;	1423	{
		1424	int tot;
1400		1425
1401	/* Is this correct? From the docs, it doesn't look like it	1426	for (ab = trap->above, tot = 0; ab; ab = ab->above)
1402	* should be divided by trap->speed	1427	if ((ab->move_type && trap->move_on) || ab->move_type == 0)
		1428	tot += ab->head_ ()->total_weight ();
		1429
		1430	if (!(trap->value = (tot > trap->weight) ? 1 : 0))
		1431	break;
		1432
		1433	SET_ANIMATION (trap, trap->value);
		1434	update_object (trap, UP_OBJ_FACE);
		1435	}
		1436
		1437	for (ab = trap->above, max = 100, sound_was_played = 0; --max && ab; ab = ab_next)
		1438	{
		1439	/* need to set this up, since if we do transfer the object,
		1440	* ab->above would be bogus
1403	*/	1441	*/
1404	victim->speed_left = -FABS (trap->stats.maxsp * victim->speed / trap->speed);	1442	ab_next = ab->above;
1405		1443
1406	/* Just put in some sanity check. I think there is a bug in the	1444	if ((ab->move_type && trap->move_on) || ab->move_type == 0)
1407	* above with some objects have zero speed, and thus the player	1445	{
1408	* getting permanently paralyzed.	1446	if (!sound_was_played)
		1447	{
		1448	trap->play_sound (trap->sound ? trap->sound : sound_find ("fall_hole"));
		1449	sound_was_played = 1;
		1450	}
		1451
		1452	ab->statusmsg ("You fall into a trapdoor!", NDI_RED);
		1453	transfer_ob (ab, EXIT_X (trap), EXIT_Y (trap), 0, ab);
		1454	}
1409	*/	1455	}
1410	if (victim->speed_left < -50.f)	1456	break;
1411	victim->speed_left = -50.f;
1412	/* LOG(llevDebug, "apply, playermove, player speed_left=%f\n", victim->speed_left); */
1413	}	1457	}
1414	goto leave;
1415		1458
1416	case SPINNER:	1459	case CONVERTER:
1417	if (victim->direction)	1460	if (convert_item (victim, trap) < 0)
1418	{
1419	victim->direction = absdir (victim->direction - trap->stats.sp);
1420	update_turn_face (victim);
1421	}
1422	goto leave;
1423
1424	case DIRECTOR:
1425	if (victim->direction && !should_director_abort (trap, victim))
1426	{
1427	victim->direction = trap->stats.sp;
1428	update_turn_face (victim);
1429	}
1430	goto leave;
1431
1432	case BUTTON:
1433	case PEDESTAL:
1434	update_button (trap);
1435	goto leave;
1436
1437	case ALTAR:
1438	/* sacrifice victim on trap */
1439	apply_altar (trap, victim, originator);
1440	goto leave;
1441
1442	case THROWN_OBJ:
1443	if (trap->inv == NULL)
1444	goto leave;
1445	/* fallthrough */
1446
1447	case ARROW:
1448	/* bad bug: monster throw a object, make a step forwards, step on object ,
1449	* trigger this here and get hit by own missile - and will be own enemy.
1450	* Victim then is his own enemy and will start to kill herself (this is
1451	* removed) but we have not synced victim and his missile. To avoid senseless
1452	* action, we avoid hits here
1453	*/
1454	if ((QUERY_FLAG (victim, FLAG_ALIVE) && trap->speed) && trap->owner != victim)
1455	hit_with_arrow (trap, victim);
1456	goto leave;
1457
1458	case SPELL_EFFECT:
1459	apply_spell_effect (trap, victim);
1460	goto leave;
1461
1462	case TRAPDOOR:
1463	{
1464	int max, sound_was_played;
1465	object *ab, *ab_next;
1466
1467	if (!trap->value)
1468	{	1461	{
1469	int tot;	1462	originator->failmsg (format ("The %s seems to be broken!", query_name (trap)));
1470		1463	archetype::get (shstr_burnout)->insert_at (trap, trap);
1471	for (ab = trap->above, tot = 0; ab; ab = ab->above)
1472	if ((ab->move_type && trap->move_on) || ab->move_type == 0)
1473	tot += ab->head_ ()->total_weight ();
1474
1475	if (!(trap->value = (tot > trap->weight) ? 1 : 0))
1476	goto leave;
1477
1478	SET_ANIMATION (trap, trap->value);
1479	update_object (trap, UP_OBJ_FACE);
1480	}	1464	}
1481		1465
1482	for (ab = trap->above, max = 100, sound_was_played = 0; --max && ab; ab = ab_next)	1466	break;
		1467
		1468	case TRIGGER_BUTTON:
		1469	case TRIGGER_PEDESTAL:
		1470	case TRIGGER_ALTAR:
		1471	check_trigger (trap, victim, originator);
		1472	break;
		1473
		1474	case DEEP_SWAMP:
		1475	walk_on_deep_swamp (trap, victim);
		1476	break;
		1477
		1478	case CHECK_INV:
		1479	check_inv (victim, trap);
		1480	break;
		1481
		1482	case HOLE:
		1483	move_apply_hole (trap, victim);
		1484	break;
		1485
		1486	case EXIT:
		1487	if (victim->type == PLAYER && EXIT_PATH (trap))
1483	{	1488	{
1484	/* need to set this up, since if we do transfer the object,	1489	/* Basically, don't show exits leading to random maps the
1485	* ab->above would be bogus	1490	* players output.
1486	*/	1491	*/
1487	ab_next = ab->above;	1492	if (trap->msg && !EXIT_PATH (trap).starts_with ("/!"))
		1493	victim->statusmsg (trap->msg, NDI_NAVY);
1488		1494
1489	if ((ab->move_type && trap->move_on) || ab->move_type == 0)	1495	trap->play_sound (trap->sound);
1490	{	1496	victim->enter_exit (trap);
1491	if (!sound_was_played)
1492	{
1493	trap->play_sound (trap->sound ? trap->sound : sound_find ("fall_hole"));
1494	sound_was_played = 1;
1495	}
1496
1497	ab->statusmsg ("You fall into a trapdoor!", NDI_RED);
1498	transfer_ob (ab, EXIT_X (trap), EXIT_Y (trap), 0, ab);
1499	}
1500	}	1497	}
1501	goto leave;	1498	break;
1502	}
1503		1499
1504	case CONVERTER:
1505	if (convert_item (victim, trap) < 0)
1506	{
1507	originator->failmsg (format ("The %s seems to be broken!", query_name (trap)));
1508	archetype::get (shstr_burnout)->insert_at (trap, trap);
1509	}
1510
1511	goto leave;
1512
1513	case TRIGGER_BUTTON:
1514	case TRIGGER_PEDESTAL:
1515	case TRIGGER_ALTAR:
1516	check_trigger (trap, victim);
1517	goto leave;
1518
1519	case DEEP_SWAMP:
1520	walk_on_deep_swamp (trap, victim);
1521	goto leave;
1522
1523	case CHECK_INV:
1524	check_inv (victim, trap);
1525	goto leave;
1526
1527	case HOLE:
1528	move_apply_hole (trap, victim);
1529	goto leave;
1530
1531	case EXIT:
1532	if (victim->type == PLAYER && EXIT_PATH (trap))
1533	{
1534	/* Basically, don't show exits leading to random maps the
1535	* players output.
1536	*/
1537	if (trap->msg && strncmp (EXIT_PATH (trap), "/!", 2))
1538	victim->statusmsg (trap->msg, NDI_NAVY);
1539
1540	trap->play_sound (trap->sound);
1541	victim->enter_exit (trap);
1542	}
1543	goto leave;
1544
1545	case ENCOUNTER:	1500	case ENCOUNTER:
1546	/* may be some leftovers on this */	1501	/* may be some leftovers on this */
1547	goto leave;	1502	break;
1548		1503
1549	case SHOP_MAT:	1504	case SHOP_MAT:
1550	apply_shop_mat (trap, victim);	1505	apply_shop_mat (trap, victim);
1551	goto leave;	1506	break;
1552		1507
1553	/* Drop a certain amount of gold, and have one item identified */	1508	/* Drop a certain amount of gold, and have one item identified */
1554	case IDENTIFY_ALTAR:	1509	case IDENTIFY_ALTAR:
1555	apply_id_altar (victim, trap, originator);	1510	apply_id_altar (victim, trap, originator);
1556	goto leave;	1511	break;
1557		1512
1558	case SIGN:	1513	case SIGN:
1559	if (victim->type != PLAYER && trap->stats.food > 0)	1514	if (victim->type != PLAYER && trap->stats.food > 0)
1560	goto leave; /* monsters musn't apply magic_mouths with counters */	1515	break; /* monsters musn't apply magic_mouths with counters */
1561		1516
1562	apply_sign (victim, trap, 1);	1517	apply_sign (victim, trap, 1);
1563	goto leave;	1518	break;
1564		1519
1565	case CONTAINER:	1520	case CONTAINER:
1566	apply_container (victim, trap);	1521	apply_container (victim, trap);
1567	goto leave;	1522	break;
1568		1523
1569	case RUNE:	1524	case RUNE:
1570	case TRAP:	1525	case TRAP:
1571	if (trap->level && QUERY_FLAG (victim, FLAG_ALIVE))	1526	if (trap->level && QUERY_FLAG (victim, FLAG_ALIVE))
1572	spring_trap (trap, victim);	1527	spring_trap (trap, victim);
1573	goto leave;	1528	break;
1574		1529
1575	default:	1530	default:
1576	LOG (llevDebug, "name %s, arch %s, type %d with fly/walk on/off not "	1531	LOG (llevDebug, "name %s, arch %s, type %d with fly/walk on/off not "
1577	"handled in move_apply()\n", &trap->name, &trap->arch->archname, trap->type);	1532	"handled in move_apply()\n", &trap->name, &trap->arch->archname, trap->type);
1578	goto leave;	1533	break;
1579	}	1534	}
1580		1535
1581	leave:
1582	recursion_depth--;	1536	recursion_depth--;
1583	}	1537	}
1584		1538
1585	/**	1539	/**
1586	* Handles reading a regular (ie not containing a spell) book.	1540	* Handles reading a regular (ie not containing a spell) book.
…		…
1597	return;	1551	return;
1598	}	1552	}
1599		1553
1600	if (!tmp->msg)	1554	if (!tmp->msg)
1601	{	1555	{
1602	op->failmsg (format ("You open the %s and find it empty.", &tmp->name));	1556	op->failmsg (format ("The %s contains nothing but meaningless gibberish. H<There is nothing interesting to read here.>", &tmp->name));
1603	return;	1557	return;
1604	}	1558	}
1605		1559
1606	/* need a literacy skill to read stuff! */	1560	/* need a literacy skill to read stuff! */
1607	skill_ob = find_skill_by_name (op, tmp->skill);	1561	skill_ob = find_skill_by_name (op, tmp->skill);
…		…
1647	SET_FLAG (tmp, FLAG_NO_SKILL_IDENT); /* so no more xp gained from this book */	1601	SET_FLAG (tmp, FLAG_NO_SKILL_IDENT); /* so no more xp gained from this book */
1648	}	1602	}
1649	}	1603	}
1650		1604
1651	/**	1605	/**
		1606	* op made some mistake with a scroll, this takes care of punishment.
		1607	* scroll_failure()- hacked directly from spell_failure
		1608	*/
		1609	static void
		1610	scroll_failure (object *op, int failure, int power)
		1611	{
		1612	if (abs (failure / 4) > power)
		1613	power = abs (failure / 4); /* set minimum effect */
		1614
		1615	if (failure <= -1 && failure > -15)
		1616	{ /* wonder */
		1617	object *tmp;
		1618
		1619	op->failmsg ("Your spell warps!");
		1620	tmp = get_archetype (SPELL_WONDER);
		1621	cast_wonder (op, op, 0, tmp);
		1622	tmp->destroy ();
		1623	}
		1624	else if (failure <= -15 && failure > -35)
		1625	{ /* drain mana */
		1626	op->failmsg ("Your mana is drained!");
		1627	op->stats.sp -= random_roll (0, power - 1, op, PREFER_LOW);
		1628	if (op->stats.sp < 0)
		1629	op->stats.sp = 0;
		1630	}
		1631	else if (settings.spell_failure_effects == TRUE)
		1632	{
		1633	if (failure <= -35 && failure > -60)
		1634	{ /* confusion */
		1635	op->failmsg ("The magic recoils on you!");
		1636	confuse_player (op, op, power);
		1637	}
		1638	else if (failure <= -60 && failure > -70)
		1639	{ /* paralysis */
		1640	op->failmsg ("The magic recoils and paralyzes you!");
		1641	paralyze_player (op, op, power);
		1642	}
		1643	else if (failure <= -70 && failure > -80)
		1644	{ /* blind */
		1645	op->failmsg ("The magic recoils on you!");
		1646	blind_player (op, op, power);
		1647	}
		1648	else if (failure <= -80)
		1649	{ /* blast the immediate area */
		1650	object *tmp = get_archetype (LOOSE_MANA);
		1651	cast_magic_storm (op, tmp, power);
		1652	op->failmsg ("You unleash uncontrolled mana!");
		1653	tmp->destroy ();
		1654	}
		1655	}
		1656	}
		1657
		1658	/**
1652	* Handles the applying of a skill scroll, calling learn_skill straight.	1659	* Handles the applying of a skill scroll, calling learn_skill straight.
1653	* op is the person learning the skill, tmp is the skill scroll object	1660	* op is the person learning the skill, tmp is the skill scroll object
1654	*/	1661	*/
1655	static void	1662	static void
1656	apply_skillscroll (object *op, object *tmp)	1663	apply_skillscroll (object *op, object *tmp)
…		…
1789	LOG (llevError, "apply_spellbook: Book %s has no spell in it!\n", &tmp->name);	1796	LOG (llevError, "apply_spellbook: Book %s has no spell in it!\n", &tmp->name);
1790	op->failmsg ("The spellbook symbols make no sense. This is a bug, please report!");	1797	op->failmsg ("The spellbook symbols make no sense. This is a bug, please report!");
1791	return;	1798	return;
1792	}	1799	}
1793		1800
1794	if (skop->level < int (sqrtf (spell->level) * 1.5f))	1801	int learn_level = sqrtf (spell->level) * 1.5f;
		1802	if (skop->level < learn_level)
1795	{	1803	{
1796	op->failmsg (format ("You are unable to decipher the strange symbols. H<Your %s level is too low.>", &tmp->skill));	1804	op->failmsg (format ("You are unable to decipher the strange symbols. H<Your %s level is too low, it must be at least %d.>",
		1805	&tmp->skill, learn_level));
1797	return;	1806	return;
1798	}	1807	}
1799		1808
1800	op->statusmsg (format ("The spellbook contains the %s level spell %s.", get_levelnumber (spell->level), &spell->name));	1809	op->statusmsg (format ("The spellbook contains the %s level spell %s.", get_levelnumber (spell->level), &spell->name));
1801		1810
…		…
1962	if (!tmp->destroyed () && !tmp->inv)	1971	if (!tmp->destroyed () && !tmp->inv)
1963	tmp->decrease (true);	1972	tmp->decrease (true);
1964	}	1973	}
1965		1974
1966	/**	1975	/**
1967	* op eats food.
1968	* If player, takes care of messages and dragon special food.
1969	*/
1970	static void
1971	apply_food (object *op, object *tmp)
1972	{
1973	int capacity_remaining;
1974
1975	if (op->type != PLAYER)
1976	op->stats.hp = op->stats.maxhp;
1977	else
1978	{
1979	/* check if this is a dragon (player), eating some flesh */
1980	if (tmp->type == FLESH && is_dragon_pl (op) && dragon_eat_flesh (op, tmp))
1981	;
1982	else
1983	{
1984	/* usual case - no dragon meal: */
1985	if (op->stats.food + tmp->stats.food > 999)
1986	{
1987	if (tmp->type == FOOD || tmp->type == FLESH)
1988	op->failmsg ("You feel full, but what a waste of food!");
1989	else
1990	op->statusmsg ("Most of the drink goes down your face not your throat!");
1991	}
1992
1993	tmp->play_sound (
1994	tmp->sound
1995	? tmp->sound
1996	: tmp->type == DRINK
1997	? sound_find ("eat_drink")
1998	: sound_find ("eat_food")
1999	);
2000
2001	if (!QUERY_FLAG (tmp, FLAG_CURSED))
2002	{
2003	const char *buf;
2004
2005	if (!is_dragon_pl (op))
2006	{
2007	/* eating message for normal players */
2008	if (tmp->type == DRINK)
2009	buf = format ("Ahhh...that %s tasted good.", &tmp->name);
2010	else
2011	buf = format ("The %s tasted %s", &tmp->name, tmp->type == FLESH ? "terrible!" : "good.");
2012	}
2013	else
2014	/* eating message for dragon players */
2015	buf = format ("The %s tasted terrible!", &tmp->name);
2016
2017	op->statusmsg (buf);
2018
2019	capacity_remaining = 999 - op->stats.food;
2020	op->stats.food += tmp->stats.food;
2021	if (capacity_remaining < tmp->stats.food)
2022	op->stats.hp += capacity_remaining / 50;
2023	else
2024	op->stats.hp += tmp->stats.food / 50;
2025
2026	if (op->stats.hp > op->stats.maxhp)
2027	op->stats.hp = op->stats.maxhp;
2028	if (op->stats.food > 999)
2029	op->stats.food = 999;
2030	}
2031
2032	/* special food hack -b.t. */
2033	if (tmp->title || QUERY_FLAG (tmp, FLAG_CURSED))
2034	eat_special_food (op, tmp);
2035	}
2036	}
2037
2038	handle_apply_yield (tmp);
2039	tmp->decrease ();
2040	}
2041
2042	/**
2043	* A dragon is eating some flesh. If the flesh contains resistances,	1976	* A dragon is eating some flesh. If the flesh contains resistances,
2044	* there is a chance for the dragon's skin to get improved.	1977	* there is a chance for the dragon's skin to get improved.
2045	*	1978	*
2046	* attributes:	1979	* attributes:
2047	* object *op the object (dragon player) eating the flesh	1980	* object *op the object (dragon player) eating the flesh
2048	* object *meal the flesh item, getting chewed in dragon's mouth	1981	* object *meal the flesh item, getting chewed in dragon's mouth
2049	* return:	1982	* return:
2050	* int 1 if eating successful, 0 if it doesn't work	1983	* int 1 if eating successful, 0 if it doesn't work
2051	*/	1984	*/
2052	int	1985	static int
2053	dragon_eat_flesh (object *op, object *meal)	1986	dragon_eat_flesh (object *op, object *meal)
2054	{	1987	{
2055	object *skin = NULL; /* pointer to dragon skin force */	1988	object *skin = NULL; /* pointer to dragon skin force */
2056	object *abil = NULL; /* pointer to dragon ability force */	1989	object *abil = NULL; /* pointer to dragon ability force */
2057	object *tmp = NULL; /* tmp. object */	1990	object *tmp = NULL; /* tmp. object */
…		…
2198		2131
2199	return 1;	2132	return 1;
2200	}	2133	}
2201		2134
2202	/**	2135	/**
		2136	* op eats food.
		2137	* If player, takes care of messages and dragon special food.
		2138	*/
		2139	static void
		2140	apply_food (object *op, object *tmp)
		2141	{
		2142	int capacity_remaining;
		2143
		2144	if (op->type != PLAYER)
		2145	op->stats.hp = op->stats.maxhp;
		2146	else
		2147	{
		2148	/* check if this is a dragon (player), eating some flesh */
		2149	if (tmp->type == FLESH && is_dragon_pl (op) && dragon_eat_flesh (op, tmp))
		2150	;
		2151	else
		2152	{
		2153	/* usual case - no dragon meal: */
		2154	if (op->stats.food + tmp->stats.food > 999)
		2155	{
		2156	if (tmp->type == FOOD || tmp->type == FLESH)
		2157	op->failmsg ("You feel full, but what a waste of food!");
		2158	else
		2159	op->statusmsg ("Most of the drink goes down your face not your throat!");
		2160	}
		2161
		2162	tmp->play_sound (
		2163	tmp->sound
		2164	? tmp->sound
		2165	: tmp->type == DRINK
		2166	? sound_find ("eat_drink")
		2167	: sound_find ("eat_food")
		2168	);
		2169
		2170	if (!QUERY_FLAG (tmp, FLAG_CURSED))
		2171	{
		2172	const char *buf;
		2173
		2174	if (!is_dragon_pl (op))
		2175	{
		2176	/* eating message for normal players */
		2177	if (tmp->type == DRINK)
		2178	buf = format ("Ahhh...that %s tasted good.", &tmp->name);
		2179	else
		2180	buf = format ("The %s tasted %s", &tmp->name, tmp->type == FLESH ? "terrible!" : "good.");
		2181	}
		2182	else
		2183	/* eating message for dragon players */
		2184	buf = format ("The %s tasted terrible!", &tmp->name);
		2185
		2186	op->statusmsg (buf);
		2187
		2188	capacity_remaining = 999 - op->stats.food;
		2189	op->stats.food += tmp->stats.food;
		2190	if (capacity_remaining < tmp->stats.food)
		2191	op->stats.hp += capacity_remaining / 50;
		2192	else
		2193	op->stats.hp += tmp->stats.food / 50;
		2194
		2195	if (op->stats.hp > op->stats.maxhp)
		2196	op->stats.hp = op->stats.maxhp;
		2197	if (op->stats.food > 999)
		2198	op->stats.food = 999;
		2199	}
		2200
		2201	/* special food hack -b.t. */
		2202	if (tmp->title || QUERY_FLAG (tmp, FLAG_CURSED))
		2203	eat_special_food (op, tmp);
		2204	}
		2205	}
		2206
		2207	handle_apply_yield (tmp);
		2208	tmp->decrease ();
		2209	}
		2210
		2211	/**
2203	* Handles applying an improve armor scroll.	2212	* Handles applying an improve armor scroll.
2204	* Does some sanity checks, then calls improve_armour.	2213	* Does some sanity checks, then calls improve_armour.
2205	*/	2214	*/
2206	static void	2215	static void
2207	apply_armour_improver (object *op, object *tmp)	2216	apply_armour_improver (object *op, object *tmp)
…		…
2348		2357
2349	return 0;	2358	return 0;
2350	}	2359	}
2351		2360
2352	/**	2361	/**
		2362	* This function will try to apply a lighter and in case no lighter
		2363	* is specified it will try to find a lighter in the players inventory,
		2364	* and inform him about this requirement.
		2365	*
		2366	* who - the player
		2367	* op - the item we want to light
		2368	* lighter - the lighter or 0 if a lighter has yet to be found
		2369	*/
		2370	static object *
		2371	auto_apply_lighter (object *who, object *op, object *lighter)
		2372	{
		2373	if (lighter == 0)
		2374	{
		2375	for (object *tmp = who->inv; tmp; tmp = tmp->below)
		2376	{
		2377	if (tmp->type == LIGHTER)
		2378	{
		2379	lighter = tmp;
		2380	break;
		2381	}
		2382	}
		2383
		2384	if (!lighter)
		2385	{
		2386	who->failmsg (format (
		2387	"You can't light up the %s with your bare hands! "
		2388	"H<You need a lighter in your inventory, for example a flint and steel.>",
		2389	&op->name));
		2390	return 0;
		2391	}
		2392	}
		2393
		2394	// last_eat == 0 means the lighter is not being used up!
		2395	if (lighter->last_eat && lighter->stats.food)
		2396	{
		2397	/* lighter gets used up */
		2398	lighter = lighter->split ();
		2399	lighter->stats.food--;
		2400	who->insert (lighter);
		2401	}
		2402	else if (lighter->last_eat)
		2403	{
		2404	/* no charges left in lighter */
		2405	who->failmsg (format (
		2406	"You attempt to light the %s with a used up %s.",
		2407	&op->name, &lighter->name));
		2408	return 0;
		2409	}
		2410
		2411	return lighter;
		2412	}
		2413
		2414	/**
		2415	* Designed primarily to light torches/lanterns/etc.
		2416	* Also burns up burnable material too. First object in the inventory is
		2417	* the selected object to "burn". -b.t.
		2418	*/
		2419	static void
		2420	apply_lighter (object *who, object *lighter)
		2421	{
		2422	object *item;
		2423	int is_player_env = 0;
		2424
		2425	item = find_marked_object (who);
		2426	if (item)
		2427	{
		2428	if (!auto_apply_lighter (who, item, lighter))
		2429	return;
		2430
		2431	/* Perhaps we should split what we are trying to light on fire?
		2432	* I can't see many times when you would want to light multiple
		2433	* objects at once.
		2434	*/
		2435
		2436	save_throw_object (item, AT_FIRE, who);
		2437
		2438	if (item->destroyed ()
		2439	|| ((item->type == LAMP || item->type == TORCH)
		2440	&& item->glow_radius > 0))
		2441	who->statusmsg (format (
		2442	"You light the %s with the %s.",
		2443	&item->name, &lighter->name));
		2444	else
		2445	who->failmsg (format (
		2446	"You attempt to light the %s with the %s and fail.",
		2447	&item->name, &lighter->name));
		2448	}
		2449	else
		2450	who->failmsg ("You need to mark a lightable object.");
		2451	}
		2452
		2453	/**
		2454	* This function generates a cursed effect for cursed lamps and torches.
		2455	*/
		2456	void player_apply_lamp_cursed_effect (object *who, object *op)
		2457	{
		2458	if (op->level)
		2459	{
		2460	who->failmsg (format (
		2461	"The %s was cursed, it explodes in a big fireball!",
		2462	&op->name));
		2463	create_exploding_ball_at (who, op->level);
		2464	}
		2465	else
		2466	{
		2467	who->failmsg (format (
		2468	"The %s was cursed, it crumbles to dust, at least it didn't explode.!",
		2469	&op->name));
		2470	}
		2471
		2472	op->destroy ();
		2473	}
		2474
		2475	/**
		2476	* Apply for players and lamps
		2477	*
		2478	* who - the player
		2479	* op - the lamp
		2480	*/
		2481	void player_apply_lamp (object *who, object *op)
		2482	{
		2483	bool switch_on = op->glow_radius ? false : true;
		2484
		2485	if (switch_on)
		2486	{
		2487	object *lighter = 0;
		2488
		2489	if (op->flag [FLAG_IS_LIGHTABLE]
		2490	&& !(lighter = auto_apply_lighter (who, op, 0)))
		2491	return;
		2492
		2493	if (op->stats.food < 1)
		2494	{
		2495	if (op->type == LAMP)
		2496	who->failmsg (format (
		2497	"The %s is out of fuel! "
		2498	"H<Lamps and similar items need fuel. They cannot be refilled.>",
		2499	&op->name));
		2500	else
		2501	who->failmsg (format (
		2502	"The %s is burnt out! "
		2503	"H<Torches and similar items burn out and become worthless.>",
		2504	&op->name));
		2505	return;
		2506	}
		2507
		2508	if (op->flag [FLAG_CURSED])
		2509	{
		2510	player_apply_lamp_cursed_effect (who, op);
		2511	return;
		2512	}
		2513
		2514	if (lighter)
		2515	who->statusmsg (format (
		2516	"You light up the %s with the %s.", &op->name, &lighter->name));
		2517	else
		2518	who->statusmsg (format ("You light up the %s.", &op->name));
		2519	}
		2520	else
		2521	{
		2522	if (op->flag [FLAG_CURSED])
		2523	{
		2524	player_apply_lamp_cursed_effect (who, op);
		2525	return;
		2526	}
		2527
		2528	if (op->type == TORCH)
		2529	{
		2530	if (!op->flag [FLAG_IS_LIGHTABLE])
		2531	{
		2532	who->statusmsg (format (
		2533	"You put out the %s. "
		2534	"H<The %s can't be used anymore, as it can't be lighted up again.>",
		2535	&op->name, &op->name));
		2536	}
		2537	else
		2538	who->statusmsg (format (
		2539	"You put out the %s."
		2540	"H<Torches wear out if you put them out.>",
		2541	&op->name));
		2542	}
		2543	else
		2544	who->statusmsg (format ("You turn off the %s.", &op->name));
		2545	}
		2546
		2547	apply_lamp (op, switch_on);
		2548	}
		2549
		2550	void get_animation_from_arch (object *op, arch_ptr a)
		2551	{
		2552	op->animation_id = a->animation_id;
		2553	op->flag [FLAG_IS_TURNABLE] = a->flag [FLAG_IS_TURNABLE];
		2554	op->flag [FLAG_ANIMATE] = a->flag [FLAG_ANIMATE];
		2555	op->anim_speed = a->anim_speed;
		2556	op->last_anim = 0;
		2557	op->state = 0;
		2558	op->face = a->face;
		2559
		2560	if (NUM_ANIMATIONS(op) > 1)
		2561	{
		2562	SET_ANIMATION(op, 0);
		2563	animate_object (op, op->direction);
		2564	}
		2565	else
		2566	update_object (op, UP_OBJ_FACE);
		2567	}
		2568
		2569	/**
		2570	* Apply for LAMPs and TORCHes.
		2571	*
		2572	* op - the lamp
		2573	* switch_on - a flag which says whether the lamp should be switched on or off
		2574	*/
		2575	void apply_lamp (object *op, bool switch_on)
		2576	{
		2577	op->set_glow_radius (switch_on ? op->range : 0);
		2578	op->set_speed (switch_on ? op->arch->speed : 0);
		2579
		2580	// torches wear out if you put them out
		2581	if (op->type == TORCH && !switch_on)
		2582	{
		2583	if (op->flag [FLAG_IS_LIGHTABLE])
		2584	{
		2585	op->stats.food -= (double) op->arch->stats.food / 15;
		2586	if (op->stats.food < 0)
		2587	op->stats.food = 0;
		2588	}
		2589	else
		2590	op->stats.food = 0;
		2591	}
		2592
		2593	// lamps and torched get worthless when used up
		2594	if (op->stats.food <= 0)
		2595	op->value = 0;
		2596
		2597	// FIXME: This is a hack to make the more sane torches and lamps
		2598	// still animated ;-/
		2599	if (op->other_arch)
		2600	get_animation_from_arch (op, switch_on ? op->other_arch : op->arch);
		2601
		2602	if (object *pl = op->visible_to ())
		2603	esrv_update_item (UPD_ANIM | UPD_FACE | UPD_NAME, pl, op);
		2604	}
		2605
		2606	/**
		2607	* This handles items of type 'transformer'.
		2608	* Basically those items, used with a marked item, transform both items into something
		2609	* else.
		2610	* "Transformer" item has food decreased by 1, removed if 0 (0 at start means illimited)..
		2611	* Change information is contained in the 'slaying' field of the marked item.
		2612	* The format is as follow: transformer:[number ]yield[;transformer:...].
		2613	* This way an item can be transformed in many things, and/or many objects.
		2614	* The 'slaying' field for transformer is used as verb for the action.
		2615	*/
		2616	static void
		2617	apply_item_transformer (object *pl, object *transformer)
		2618	{
		2619	object *marked;
		2620	object *new_item;
		2621	char *find;
		2622	char *separator;
		2623	int yield;
		2624	char got[MAX_BUF];
		2625	int len;
		2626
		2627	if (!pl || !transformer)
		2628	return;
		2629
		2630	marked = find_marked_object (pl);
		2631
		2632	if (!marked)
		2633	{
		2634	pl->failmsg (format ("Use the %s with what item?", query_name (transformer)));
		2635	return;
		2636	}
		2637
		2638	if (!marked->slaying)
		2639	{
		2640	pl->failmsg (format ("You can't use the %s with your %s!", query_name (transformer), query_name (marked)));
		2641	return;
		2642	}
		2643
		2644	/* check whether they are compatible or not */
		2645	find = strstr (&marked->slaying, transformer->arch->archname);
		2646	if (!find || (*(find + strlen (transformer->arch->archname)) != ':'))
		2647	{
		2648	pl->failmsg (format ("You can't use the %s with your %s!", query_name (transformer), query_name (marked)));
		2649	return;
		2650	}
		2651
		2652	find += strlen (transformer->arch->archname) + 1;
		2653	/* Item can be used, now find how many and what it yields */
		2654	if (isdigit (*(find)))
		2655	{
		2656	yield = atoi (find);
		2657	if (yield < 1)
		2658	{
		2659	LOG (llevDebug, "apply_item_transformer: item %s has slaying-yield %d.", query_base_name (marked, 0), yield);
		2660	yield = 1;
		2661	}
		2662	}
		2663	else
		2664	yield = 1;
		2665
		2666	while (isdigit (*find))
		2667	find++;
		2668
		2669	while (*find == ' ')
		2670	find++;
		2671
		2672	memset (got, 0, MAX_BUF);
		2673
		2674	if ((separator = strchr (find, ';')) != NULL)
		2675	len = separator - find;
		2676	else
		2677	len = strlen (find);
		2678
		2679	if (len > MAX_BUF - 1)
		2680	len = MAX_BUF - 1;
		2681
		2682	strcpy (got, find);
		2683	got[len] = '\0';
		2684
		2685	/* Now create new item, remove used ones when required. */
		2686	new_item = get_archetype (got);
		2687	if (!new_item)
		2688	{
		2689	pl->failmsg (format ("This %s is strange, better to not use it.", query_base_name (marked, 0)));
		2690	return;
		2691	}
		2692
		2693	new_item->nrof = yield;
		2694
		2695	pl->statusmsg (format ("You %s the %s.", &transformer->slaying, query_base_name (marked, 0)));
		2696
		2697	pl->insert (new_item);
		2698	/* Eat up one item */
		2699	marked->decrease ();
		2700
		2701	/* Eat one transformer if needed */
		2702	if (transformer->stats.food)
		2703	if (--transformer->stats.food == 0)
		2704	transformer->decrease ();
		2705	}
		2706
		2707	/**
2353	* Main apply handler.	2708	* Main apply handler.
2354	*	2709	*
2355	* Checks for unpaid items before applying.	2710	* Checks for unpaid items before applying.
2356	*	2711	*
2357	* Return value:	2712	* Return value:
2358	* 0: player or monster can't apply objects of that type	2713	* 0: player or monster can't apply objects of that type
2359	* 1: has been applied, or there was an error applying the object	2714	* 1: has been applied, or there was an error applying the object
2360	* 2: objects of that type can't be applied if not in inventory	2715	* 2: objects of that type can't be applied if not in inventory
2361	*	2716	*
2362	* op is the object that is causing object to be applied, tmp is the object	2717	* who is the object that is causing object to be applied, op is the object
2363	* being applied.	2718	* being applied.
2364	*	2719	*
2365	* aflag is special (always apply/unapply) flags. Nothing is done with	2720	* aflag is special (always apply/unapply) flags. Nothing is done with
2366	* them in this function - they are passed to apply_special	2721	* them in this function - they are passed to apply_special
2367	*/	2722	*/
2368	int	2723	int
2369	manual_apply (object *op, object *tmp, int aflag)	2724	manual_apply (object *who, object *op, int aflag)
2370	{	2725	{
2371	tmp = tmp->head_ ();	2726	op = op->head_ ();
2372		2727
2373	if (QUERY_FLAG (tmp, FLAG_UNPAID) && !QUERY_FLAG (tmp, FLAG_APPLIED))	2728	if (QUERY_FLAG (op, FLAG_UNPAID) && !QUERY_FLAG (op, FLAG_APPLIED))
2374	{	2729	{
2375	if (op->type == PLAYER)	2730	if (who->type == PLAYER)
2376	{	2731	{
		2732	examine (who, op);
2377	op->failmsg ("You should pay for it first! H<You cannot use items marked as unpaid.>");	2733	//who->failmsg ("You should pay for it first! H<You cannot use items marked as unpaid.>");//TODO remove
2378	return 1;	2734	return 1;
2379	}	2735	}
2380	else	2736	else
2381	return 0; /* monsters just skip unpaid items */	2737	return 0; /* monsters just skip unpaid items */
2382	}	2738	}
2383		2739
2384	if (INVOKE_OBJECT (APPLY, tmp, ARG_OBJECT (op)))	2740	if (INVOKE_OBJECT (APPLY, op, ARG_OBJECT (who)))
2385	return RESULT_INT (0);	2741	return RESULT_INT (0);
2386		2742
2387	switch (tmp->type)	2743	switch (op->type)
2388	{	2744	{
2389	case CF_HANDLE:	2745	case T_HANDLE:
2390	op->play_sound (sound_find ("turn_handle"));	2746	who->play_sound (sound_find ("turn_handle"));
2391	op->statusmsg ("You turn the handle.");	2747	who->statusmsg ("You turn the handle.");
2392	tmp->value = tmp->value ? 0 : 1;	2748	op->value = op->value ? 0 : 1;
2393	SET_ANIMATION (tmp, tmp->value);	2749	SET_ANIMATION (op, op->value);
2394	update_object (tmp, UP_OBJ_FACE);	2750	update_object (op, UP_OBJ_FACE);
2395	push_button (tmp);	2751	push_button (op, who);
2396	return 1;	2752	return 1;
2397		2753
2398	case TRIGGER:	2754	case TRIGGER:
2399	if (check_trigger (tmp, op))	2755	if (check_trigger (op, who, who))
2400	{	2756	{
2401	op->statusmsg ("You turn the handle.");	2757	who->statusmsg ("You turn the handle.");
2402	op->play_sound (sound_find ("turn_handle"));	2758	who->play_sound (sound_find ("turn_handle"));
2403	}	2759	}
2404	else	2760	else
2405	op->failmsg ("The handle doesn't move.");	2761	who->failmsg ("The handle doesn't move.");
2406		2762
2407	return 1;	2763	return 1;
2408		2764
2409	case EXIT:	2765	case EXIT:
2410	if (op->type != PLAYER)	2766	if (who->type != PLAYER)
2411	return 0;	2767	return 0;
2412		2768
2413	if (!EXIT_PATH (tmp) || !is_legal_2ways_exit (op, tmp))	2769	if (!EXIT_PATH (op) || !is_legal_2ways_exit (who, op))
2414	op->failmsg (format ("The %s is closed.", query_name (tmp)));	2770	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)));
2415	else	2771	else
2416	{	2772	{
2417	/* Don't display messages for random maps. */	2773	/* Don't display messages for random maps. */
2418	if (tmp->msg && strncmp (EXIT_PATH (tmp), "/!", 2))	2774	if (op->msg && !EXIT_PATH (op).starts_with ("/!"))
2419	op->statusmsg (tmp->msg, NDI_NAVY);	2775	who->statusmsg (op->msg, NDI_NAVY);
2420		2776
2421	op->enter_exit (tmp);	2777	who->enter_exit (op);
2422	}	2778	}
2423		2779
2424	return 1;	2780	return 1;
2425		2781
2426	case INSCRIBABLE:	2782	case INSCRIBABLE:
2427	op->statusmsg (tmp->msg);	2783	who->statusmsg (op->msg);
2428	// maybe show a spell menu to chose from or something like that	2784	// maybe show a spell menu to chose from or something like that
2429	return 1;	2785	return 1;
2430		2786
2431	case SIGN:	2787	case SIGN:
2432	apply_sign (op, tmp, 0);	2788	apply_sign (who, op, 0);
2433	return 1;	2789	return 1;
2434		2790
2435	case BOOK:	2791	case BOOK:
2436	if (op->type == PLAYER)	2792	if (who->type == PLAYER)
2437	{	2793	{
2438	apply_book (op, tmp);	2794	apply_book (who, op);
2439	return 1;	2795	return 1;
2440	}	2796	}
2441	else	2797	else
2442	return 0;	2798	return 0;
2443		2799
2444	case SKILLSCROLL:	2800	case SKILLSCROLL:
2445	if (op->type == PLAYER)	2801	if (who->type == PLAYER)
2446	{	2802	{
2447	apply_skillscroll (op, tmp);	2803	apply_skillscroll (who, op);
2448	return 1;	2804	return 1;
2449	}	2805	}
2450	else	2806	else
2451	return 0;	2807	return 0;
2452		2808
2453	case SPELLBOOK:	2809	case SPELLBOOK:
2454	if (op->type == PLAYER)	2810	if (who->type == PLAYER)
2455	{	2811	{
2456	apply_spellbook (op, tmp);	2812	apply_spellbook (who, op);
2457	return 1;	2813	return 1;
2458	}	2814	}
2459	else	2815	else
2460	return 0;	2816	return 0;
2461		2817
2462	case SCROLL:	2818	case SCROLL:
2463	apply_scroll (op, tmp, 0);	2819	apply_scroll (who, op, 0);
2464	return 1;	2820	return 1;
2465		2821
2466	case POTION:	2822	case POTION:
2467	apply_potion (op, tmp);	2823	apply_potion (who, op);
2468	return 1;	2824	return 1;
2469		2825
2470	/* Eneq(@csd.uu.se): Handle apply on containers. */	2826	/* Eneq(@csd.uu.se): Handle apply on containers. */
2471	//TODO: remove, as it is unsed?	2827	//TODO: remove, as it is unsed?
2472	case CLOSE_CON:	2828	case CLOSE_CON:
2473	apply_container (op, tmp->env);	2829	apply_container (who, op->env);
2474	return 1;	2830	return 1;
2475		2831
2476	case CONTAINER:	2832	case CONTAINER:
2477	apply_container (op, tmp);	2833	apply_container (who, op);
2478	return 1;	2834	return 1;
2479		2835
2480	case TREASURE:	2836	case TREASURE:
2481	if (op->type == PLAYER)	2837	if (who->type == PLAYER)
2482	{	2838	{
2483	apply_treasure (op, tmp);	2839	apply_treasure (who, op);
2484	return 1;	2840	return 1;
2485	}	2841	}
2486	else	2842	else
2487	return 0;	2843	return 0;
		2844
		2845	case LAMP:
		2846	case TORCH:
		2847	player_apply_lamp (who, op);
		2848	return 1;
2488		2849
2489	case WEAPON:	2850	case WEAPON:
2490	case ARMOUR:	2851	case ARMOUR:
2491	case BOOTS:	2852	case BOOTS:
2492	case GLOVES:	2853	case GLOVES:
…		…
2500	case WAND:	2861	case WAND:
2501	case ROD:	2862	case ROD:
2502	case HORN:	2863	case HORN:
2503	case SKILL:	2864	case SKILL:
2504	case BOW:	2865	case BOW:
2505	case LAMP:
2506	case BUILDER:	2866	case BUILDER:
2507	case SKILL_TOOL:	2867	case SKILL_TOOL:
2508	if (tmp->env != op)	2868	if (op->env != who)
2509	return 2; /* not in inventory */	2869	return 2; /* not in inventory */
2510		2870
2511	apply_special (op, tmp, aflag);	2871	apply_special (who, op, aflag);
2512	return 1;	2872	return 1;
2513		2873
2514	case DRINK:	2874	case DRINK:
2515	case FOOD:	2875	case FOOD:
2516	case FLESH:	2876	case FLESH:
2517	apply_food (op, tmp);	2877	apply_food (who, op);
2518	return 1;	2878	return 1;
2519		2879
2520	case POISON:	2880	case POISON:
2521	apply_poison (op, tmp);	2881	apply_poison (who, op);
2522	return 1;	2882	return 1;
2523		2883
2524	case SAVEBED:	2884	case SAVEBED:
2525	return 1;	2885	return 1;
2526		2886
2527	case ARMOUR_IMPROVER:	2887	case ARMOUR_IMPROVER:
2528	if (op->type == PLAYER)	2888	if (who->type == PLAYER)
2529	{	2889	{
2530	apply_armour_improver (op, tmp);	2890	apply_armour_improver (who, op);
2531	return 1;	2891	return 1;
2532	}	2892	}
2533	else	2893	else
2534	return 0;	2894	return 0;
2535		2895
2536	case WEAPON_IMPROVER:	2896	case WEAPON_IMPROVER:
2537	check_improve_weapon (op, tmp);	2897	check_improve_weapon (who, op);
2538	return 1;	2898	return 1;
2539		2899
2540	case CLOCK:	2900	case CLOCK:
2541	if (op->type == PLAYER)	2901	if (who->type == PLAYER)
2542	{	2902	{
2543	char buf[MAX_BUF];	2903	char buf[MAX_BUF];
2544	timeofday_t tod;	2904	timeofday_t tod;
2545		2905
2546	get_tod (&tod);	2906	get_tod (&tod);
2547	op->play_sound (sound_find ("sound_clock"));	2907	who->play_sound (sound_find ("sound_clock"));
2548	op->statusmsg (format (	2908	who->statusmsg (format (
2549	"It is %d minute%s past %d o'clock %s",	2909	"It is %d minute%s past %d o'clock %s",
2550	tod.minute + 1, ((tod.minute + 1 < 2) ? "" : "s"),	2910	tod.minute + 1, ((tod.minute + 1 < 2) ? "" : "s"),
2551	((tod.hour % 14 == 0) ? 14 : ((tod.hour) % 14)), ((tod.hour >= 14) ? "pm" : "am")	2911	((tod.hour % 14 == 0) ? 14 : ((tod.hour) % 14)), ((tod.hour >= 14) ? "pm" : "am")
2552	));	2912	));
2553	return 1;	2913	return 1;
2554	}	2914	}
2555	else	2915	else
2556	return 0;	2916	return 0;
2557		2917
2558	case MENU:	2918	case MENU:
2559	if (op->type == PLAYER)	2919	if (who->type == PLAYER)
2560	{	2920	{
2561	shop_listing (tmp, op);	2921	shop_listing (op, who);
2562	return 1;	2922	return 1;
2563	}	2923	}
2564	else	2924	else
2565	return 0;	2925	return 0;
2566		2926
2567	case POWER_CRYSTAL:	2927	case POWER_CRYSTAL:
2568	apply_power_crystal (op, tmp); /* see egoitem.c */	2928	apply_power_crystal (who, op); /* see egoitem.c */
2569	return 1;	2929	return 1;
2570		2930
2571	case LIGHTER: /* for lighting torches/lanterns/etc */	2931	case LIGHTER: /* for lighting torches/lanterns/etc */
2572	if (op->type == PLAYER)	2932	if (who->type == PLAYER)
2573	{	2933	{
2574	apply_lighter (op, tmp);	2934	apply_lighter (who, op);
2575	return 1;	2935	return 1;
2576	}	2936	}
2577	else	2937	else
2578	return 0;	2938	return 0;
2579		2939
2580	case ITEM_TRANSFORMER:	2940	case ITEM_TRANSFORMER:
2581	apply_item_transformer (op, tmp);	2941	apply_item_transformer (who, op);
2582	return 1;	2942	return 1;
2583		2943
2584	default:	2944	default:
2585	return 0;	2945	return 0;
2586	}	2946	}
…		…
2638	* we don't use a corrupt pointer for the next object, so we get the	2998	* we don't use a corrupt pointer for the next object, so we get the
2639	* next object in the stack before applying. This is can only be a	2999	* next object in the stack before applying. This is can only be a
2640	* problem if player_apply() has a bug in that it uses the object but does	3000	* problem if player_apply() has a bug in that it uses the object but does
2641	* not return a proper value.	3001	* not return a proper value.
2642	*/	3002	*/
2643	for (object *next, *tmp = pl->container ? pl->container->inv : pl->below; tmp; tmp = next)	3003	for (object *next, *tmp = pl->container_ () ? pl->container_ ()->inv : pl->below; tmp; tmp = next)
2644	{	3004	{
2645	next = tmp->below;	3005	next = tmp->below;
2646		3006
2647	if (QUERY_FLAG (tmp, FLAG_IS_FLOOR))	3007	if (QUERY_FLAG (tmp, FLAG_IS_FLOOR))
2648	floors++;	3008	floors++;
…		…
2737	case BRACERS:	3097	case BRACERS:
2738	case CLOAK:	3098	case CLOAK:
2739	who->statusmsg (format ("You unwear %s.", query_name (op)));	3099	who->statusmsg (format ("You unwear %s.", query_name (op)));
2740	change_abil (who, op);	3100	change_abil (who, op);
2741	break;	3101	break;
2742
2743	case LAMP:
2744	{
2745	who->statusmsg (format ("You turn off your %s.", &op->name));
2746
2747	object *tmp2 = arch_to_object (op->other_arch);
2748	tmp2->x = op->x;
2749	tmp2->y = op->y;
2750	tmp2->map = op->map;
2751	tmp2->below = op->below;
2752	tmp2->above = op->above;
2753	tmp2->stats.food = op->stats.food;
2754	CLEAR_FLAG (tmp2, FLAG_APPLIED);
2755
2756	if (QUERY_FLAG (op, FLAG_INV_LOCKED))
2757	SET_FLAG (tmp2, FLAG_INV_LOCKED);
2758
2759	op->destroy ();
2760	who->insert (tmp2);
2761	who->update_stats ();
2762
2763	if (who->contr)
2764	if (QUERY_FLAG (op, FLAG_CURSED) || QUERY_FLAG (op, FLAG_DAMNED))
2765	{
2766	who->failmsg ("Oops, it feels deadly cold!");
2767	SET_FLAG (tmp2, FLAG_KNOWN_CURSED);
2768	}
2769	}
2770
2771	return 1; /* otherwise, an attempt to drop causes problems */
2772		3102
2773	case BOW:	3103	case BOW:
2774	case WAND:	3104	case WAND:
2775	case ROD:	3105	case ROD:
2776	case HORN:	3106	case HORN:
…		…
3184	* skill so that the dam and wc get updated	3514	* skill so that the dam and wc get updated
3185	*/	3515	*/
3186	who->change_skill (skop);	3516	who->change_skill (skop);
3187	}	3517	}
3188		3518
3189	if (who->type == PLAYER	3519	if (!check_item_power (who, op->item_power))
3190	&& op->item_power
3191	&& op->item_power + who->contr->item_power > settings.item_power_factor * who->level)
3192	{	3520	{
3193	who->failmsg ("Equipping that combined with other items would consume your soul!" LACK_ITEM_POWER);	3521	who->failmsg ("Equipping that combined with other items would consume your soul!" LACK_ITEM_POWER);
3194	return 1;	3522	return 1;
3195	}	3523	}
3196		3524
…		…
3204	return RESULT_INT (0);	3532	return RESULT_INT (0);
3205		3533
3206	switch (op->type)	3534	switch (op->type)
3207	{	3535	{
3208	case WEAPON:	3536	case WEAPON:
3209	if (!check_weapon_power (who, op->last_eat))
3210	{
3211	op->failmsg ("This weapon is too powerful for you to use. It would consume your soul!" LACK_ITEM_POWER);
3212
3213	if (tmp)
3214	insert_ob_in_ob (tmp, who);
3215
3216	return 1;
3217	}
3218
3219	//TODO: this obviously fails for players using a shorter prefix	3537	//TODO: this obviously fails for players using a shorter prefix
3220	// i.e. "R" can use Ragnarok's sword.	3538	// i.e. "R" can use Ragnarok's sword.
3221	if (op->level && (strncmp (op->name, who->name, strlen (who->name))))	3539	if (op->level && !op->name.starts_with (who->name))
3222	{	3540	{
3223	/* if the weapon does not have the name as the character, can't use it. */	3541	/* if the weapon does not have the name as the character, can't use it. */
3224	/* (Ragnarok's sword attempted to be used by Foo: won't work) */	3542	/* (Ragnarok's sword attempted to be used by Foo: won't work) */
3225	who->failmsg ("The weapon does not recognize you as its owner. H<Its name indicates that it belongs to somebody else.>");	3543	who->failmsg ("The weapon does not recognize you as its owner. H<Its name indicates that it belongs to somebody else.>");
3226		3544
…		…
3260	case AMULET:	3578	case AMULET:
3261	SET_FLAG (op, FLAG_APPLIED);	3579	SET_FLAG (op, FLAG_APPLIED);
3262	who->statusmsg (format ("You wear %s.", query_name (op)));	3580	who->statusmsg (format ("You wear %s.", query_name (op)));
3263	change_abil (who, op);	3581	change_abil (who, op);
3264	break;	3582	break;
3265
3266	case LAMP:
3267	if (op->stats.food < 1)
3268	{
3269	who->failmsg (format (
3270	"Your %s is out of fuel! "
3271	"H<Lamps and similar items need fuel. They cannot be refilled.>",
3272	&op->name
3273	));
3274	return 1;
3275	}
3276
3277	who->statusmsg (format ("You turn on your %s.", &op->name));
3278
3279	tmp2 = arch_to_object (op->other_arch);
3280	tmp2->stats.food = op->stats.food;
3281	SET_FLAG (tmp2, FLAG_APPLIED);
3282
3283	if (QUERY_FLAG (op, FLAG_INV_LOCKED))
3284	SET_FLAG (tmp2, FLAG_INV_LOCKED);
3285
3286	who->insert (tmp2);
3287
3288	/* Remove the old lantern */
3289	op->destroy ();
3290
3291	/* insert the portion that was split off */
3292	if (tmp)
3293	who->insert (tmp);
3294
3295	who->update_stats ();
3296
3297	if (QUERY_FLAG (op, FLAG_CURSED) || QUERY_FLAG (op, FLAG_DAMNED))
3298	if (who->type == PLAYER)
3299	{
3300	who->failmsg ("Oops, it feels deadly cold! H<Maybe it wasn't such a bright (hrhrhr) idea to apply this cursed or damned item.>");
3301	SET_FLAG (tmp2, FLAG_KNOWN_CURSED);
3302	}
3303
3304	return 0;
3305		3583
3306	case SKILL_TOOL:	3584	case SKILL_TOOL:
3307	// applying a skill tool also readies the skill	3585	// applying a skill tool also readies the skill
3308	SET_FLAG (op, FLAG_APPLIED);	3586	SET_FLAG (op, FLAG_APPLIED);
3309		3587
…		…
3389	}	3667	}
3390		3668
3391	break;	3669	break;
3392		3670
3393	case BOW:	3671	case BOW:
3394	if (!check_weapon_power (who, op->last_eat))	3672	if (op->level && !op->name.starts_with (who->name))
3395	{
3396	who->failmsg ("That weapon is too powerful for you to use. It would consume your soul!" LACK_ITEM_POWER);
3397
3398	if (tmp)
3399	insert_ob_in_ob (tmp, who);
3400
3401	return 1;
3402	}
3403
3404	if (op->level && (strncmp (op->name, who->name, strlen (who->name))))
3405	{	3673	{
3406	who->failmsg ("The weapon does not recognize you as its owner. "	3674	who->failmsg ("The weapon does not recognize you as its owner. "
3407	"H<Its name indicates that it belongs to somebody else.>");	3675	"H<Its name indicates that it belongs to somebody else.>");
3408	if (tmp)	3676	if (tmp)
3409	insert_ob_in_ob (tmp, who);	3677	insert_ob_in_ob (tmp, who);
…		…
3673	}	3941	}
3674		3942
3675	for (mapspace *ms = spaces + size (); ms-- > spaces; )	3943	for (mapspace *ms = spaces + size (); ms-- > spaces; )
3676	for (object *tmp = ms->bot; tmp; tmp = tmp->above)	3944	for (object *tmp = ms->bot; tmp; tmp = tmp->above)
3677	if (tmp->above && (tmp->type == TRIGGER_BUTTON || tmp->type == TRIGGER_PEDESTAL))	3945	if (tmp->above && (tmp->type == TRIGGER_BUTTON || tmp->type == TRIGGER_PEDESTAL))
3678	check_trigger (tmp, tmp->above);	3946	check_trigger (tmp, tmp->above, tmp->above);
3679	}	3947	}
3680		3948
3681	/**	3949	/**
3682	* Handles player eating food that temporarily changes status (resistances, stats).	3950	* Handles player eating food that temporarily changes status (resistances, stats).
3683	* This used to call cast_change_attr(), but	3951	* This used to call cast_change_attr(), but
…		…
3688	eat_special_food (object *who, object *food)	3956	eat_special_food (object *who, object *food)
3689	{	3957	{
3690	object *force;	3958	object *force;
3691	int i, did_one = 0;	3959	int i, did_one = 0;
3692		3960
3693	force = get_archetype (FORCE_NAME);	3961	char buf[64];
		3962	snprintf (buf, sizeof(buf), "sp_food_%s", &food->title);
		3963	shstr key (buf);
3694		3964
3695	for (i = 0; i < NUM_STATS; i++)
3696	if (sint8 k = food->stats.stat (i))
3697	{
3698	force->stats.stat (i) = k;
3699	did_one = 1;
3700	}
3701
3702	/* check if we can protect the eater */
3703	for (i = 0; i < NROFATTACKS; i++)
3704	{
3705	if (food->resist[i] > 0)
3706	{
3707	force->resist[i] = food->resist[i] / 2;
3708	did_one = 1;
3709	}
3710	}
3711
3712	if (did_one)
3713	{
3714	force->set_speed (0.1);
3715	/* bigger morsel of food = longer effect time */	3965	/* bigger morsel of food = longer effect time */
3716	force->duration = food->stats.food / 5;	3966	int duration = TIME2TICK (food->stats.food);
3717	SET_FLAG (force, FLAG_APPLIED);	3967
3718	change_abil (who, force);	3968	if (force = who->force_find (key))
3719	insert_ob_in_ob (force, who);	3969	{
		3970	if (duration > abs (force->speed_left / force->speed))
		3971	{
		3972	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));
		3973	force->force_set_timer (duration);
		3974	}
		3975	else
		3976	new_draw_info (NDI_UNIQUE, 0, who, "It had no additional effect.");
		3977
		3978	return;
3720	}	3979	}
3721	else	3980	else
		3981	{
		3982	force = who->force_add (key, duration);
		3983	force->name = key;
		3984
		3985	/* check if the food affects a stat */
		3986	for (i = 0; i < NUM_STATS; i++)
		3987	if (sint8 k = food->stats.stat (i))
		3988	{
		3989	force->stats.stat (i) = k;
		3990	did_one = 1;
		3991	}
		3992
		3993	/* check if we can protect the eater */
		3994	for (i = 0; i < NROFATTACKS; i++)
		3995	{
		3996	if (food->resist[i] > 0)
		3997	{
		3998	force->resist[i] = food->resist[i];
		3999	did_one = 1;
		4000	}
		4001	}
		4002
		4003	if (did_one)
		4004	{
		4005	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));
		4006
		4007	/* make the force take effect and report effects to user */
		4008	change_abil (who, force);
		4009	}
		4010	else
3722	force->destroy ();	4011	force->destroy ();
		4012	}
3723		4013
3724	/* check for hp, sp change */	4014	/* check for hp, sp change */
3725	if (food->stats.hp != 0)	4015	if (food->stats.hp != 0)
3726	{	4016	{
3727	if (QUERY_FLAG (food, FLAG_CURSED))	4017	if (QUERY_FLAG (food, FLAG_CURSED))
…		…
3757	/* place limit on max sp from food? */	4047	/* place limit on max sp from food? */
3758	}	4048	}
3759	}	4049	}
3760		4050
3761	who->update_stats ();	4051	who->update_stats ();
3762	}
3763
3764	/**
3765	* Designed primarily to light torches/lanterns/etc.
3766	* Also burns up burnable material too. First object in the inventory is
3767	* the selected object to "burn". -b.t.
3768	*/
3769	void
3770	apply_lighter (object *who, object *lighter)
3771	{
3772	object *item;
3773	int is_player_env = 0;
3774
3775	item = find_marked_object (who);
3776	if (item)
3777	{
3778	if (lighter->last_eat && lighter->stats.food)
3779	{ /* lighter gets used up */
3780	object *oneLighter = lighter->split ();
3781	oneLighter->stats.food--;
3782	who->insert (oneLighter);
3783	}
3784	else if (lighter->last_eat)
3785	{
3786	/* no charges left in lighter */
3787	who->failmsg (format ("You attempt to light the %s with a used up %s.", &item->name, &lighter->name));
3788	return;
3789	}
3790
3791	/* Perhaps we should split what we are trying to light on fire?
3792	* I can't see many times when you would want to light multiple
3793	* objects at once.
3794	*/
3795
3796	if (who == item->in_player ())
3797	is_player_env = 1;
3798
3799	save_throw_object (item, AT_FIRE, who);
3800
3801	if (item->destroyed ())
3802	{
3803	who->statusmsg (format ("You light the %s with the %s.", &item->name, &lighter->name));
3804	/* Need to update the player so that the players glow radius
3805	* gets changed.
3806	*/
3807	if (is_player_env)
3808	who->update_stats ();
3809	}
3810	else
3811	who->failmsg (format ("You attempt to light the %s with the %s and fail.", &item->name, &lighter->name));
3812	}
3813	else
3814	who->failmsg ("You need to mark a lightable object.");
3815	}
3816
3817	/**
3818	* op made some mistake with a scroll, this takes care of punishment.
3819	* scroll_failure()- hacked directly from spell_failure
3820	*/
3821	void
3822	scroll_failure (object *op, int failure, int power)
3823	{
3824	if (abs (failure / 4) > power)
3825	power = abs (failure / 4); /* set minimum effect */
3826
3827	if (failure <= -1 && failure > -15)
3828	{ /* wonder */
3829	object *tmp;
3830
3831	op->failmsg ("Your spell warps!");
3832	tmp = get_archetype (SPELL_WONDER);
3833	cast_wonder (op, op, 0, tmp);
3834	tmp->destroy ();
3835	}
3836	else if (failure <= -15 && failure > -35)
3837	{ /* drain mana */
3838	op->failmsg ("Your mana is drained!");
3839	op->stats.sp -= random_roll (0, power - 1, op, PREFER_LOW);
3840	if (op->stats.sp < 0)
3841	op->stats.sp = 0;
3842	}
3843	else if (settings.spell_failure_effects == TRUE)
3844	{
3845	if (failure <= -35 && failure > -60)
3846	{ /* confusion */
3847	op->failmsg ("The magic recoils on you!");
3848	confuse_player (op, op, power);
3849	}
3850	else if (failure <= -60 && failure > -70)
3851	{ /* paralysis */
3852	op->failmsg ("The magic recoils and paralyzes you!");
3853	paralyze_player (op, op, power);
3854	}
3855	else if (failure <= -70 && failure > -80)
3856	{ /* blind */
3857	op->failmsg ("The magic recoils on you!");
3858	blind_player (op, op, power);
3859	}
3860	else if (failure <= -80)
3861	{ /* blast the immediate area */
3862	object *tmp = get_archetype (LOOSE_MANA);
3863	cast_magic_storm (op, tmp, power);
3864	op->failmsg ("You unleash uncontrolled mana!");
3865	tmp->destroy ();
3866	}
3867	}
3868	}	4052	}
3869		4053
3870	void	4054	void
3871	apply_changes_to_player (object *pl, object *change)	4055	apply_changes_to_player (object *pl, object *change)
3872	{	4056	{
…		…
3920	}	4104	}
3921		4105
3922	/* insert the randomitems from the change's treasurelist into	4106	/* insert the randomitems from the change's treasurelist into
3923	* the player ref: player.c	4107	* the player ref: player.c
3924	*/	4108	*/
3925	if (change->randomitems != NULL)	4109	if (change->randomitems)
3926	give_initial_items (pl, change->randomitems);	4110	give_initial_items (pl, change->randomitems);
3927		4111
3928	/* set up the face, for some races. */	4112	/* set up the face, for some races. */
3929		4113
3930	/* first, look for the force object banning	4114	/* first, look for the force object banning
3931	* changing the face. Certain races never change face with class.	4115	* changing the face. Certain races never change face with class.
3932	*/	4116	*/
3933	for (walk = pl->inv; walk != NULL; walk = walk->below)	4117	for (walk = pl->inv; walk; walk = walk->below)
3934	if (!strcmp (walk->name, "NOCLASSFACECHANGE"))	4118	if (walk->name == shstr_NOCLASSFACECHANGE)
3935	flag_change_face = 0;	4119	flag_change_face = 0;
3936		4120
3937	if (flag_change_face)	4121	if (flag_change_face)
3938	{	4122	{
3939	pl->face = change->face;	4123	pl->face = change->face;
…		…
3941	pl->flag [FLAG_ANIMATE] = change->flag [FLAG_ANIMATE];	4125	pl->flag [FLAG_ANIMATE] = change->flag [FLAG_ANIMATE];
3942	}	4126	}
3943		4127
3944	/* check the special case of can't use weapons */	4128	/* check the special case of can't use weapons */
3945	/*if(QUERY_FLAG(change,FLAG_USE_WEAPON)) CLEAR_FLAG(pl,FLAG_USE_WEAPON); */	4129	/*if(QUERY_FLAG(change,FLAG_USE_WEAPON)) CLEAR_FLAG(pl,FLAG_USE_WEAPON); */
3946	if (!strcmp (change->name, "monk"))	4130	if (change->name == shstr_monk)
3947	CLEAR_FLAG (pl, FLAG_USE_WEAPON);	4131	CLEAR_FLAG (pl, FLAG_USE_WEAPON);
3948		4132
3949	break;	4133	break;
3950	}	4134	}
3951	}	4135	}
3952	}	4136	}
3953		4137
3954	/**
3955	* This handles items of type 'transformer'.
3956	* Basically those items, used with a marked item, transform both items into something
3957	* else.
3958	* "Transformer" item has food decreased by 1, removed if 0 (0 at start means illimited)..
3959	* Change information is contained in the 'slaying' field of the marked item.
3960	* The format is as follow: transformer:[number ]yield[;transformer:...].
3961	* This way an item can be transformed in many things, and/or many objects.
3962	* The 'slaying' field for transformer is used as verb for the action.
3963	*/
3964	void
3965	apply_item_transformer (object *pl, object *transformer)
3966	{
3967	object *marked;
3968	object *new_item;
3969	char *find;
3970	char *separator;
3971	int yield;
3972	char got[MAX_BUF];
3973	int len;
3974
3975	if (!pl || !transformer)
3976	return;
3977
3978	marked = find_marked_object (pl);
3979
3980	if (!marked)
3981	{
3982	pl->failmsg (format ("Use the %s with what item?", query_name (transformer)));
3983	return;
3984	}
3985
3986	if (!marked->slaying)
3987	{
3988	pl->failmsg (format ("You can't use the %s with your %s!", query_name (transformer), query_name (marked)));
3989	return;
3990	}
3991
3992	/* check whether they are compatible or not */
3993	find = strstr (marked->slaying, transformer->arch->archname);
3994	if (!find || (*(find + strlen (transformer->arch->archname)) != ':'))
3995	{
3996	pl->failmsg (format ("You can't use the %s with your %s!", query_name (transformer), query_name (marked)));
3997	return;
3998	}
3999
4000	find += strlen (transformer->arch->archname) + 1;
4001	/* Item can be used, now find how many and what it yields */
4002	if (isdigit (*(find)))
4003	{
4004	yield = atoi (find);
4005	if (yield < 1)
4006	{
4007	LOG (llevDebug, "apply_item_transformer: item %s has slaying-yield %d.", query_base_name (marked, 0), yield);
4008	yield = 1;
4009	}
4010	}
4011	else
4012	yield = 1;
4013
4014	while (isdigit (*find))
4015	find++;
4016
4017	while (*find == ' ')
4018	find++;
4019
4020	memset (got, 0, MAX_BUF);
4021
4022	if ((separator = strchr (find, ';')) != NULL)
4023	len = separator - find;
4024	else
4025	len = strlen (find);
4026
4027	if (len > MAX_BUF - 1)
4028	len = MAX_BUF - 1;
4029
4030	strcpy (got, find);
4031	got[len] = '\0';
4032
4033	/* Now create new item, remove used ones when required. */
4034	new_item = get_archetype (got);
4035	if (!new_item)
4036	{
4037	pl->failmsg (format ("This %s is strange, better to not use it.", query_base_name (marked, 0)));
4038	return;
4039	}
4040
4041	new_item->nrof = yield;
4042
4043	pl->statusmsg (format ("You %s the %s.", &transformer->slaying, query_base_name (marked, 0)));
4044
4045	pl->insert (new_item);
4046	/* Eat up one item */
4047	marked->decrease ();
4048
4049	/* Eat one transformer if needed */
4050	if (transformer->stats.food)
4051	if (--transformer->stats.food == 0)
4052	transformer->decrease ();
4053	}
4054

Diff Legend

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