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.187 by elmex, Tue Jan 13 13:29:57 2009 UTC vs.
Revision 1.213 by elmex, Mon Nov 9 13:38:36 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>
25		26
…		…
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)
…		…
203	op->update_stats ();	204	op->update_stats ();
204	tmp->decrease ();	205	tmp->decrease ();
205	return 1;	206	return 1;
206	}	207	}
207		208
208	if (!(at = archetype::find (ARCH_DEPLETION)))	209	if (!(at = archetype::find (shstr_depletion)))
209	{	210	{
210	LOG (llevError, "Could not find archetype depletion\n");	211	LOG (llevError, "Could not find archetype depletion\n");
211	return 0;	212	return 0;
212	}	213	}
213		214
…		…
230	}	231	}
231		232
232	/* improvement potion - only for players */	233	/* improvement potion - only for players */
233	if (op->type == PLAYER && (tmp->attacktype & AT_GODPOWER))	234	if (op->type == PLAYER && (tmp->attacktype & AT_GODPOWER))
234	{	235	{
235	for (i = 1; i < MIN (11, op->level); i++)	236	for (i = 1; i < min (11, op->level); i++)
236	{	237	{
237	if (QUERY_FLAG (tmp, FLAG_CURSED) || QUERY_FLAG (tmp, FLAG_DAMNED))	238	if (QUERY_FLAG (tmp, FLAG_CURSED) || QUERY_FLAG (tmp, FLAG_DAMNED))
238	{	239	{
239	if (op->contr->levhp[i] != 1)	240	if (op->contr->levhp[i] != 1)
240	{	241	{
…		…
275	}	276	}
276	}	277	}
277	}	278	}
278		279
279	/* Just makes checking easier */	280	/* Just makes checking easier */
280	if (i < MIN (11, op->level))	281	if (i < min (11, op->level))
281	got_one = 1;	282	got_one = 1;
282		283
283	if (!QUERY_FLAG (tmp, FLAG_CURSED) && !QUERY_FLAG (tmp, FLAG_DAMNED))	284	if (!QUERY_FLAG (tmp, FLAG_CURSED) && !QUERY_FLAG (tmp, FLAG_DAMNED))
284	{	285	{
285	if (got_one)	286	if (got_one)
…		…
394	}	395	}
395		396
396	/****************************************************************************	397	/****************************************************************************
397	* Weapon improvement code follows	398	* Weapon improvement code follows
398	****************************************************************************/	399	****************************************************************************/
		400
		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	}
399		415
400	/**	416	/**
401	* This returns the sum of nrof of item (arch name).	417	* This returns the sum of nrof of item (arch name).
402	*/	418	*/
403	static int	419	static int
…		…
450	}	466	}
451		467
452	prev = op;	468	prev = op;
453	op = op->below;	469	op = op->below;
454	}	470	}
455	}
456
457	/**
458	* This checks to see of the player (who) is sufficient level to use a weapon
459	* with improvs improvements (typically last_eat). We take an int here
460	* instead of the object so that the improvement code can pass along the
461	* increased value to see if the object is usuable.
462	* we return 1 (true) if the player can use the weapon.
463	*/
464	static int
465	check_weapon_power (const object *who, int improvs)
466	{
467	/* Old code is below (commented out). Basically, since weapons are the only
468	* object players really have any control to improve, it's a bit harsh to
469	* require high level in some combat skill, so we just use overall level.
470	*/
471	#if 1
472	if (((who->level / 5) + 5) >= improvs)
473	return 1;
474	else
475	return 0;
476
477	#else
478	int level = 0;
479
480	/* The skill system hands out wc and dam bonuses to fighters
481	* more generously than the old system (see fix_player). Thus
482	* we need to curtail the power of player enchanted weapons.
483	* I changed this to 1 improvement per "fighter" level/5 -b.t.
484	* Note: Nothing should break by allowing this ratio to be different or
485	* using normal level - it is just a matter of play balance.
486	*/
487	if (who->type == PLAYER)
488	{
489	object *wc_obj = NULL;
490
491	for (wc_obj = who->inv; wc_obj; wc_obj = wc_obj->below)
492	if (wc_obj->type == SKILL && IS_COMBAT_SKILL (wc_obj->subtype) && wc_obj->level > level)
493	level = wc_obj->level;
494
495	if (!level)
496	{
497	LOG (llevError, "Error: Player: %s lacks wc experience object\n", who->name);
498	level = who->level;
499	}
500	}
501	else
502	level = who->level;
503
504	return (improvs <= ((level / 5) + 5));
505	#endif
506	}	471	}
507		472
508	/**	473	/**
509	* 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.
510	* 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.
…		…
566		531
567	/**	532	/**
568	* This does the prepare weapon scroll.	533	* This does the prepare weapon scroll.
569	* Checks for sacrifice, and so on.	534	* Checks for sacrifice, and so on.
570	*/	535	*/
571	int	536	static int
572	prepare_weapon (object *op, object *improver, object *weapon)	537	prepare_weapon (object *op, object *improver, object *weapon)
573	{	538	{
574	int sacrifice_count, i;	539	int sacrifice_count, i;
575	char buf[MAX_BUF];	540	char buf[MAX_BUF];
576		541
…		…
629	*	594	*
630	* We are hiding extra information about the weapon in the level and	595	* We are hiding extra information about the weapon in the level and
631	* last_eat numbers for an object. Hopefully this won't break anything ??	596	* last_eat numbers for an object. Hopefully this won't break anything ??
632	* level == max improve last_eat == current improve	597	* level == max improve last_eat == current improve
633	*/	598	*/
634	int	599	static int
635	improve_weapon (object *op, object *improver, object *weapon)	600	improve_weapon (object *op, object *improver, object *weapon)
636	{	601	{
637	int sacrifice_count, sacrifice_needed = 0;	602	int sacrifice_count, sacrifice_needed = 0;
638		603
639	if (improver->stats.sp == IMPROVE_PREPARE)	604	if (improver->stats.sp == IMPROVE_PREPARE)
640	return prepare_weapon (op, improver, weapon);	605	return prepare_weapon (op, improver, weapon);
641		606
642	if (weapon->level == 0)	607	if (weapon->level == 0)
643	{	608	{
644	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.>");
645	return 0;	612	return 0;
646	}	613	}
647		614
648	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
649	{	617	{
650	op->failmsg ("This weapon cannot be improved any more.");	618	op->failmsg ("This weapon cannot be improved any more.");
651	return 0;	619	return 0;
652	}	620	}
653		621
654	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))
655	{	624	{
656	op->failmsg ("Improving the weapon will make it too "	625	op->failmsg ("Improving the weapon will make it too "
657	"powerful for you to use. Unready it if you "	626	"powerful for you to use. Unready it if you "
658	"really want to improve it.");	627	"really want to improve it.");
659	return 0;	628	return 0;
…		…
737	/**	706	/**
738	* Handles the applying of improve/prepare/enchant weapon scroll.	707	* Handles the applying of improve/prepare/enchant weapon scroll.
739	* 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, ...),
740	* then calls improve_weapon to do the dirty work.	709	* then calls improve_weapon to do the dirty work.
741	*/	710	*/
742	int	711	static int
743	check_improve_weapon (object *op, object *tmp)	712	check_improve_weapon (object *op, object *tmp)
744	{	713	{
745	object *otmp;	714	object *otmp;
746		715
747	if (op->type != PLAYER)	716	if (op->type != PLAYER)
…		…
794	* the armour value of the piece of equipment exceed either	763	* the armour value of the piece of equipment exceed either
795	* the users level or 90)	764	* the users level or 90)
796	* Modified by MSW for partial resistance. Only support	765	* Modified by MSW for partial resistance. Only support
797	* changing of physical area right now.	766	* changing of physical area right now.
798	*/	767	*/
799	int	768	static int
800	improve_armour (object *op, object *improver, object *armour)	769	improve_armour (object *op, object *improver, object *armour)
801	{	770	{
802	object *tmp;	771	object *tmp;
803		772
804	if (armour->magic >= settings.armor_max_enchant)	773	if (armour->magic >= settings.armor_max_enchant)
…		…
888	* Takes one type of items and makes another.	857	* Takes one type of items and makes another.
889	* converter is the object that is doing the conversion.	858	* converter is the object that is doing the conversion.
890	* 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
891	* what the converter wants, this will not do anything.	860	* what the converter wants, this will not do anything.
892	*/	861	*/
893	static int	862	int
894	convert_item (object *item, object *converter)	863	convert_item (object *item, object *converter)
895	{	864	{
896	sint64 nr, price_in;	865	sint64 nr = 0, price_in;
897		866
898	if (item->flag [FLAG_UNPAID])	867	if (item->flag [FLAG_UNPAID])
899	return 0;	868	return 0;
900		869
901	shstr conv_from = converter->slaying;	870	shstr conv_from = converter->slaying;
902	archetype *conv_to = converter->other_arch;	871	archetype *conv_to = converter->other_arch;
903	sint64 need = converter->stats.food;	872	sint64 need = converter->stats.food;
904	sint64 give = converter->stats.sp;	873	sint64 give = converter->stats.sp;
905		874
…		…
1015	* Handle apply on containers.	984	* Handle apply on containers.
1016	* By Eneq(@csd.uu.se).	985	* By Eneq(@csd.uu.se).
1017	* 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]
1018	* added the alchemical cauldron to the code -b.t.	987	* added the alchemical cauldron to the code -b.t.
1019	*/	988	*/
1020	int	989	static int
1021	apply_container (object *op, object *sack)	990	apply_container (object *op, object *sack)
1022	{	991	{
1023	if (op->type != PLAYER || !op->contr->ns)	992	if (op->type != PLAYER || !op->contr->ns)
1024	return 0; /* This might change */	993	return 0; /* This might change */
1025		994
…		…
1038	}	1007	}
1039		1008
1040	// 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
1041	if (sack->flag [FLAG_APPLIED])	1010	if (sack->flag [FLAG_APPLIED])
1042	{	1011	{
1043	if (op->container == sack)	1012	if (op->container_ () == sack)
1044	{	1013	{
1045	// open on ground or inv, so close	1014	// open on ground or inv, so close
1046	op->close_container ();	1015	op->close_container ();
1047	return 1;	1016	return 1;
1048	}	1017	}
…		…
1091	{	1060	{
1092	/* Only players can make sacrifices on spell casting altars. */	1061	/* Only players can make sacrifices on spell casting altars. */
1093	if (altar->inv && (!originator || originator->type != PLAYER))	1062	if (altar->inv && (!originator || originator->type != PLAYER))
1094	return 0;	1063	return 0;
1095		1064
1096	if (operate_altar (altar, &sacrifice))	1065	if (operate_altar (altar, &sacrifice, originator))
1097	{	1066	{
1098	/* Simple check. Unfortunately, it means you can't cast magic bullet	1067	/* Simple check. Unfortunately, it means you can't cast magic bullet
1099	* 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
1100	* is up to map designers to use them properly.	1069	* is up to map designers to use them properly.
1101	*/	1070	*/
…		…
1137		1106
1138	SET_FLAG (op, FLAG_NO_APPLY); /* prevent loops */	1107	SET_FLAG (op, FLAG_NO_APPLY); /* prevent loops */
1139		1108
1140	bool has_unpaid = false;	1109	bool has_unpaid = false;
1141		1110
1142	// 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
1143	// a quick and small change :(	1112	// a quick and small change :(
1144	for (object::depth_iterator item = op->begin (); item != op->end (); ++item)	1113	for (object::depth_iterator item = op->begin (); item != op->end (); ++item)
1145	if (item->flag [FLAG_UNPAID])	1114	if (item->flag [FLAG_UNPAID])
1146	{	1115	{
1147	has_unpaid = true;	1116	has_unpaid = true;
…		…
1355	return;	1324	return;
1356		1325
1357	/* move_apply() is the most likely candidate for causing unwanted and	1326	/* move_apply() is the most likely candidate for causing unwanted and
1358	* possibly unlimited recursion.	1327	* possibly unlimited recursion.
1359	*/	1328	*/
1360	/* The following was changed because it was causing perfeclty correct	1329	/* The following was changed because it was causing perfectly correct
1361	* maps to fail. 1) it's not an error to recurse:	1330	* maps to fail. 1) it's not an error to recurse:
1362	* rune detonates, summoning monster. monster lands on nearby rune.	1331	* rune detonates, summoning monster. monster lands on nearby rune.
1363	* nearby rune detonates. This sort of recursion is expected and	1332	* nearby rune detonates. This sort of recursion is expected and
1364	* proper. This code was causing needless crashes.	1333	* proper. This code was causing needless crashes.
1365	*/	1334	*/
…		…
1372		1341
1373	recursion_depth++;	1342	recursion_depth++;
1374	if (trap->head)	1343	if (trap->head)
1375	trap = trap->head;	1344	trap = trap->head;
1376		1345
1377	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)))
1378	goto leave;
1379
1380	switch (trap->type)	1347	switch (trap->type)
1381	{	1348	{
1382	case PLAYERMOVER:	1349	case PLAYERMOVER:
1383	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->has_active_speed ())
		1410	&& trap->owner != victim)
		1411	hit_with_arrow (trap, victim);
		1412	break;
		1413
		1414	case SPELL_EFFECT:
		1415	apply_spell_effect (trap, victim);
		1416	break;
		1417
		1418	case TRAPDOOR:
1384	{	1419	{
		1420	int max, sound_was_played;
		1421	object *ab, *ab_next;
		1422
1385	if (!trap->stats.maxsp)	1423	if (!trap->value)
1386	trap->stats.maxsp = 2;	1424	{
		1425	int tot;
1387		1426
1388	/* Is this correct? From the docs, it doesn't look like it	1427	for (ab = trap->above, tot = 0; ab; ab = ab->above)
1389	* should be divided by trap->speed	1428	if ((ab->move_type && trap->move_on) || ab->move_type == 0)
		1429	tot += ab->head_ ()->total_weight ();
		1430
		1431	if (!(trap->value = (tot > trap->weight) ? 1 : 0))
		1432	break;
		1433
		1434	SET_ANIMATION (trap, trap->value);
		1435	update_object (trap, UP_OBJ_FACE);
		1436	}
		1437
		1438	for (ab = trap->above, max = 100, sound_was_played = 0; --max && ab; ab = ab_next)
		1439	{
		1440	/* need to set this up, since if we do transfer the object,
		1441	* ab->above would be bogus
1390	*/	1442	*/
1391	victim->speed_left = -FABS (trap->stats.maxsp * victim->speed / trap->speed);	1443	ab_next = ab->above;
1392		1444
1393	/* Just put in some sanity check. I think there is a bug in the	1445	if ((ab->move_type && trap->move_on) || ab->move_type == 0)
1394	* above with some objects have zero speed, and thus the player	1446	{
1395	* getting permanently paralyzed.	1447	if (!sound_was_played)
		1448	{
		1449	trap->play_sound (trap->sound ? trap->sound : sound_find ("fall_hole"));
		1450	sound_was_played = 1;
		1451	}
		1452
		1453	ab->statusmsg ("You fall into a trapdoor!", NDI_RED);
		1454	transfer_ob (ab, EXIT_X (trap), EXIT_Y (trap), 0, ab);
		1455	}
1396	*/	1456	}
1397	if (victim->speed_left < -50.f)	1457	break;
1398	victim->speed_left = -50.f;
1399	/* LOG(llevDebug, "apply, playermove, player speed_left=%f\n", victim->speed_left); */
1400	}	1458	}
1401	goto leave;
1402		1459
1403	case SPINNER:	1460	case CONVERTER:
1404	if (victim->direction)	1461	if (convert_item (victim, trap) < 0)
1405	{
1406	victim->direction = absdir (victim->direction - trap->stats.sp);
1407	update_turn_face (victim);
1408	}
1409	goto leave;
1410
1411	case DIRECTOR:
1412	if (victim->direction && !should_director_abort (trap, victim))
1413	{
1414	victim->direction = trap->stats.sp;
1415	update_turn_face (victim);
1416	}
1417	goto leave;
1418
1419	case BUTTON:
1420	case PEDESTAL:
1421	update_button (trap, originator);
1422	goto leave;
1423
1424	case ALTAR:
1425	/* sacrifice victim on trap */
1426	apply_altar (trap, victim, originator);
1427	goto leave;
1428
1429	case THROWN_OBJ:
1430	if (trap->inv == NULL)
1431	goto leave;
1432	/* fallthrough */
1433
1434	case ARROW:
1435	/* bad bug: monster throw a object, make a step forwards, step on object ,
1436	* trigger this here and get hit by own missile - and will be own enemy.
1437	* Victim then is his own enemy and will start to kill herself (this is
1438	* removed) but we have not synced victim and his missile. To avoid senseless
1439	* action, we avoid hits here
1440	*/
1441	if ((QUERY_FLAG (victim, FLAG_ALIVE) && trap->speed) && trap->owner != victim)
1442	hit_with_arrow (trap, victim);
1443	goto leave;
1444
1445	case SPELL_EFFECT:
1446	apply_spell_effect (trap, victim);
1447	goto leave;
1448
1449	case TRAPDOOR:
1450	{
1451	int max, sound_was_played;
1452	object *ab, *ab_next;
1453
1454	if (!trap->value)
1455	{	1462	{
1456	int tot;	1463	originator->failmsg (format ("The %s seems to be broken!", query_name (trap)));
1457		1464	archetype::get (shstr_burnout)->insert_at (trap, trap);
1458	for (ab = trap->above, tot = 0; ab; ab = ab->above)
1459	if ((ab->move_type && trap->move_on) || ab->move_type == 0)
1460	tot += ab->head_ ()->total_weight ();
1461
1462	if (!(trap->value = (tot > trap->weight) ? 1 : 0))
1463	goto leave;
1464
1465	SET_ANIMATION (trap, trap->value);
1466	update_object (trap, UP_OBJ_FACE);
1467	}	1465	}
1468		1466
1469	for (ab = trap->above, max = 100, sound_was_played = 0; --max && ab; ab = ab_next)	1467	break;
		1468
		1469	case TRIGGER_BUTTON:
		1470	case TRIGGER_PEDESTAL:
		1471	case TRIGGER_ALTAR:
		1472	check_trigger (trap, victim, originator);
		1473	break;
		1474
		1475	case DEEP_SWAMP:
		1476	walk_on_deep_swamp (trap, victim);
		1477	break;
		1478
		1479	case CHECK_INV:
		1480	check_inv (victim, trap);
		1481	break;
		1482
		1483	case HOLE:
		1484	move_apply_hole (trap, victim);
		1485	break;
		1486
		1487	case EXIT:
		1488	if (victim->type == PLAYER && EXIT_PATH (trap))
1470	{	1489	{
1471	/* need to set this up, since if we do transfer the object,	1490	/* Basically, don't show exits leading to random maps the
1472	* ab->above would be bogus	1491	* players output.
1473	*/	1492	*/
1474	ab_next = ab->above;	1493	if (trap->msg && !EXIT_PATH (trap).starts_with ("/!"))
		1494	victim->statusmsg (trap->msg, NDI_NAVY);
1475		1495
1476	if ((ab->move_type && trap->move_on) || ab->move_type == 0)	1496	trap->play_sound (trap->sound);
1477	{	1497	victim->enter_exit (trap);
1478	if (!sound_was_played)
1479	{
1480	trap->play_sound (trap->sound ? trap->sound : sound_find ("fall_hole"));
1481	sound_was_played = 1;
1482	}
1483
1484	ab->statusmsg ("You fall into a trapdoor!", NDI_RED);
1485	transfer_ob (ab, EXIT_X (trap), EXIT_Y (trap), 0, ab);
1486	}
1487	}	1498	}
1488	goto leave;	1499	break;
1489	}
1490		1500
1491	case CONVERTER:
1492	if (convert_item (victim, trap) < 0)
1493	{
1494	originator->failmsg (format ("The %s seems to be broken!", query_name (trap)));
1495	archetype::get (shstr_burnout)->insert_at (trap, trap);
1496	}
1497
1498	goto leave;
1499
1500	case TRIGGER_BUTTON:
1501	case TRIGGER_PEDESTAL:
1502	case TRIGGER_ALTAR:
1503	check_trigger (trap, victim);
1504	goto leave;
1505
1506	case DEEP_SWAMP:
1507	walk_on_deep_swamp (trap, victim);
1508	goto leave;
1509
1510	case CHECK_INV:
1511	check_inv (victim, trap);
1512	goto leave;
1513
1514	case HOLE:
1515	move_apply_hole (trap, victim);
1516	goto leave;
1517
1518	case EXIT:
1519	if (victim->type == PLAYER && EXIT_PATH (trap))
1520	{
1521	/* Basically, don't show exits leading to random maps the
1522	* players output.
1523	*/
1524	if (trap->msg && !EXIT_PATH (trap).starts_with ("/!"))
1525	victim->statusmsg (trap->msg, NDI_NAVY);
1526
1527	trap->play_sound (trap->sound);
1528	victim->enter_exit (trap);
1529	}
1530	goto leave;
1531
1532	case ENCOUNTER:	1501	case ENCOUNTER:
1533	/* may be some leftovers on this */	1502	/* may be some leftovers on this */
1534	goto leave;	1503	break;
1535		1504
1536	case SHOP_MAT:	1505	case SHOP_MAT:
1537	apply_shop_mat (trap, victim);	1506	apply_shop_mat (trap, victim);
1538	goto leave;	1507	break;
1539		1508
1540	/* Drop a certain amount of gold, and have one item identified */	1509	/* Drop a certain amount of gold, and have one item identified */
1541	case IDENTIFY_ALTAR:	1510	case IDENTIFY_ALTAR:
1542	apply_id_altar (victim, trap, originator);	1511	apply_id_altar (victim, trap, originator);
1543	goto leave;	1512	break;
1544		1513
1545	case SIGN:	1514	case SIGN:
1546	if (victim->type != PLAYER && trap->stats.food > 0)	1515	if (victim->type != PLAYER && trap->stats.food > 0)
1547	goto leave; /* monsters musn't apply magic_mouths with counters */	1516	break; /* monsters musn't apply magic_mouths with counters */
1548		1517
1549	apply_sign (victim, trap, 1);	1518	apply_sign (victim, trap, 1);
1550	goto leave;	1519	break;
1551		1520
1552	case CONTAINER:	1521	case CONTAINER:
1553	apply_container (victim, trap);	1522	apply_container (victim, trap);
1554	goto leave;	1523	break;
1555		1524
1556	case RUNE:	1525	case RUNE:
1557	case TRAP:	1526	case TRAP:
1558	if (trap->level && QUERY_FLAG (victim, FLAG_ALIVE))	1527	if (trap->level && QUERY_FLAG (victim, FLAG_ALIVE))
1559	spring_trap (trap, victim);	1528	spring_trap (trap, victim);
1560	goto leave;	1529	break;
1561		1530
1562	default:	1531	default:
1563	LOG (llevDebug, "name %s, arch %s, type %d with fly/walk on/off not "	1532	LOG (llevDebug, "name %s, arch %s, type %d with fly/walk on/off not "
1564	"handled in move_apply()\n", &trap->name, &trap->arch->archname, trap->type);	1533	"handled in move_apply()\n", &trap->name, &trap->arch->archname, trap->type);
1565	goto leave;	1534	break;
1566	}	1535	}
1567		1536
1568	leave:
1569	recursion_depth--;	1537	recursion_depth--;
1570	}	1538	}
1571		1539
1572	/**	1540	/**
1573	* Handles reading a regular (ie not containing a spell) book.	1541	* Handles reading a regular (ie not containing a spell) book.
…		…
1584	return;	1552	return;
1585	}	1553	}
1586		1554
1587	if (!tmp->msg)	1555	if (!tmp->msg)
1588	{	1556	{
1589	op->failmsg (format ("You open the %s and find it empty.", &tmp->name));	1557	op->failmsg (format ("The %s contains nothing but meaningless gibberish. H<There is nothing interesting to read here.>", &tmp->name));
1590	return;	1558	return;
1591	}	1559	}
1592		1560
1593	/* need a literacy skill to read stuff! */	1561	/* need a literacy skill to read stuff! */
1594	skill_ob = find_skill_by_name (op, tmp->skill);	1562	skill_ob = find_skill_by_name (op, tmp->skill);
…		…
1634	SET_FLAG (tmp, FLAG_NO_SKILL_IDENT); /* so no more xp gained from this book */	1602	SET_FLAG (tmp, FLAG_NO_SKILL_IDENT); /* so no more xp gained from this book */
1635	}	1603	}
1636	}	1604	}
1637		1605
1638	/**	1606	/**
		1607	* op made some mistake with a scroll, this takes care of punishment.
		1608	* scroll_failure()- hacked directly from spell_failure
		1609	*/
		1610	static void
		1611	scroll_failure (object *op, int failure, int power)
		1612	{
		1613	if (abs (failure / 4) > power)
		1614	power = abs (failure / 4); /* set minimum effect */
		1615
		1616	if (failure <= -1 && failure > -15)
		1617	{ /* wonder */
		1618	object *tmp;
		1619
		1620	op->failmsg ("Your spell warps!");
		1621	tmp = get_archetype (SPELL_WONDER);
		1622	cast_wonder (op, op, 0, tmp);
		1623	tmp->destroy ();
		1624	}
		1625	else if (failure <= -15 && failure > -35)
		1626	{ /* drain mana */
		1627	op->failmsg ("Your mana is drained!");
		1628	op->stats.sp -= random_roll (0, power - 1, op, PREFER_LOW);
		1629	if (op->stats.sp < 0)
		1630	op->stats.sp = 0;
		1631	}
		1632	else if (settings.spell_failure_effects == TRUE)
		1633	{
		1634	if (failure <= -35 && failure > -60)
		1635	{ /* confusion */
		1636	op->failmsg ("The magic recoils on you!");
		1637	confuse_player (op, op, power);
		1638	}
		1639	else if (failure <= -60 && failure > -70)
		1640	{ /* paralysis */
		1641	op->failmsg ("The magic recoils and paralyzes you!");
		1642	paralyze_player (op, op, power);
		1643	}
		1644	else if (failure <= -70 && failure > -80)
		1645	{ /* blind */
		1646	op->failmsg ("The magic recoils on you!");
		1647	blind_player (op, op, power);
		1648	}
		1649	else if (failure <= -80)
		1650	{ /* blast the immediate area */
		1651	object *tmp = get_archetype (LOOSE_MANA);
		1652	cast_magic_storm (op, tmp, power);
		1653	op->failmsg ("You unleash uncontrolled mana!");
		1654	tmp->destroy ();
		1655	}
		1656	}
		1657	}
		1658
		1659	/**
1639	* Handles the applying of a skill scroll, calling learn_skill straight.	1660	* Handles the applying of a skill scroll, calling learn_skill straight.
1640	* op is the person learning the skill, tmp is the skill scroll object	1661	* op is the person learning the skill, tmp is the skill scroll object
1641	*/	1662	*/
1642	static void	1663	static void
1643	apply_skillscroll (object *op, object *tmp)	1664	apply_skillscroll (object *op, object *tmp)
…		…
1776	LOG (llevError, "apply_spellbook: Book %s has no spell in it!\n", &tmp->name);	1797	LOG (llevError, "apply_spellbook: Book %s has no spell in it!\n", &tmp->name);
1777	op->failmsg ("The spellbook symbols make no sense. This is a bug, please report!");	1798	op->failmsg ("The spellbook symbols make no sense. This is a bug, please report!");
1778	return;	1799	return;
1779	}	1800	}
1780		1801
1781	if (skop->level < int (sqrtf (spell->level) * 1.5f))	1802	int learn_level = sqrtf (spell->level) * 1.5f;
		1803	if (skop->level < learn_level)
1782	{	1804	{
1783	op->failmsg (format ("You are unable to decipher the strange symbols. H<Your %s level is too low.>", &tmp->skill));	1805	op->failmsg (format ("You are unable to decipher the strange symbols. H<Your %s level is too low, it must be at least %d.>",
		1806	&tmp->skill, learn_level));
1784	return;	1807	return;
1785	}	1808	}
1786		1809
1787	op->statusmsg (format ("The spellbook contains the %s level spell %s.", get_levelnumber (spell->level), &spell->name));	1810	op->statusmsg (format ("The spellbook contains the %s level spell %s.", get_levelnumber (spell->level), &spell->name));
1788		1811
…		…
1830	* literacy rate very useful! -b.t.	1853	* literacy rate very useful! -b.t.
1831	*/	1854	*/
1832	if (QUERY_FLAG (op, FLAG_CONFUSED))	1855	if (QUERY_FLAG (op, FLAG_CONFUSED))
1833	{	1856	{
1834	op->failmsg ("In your confused state you flub the wording of the text!");	1857	op->failmsg ("In your confused state you flub the wording of the text!");
1835	scroll_failure (op, 0 - random_roll (0, spell->level, op, PREFER_LOW), MAX (spell->stats.sp, spell->stats.grace));	1858	scroll_failure (op, 0 - random_roll (0, spell->level, op, PREFER_LOW), max (spell->stats.sp, spell->stats.grace));
1836	}	1859	}
1837	else if (QUERY_FLAG (tmp, FLAG_STARTEQUIP) ||	1860	else if (QUERY_FLAG (tmp, FLAG_STARTEQUIP) ||
1838	(random_roll (0, 100, op, PREFER_LOW) - (5 * skop->level)) < learn_spell[spell->stats.grace ? op->stats.Wis : op->stats.Int])	1861	(random_roll (0, 100, op, PREFER_LOW) - (5 * skop->level)) < learn_spell[spell->stats.grace ? op->stats.Wis : op->stats.Int])
1839	{	1862	{
1840	op->statusmsg ("You succeed in learning the spell!", NDI_GREEN);	1863	op->statusmsg ("You succeed in learning the spell!", NDI_GREEN);
…		…
1946	break;	1969	break;
1947	}	1970	}
1948		1971
1949	if (!tmp->destroyed () && !tmp->inv)	1972	if (!tmp->destroyed () && !tmp->inv)
1950	tmp->decrease (true);	1973	tmp->decrease (true);
1951	}
1952
1953	/**
1954	* op eats food.
1955	* If player, takes care of messages and dragon special food.
1956	*/
1957	static void
1958	apply_food (object *op, object *tmp)
1959	{
1960	int capacity_remaining;
1961
1962	if (op->type != PLAYER)
1963	op->stats.hp = op->stats.maxhp;
1964	else
1965	{
1966	/* check if this is a dragon (player), eating some flesh */
1967	if (tmp->type == FLESH && is_dragon_pl (op) && dragon_eat_flesh (op, tmp))
1968	;
1969	else
1970	{
1971	/* usual case - no dragon meal: */
1972	if (op->stats.food + tmp->stats.food > 999)
1973	{
1974	if (tmp->type == FOOD || tmp->type == FLESH)
1975	op->failmsg ("You feel full, but what a waste of food!");
1976	else
1977	op->statusmsg ("Most of the drink goes down your face not your throat!");
1978	}
1979
1980	tmp->play_sound (
1981	tmp->sound
1982	? tmp->sound
1983	: tmp->type == DRINK
1984	? sound_find ("eat_drink")
1985	: sound_find ("eat_food")
1986	);
1987
1988	if (!QUERY_FLAG (tmp, FLAG_CURSED))
1989	{
1990	const char *buf;
1991
1992	if (!is_dragon_pl (op))
1993	{
1994	/* eating message for normal players */
1995	if (tmp->type == DRINK)
1996	buf = format ("Ahhh...that %s tasted good.", &tmp->name);
1997	else
1998	buf = format ("The %s tasted %s", &tmp->name, tmp->type == FLESH ? "terrible!" : "good.");
1999	}
2000	else
2001	/* eating message for dragon players */
2002	buf = format ("The %s tasted terrible!", &tmp->name);
2003
2004	op->statusmsg (buf);
2005
2006	capacity_remaining = 999 - op->stats.food;
2007	op->stats.food += tmp->stats.food;
2008	if (capacity_remaining < tmp->stats.food)
2009	op->stats.hp += capacity_remaining / 50;
2010	else
2011	op->stats.hp += tmp->stats.food / 50;
2012
2013	if (op->stats.hp > op->stats.maxhp)
2014	op->stats.hp = op->stats.maxhp;
2015	if (op->stats.food > 999)
2016	op->stats.food = 999;
2017	}
2018
2019	/* special food hack -b.t. */
2020	if (tmp->title || QUERY_FLAG (tmp, FLAG_CURSED))
2021	eat_special_food (op, tmp);
2022	}
2023	}
2024
2025	handle_apply_yield (tmp);
2026	tmp->decrease ();
2027	}	1974	}
2028		1975
2029	/**	1976	/**
2030	* A dragon is eating some flesh. If the flesh contains resistances,	1977	* A dragon is eating some flesh. If the flesh contains resistances,
2031	* there is a chance for the dragon's skin to get improved.	1978	* there is a chance for the dragon's skin to get improved.
…		…
2034	* object *op the object (dragon player) eating the flesh	1981	* object *op the object (dragon player) eating the flesh
2035	* object *meal the flesh item, getting chewed in dragon's mouth	1982	* object *meal the flesh item, getting chewed in dragon's mouth
2036	* return:	1983	* return:
2037	* int 1 if eating successful, 0 if it doesn't work	1984	* int 1 if eating successful, 0 if it doesn't work
2038	*/	1985	*/
2039	int	1986	static int
2040	dragon_eat_flesh (object *op, object *meal)	1987	dragon_eat_flesh (object *op, object *meal)
2041	{	1988	{
2042	object *skin = NULL; /* pointer to dragon skin force */	1989	object *skin = NULL; /* pointer to dragon skin force */
2043	object *abil = NULL; /* pointer to dragon ability force */	1990	object *abil = NULL; /* pointer to dragon ability force */
2044	object *tmp = NULL; /* tmp. object */	1991	object *tmp = NULL; /* tmp. object */
…		…
2076	op->stats.hp += meal->stats.food / 50;	2023	op->stats.hp += meal->stats.food / 50;
2077		2024
2078	if (op->stats.hp > op->stats.maxhp)	2025	if (op->stats.hp > op->stats.maxhp)
2079	op->stats.hp = op->stats.maxhp;	2026	op->stats.hp = op->stats.maxhp;
2080		2027
2081	op->stats.food = MIN (999, op->stats.food + meal->stats.food);	2028	op->stats.food = min (999, op->stats.food + meal->stats.food);
2082		2029
2083	/*LOG(llevDebug, "-> player: %d, flesh: %d\n", op->level, meal->level); */	2030	/*LOG(llevDebug, "-> player: %d, flesh: %d\n", op->level, meal->level); */
2084		2031
2085	/* on to the interesting part: chances for adding resistance */	2032	/* on to the interesting part: chances for adding resistance */
2086	for (i = 0; i < NROFATTACKS; i++)	2033	for (i = 0; i < NROFATTACKS; i++)
…		…
2096		2043
2097	/* monster bonus increases with level, because high-level	2044	/* monster bonus increases with level, because high-level
2098	flesh is too rare */	2045	flesh is too rare */
2099	mbonus = op->level * 20. / ((double) settings.max_level);	2046	mbonus = op->level * 20. / ((double) settings.max_level);
2100		2047
2101	chance = (((double) MIN (op->level + bonus, meal->level + bonus + mbonus)) * 100. /	2048	chance = (((double)min (op->level + bonus, meal->level + bonus + mbonus)) * 100. /
2102	((double) settings.max_level)) - skin->resist[i];	2049	((double)settings.max_level)) - skin->resist[i];
2103		2050
2104	if (chance >= 0.)	2051	if (chance >= 0.)
2105	chance += 1.;	2052	chance += 1.;
2106	else	2053	else
2107	chance = (chance < -12) ? 0. : 1. / pow (2., -chance);	2054	chance = (chance < -12) ? 0. : 1. / pow (2., -chance);
2108		2055
2109	/* chance is proportional to amount of resistance (max. 50) */	2056	/* chance is proportional to amount of resistance (max. 50) */
2110	chance *= ((double) (MIN (meal->resist[i], 50))) / 50.;	2057	chance *= ((double)(min (meal->resist[i], 50))) / 50.;
2111		2058
2112	/* doubled chance for resistance of ability-focus */	2059	/* doubled chance for resistance of ability-focus */
2113	if (i == abil->stats.exp)	2060	if (i == abil->stats.exp)
2114	chance = MIN (100., chance * 2.);	2061	chance = min (100., chance * 2.);
2115		2062
2116	/* now make the throw and save all winners (Don't insert luck bonus here!) */	2063	/* now make the throw and save all winners (Don't insert luck bonus here!) */
2117	if (rndm (10000) < (unsigned int) (chance * 100))	2064	if (rndm (10000) < (unsigned int)(chance * 100))
2118	{	2065	{
2119	atnr_winner[winners] = i;	2066	atnr_winner[winners] = i;
2120	winners++;	2067	winners++;
2121	}	2068	}
2122		2069
…		…
2185		2132
2186	return 1;	2133	return 1;
2187	}	2134	}
2188		2135
2189	/**	2136	/**
		2137	* op eats food.
		2138	* If player, takes care of messages and dragon special food.
		2139	*/
		2140	static void
		2141	apply_food (object *op, object *tmp)
		2142	{
		2143	int capacity_remaining;
		2144
		2145	if (op->type != PLAYER)
		2146	op->stats.hp = op->stats.maxhp;
		2147	else
		2148	{
		2149	/* check if this is a dragon (player), eating some flesh */
		2150	if (tmp->type == FLESH && is_dragon_pl (op) && dragon_eat_flesh (op, tmp))
		2151	;
		2152	else
		2153	{
		2154	/* usual case - no dragon meal: */
		2155	if (op->stats.food + tmp->stats.food > 999)
		2156	{
		2157	if (tmp->type == FOOD || tmp->type == FLESH)
		2158	op->failmsg ("You feel full, but what a waste of food!");
		2159	else
		2160	op->statusmsg ("Most of the drink goes down your face not your throat!");
		2161	}
		2162
		2163	tmp->play_sound (
		2164	tmp->sound
		2165	? tmp->sound
		2166	: tmp->type == DRINK
		2167	? sound_find ("eat_drink")
		2168	: sound_find ("eat_food")
		2169	);
		2170
		2171	if (!QUERY_FLAG (tmp, FLAG_CURSED))
		2172	{
		2173	const char *buf;
		2174
		2175	if (!is_dragon_pl (op))
		2176	{
		2177	/* eating message for normal players */
		2178	if (tmp->type == DRINK)
		2179	buf = format ("Ahhh...that %s tasted good.", &tmp->name);
		2180	else
		2181	buf = format ("The %s tasted %s", &tmp->name, tmp->type == FLESH ? "terrible!" : "good.");
		2182	}
		2183	else
		2184	/* eating message for dragon players */
		2185	buf = format ("The %s tasted terrible!", &tmp->name);
		2186
		2187	op->statusmsg (buf);
		2188
		2189	capacity_remaining = 999 - op->stats.food;
		2190	op->stats.food += tmp->stats.food;
		2191	if (capacity_remaining < tmp->stats.food)
		2192	op->stats.hp += capacity_remaining / 50;
		2193	else
		2194	op->stats.hp += tmp->stats.food / 50;
		2195
		2196	if (op->stats.hp > op->stats.maxhp)
		2197	op->stats.hp = op->stats.maxhp;
		2198	if (op->stats.food > 999)
		2199	op->stats.food = 999;
		2200	}
		2201
		2202	/* special food hack -b.t. */
		2203	if (tmp->title || QUERY_FLAG (tmp, FLAG_CURSED))
		2204	eat_special_food (op, tmp);
		2205	}
		2206	}
		2207
		2208	handle_apply_yield (tmp);
		2209	tmp->decrease ();
		2210	}
		2211
		2212	/**
2190	* Handles applying an improve armor scroll.	2213	* Handles applying an improve armor scroll.
2191	* Does some sanity checks, then calls improve_armour.	2214	* Does some sanity checks, then calls improve_armour.
2192	*/	2215	*/
2193	static void	2216	static void
2194	apply_armour_improver (object *op, object *tmp)	2217	apply_armour_improver (object *op, object *tmp)
…		…
2256	*	2279	*
2257	* Note: a owner in a 2 way exit is saved as the owner's name	2280	* Note: a owner in a 2 way exit is saved as the owner's name
2258	* in the field exit->name cause the field exit->owner doesn't	2281	* in the field exit->name cause the field exit->owner doesn't
2259	* survive in the swapping (in fact the whole exit doesn't survive).	2282	* survive in the swapping (in fact the whole exit doesn't survive).
2260	*/	2283	*/
2261	int	2284	static int
2262	is_legal_2ways_exit (object *op, object *exit)	2285	is_legal_2ways_exit (object *op, object *exit)
2263	{	2286	{
2264	if (exit->stats.exp != 1)	2287	if (exit->stats.exp != 1)
2265	return 1; /*This is not a 2 way, so it is legal */	2288	return 1; /*This is not a 2 way, so it is legal */
2266		2289
…		…
2339	/**	2362	/**
2340	* This function will try to apply a lighter and in case no lighter	2363	* This function will try to apply a lighter and in case no lighter
2341	* is specified it will try to find a lighter in the players inventory,	2364	* is specified it will try to find a lighter in the players inventory,
2342	* and inform him about this requirement.	2365	* and inform him about this requirement.
2343	*	2366	*
2344	* who - the player	2367	* who - the player
2345	* op - the item we want to light	2368	* op - the item we want to light
2346	* ligher - the lighter or 0 if a lighter has yet to be found	2369	* lighter - the lighter or 0 if a lighter has yet to be found
2347	*/	2370	*/
		2371	static object *
2348	object *auto_apply_lighter (object *who, object *op, object *lighter)	2372	auto_apply_lighter (object *who, object *op, object *lighter)
2349	{	2373	{
2350	if (lighter == 0)	2374	if (lighter == 0)
2351	{	2375	{
2352	for (object *tmp = who->inv; tmp; tmp = tmp->below)	2376	for (object *tmp = who->inv; tmp; tmp = tmp->below)
2353	{	2377	{
…		…
2391	/**	2415	/**
2392	* Designed primarily to light torches/lanterns/etc.	2416	* Designed primarily to light torches/lanterns/etc.
2393	* Also burns up burnable material too. First object in the inventory is	2417	* Also burns up burnable material too. First object in the inventory is
2394	* the selected object to "burn". -b.t.	2418	* the selected object to "burn". -b.t.
2395	*/	2419	*/
2396	void	2420	static void
2397	apply_lighter (object *who, object *lighter)	2421	apply_lighter (object *who, object *lighter)
2398	{	2422	{
2399	object *item;	2423	object *item;
2400	int is_player_env = 0;	2424	int is_player_env = 0;
2401		2425
2402	item = find_marked_object (who);	2426	item = find_marked_object (who);
2403	if (item)	2427	if (item)
2404	{	2428	{
2405	if (!auto_apply_lighter (who, 0, lighter))	2429	if (!auto_apply_lighter (who, item, lighter))
2406	return;	2430	return;
2407		2431
2408	/* Perhaps we should split what we are trying to light on fire?	2432	/* Perhaps we should split what we are trying to light on fire?
2409	* I can't see many times when you would want to light multiple	2433	* I can't see many times when you would want to light multiple
2410	* objects at once.	2434	* objects at once.
…		…
2428	}	2452	}
2429		2453
2430	/**	2454	/**
2431	* This function generates a cursed effect for cursed lamps and torches.	2455	* This function generates a cursed effect for cursed lamps and torches.
2432	*/	2456	*/
		2457	static void
2433	void player_apply_lamp_cursed_effect (object *who, object *op)	2458	player_apply_lamp_cursed_effect (object *who, object *op)
2434	{	2459	{
2435	if (op->level)	2460	if (op->level)
2436	{	2461	{
2437	who->failmsg (format (	2462	who->failmsg (format (
2438	"The %s was cursed, it explodes in a big fireball!",	2463	"The %s was cursed, it explodes in a big fireball!",
…		…
2453	* Apply for players and lamps	2478	* Apply for players and lamps
2454	*	2479	*
2455	* who - the player	2480	* who - the player
2456	* op - the lamp	2481	* op - the lamp
2457	*/	2482	*/
		2483	static void
2458	void player_apply_lamp (object *who, object *op)	2484	player_apply_lamp (object *who, object *op)
2459	{	2485	{
2460	bool switch_on = op->glow_radius ? false : true;	2486	bool switch_on = op->glow_radius ? false : true;
2461		2487
2462	if (switch_on)	2488	if (switch_on)
2463	{	2489	{
…		…
2576	if (op->other_arch)	2602	if (op->other_arch)
2577	get_animation_from_arch (op, switch_on ? op->other_arch : op->arch);	2603	get_animation_from_arch (op, switch_on ? op->other_arch : op->arch);
2578		2604
2579	if (object *pl = op->visible_to ())	2605	if (object *pl = op->visible_to ())
2580	esrv_update_item (UPD_ANIM | UPD_FACE | UPD_NAME, pl, op);	2606	esrv_update_item (UPD_ANIM | UPD_FACE | UPD_NAME, pl, op);
		2607	}
		2608
		2609	/**
		2610	* This handles items of type 'transformer'.
		2611	* Basically those items, used with a marked item, transform both items into something
		2612	* else.
		2613	* "Transformer" item has food decreased by 1, removed if 0 (0 at start means illimited)..
		2614	* Change information is contained in the 'slaying' field of the marked item.
		2615	* The format is as follow: transformer:[number ]yield[;transformer:...].
		2616	* This way an item can be transformed in many things, and/or many objects.
		2617	* The 'slaying' field for transformer is used as verb for the action.
		2618	*/
		2619	static void
		2620	apply_item_transformer (object *pl, object *transformer)
		2621	{
		2622	object *marked;
		2623	object *new_item;
		2624	char *find;
		2625	char *separator;
		2626	int yield;
		2627	char got[MAX_BUF];
		2628	int len;
		2629
		2630	if (!pl || !transformer)
		2631	return;
		2632
		2633	marked = find_marked_object (pl);
		2634
		2635	if (!marked)
		2636	{
		2637	pl->failmsg (format ("Use the %s with what item?", query_name (transformer)));
		2638	return;
		2639	}
		2640
		2641	if (!marked->slaying)
		2642	{
		2643	pl->failmsg (format ("You can't use the %s with your %s!", query_name (transformer), query_name (marked)));
		2644	return;
		2645	}
		2646
		2647	/* check whether they are compatible or not */
		2648	find = strstr (&marked->slaying, transformer->arch->archname);
		2649	if (!find || (*(find + strlen (transformer->arch->archname)) != ':'))
		2650	{
		2651	pl->failmsg (format ("You can't use the %s with your %s!", query_name (transformer), query_name (marked)));
		2652	return;
		2653	}
		2654
		2655	find += strlen (transformer->arch->archname) + 1;
		2656	/* Item can be used, now find how many and what it yields */
		2657	if (isdigit (*(find)))
		2658	{
		2659	yield = atoi (find);
		2660	if (yield < 1)
		2661	{
		2662	LOG (llevDebug, "apply_item_transformer: item %s has slaying-yield %d.", query_base_name (marked, 0), yield);
		2663	yield = 1;
		2664	}
		2665	}
		2666	else
		2667	yield = 1;
		2668
		2669	while (isdigit (*find))
		2670	find++;
		2671
		2672	while (*find == ' ')
		2673	find++;
		2674
		2675	memset (got, 0, MAX_BUF);
		2676
		2677	if ((separator = strchr (find, ';')) != NULL)
		2678	len = separator - find;
		2679	else
		2680	len = strlen (find);
		2681
		2682	if (len > MAX_BUF - 1)
		2683	len = MAX_BUF - 1;
		2684
		2685	strcpy (got, find);
		2686	got[len] = '\0';
		2687
		2688	/* Now create new item, remove used ones when required. */
		2689	new_item = get_archetype (got);
		2690	if (!new_item)
		2691	{
		2692	pl->failmsg (format ("This %s is strange, better to not use it.", query_base_name (marked, 0)));
		2693	return;
		2694	}
		2695
		2696	new_item->nrof = yield;
		2697
		2698	pl->statusmsg (format ("You %s the %s.", &transformer->slaying, query_base_name (marked, 0)));
		2699
		2700	pl->insert (new_item);
		2701	/* Eat up one item */
		2702	marked->decrease ();
		2703
		2704	/* Eat one transformer if needed */
		2705	if (transformer->stats.food)
		2706	if (--transformer->stats.food == 0)
		2707	transformer->decrease ();
2581	}	2708	}
2582		2709
2583	/**	2710	/**
2584	* Main apply handler.	2711	* Main apply handler.
2585	*	2712	*
…		…
2616	if (INVOKE_OBJECT (APPLY, op, ARG_OBJECT (who)))	2743	if (INVOKE_OBJECT (APPLY, op, ARG_OBJECT (who)))
2617	return RESULT_INT (0);	2744	return RESULT_INT (0);
2618		2745
2619	switch (op->type)	2746	switch (op->type)
2620	{	2747	{
2621	case CF_HANDLE:	2748	case T_HANDLE:
2622	who->play_sound (sound_find ("turn_handle"));	2749	who->play_sound (sound_find ("turn_handle"));
2623	who->statusmsg ("You turn the handle.");	2750	who->statusmsg ("You turn the handle.");
2624	op->value = op->value ? 0 : 1;	2751	op->value = op->value ? 0 : 1;
2625	SET_ANIMATION (op, op->value);	2752	SET_ANIMATION (op, op->value);
2626	update_object (op, UP_OBJ_FACE);	2753	update_object (op, UP_OBJ_FACE);
2627	push_button (op, who);	2754	push_button (op, who);
2628	return 1;	2755	return 1;
2629		2756
2630	case TRIGGER:	2757	case TRIGGER:
2631	if (check_trigger (op, who))	2758	if (check_trigger (op, who, who))
2632	{	2759	{
2633	who->statusmsg ("You turn the handle.");	2760	who->statusmsg ("You turn the handle.");
2634	who->play_sound (sound_find ("turn_handle"));	2761	who->play_sound (sound_find ("turn_handle"));
2635	}	2762	}
2636	else	2763	else
…		…
2641	case EXIT:	2768	case EXIT:
2642	if (who->type != PLAYER)	2769	if (who->type != PLAYER)
2643	return 0;	2770	return 0;
2644		2771
2645	if (!EXIT_PATH (op) || !is_legal_2ways_exit (who, op))	2772	if (!EXIT_PATH (op) || !is_legal_2ways_exit (who, op))
2646	who->failmsg (format ("The %s is closed.", query_name (op)));	2773	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)));
2647	else	2774	else
2648	{	2775	{
2649	/* Don't display messages for random maps. */	2776	/* Don't display messages for random maps. */
2650	if (op->msg && !EXIT_PATH (op).starts_with ("/!"))	2777	if (op->msg && !EXIT_PATH (op).starts_with ("/!"))
2651	who->statusmsg (op->msg, NDI_NAVY);	2778	who->statusmsg (op->msg, NDI_NAVY);
…		…
2874	* we don't use a corrupt pointer for the next object, so we get the	3001	* we don't use a corrupt pointer for the next object, so we get the
2875	* next object in the stack before applying. This is can only be a	3002	* next object in the stack before applying. This is can only be a
2876	* problem if player_apply() has a bug in that it uses the object but does	3003	* problem if player_apply() has a bug in that it uses the object but does
2877	* not return a proper value.	3004	* not return a proper value.
2878	*/	3005	*/
2879	for (object *next, *tmp = pl->container ? pl->container->inv : pl->below; tmp; tmp = next)	3006	for (object *next, *tmp = pl->container_ () ? pl->container_ ()->inv : pl->below; tmp; tmp = next)
2880	{	3007	{
2881	next = tmp->below;	3008	next = tmp->below;
2882		3009
2883	if (QUERY_FLAG (tmp, FLAG_IS_FLOOR))	3010	if (QUERY_FLAG (tmp, FLAG_IS_FLOOR))
2884	floors++;	3011	floors++;
…		…
3062	#define CANNOT_REMOVE_CURSED \	3189	#define CANNOT_REMOVE_CURSED \
3063	"H<You cannot remove cursed or damned items, you first have to remove the curse. " \	3190	"H<You cannot remove cursed or damned items, you first have to remove the curse. " \
3064	"Praying over an altar, scrolls of remove curse/damnation, " \	3191	"Praying over an altar, scrolls of remove curse/damnation, " \
3065	"priests or even other players might help.>"	3192	"priests or even other players might help.>"
3066		3193
3067	int	3194	static int
3068	unapply_for_ob (object *who, object *op, int aflags)	3195	unapply_for_ob (object *who, object *op, int aflags)
3069	{	3196	{
3070	if (op->is_range ())	3197	if (op->is_range ())
3071	for (object *tmp = who->inv; tmp; tmp = tmp->below)	3198	for (object *tmp = who->inv; tmp; tmp = tmp->below)
3072	if (QUERY_FLAG (tmp, FLAG_APPLIED) && tmp->is_range ())	3199	if (QUERY_FLAG (tmp, FLAG_APPLIED) && tmp->is_range ())
…		…
3390	* skill so that the dam and wc get updated	3517	* skill so that the dam and wc get updated
3391	*/	3518	*/
3392	who->change_skill (skop);	3519	who->change_skill (skop);
3393	}	3520	}
3394		3521
3395	if (who->type == PLAYER	3522	if (!check_item_power (who, op->item_power))
3396	&& op->item_power
3397	&& op->item_power + who->contr->item_power > settings.item_power_factor * who->level)
3398	{	3523	{
3399	who->failmsg ("Equipping that combined with other items would consume your soul!" LACK_ITEM_POWER);	3524	who->failmsg ("Equipping that combined with other items would consume your soul!" LACK_ITEM_POWER);
3400	return 1;	3525	return 1;
3401	}	3526	}
3402		3527
…		…
3410	return RESULT_INT (0);	3535	return RESULT_INT (0);
3411		3536
3412	switch (op->type)	3537	switch (op->type)
3413	{	3538	{
3414	case WEAPON:	3539	case WEAPON:
3415	if (!check_weapon_power (who, op->last_eat))
3416	{
3417	op->failmsg ("This weapon is too powerful for you to use. It would consume your soul!" LACK_ITEM_POWER);
3418
3419	if (tmp)
3420	insert_ob_in_ob (tmp, who);
3421
3422	return 1;
3423	}
3424
3425	//TODO: this obviously fails for players using a shorter prefix	3540	//TODO: this obviously fails for players using a shorter prefix
3426	// i.e. "R" can use Ragnarok's sword.	3541	// i.e. "R" can use Ragnarok's sword.
3427	if (op->level && !op->name.starts_with (who->name))	3542	if (op->level && !op->name.starts_with (who->name))
3428	{	3543	{
3429	/* if the weapon does not have the name as the character, can't use it. */	3544	/* if the weapon does not have the name as the character, can't use it. */
…		…
3555	}	3670	}
3556		3671
3557	break;	3672	break;
3558		3673
3559	case BOW:	3674	case BOW:
3560	if (!check_weapon_power (who, op->last_eat))
3561	{
3562	who->failmsg ("That weapon is too powerful for you to use. It would consume your soul!" LACK_ITEM_POWER);
3563
3564	if (tmp)
3565	insert_ob_in_ob (tmp, who);
3566
3567	return 1;
3568	}
3569
3570	if (op->level && !op->name.starts_with (who->name))	3675	if (op->level && !op->name.starts_with (who->name))
3571	{	3676	{
3572	who->failmsg ("The weapon does not recognize you as its owner. "	3677	who->failmsg ("The weapon does not recognize you as its owner. "
3573	"H<Its name indicates that it belongs to somebody else.>");	3678	"H<Its name indicates that it belongs to somebody else.>");
3574	if (tmp)	3679	if (tmp)
…		…
3658		3763
3659	if (object *pl = op->visible_to ())	3764	if (object *pl = op->visible_to ())
3660	esrv_send_item (pl, op);	3765	esrv_send_item (pl, op);
3661		3766
3662	return 0;	3767	return 0;
3663	}
3664
3665	int
3666	monster_apply_special (object *who, object *op, int aflags)
3667	{
3668	if (QUERY_FLAG (op, FLAG_UNPAID) && !QUERY_FLAG (op, FLAG_APPLIED))
3669	return 1;
3670
3671	return apply_special (who, op, aflags);
3672	}	3768	}
3673		3769
3674	/**	3770	/**
3675	* Map was just loaded, handle op's initialisation.	3771	* Map was just loaded, handle op's initialisation.
3676	*	3772	*
…		…
3839	}	3935	}
3840		3936
3841	for (mapspace *ms = spaces + size (); ms-- > spaces; )	3937	for (mapspace *ms = spaces + size (); ms-- > spaces; )
3842	for (object *tmp = ms->bot; tmp; tmp = tmp->above)	3938	for (object *tmp = ms->bot; tmp; tmp = tmp->above)
3843	if (tmp->above && (tmp->type == TRIGGER_BUTTON || tmp->type == TRIGGER_PEDESTAL))	3939	if (tmp->above && (tmp->type == TRIGGER_BUTTON || tmp->type == TRIGGER_PEDESTAL))
3844	check_trigger (tmp, tmp->above);	3940	check_trigger (tmp, tmp->above, tmp->above);
3845	}	3941	}
3846		3942
3847	/**	3943	/**
3848	* Handles player eating food that temporarily changes status (resistances, stats).	3944	* Handles player eating food that temporarily changes status (resistances, stats).
3849	* This used to call cast_change_attr(), but	3945	* This used to call cast_change_attr(), but
…		…
3854	eat_special_food (object *who, object *food)	3950	eat_special_food (object *who, object *food)
3855	{	3951	{
3856	object *force;	3952	object *force;
3857	int i, did_one = 0;	3953	int i, did_one = 0;
3858		3954
3859	force = get_archetype (FORCE_NAME);	3955	char buf[64];
		3956	snprintf (buf, sizeof(buf), "sp_food_%s", &food->title);
		3957	shstr key (buf);
3860		3958
3861	for (i = 0; i < NUM_STATS; i++)
3862	if (sint8 k = food->stats.stat (i))
3863	{
3864	force->stats.stat (i) = k;
3865	did_one = 1;
3866	}
3867
3868	/* check if we can protect the eater */
3869	for (i = 0; i < NROFATTACKS; i++)
3870	{
3871	if (food->resist[i] > 0)
3872	{
3873	force->resist[i] = food->resist[i] / 2;
3874	did_one = 1;
3875	}
3876	}
3877
3878	if (did_one)
3879	{
3880	force->set_speed (0.1);
3881	/* bigger morsel of food = longer effect time */	3959	/* bigger morsel of food = longer effect time */
3882	force->duration = food->stats.food / 5;	3960	int duration = TIME2TICK (food->stats.food);
3883	SET_FLAG (force, FLAG_APPLIED);	3961
3884	change_abil (who, force);	3962	if (force = who->force_find (key))
3885	insert_ob_in_ob (force, who);	3963	{
		3964	if (duration > abs (force->speed_left / force->speed))
		3965	{
		3966	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));
		3967	force->force_set_timer (duration);
		3968	}
		3969	else
		3970	new_draw_info (NDI_UNIQUE, 0, who, "It had no additional effect.");
		3971
		3972	return;
3886	}	3973	}
3887	else	3974	else
		3975	{
		3976	force = who->force_add (key, duration);
		3977	force->name = key;
		3978
		3979	/* check if the food affects a stat */
		3980	for (i = 0; i < NUM_STATS; i++)
		3981	if (sint8 k = food->stats.stat (i))
		3982	{
		3983	force->stats.stat (i) = k;
		3984	did_one = 1;
		3985	}
		3986
		3987	/* check if we can protect the eater */
		3988	for (i = 0; i < NROFATTACKS; i++)
		3989	{
		3990	if (food->resist[i] > 0)
		3991	{
		3992	force->resist[i] = food->resist[i];
		3993	did_one = 1;
		3994	}
		3995	}
		3996
		3997	if (did_one)
		3998	{
		3999	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));
		4000
		4001	/* make the force take effect and report effects to user */
		4002	change_abil (who, force);
		4003	}
		4004	else
3888	force->destroy ();	4005	force->destroy ();
		4006	}
3889		4007
3890	/* check for hp, sp change */	4008	/* check for hp, sp change */
3891	if (food->stats.hp != 0)	4009	if (food->stats.hp != 0)
3892	{	4010	{
3893	if (QUERY_FLAG (food, FLAG_CURSED))	4011	if (QUERY_FLAG (food, FLAG_CURSED))
…		…
3923	/* place limit on max sp from food? */	4041	/* place limit on max sp from food? */
3924	}	4042	}
3925	}	4043	}
3926		4044
3927	who->update_stats ();	4045	who->update_stats ();
3928	}
3929
3930
3931	/**
3932	* op made some mistake with a scroll, this takes care of punishment.
3933	* scroll_failure()- hacked directly from spell_failure
3934	*/
3935	void
3936	scroll_failure (object *op, int failure, int power)
3937	{
3938	if (abs (failure / 4) > power)
3939	power = abs (failure / 4); /* set minimum effect */
3940
3941	if (failure <= -1 && failure > -15)
3942	{ /* wonder */
3943	object *tmp;
3944
3945	op->failmsg ("Your spell warps!");
3946	tmp = get_archetype (SPELL_WONDER);
3947	cast_wonder (op, op, 0, tmp);
3948	tmp->destroy ();
3949	}
3950	else if (failure <= -15 && failure > -35)
3951	{ /* drain mana */
3952	op->failmsg ("Your mana is drained!");
3953	op->stats.sp -= random_roll (0, power - 1, op, PREFER_LOW);
3954	if (op->stats.sp < 0)
3955	op->stats.sp = 0;
3956	}
3957	else if (settings.spell_failure_effects == TRUE)
3958	{
3959	if (failure <= -35 && failure > -60)
3960	{ /* confusion */
3961	op->failmsg ("The magic recoils on you!");
3962	confuse_player (op, op, power);
3963	}
3964	else if (failure <= -60 && failure > -70)
3965	{ /* paralysis */
3966	op->failmsg ("The magic recoils and paralyzes you!");
3967	paralyze_player (op, op, power);
3968	}
3969	else if (failure <= -70 && failure > -80)
3970	{ /* blind */
3971	op->failmsg ("The magic recoils on you!");
3972	blind_player (op, op, power);
3973	}
3974	else if (failure <= -80)
3975	{ /* blast the immediate area */
3976	object *tmp = get_archetype (LOOSE_MANA);
3977	cast_magic_storm (op, tmp, power);
3978	op->failmsg ("You unleash uncontrolled mana!");
3979	tmp->destroy ();
3980	}
3981	}
3982	}	4046	}
3983		4047
3984	void	4048	void
3985	apply_changes_to_player (object *pl, object *change)	4049	apply_changes_to_player (object *pl, object *change)
3986	{	4050	{
…		…
4063	break;	4127	break;
4064	}	4128	}
4065	}	4129	}
4066	}	4130	}
4067		4131
4068	/**
4069	* This handles items of type 'transformer'.
4070	* Basically those items, used with a marked item, transform both items into something
4071	* else.
4072	* "Transformer" item has food decreased by 1, removed if 0 (0 at start means illimited)..
4073	* Change information is contained in the 'slaying' field of the marked item.
4074	* The format is as follow: transformer:[number ]yield[;transformer:...].
4075	* This way an item can be transformed in many things, and/or many objects.
4076	* The 'slaying' field for transformer is used as verb for the action.
4077	*/
4078	void
4079	apply_item_transformer (object *pl, object *transformer)
4080	{
4081	object *marked;
4082	object *new_item;
4083	char *find;
4084	char *separator;
4085	int yield;
4086	char got[MAX_BUF];
4087	int len;
4088
4089	if (!pl || !transformer)
4090	return;
4091
4092	marked = find_marked_object (pl);
4093
4094	if (!marked)
4095	{
4096	pl->failmsg (format ("Use the %s with what item?", query_name (transformer)));
4097	return;
4098	}
4099
4100	if (!marked->slaying)
4101	{
4102	pl->failmsg (format ("You can't use the %s with your %s!", query_name (transformer), query_name (marked)));
4103	return;
4104	}
4105
4106	/* check whether they are compatible or not */
4107	find = strstr (&marked->slaying, transformer->arch->archname);
4108	if (!find || (*(find + strlen (transformer->arch->archname)) != ':'))
4109	{
4110	pl->failmsg (format ("You can't use the %s with your %s!", query_name (transformer), query_name (marked)));
4111	return;
4112	}
4113
4114	find += strlen (transformer->arch->archname) + 1;
4115	/* Item can be used, now find how many and what it yields */
4116	if (isdigit (*(find)))
4117	{
4118	yield = atoi (find);
4119	if (yield < 1)
4120	{
4121	LOG (llevDebug, "apply_item_transformer: item %s has slaying-yield %d.", query_base_name (marked, 0), yield);
4122	yield = 1;
4123	}
4124	}
4125	else
4126	yield = 1;
4127
4128	while (isdigit (*find))
4129	find++;
4130
4131	while (*find == ' ')
4132	find++;
4133
4134	memset (got, 0, MAX_BUF);
4135
4136	if ((separator = strchr (find, ';')) != NULL)
4137	len = separator - find;
4138	else
4139	len = strlen (find);
4140
4141	if (len > MAX_BUF - 1)
4142	len = MAX_BUF - 1;
4143
4144	strcpy (got, find);
4145	got[len] = '\0';
4146
4147	/* Now create new item, remove used ones when required. */
4148	new_item = get_archetype (got);
4149	if (!new_item)
4150	{
4151	pl->failmsg (format ("This %s is strange, better to not use it.", query_base_name (marked, 0)));
4152	return;
4153	}
4154
4155	new_item->nrof = yield;
4156
4157	pl->statusmsg (format ("You %s the %s.", &transformer->slaying, query_base_name (marked, 0)));
4158
4159	pl->insert (new_item);
4160	/* Eat up one item */
4161	marked->decrease ();
4162
4163	/* Eat one transformer if needed */
4164	if (transformer->stats.food)
4165	if (--transformer->stats.food == 0)
4166	transformer->decrease ();
4167	}
4168

Diff Legend

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