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.184 by elmex, Mon Jan 12 00:17:23 2009 UTC vs.
Revision 1.229 by root, Fri Mar 26 20:17:48 2010 UTC

1	/*	1	/*
2	* This file is part of Deliantra, the Roguelike Realtime MMORPG.	2	* This file is part of Deliantra, the Roguelike Realtime MMORPG.
3	*	3	*
4	* Copyright (©) 2005,2006,2007,2008 Marc Alexander Lehmann / Robin Redeker / the Deliantra team	4	* Copyright (©) 2005,2006,2007,2008,2009,2010 Marc Alexander Lehmann / Robin Redeker / the Deliantra team
5	* Copyright (©) 2001,2007 Mark Wedel & Crossfire Development Team	5	* Copyright (©) 2001 Mark Wedel & Crossfire Development Team
6	* Copyright (©) 1992,2007 Frank Tore Johansen	6	* Copyright (©) 1992 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)
…		…
171	*/	172	*/
172	int	173	int
173	apply_potion (object *op, object *tmp)	174	apply_potion (object *op, object *tmp)
174	{	175	{
175	int got_one = 0, i;	176	int got_one = 0, i;
176	object *force = 0, *floor = 0;	177	object *force = 0;
177		178
178	floor = GET_MAP_OB (op->map, op->x, op->y);	179	object *floor = GET_MAP_OB (op->map, op->x, op->y);
179		180
180	if (get_map_flags (op->map, NULL, op->x, op->y, NULL, NULL) & P_SAFE)	181	if (get_map_flags (op->map, NULL, op->x, op->y, NULL, NULL) & P_SAFE)
181	{	182	{
182	op->failmsg ("Gods prevent you from using this here, it's sacred ground!");	183	op->failmsg ("Gods prevent you from using this here, it's sacred ground!");
183		184
…		…
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)
…		…
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))
…		…
401	}	395	}
402		396
403	/****************************************************************************	397	/****************************************************************************
404	* Weapon improvement code follows	398	* Weapon improvement code follows
405	****************************************************************************/	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	}
406		415
407	/**	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
…		…
457	}	466	}
458		467
459	prev = op;	468	prev = op;
460	op = op->below;	469	op = op->below;
461	}	470	}
462	}
463
464	/**
465	* This checks to see of the player (who) is sufficient level to use a weapon
466	* with improvs improvements (typically last_eat). We take an int here
467	* instead of the object so that the improvement code can pass along the
468	* increased value to see if the object is usuable.
469	* we return 1 (true) if the player can use the weapon.
470	*/
471	static int
472	check_weapon_power (const object *who, int improvs)
473	{
474	/* Old code is below (commented out). Basically, since weapons are the only
475	* object players really have any control to improve, it's a bit harsh to
476	* require high level in some combat skill, so we just use overall level.
477	*/
478	#if 1
479	if (((who->level / 5) + 5) >= improvs)
480	return 1;
481	else
482	return 0;
483
484	#else
485	int level = 0;
486
487	/* The skill system hands out wc and dam bonuses to fighters
488	* more generously than the old system (see fix_player). Thus
489	* we need to curtail the power of player enchanted weapons.
490	* I changed this to 1 improvement per "fighter" level/5 -b.t.
491	* Note: Nothing should break by allowing this ratio to be different or
492	* using normal level - it is just a matter of play balance.
493	*/
494	if (who->type == PLAYER)
495	{
496	object *wc_obj = NULL;
497
498	for (wc_obj = who->inv; wc_obj; wc_obj = wc_obj->below)
499	if (wc_obj->type == SKILL && IS_COMBAT_SKILL (wc_obj->subtype) && wc_obj->level > level)
500	level = wc_obj->level;
501
502	if (!level)
503	{
504	LOG (llevError, "Error: Player: %s lacks wc experience object\n", who->name);
505	level = who->level;
506	}
507	}
508	else
509	level = who->level;
510
511	return (improvs <= ((level / 5) + 5));
512	#endif
513	}	471	}
514		472
515	/**	473	/**
516	* 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.
517	* 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.
…		…
573		531
574	/**	532	/**
575	* This does the prepare weapon scroll.	533	* This does the prepare weapon scroll.
576	* Checks for sacrifice, and so on.	534	* Checks for sacrifice, and so on.
577	*/	535	*/
578	int	536	static int
579	prepare_weapon (object *op, object *improver, object *weapon)	537	prepare_weapon (object *op, object *improver, object *weapon)
580	{	538	{
581	int sacrifice_count, i;	539	int sacrifice_count, i;
582	char buf[MAX_BUF];	540	char buf[MAX_BUF];
583		541
…		…
636	*	594	*
637	* 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
638	* 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 ??
639	* level == max improve last_eat == current improve	597	* level == max improve last_eat == current improve
640	*/	598	*/
641	int	599	static int
642	improve_weapon (object *op, object *improver, object *weapon)	600	improve_weapon (object *op, object *improver, object *weapon)
643	{	601	{
644	int sacrifice_count, sacrifice_needed = 0;	602	int sacrifice_count, sacrifice_needed = 0;
645		603
646	if (improver->stats.sp == IMPROVE_PREPARE)	604	if (improver->stats.sp == IMPROVE_PREPARE)
647	return prepare_weapon (op, improver, weapon);	605	return prepare_weapon (op, improver, weapon);
648		606
649	if (weapon->level == 0)	607	if (weapon->level == 0)
650	{	608	{
651	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.>");
652	return 0;	612	return 0;
653	}	613	}
654		614
655	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
656	{	617	{
657	op->failmsg ("This weapon cannot be improved any more.");	618	op->failmsg ("This weapon cannot be improved any more.");
658	return 0;	619	return 0;
659	}	620	}
660		621
661	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))
662	{	624	{
663	op->failmsg ("Improving the weapon will make it too "	625	op->failmsg ("Improving the weapon will make it too "
664	"powerful for you to use. Unready it if you "	626	"powerful for you to use. Unready it if you "
665	"really want to improve it.");	627	"really want to improve it.");
666	return 0;	628	return 0;
…		…
744	/**	706	/**
745	* Handles the applying of improve/prepare/enchant weapon scroll.	707	* Handles the applying of improve/prepare/enchant weapon scroll.
746	* 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, ...),
747	* then calls improve_weapon to do the dirty work.	709	* then calls improve_weapon to do the dirty work.
748	*/	710	*/
749	int	711	static int
750	check_improve_weapon (object *op, object *tmp)	712	check_improve_weapon (object *op, object *tmp)
751	{	713	{
752	object *otmp;	714	object *otmp;
753		715
754	if (op->type != PLAYER)	716	if (op->type != PLAYER)
…		…
801	* the armour value of the piece of equipment exceed either	763	* the armour value of the piece of equipment exceed either
802	* the users level or 90)	764	* the users level or 90)
803	* Modified by MSW for partial resistance. Only support	765	* Modified by MSW for partial resistance. Only support
804	* changing of physical area right now.	766	* changing of physical area right now.
805	*/	767	*/
806	int	768	static int
807	improve_armour (object *op, object *improver, object *armour)	769	improve_armour (object *op, object *improver, object *armour)
808	{	770	{
809	object *tmp;	771	object *tmp;
810		772
811	if (armour->magic >= settings.armor_max_enchant)	773	if (armour->magic >= settings.armor_max_enchant)
…		…
895	* Takes one type of items and makes another.	857	* Takes one type of items and makes another.
896	* converter is the object that is doing the conversion.	858	* converter is the object that is doing the conversion.
897	* 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
898	* what the converter wants, this will not do anything.	860	* what the converter wants, this will not do anything.
899	*/	861	*/
900	static int	862	int
901	convert_item (object *item, object *converter)	863	convert_item (object *item, object *converter)
902	{	864	{
903	sint64 nr, price_in;	865	sint64 nr = 0, price_in;
904		866
905	if (item->flag [FLAG_UNPAID])	867	if (item->flag [FLAG_UNPAID])
906	return 0;	868	return 0;
907		869
908	shstr conv_from = converter->slaying;	870	shstr conv_from = converter->slaying;
909	archetype *conv_to = converter->other_arch;	871	archetype *conv_to = converter->other_arch;
910	sint64 need = converter->stats.food;	872	sint64 need = converter->stats.food;
911	sint64 give = converter->stats.sp;	873	sint64 give = converter->stats.sp;
912		874
…		…
1022	* Handle apply on containers.	984	* Handle apply on containers.
1023	* By Eneq(@csd.uu.se).	985	* By Eneq(@csd.uu.se).
1024	* 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]
1025	* added the alchemical cauldron to the code -b.t.	987	* added the alchemical cauldron to the code -b.t.
1026	*/	988	*/
1027	int	989	static int
1028	apply_container (object *op, object *sack)	990	apply_container (object *op, object *sack)
1029	{	991	{
1030	if (op->type != PLAYER || !op->contr->ns)	992	if (op->type != PLAYER || !op->contr->ns)
1031	return 0; /* This might change */	993	return 0; /* This might change */
1032		994
…		…
1045	}	1007	}
1046		1008
1047	// 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
1048	if (sack->flag [FLAG_APPLIED])	1010	if (sack->flag [FLAG_APPLIED])
1049	{	1011	{
1050	if (op->container == sack)	1012	if (op->container_ () == sack)
1051	{	1013	{
1052	// open on ground or inv, so close	1014	// open on ground or inv, so close
1053	op->close_container ();	1015	op->close_container ();
1054	return 1;	1016	return 1;
1055	}	1017	}
…		…
1098	{	1060	{
1099	/* Only players can make sacrifices on spell casting altars. */	1061	/* Only players can make sacrifices on spell casting altars. */
1100	if (altar->inv && (!originator || originator->type != PLAYER))	1062	if (altar->inv && (!originator || originator->type != PLAYER))
1101	return 0;	1063	return 0;
1102		1064
1103	if (operate_altar (altar, &sacrifice))	1065	if (operate_altar (altar, &sacrifice, originator))
1104	{	1066	{
1105	/* Simple check. Unfortunately, it means you can't cast magic bullet	1067	/* Simple check. Unfortunately, it means you can't cast magic bullet
1106	* with an altar. We call it a Potion - altars are stationary - it	1068	* with an altar. We call it a Potion - altars are stationary - it
1107	* is up to map designers to use them properly.	1069	* is up to map designers to use them properly.
1108	*/	1070	*/
…		…
1144		1106
1145	SET_FLAG (op, FLAG_NO_APPLY); /* prevent loops */	1107	SET_FLAG (op, FLAG_NO_APPLY); /* prevent loops */
1146		1108
1147	bool has_unpaid = false;	1109	bool has_unpaid = false;
1148		1110
1149	// quite inefficient to do this here twice, but the api doesn'T lend itself to	1111	// quite inefficient to do this here twice, but the api doesn't lend itself to
1150	// a quick and small change :(	1112	// a quick and small change :(
1151	for (object::depth_iterator item = op->begin (); item != op->end (); ++item)	1113	for (object::depth_iterator item = op->begin (); item != op->end (); ++item)
1152	if (item->flag [FLAG_UNPAID])	1114	if (item->flag [FLAG_UNPAID])
1153	{	1115	{
1154	has_unpaid = true;	1116	has_unpaid = true;
…		…
1362	return;	1324	return;
1363		1325
1364	/* move_apply() is the most likely candidate for causing unwanted and	1326	/* move_apply() is the most likely candidate for causing unwanted and
1365	* possibly unlimited recursion.	1327	* possibly unlimited recursion.
1366	*/	1328	*/
1367	/* The following was changed because it was causing perfeclty correct	1329	/* The following was changed because it was causing perfectly correct
1368	* maps to fail. 1) it's not an error to recurse:	1330	* maps to fail. 1) it's not an error to recurse:
1369	* rune detonates, summoning monster. monster lands on nearby rune.	1331	* rune detonates, summoning monster. monster lands on nearby rune.
1370	* nearby rune detonates. This sort of recursion is expected and	1332	* nearby rune detonates. This sort of recursion is expected and
1371	* proper. This code was causing needless crashes.	1333	* proper. This code was causing needless crashes.
1372	*/	1334	*/
…		…
1379		1341
1380	recursion_depth++;	1342	recursion_depth++;
1381	if (trap->head)	1343	if (trap->head)
1382	trap = trap->head;	1344	trap = trap->head;
1383		1345
1384	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)))
1385	goto leave;
1386
1387	switch (trap->type)	1347	switch (trap->type)
1388	{	1348	{
1389	case PLAYERMOVER:	1349	case PLAYERMOVER:
1390	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 = -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:
1391	{	1419	{
		1420	int max, sound_was_played;
		1421	object *ab, *ab_next;
		1422
1392	if (!trap->stats.maxsp)	1423	if (!trap->value)
1393	trap->stats.maxsp = 2;	1424	{
		1425	int tot;
1394		1426
1395	/* Is this correct? From the docs, it doesn't look like it	1427	for (ab = trap->above, tot = 0; ab; ab = ab->above)
1396	* 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
1397	*/	1442	*/
1398	victim->speed_left = -FABS (trap->stats.maxsp * victim->speed / trap->speed);	1443	ab_next = ab->above;
1399		1444
1400	/* 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)
1401	* above with some objects have zero speed, and thus the player	1446	{
1402	* 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	}
1403	*/	1456	}
1404	if (victim->speed_left < -50.f)	1457	break;
1405	victim->speed_left = -50.f;
1406	/* LOG(llevDebug, "apply, playermove, player speed_left=%f\n", victim->speed_left); */
1407	}	1458	}
1408	goto leave;
1409		1459
1410	case SPINNER:	1460	case CONVERTER:
1411	if (victim->direction)	1461	if (convert_item (victim, trap) < 0)
1412	{
1413	victim->direction = absdir (victim->direction - trap->stats.sp);
1414	update_turn_face (victim);
1415	}
1416	goto leave;
1417
1418	case DIRECTOR:
1419	if (victim->direction && !should_director_abort (trap, victim))
1420	{
1421	victim->direction = trap->stats.sp;
1422	update_turn_face (victim);
1423	}
1424	goto leave;
1425
1426	case BUTTON:
1427	case PEDESTAL:
1428	update_button (trap, originator);
1429	goto leave;
1430
1431	case ALTAR:
1432	/* sacrifice victim on trap */
1433	apply_altar (trap, victim, originator);
1434	goto leave;
1435
1436	case THROWN_OBJ:
1437	if (trap->inv == NULL)
1438	goto leave;
1439	/* fallthrough */
1440
1441	case ARROW:
1442	/* bad bug: monster throw a object, make a step forwards, step on object ,
1443	* trigger this here and get hit by own missile - and will be own enemy.
1444	* Victim then is his own enemy and will start to kill herself (this is
1445	* removed) but we have not synced victim and his missile. To avoid senseless
1446	* action, we avoid hits here
1447	*/
1448	if ((QUERY_FLAG (victim, FLAG_ALIVE) && trap->speed) && trap->owner != victim)
1449	hit_with_arrow (trap, victim);
1450	goto leave;
1451
1452	case SPELL_EFFECT:
1453	apply_spell_effect (trap, victim);
1454	goto leave;
1455
1456	case TRAPDOOR:
1457	{
1458	int max, sound_was_played;
1459	object *ab, *ab_next;
1460
1461	if (!trap->value)
1462	{	1462	{
1463	int tot;	1463	originator->failmsg (format ("The %s seems to be broken!", query_name (trap)));
1464		1464	archetype::get (shstr_burnout)->insert_at (trap, trap);
1465	for (ab = trap->above, tot = 0; ab; ab = ab->above)
1466	if ((ab->move_type && trap->move_on) || ab->move_type == 0)
1467	tot += ab->head_ ()->total_weight ();
1468
1469	if (!(trap->value = (tot > trap->weight) ? 1 : 0))
1470	goto leave;
1471
1472	SET_ANIMATION (trap, trap->value);
1473	update_object (trap, UP_OBJ_FACE);
1474	}	1465	}
1475		1466
1476	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))
1477	{	1489	{
1478	/* need to set this up, since if we do transfer the object,	1490	/* Basically, don't show exits leading to random maps the
1479	* ab->above would be bogus	1491	* players output.
1480	*/	1492	*/
1481	ab_next = ab->above;	1493	if (trap->msg && EXIT_PATH (trap) != shstr_random_map_exit)
		1494	victim->statusmsg (trap->msg, NDI_NAVY);
1482		1495
1483	if ((ab->move_type && trap->move_on) || ab->move_type == 0)	1496	trap->play_sound (trap->sound);
1484	{	1497	victim->enter_exit (trap);
1485	if (!sound_was_played)
1486	{
1487	trap->play_sound (trap->sound ? trap->sound : sound_find ("fall_hole"));
1488	sound_was_played = 1;
1489	}
1490
1491	ab->statusmsg ("You fall into a trapdoor!", NDI_RED);
1492	transfer_ob (ab, EXIT_X (trap), EXIT_Y (trap), 0, ab);
1493	}
1494	}	1498	}
1495	goto leave;	1499	break;
1496	}
1497		1500
1498	case CONVERTER:
1499	if (convert_item (victim, trap) < 0)
1500	{
1501	originator->failmsg (format ("The %s seems to be broken!", query_name (trap)));
1502	archetype::get (shstr_burnout)->insert_at (trap, trap);
1503	}
1504
1505	goto leave;
1506
1507	case TRIGGER_BUTTON:
1508	case TRIGGER_PEDESTAL:
1509	case TRIGGER_ALTAR:
1510	check_trigger (trap, victim);
1511	goto leave;
1512
1513	case DEEP_SWAMP:
1514	walk_on_deep_swamp (trap, victim);
1515	goto leave;
1516
1517	case CHECK_INV:
1518	check_inv (victim, trap);
1519	goto leave;
1520
1521	case HOLE:
1522	move_apply_hole (trap, victim);
1523	goto leave;
1524
1525	case EXIT:
1526	if (victim->type == PLAYER && EXIT_PATH (trap))
1527	{
1528	/* Basically, don't show exits leading to random maps the
1529	* players output.
1530	*/
1531	if (trap->msg && !EXIT_PATH (trap).starts_with ("/!"))
1532	victim->statusmsg (trap->msg, NDI_NAVY);
1533
1534	trap->play_sound (trap->sound);
1535	victim->enter_exit (trap);
1536	}
1537	goto leave;
1538
1539	case ENCOUNTER:	1501	case ENCOUNTER:
1540	/* may be some leftovers on this */	1502	/* may be some leftovers on this */
1541	goto leave;	1503	break;
1542		1504
1543	case SHOP_MAT:	1505	case SHOP_MAT:
1544	apply_shop_mat (trap, victim);	1506	apply_shop_mat (trap, victim);
1545	goto leave;	1507	break;
1546		1508
1547	/* Drop a certain amount of gold, and have one item identified */	1509	/* Drop a certain amount of gold, and have one item identified */
1548	case IDENTIFY_ALTAR:	1510	case IDENTIFY_ALTAR:
1549	apply_id_altar (victim, trap, originator);	1511	apply_id_altar (victim, trap, originator);
1550	goto leave;	1512	break;
1551		1513
1552	case SIGN:	1514	case SIGN:
1553	if (victim->type != PLAYER && trap->stats.food > 0)	1515	if (victim->type != PLAYER && trap->stats.food > 0)
1554	goto leave; /* monsters musn't apply magic_mouths with counters */	1516	break; /* monsters musn't apply magic_mouths with counters */
1555		1517
1556	apply_sign (victim, trap, 1);	1518	apply_sign (victim, trap, 1);
1557	goto leave;	1519	break;
1558		1520
1559	case CONTAINER:	1521	case CONTAINER:
1560	apply_container (victim, trap);	1522	apply_container (victim, trap);
1561	goto leave;	1523	break;
1562		1524
1563	case RUNE:	1525	case RUNE:
1564	case TRAP:	1526	case TRAP:
1565	if (trap->level && QUERY_FLAG (victim, FLAG_ALIVE))	1527	if (trap->level && QUERY_FLAG (victim, FLAG_ALIVE))
1566	spring_trap (trap, victim);	1528	spring_trap (trap, victim);
1567	goto leave;	1529	break;
1568		1530
1569	default:	1531	default:
1570	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 "
1571	"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);
1572	goto leave;	1534	break;
1573	}	1535	}
1574		1536
1575	leave:
1576	recursion_depth--;	1537	recursion_depth--;
1577	}	1538	}
1578		1539
1579	/**	1540	/**
1580	* Handles reading a regular (ie not containing a spell) book.	1541	* Handles reading a regular (ie not containing a spell) book.
…		…
1591	return;	1552	return;
1592	}	1553	}
1593		1554
1594	if (!tmp->msg)	1555	if (!tmp->msg)
1595	{	1556	{
1596	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));
1597	return;	1558	return;
1598	}	1559	}
1599		1560
1600	/* need a literacy skill to read stuff! */	1561	/* need a literacy skill to read stuff! */
1601	skill_ob = find_skill_by_name (op, tmp->skill);	1562	skill_ob = find_skill_by_name (op, tmp->skill);
…		…
1615	: lev_diff < 15 ? "This book is way beyond your comprehension."	1576	: lev_diff < 15 ? "This book is way beyond your comprehension."
1616	: "This book is totally beyond your comprehension.");	1577	: "This book is totally beyond your comprehension.");
1617	return;	1578	return;
1618	}	1579	}
1619		1580
		1581	// we currently don't use the message types for anything.
1620	readable_message_type *msgType = get_readable_message_type (tmp);	1582	// readable_message_type *msgType = get_readable_message_type (tmp);
		1583
		1584	tmp->play_sound (tmp->sound ? tmp->sound : sound_find ("apply_book"));
1621		1585
1622	if (player *pl = op->contr)	1586	if (player *pl = op->contr)
1623	if (client *ns = pl->ns)	1587	if (client *ns = pl->ns)
1624	pl->infobox (MSG_CHANNEL ("book"), format ("T<%s>\n\n%s", (char *)long_desc (tmp, op), &tmp->msg));	1588	pl->infobox (MSG_CHANNEL ("book"), format ("T<%s>\n\n%s", (char *)long_desc (tmp, op), &tmp->msg));
1625		1589
…		…
1637	esrv_update_item (UPD_FLAGS | UPD_NAME, pl, tmp);	1601	esrv_update_item (UPD_FLAGS | UPD_NAME, pl, tmp);
1638	}	1602	}
1639		1603
1640	change_exp (op, exp_gain, skill_ob->skill, 0);	1604	change_exp (op, exp_gain, skill_ob->skill, 0);
1641	SET_FLAG (tmp, FLAG_NO_SKILL_IDENT); /* so no more xp gained from this book */	1605	SET_FLAG (tmp, FLAG_NO_SKILL_IDENT); /* so no more xp gained from this book */
		1606	}
		1607	}
		1608
		1609	/**
		1610	* op made some mistake with a scroll, this takes care of punishment.
		1611	* scroll_failure()- hacked directly from spell_failure
		1612	*/
		1613	static void
		1614	scroll_failure (object *op, int failure, int power)
		1615	{
		1616	if (abs (failure / 4) > power)
		1617	power = abs (failure / 4); /* set minimum effect */
		1618
		1619	if (failure <= -1 && failure > -15)
		1620	{ /* wonder */
		1621	object *tmp;
		1622
		1623	op->failmsg ("Your spell warps!");
		1624	tmp = get_archetype (SPELL_WONDER);
		1625	cast_wonder (op, op, 0, tmp);
		1626	tmp->destroy ();
		1627	}
		1628	else if (failure <= -15 && failure > -35)
		1629	{ /* drain mana */
		1630	op->failmsg ("Your mana is drained!");
		1631	op->stats.sp -= random_roll (0, power - 1, op, PREFER_LOW);
		1632	if (op->stats.sp < 0)
		1633	op->stats.sp = 0;
		1634	}
		1635	else if (settings.spell_failure_effects == TRUE)
		1636	{
		1637	if (failure <= -35 && failure > -60)
		1638	{ /* confusion */
		1639	op->failmsg ("The magic recoils on you!");
		1640	confuse_player (op, op, power);
		1641	}
		1642	else if (failure <= -60 && failure > -70)
		1643	{ /* paralysis */
		1644	op->failmsg ("The magic recoils and paralyzes you!");
		1645	paralyze_player (op, op, power);
		1646	}
		1647	else if (failure <= -70 && failure > -80)
		1648	{ /* blind */
		1649	op->failmsg ("The magic recoils on you!");
		1650	blind_player (op, op, power);
		1651	}
		1652	else if (failure <= -80)
		1653	{ /* blast the immediate area */
		1654	object *tmp = get_archetype (LOOSE_MANA);
		1655	cast_magic_storm (op, tmp, power);
		1656	op->failmsg ("You unleash uncontrolled mana!");
		1657	tmp->destroy ();
		1658	}
1642	}	1659	}
1643	}	1660	}
1644		1661
1645	/**	1662	/**
1646	* Handles the applying of a skill scroll, calling learn_skill straight.	1663	* Handles the applying of a skill scroll, calling learn_skill straight.
…		…
1752	* instead of having their spell stored in stats.sp. These are	1769	* instead of having their spell stored in stats.sp. These are
1753	* legacy spellbooks	1770	* legacy spellbooks
1754	*/	1771	*/
1755	if (tmp->slaying)	1772	if (tmp->slaying)
1756	{	1773	{
1757	spell = arch_to_object (find_archetype_by_object_name (tmp->slaying));	1774	spell = find_archetype_by_object_name (tmp->slaying)->instance ();
		1775
1758	if (!spell)	1776	if (!spell)
1759	{	1777	{
1760	op->failmsg (format ("The book's formula for %s is incomplete.", &tmp->slaying));	1778	op->failmsg (format ("The book's formula for %s is incomplete.", &tmp->slaying));
1761	return;	1779	return;
1762	}	1780	}
…		…
1783	LOG (llevError, "apply_spellbook: Book %s has no spell in it!\n", &tmp->name);	1801	LOG (llevError, "apply_spellbook: Book %s has no spell in it!\n", &tmp->name);
1784	op->failmsg ("The spellbook symbols make no sense. This is a bug, please report!");	1802	op->failmsg ("The spellbook symbols make no sense. This is a bug, please report!");
1785	return;	1803	return;
1786	}	1804	}
1787		1805
1788	if (skop->level < int (sqrtf (spell->level) * 1.5f))	1806	int learn_level = sqrtf (spell->level) * 1.5f;
		1807	if (skop->level < learn_level)
1789	{	1808	{
1790	op->failmsg (format ("You are unable to decipher the strange symbols. H<Your %s level is too low.>", &tmp->skill));	1809	op->failmsg (format ("You are unable to decipher the strange symbols. H<Your %s level is too low, it must be at least %d.>",
		1810	&tmp->skill, learn_level));
1791	return;	1811	return;
1792	}	1812	}
1793		1813
1794	op->statusmsg (format ("The spellbook contains the %s level spell %s.", get_levelnumber (spell->level), &spell->name));	1814	op->statusmsg (format ("The spellbook contains the %s level spell %s.", get_levelnumber (spell->level), &spell->name));
1795		1815
…		…
1837	* literacy rate very useful! -b.t.	1857	* literacy rate very useful! -b.t.
1838	*/	1858	*/
1839	if (QUERY_FLAG (op, FLAG_CONFUSED))	1859	if (QUERY_FLAG (op, FLAG_CONFUSED))
1840	{	1860	{
1841	op->failmsg ("In your confused state you flub the wording of the text!");	1861	op->failmsg ("In your confused state you flub the wording of the text!");
1842	scroll_failure (op, 0 - random_roll (0, spell->level, op, PREFER_LOW), MAX (spell->stats.sp, spell->stats.grace));	1862	scroll_failure (op, 0 - random_roll (0, spell->level, op, PREFER_LOW), max (spell->stats.sp, spell->stats.grace));
1843	}	1863	}
1844	else if (QUERY_FLAG (tmp, FLAG_STARTEQUIP) ||	1864	else if (QUERY_FLAG (tmp, FLAG_STARTEQUIP) ||
1845	(random_roll (0, 100, op, PREFER_LOW) - (5 * skop->level)) < learn_spell[spell->stats.grace ? op->stats.Wis : op->stats.Int])	1865	(random_roll (0, 100, op, PREFER_LOW) - (5 * skop->level)) < learn_spell[spell->stats.grace ? op->stats.Wis : op->stats.Int])
1846	{	1866	{
1847	op->statusmsg ("You succeed in learning the spell!", NDI_GREEN);	1867	op->statusmsg ("You succeed in learning the spell!", NDI_GREEN);
…		…
1953	break;	1973	break;
1954	}	1974	}
1955		1975
1956	if (!tmp->destroyed () && !tmp->inv)	1976	if (!tmp->destroyed () && !tmp->inv)
1957	tmp->decrease (true);	1977	tmp->decrease (true);
1958	}
1959
1960	/**
1961	* op eats food.
1962	* If player, takes care of messages and dragon special food.
1963	*/
1964	static void
1965	apply_food (object *op, object *tmp)
1966	{
1967	int capacity_remaining;
1968
1969	if (op->type != PLAYER)
1970	op->stats.hp = op->stats.maxhp;
1971	else
1972	{
1973	/* check if this is a dragon (player), eating some flesh */
1974	if (tmp->type == FLESH && is_dragon_pl (op) && dragon_eat_flesh (op, tmp))
1975	;
1976	else
1977	{
1978	/* usual case - no dragon meal: */
1979	if (op->stats.food + tmp->stats.food > 999)
1980	{
1981	if (tmp->type == FOOD || tmp->type == FLESH)
1982	op->failmsg ("You feel full, but what a waste of food!");
1983	else
1984	op->statusmsg ("Most of the drink goes down your face not your throat!");
1985	}
1986
1987	tmp->play_sound (
1988	tmp->sound
1989	? tmp->sound
1990	: tmp->type == DRINK
1991	? sound_find ("eat_drink")
1992	: sound_find ("eat_food")
1993	);
1994
1995	if (!QUERY_FLAG (tmp, FLAG_CURSED))
1996	{
1997	const char *buf;
1998
1999	if (!is_dragon_pl (op))
2000	{
2001	/* eating message for normal players */
2002	if (tmp->type == DRINK)
2003	buf = format ("Ahhh...that %s tasted good.", &tmp->name);
2004	else
2005	buf = format ("The %s tasted %s", &tmp->name, tmp->type == FLESH ? "terrible!" : "good.");
2006	}
2007	else
2008	/* eating message for dragon players */
2009	buf = format ("The %s tasted terrible!", &tmp->name);
2010
2011	op->statusmsg (buf);
2012
2013	capacity_remaining = 999 - op->stats.food;
2014	op->stats.food += tmp->stats.food;
2015	if (capacity_remaining < tmp->stats.food)
2016	op->stats.hp += capacity_remaining / 50;
2017	else
2018	op->stats.hp += tmp->stats.food / 50;
2019
2020	if (op->stats.hp > op->stats.maxhp)
2021	op->stats.hp = op->stats.maxhp;
2022	if (op->stats.food > 999)
2023	op->stats.food = 999;
2024	}
2025
2026	/* special food hack -b.t. */
2027	if (tmp->title || QUERY_FLAG (tmp, FLAG_CURSED))
2028	eat_special_food (op, tmp);
2029	}
2030	}
2031
2032	handle_apply_yield (tmp);
2033	tmp->decrease ();
2034	}	1978	}
2035		1979
2036	/**	1980	/**
2037	* A dragon is eating some flesh. If the flesh contains resistances,	1981	* A dragon is eating some flesh. If the flesh contains resistances,
2038	* there is a chance for the dragon's skin to get improved.	1982	* there is a chance for the dragon's skin to get improved.
…		…
2041	* object *op the object (dragon player) eating the flesh	1985	* object *op the object (dragon player) eating the flesh
2042	* object *meal the flesh item, getting chewed in dragon's mouth	1986	* object *meal the flesh item, getting chewed in dragon's mouth
2043	* return:	1987	* return:
2044	* int 1 if eating successful, 0 if it doesn't work	1988	* int 1 if eating successful, 0 if it doesn't work
2045	*/	1989	*/
2046	int	1990	static int
2047	dragon_eat_flesh (object *op, object *meal)	1991	dragon_eat_flesh (object *op, object *meal)
2048	{	1992	{
2049	object *skin = NULL; /* pointer to dragon skin force */	1993	object *skin = NULL; /* pointer to dragon skin force */
2050	object *abil = NULL; /* pointer to dragon ability force */	1994	object *abil = NULL; /* pointer to dragon ability force */
2051	object *tmp = NULL; /* tmp. object */	1995	object *tmp = NULL; /* tmp. object */
…		…
2057	int atnr_winner[NROFATTACKS]; /* winning candidates for resistance improvement */	2001	int atnr_winner[NROFATTACKS]; /* winning candidates for resistance improvement */
2058	int winners = 0; /* number of winners */	2002	int winners = 0; /* number of winners */
2059	int i; /* index */	2003	int i; /* index */
2060		2004
2061	/* let's make sure and doublecheck the parameters */	2005	/* let's make sure and doublecheck the parameters */
2062	if (meal->type != FLESH || !is_dragon_pl (op))	2006	if (meal->type != FLESH || !op->is_dragon ())
2063	return 0;	2007	return 0;
2064		2008
2065	/* now grab the 'dragon_skin'- and 'dragon_ability'-forces	2009	/* now grab the 'dragon_skin'- and 'dragon_ability'-forces
2066	from the player's inventory */	2010	from the player's inventory */
2067	for (tmp = op->inv; tmp; tmp = tmp->below)	2011	for (tmp = op->inv; tmp; tmp = tmp->below)
…		…
2083	op->stats.hp += meal->stats.food / 50;	2027	op->stats.hp += meal->stats.food / 50;
2084		2028
2085	if (op->stats.hp > op->stats.maxhp)	2029	if (op->stats.hp > op->stats.maxhp)
2086	op->stats.hp = op->stats.maxhp;	2030	op->stats.hp = op->stats.maxhp;
2087		2031
2088	op->stats.food = MIN (999, op->stats.food + meal->stats.food);	2032	op->stats.food = min (999, op->stats.food + meal->stats.food);
2089		2033
2090	/*LOG(llevDebug, "-> player: %d, flesh: %d\n", op->level, meal->level); */	2034	/*LOG(llevDebug, "-> player: %d, flesh: %d\n", op->level, meal->level); */
2091		2035
2092	/* on to the interesting part: chances for adding resistance */	2036	/* on to the interesting part: chances for adding resistance */
2093	for (i = 0; i < NROFATTACKS; i++)	2037	for (i = 0; i < NROFATTACKS; i++)
…		…
2103		2047
2104	/* monster bonus increases with level, because high-level	2048	/* monster bonus increases with level, because high-level
2105	flesh is too rare */	2049	flesh is too rare */
2106	mbonus = op->level * 20. / ((double) settings.max_level);	2050	mbonus = op->level * 20. / ((double) settings.max_level);
2107		2051
2108	chance = (((double) MIN (op->level + bonus, meal->level + bonus + mbonus)) * 100. /	2052	chance = (((double)min (op->level + bonus, meal->level + bonus + mbonus)) * 100. /
2109	((double) settings.max_level)) - skin->resist[i];	2053	((double)settings.max_level)) - skin->resist[i];
2110		2054
2111	if (chance >= 0.)	2055	if (chance >= 0.)
2112	chance += 1.;	2056	chance += 1.;
2113	else	2057	else
2114	chance = (chance < -12) ? 0. : 1. / pow (2., -chance);	2058	chance = (chance < -12) ? 0. : 1. / pow (2., -chance);
2115		2059
2116	/* chance is proportional to amount of resistance (max. 50) */	2060	/* chance is proportional to amount of resistance (max. 50) */
2117	chance *= ((double) (MIN (meal->resist[i], 50))) / 50.;	2061	chance *= ((double)(min (meal->resist[i], 50))) / 50.;
2118		2062
2119	/* doubled chance for resistance of ability-focus */	2063	/* doubled chance for resistance of ability-focus */
2120	if (i == abil->stats.exp)	2064	if (i == abil->stats.exp)
2121	chance = MIN (100., chance * 2.);	2065	chance = min (100., chance * 2.);
2122		2066
2123	/* now make the throw and save all winners (Don't insert luck bonus here!) */	2067	/* now make the throw and save all winners (Don't insert luck bonus here!) */
2124	if (rndm (10000) < (unsigned int) (chance * 100))	2068	if (rndm (10000) < (unsigned int)(chance * 100))
2125	{	2069	{
2126	atnr_winner[winners] = i;	2070	atnr_winner[winners] = i;
2127	winners++;	2071	winners++;
2128	}	2072	}
2129		2073
…		…
2192		2136
2193	return 1;	2137	return 1;
2194	}	2138	}
2195		2139
2196	/**	2140	/**
		2141	* op eats food.
		2142	* If player, takes care of messages and dragon special food.
		2143	*/
		2144	static void
		2145	apply_food (object *op, object *tmp)
		2146	{
		2147	int capacity_remaining;
		2148
		2149	if (op->type != PLAYER)
		2150	op->stats.hp = op->stats.maxhp;
		2151	else
		2152	{
		2153	/* check if this is a dragon (player), eating some flesh */
		2154	if (tmp->type == FLESH && op->is_dragon () && dragon_eat_flesh (op, tmp))
		2155	;
		2156	else
		2157	{
		2158	/* usual case - no dragon meal: */
		2159	if (op->stats.food + tmp->stats.food > 999)
		2160	{
		2161	if (tmp->type == FOOD || tmp->type == FLESH)
		2162	op->failmsg ("You feel full, but what a waste of food!");
		2163	else
		2164	op->statusmsg ("Most of the drink goes down your face not your throat!");
		2165	}
		2166
		2167	tmp->play_sound (
		2168	tmp->sound
		2169	? tmp->sound
		2170	: tmp->type == DRINK
		2171	? sound_find ("eat_drink")
		2172	: sound_find ("eat_food")
		2173	);
		2174
		2175	if (!QUERY_FLAG (tmp, FLAG_CURSED))
		2176	{
		2177	const char *buf;
		2178
		2179	if (!op->is_dragon ())
		2180	{
		2181	/* eating message for normal players */
		2182	if (tmp->type == DRINK)
		2183	buf = format ("Ahhh...that %s tasted good.", &tmp->name);
		2184	else
		2185	buf = format ("The %s tasted %s", &tmp->name, tmp->type == FLESH ? "terrible!" : "good.");
		2186	}
		2187	else
		2188	/* eating message for dragon players */
		2189	buf = format ("The %s tasted terrible!", &tmp->name);
		2190
		2191	op->statusmsg (buf);
		2192
		2193	capacity_remaining = 999 - op->stats.food;
		2194	op->stats.food += tmp->stats.food;
		2195	if (capacity_remaining < tmp->stats.food)
		2196	op->stats.hp += capacity_remaining / 50;
		2197	else
		2198	op->stats.hp += tmp->stats.food / 50;
		2199
		2200	if (op->stats.hp > op->stats.maxhp)
		2201	op->stats.hp = op->stats.maxhp;
		2202	if (op->stats.food > 999)
		2203	op->stats.food = 999;
		2204	}
		2205
		2206	/* special food hack -b.t. */
		2207	if (tmp->title || QUERY_FLAG (tmp, FLAG_CURSED))
		2208	eat_special_food (op, tmp);
		2209	}
		2210	}
		2211
		2212	handle_apply_yield (tmp);
		2213	tmp->decrease ();
		2214	}
		2215
		2216	/**
2197	* Handles applying an improve armor scroll.	2217	* Handles applying an improve armor scroll.
2198	* Does some sanity checks, then calls improve_armour.	2218	* Does some sanity checks, then calls improve_armour.
2199	*/	2219	*/
2200	static void	2220	static void
2201	apply_armour_improver (object *op, object *tmp)	2221	apply_armour_improver (object *op, object *tmp)
…		…
2249	hit_player (op, poison->stats.hp, tmp, AT_POISON, 1);	2269	hit_player (op, poison->stats.hp, tmp, AT_POISON, 1);
2250	}	2270	}
2251		2271
2252	op->stats.food -= op->stats.food / 4;	2272	op->stats.food -= op->stats.food / 4;
2253	poison->destroy ();	2273	poison->destroy ();
2254	}
2255
2256	/**
2257	* This function return true if the exit is not a 2 ways one or it is 2 ways, valid exit.
2258	* A valid 2 way exit means:
2259	* -You can come back (there is another exit at the other side)
2260	* -You are
2261	* ° the owner of the exit
2262	* ° or in the same party as the owner
2263	*
2264	* Note: a owner in a 2 way exit is saved as the owner's name
2265	* in the field exit->name cause the field exit->owner doesn't
2266	* survive in the swapping (in fact the whole exit doesn't survive).
2267	*/
2268	int
2269	is_legal_2ways_exit (object *op, object *exit)
2270	{
2271	if (exit->stats.exp != 1)
2272	return 1; /*This is not a 2 way, so it is legal */
2273
2274	#if 0 //TODO
2275	if (!has_been_loaded (EXIT_PATH (exit)) && exit->race)
2276	return 0; /* This is a reset town portal */
2277	#endif
2278
2279	LOG (llevError | logBacktrace, "sync map load due to %s\n", exit->debug_desc ());
2280
2281	maptile *exitmap = maptile::find_sync (EXIT_PATH (exit), exit->map);
2282
2283	if (exitmap)
2284	{
2285	exitmap->load_sync ();
2286
2287	object *tmp = exitmap->at (EXIT_X (exit), EXIT_Y (exit)).bot;
2288
2289	if (!tmp)
2290	return 0;
2291
2292	for (; tmp; tmp = tmp->above)
2293	{
2294	if (tmp->type != EXIT)
2295	continue; /*Not an exit */
2296
2297	if (!EXIT_PATH (tmp))
2298	continue; /*Not a valid exit */
2299
2300	if ((EXIT_X (tmp) != exit->x) || (EXIT_Y (tmp) != exit->y))
2301	continue; /*Not in the same place */
2302
2303	if (exit->map->path != EXIT_PATH (tmp))
2304	continue; /*Not in the same map */
2305
2306	/* From here we have found the exit is valid. However we do
2307	* here the check of the exit owner. It is important for the
2308	* town portals to prevent strangers from visiting your appartments
2309	*/
2310	if (!exit->race)
2311	return 1; /*No owner, free for all! */
2312
2313	object *exit_owner = 0;
2314
2315	for_all_players (pp)
2316	{
2317	if (!pp->ob)
2318	continue;
2319
2320	if (pp->ob->name != exit->race)
2321	continue;
2322
2323	exit_owner = pp->ob; /*We found a player which correspond to the player name */
2324	break;
2325	}
2326
2327	if (!exit_owner)
2328	return 0; /* No more owner */
2329
2330	if (exit_owner->contr == op->contr)
2331	return 1; /*It is your exit */
2332
2333	if (exit_owner && /*There is a owner */
2334	(op->contr) && /*A player tries to pass */
2335	((exit_owner->contr->party == NULL) || /*No pass if controller has no party */
2336	(exit_owner->contr->party != op->contr->party))) /* Or not the same as op */
2337	return 0;
2338
2339	return 1;
2340	}
2341	}
2342
2343	return 0;
2344	}	2274	}
2345		2275
2346	/**	2276	/**
2347	* This function will try to apply a lighter and in case no lighter	2277	* This function will try to apply a lighter and in case no lighter
2348	* is specified it will try to find a lighter in the players inventory,	2278	* is specified it will try to find a lighter in the players inventory,
2349	* and inform him about this requirement.	2279	* and inform him about this requirement.
2350	*	2280	*
2351	* who - the player	2281	* who - the player
2352	* op - the item we want to light	2282	* op - the item we want to light
2353	* ligher - the lighter or 0 if a lighter has yet to be found	2283	* lighter - the lighter or 0 if a lighter has yet to be found
2354	*/	2284	*/
		2285	static object *
2355	object *auto_apply_lighter (object *who, object *op, object *lighter)	2286	auto_apply_lighter (object *who, object *op, object *lighter)
2356	{	2287	{
2357	if (lighter == 0)	2288	if (lighter == 0)
2358	{	2289	{
2359	for (object *tmp = who->inv; tmp; tmp = tmp->below)	2290	for (object *tmp = who->inv; tmp; tmp = tmp->below)
2360	{	2291	{
…		…
2398	/**	2329	/**
2399	* Designed primarily to light torches/lanterns/etc.	2330	* Designed primarily to light torches/lanterns/etc.
2400	* Also burns up burnable material too. First object in the inventory is	2331	* Also burns up burnable material too. First object in the inventory is
2401	* the selected object to "burn". -b.t.	2332	* the selected object to "burn". -b.t.
2402	*/	2333	*/
2403	void	2334	static void
2404	apply_lighter (object *who, object *lighter)	2335	apply_lighter (object *who, object *lighter)
2405	{	2336	{
2406	object *item;	2337	object *item;
2407	int is_player_env = 0;	2338	int is_player_env = 0;
2408		2339
2409	item = find_marked_object (who);	2340	item = find_marked_object (who);
2410	if (item)	2341	if (item)
2411	{	2342	{
2412	if (!auto_apply_lighter (who, 0, lighter))	2343	if (!auto_apply_lighter (who, item, lighter))
2413	return;	2344	return;
2414		2345
2415	/* Perhaps we should split what we are trying to light on fire?	2346	/* Perhaps we should split what we are trying to light on fire?
2416	* I can't see many times when you would want to light multiple	2347	* I can't see many times when you would want to light multiple
2417	* objects at once.	2348	* objects at once.
…		…
2433	else	2364	else
2434	who->failmsg ("You need to mark a lightable object.");	2365	who->failmsg ("You need to mark a lightable object.");
2435	}	2366	}
2436		2367
2437	/**	2368	/**
		2369	* This function generates a cursed effect for cursed lamps and torches.
		2370	*/
		2371	static void
		2372	player_apply_lamp_cursed_effect (object *who, object *op)
		2373	{
		2374	if (op->level)
		2375	{
		2376	who->failmsg (format (
		2377	"The %s was cursed, it explodes in a big fireball!",
		2378	&op->name));
		2379	create_exploding_ball_at (who, op->level);
		2380	}
		2381	else
		2382	{
		2383	who->failmsg (format (
		2384	"The %s was cursed, it crumbles to dust, at least it didn't explode.!",
		2385	&op->name));
		2386	}
		2387
		2388	op->destroy ();
		2389	}
		2390
		2391	/**
2438	* Apply for players and lamps	2392	* Apply for players and lamps
2439	*	2393	*
2440	* who - the player	2394	* who - the player
2441	* op - the lamp	2395	* op - the lamp
2442	*/	2396	*/
		2397	static void
2443	void player_apply_lamp (object *who, object *op)	2398	player_apply_lamp (object *who, object *op)
2444	{	2399	{
2445	bool switch_on = op->glow_radius ? false : true;	2400	bool switch_on = op->glow_radius ? false : true;
2446		2401
2447	if (switch_on)	2402	if (switch_on)
2448	{	2403	{
…		…
2465	"H<Torches and similar items burn out and become worthless.>",	2420	"H<Torches and similar items burn out and become worthless.>",
2466	&op->name));	2421	&op->name));
2467	return;	2422	return;
2468	}	2423	}
2469		2424
		2425	if (op->flag [FLAG_CURSED])
		2426	{
		2427	player_apply_lamp_cursed_effect (who, op);
		2428	return;
		2429	}
		2430
2470	if (lighter)	2431	if (lighter)
2471	who->statusmsg (format (	2432	who->statusmsg (format (
2472	"You light up the %s with the %s.", &op->name, &lighter->name));	2433	"You light up the %s with the %s.", &op->name, &lighter->name));
2473	else	2434	else
2474	who->statusmsg (format ("You light up the %s.", &op->name));	2435	who->statusmsg (format ("You light up the %s.", &op->name));
2475	}	2436	}
2476	else	2437	else
2477	{	2438	{
		2439	if (op->flag [FLAG_CURSED])
		2440	{
		2441	player_apply_lamp_cursed_effect (who, op);
		2442	return;
		2443	}
		2444
2478	if (op->type == TORCH)	2445	if (op->type == TORCH)
2479	{	2446	{
2480	if (!op->flag [FLAG_IS_LIGHTABLE])	2447	if (!op->flag [FLAG_IS_LIGHTABLE])
2481	{	2448	{
2482	who->statusmsg (format (	2449	who->statusmsg (format (
…		…
2495	}	2462	}
2496		2463
2497	apply_lamp (op, switch_on);	2464	apply_lamp (op, switch_on);
2498	}	2465	}
2499		2466
2500	void lamp_get_animation_from_arch (object *op, arch_ptr a)	2467	void get_animation_from_arch (object *op, arch_ptr a)
2501	{	2468	{
2502	op->animation_id = a->animation_id;	2469	op->animation_id = a->animation_id;
2503	op->flag [FLAG_IS_TURNABLE] = a->flag [FLAG_IS_TURNABLE];	2470	op->flag [FLAG_IS_TURNABLE] = a->flag [FLAG_IS_TURNABLE];
2504	op->flag [FLAG_ANIMATE] = a->flag [FLAG_ANIMATE];	2471	op->flag [FLAG_ANIMATE] = a->flag [FLAG_ANIMATE];
2505	op->anim_speed = a->anim_speed;	2472	op->anim_speed = a->anim_speed;
…		…
2545	op->value = 0;	2512	op->value = 0;
2546		2513
2547	// FIXME: This is a hack to make the more sane torches and lamps	2514	// FIXME: This is a hack to make the more sane torches and lamps
2548	// still animated ;-/	2515	// still animated ;-/
2549	if (op->other_arch)	2516	if (op->other_arch)
2550	lamp_get_animation_from_arch (op, switch_on ? op->other_arch : op->arch);	2517	get_animation_from_arch (op, switch_on ? op->other_arch : op->arch);
2551		2518
2552	if (object *pl = op->visible_to ())	2519	if (object *pl = op->visible_to ())
2553	esrv_update_item (UPD_ANIM | UPD_FACE | UPD_NAME, pl, op);	2520	esrv_update_item (UPD_ANIM | UPD_FACE | UPD_NAME, pl, op);
		2521	}
		2522
		2523	/**
		2524	* This handles items of type 'transformer'.
		2525	* Basically those items, used with a marked item, transform both items into something
		2526	* else.
		2527	* "Transformer" item has food decreased by 1, removed if 0 (0 at start means illimited)..
		2528	* Change information is contained in the 'slaying' field of the marked item.
		2529	* The format is as follow: transformer:[number ]yield[;transformer:...].
		2530	* This way an item can be transformed in many things, and/or many objects.
		2531	* The 'slaying' field for transformer is used as verb for the action.
		2532	*/
		2533	static void
		2534	apply_item_transformer (object *pl, object *transformer)
		2535	{
		2536	object *marked;
		2537	object *new_item;
		2538	const char *find;
		2539	char *separator;
		2540	int yield;
		2541	char got[MAX_BUF];
		2542	int len;
		2543
		2544	if (!pl || !transformer)
		2545	return;
		2546
		2547	marked = find_marked_object (pl);
		2548
		2549	if (!marked)
		2550	{
		2551	pl->failmsg (format ("Use the %s with what item?", query_name (transformer)));
		2552	return;
		2553	}
		2554
		2555	if (!marked->slaying)
		2556	{
		2557	pl->failmsg (format ("You can't use the %s with your %s!", query_name (transformer), query_name (marked)));
		2558	return;
		2559	}
		2560
		2561	/* check whether they are compatible or not */
		2562	find = strstr (&marked->slaying, transformer->arch->archname);
		2563	if (!find || (*(find + strlen (transformer->arch->archname)) != ':'))
		2564	{
		2565	pl->failmsg (format ("You can't use the %s with your %s!", query_name (transformer), query_name (marked)));
		2566	return;
		2567	}
		2568
		2569	find += strlen (transformer->arch->archname) + 1;
		2570	/* Item can be used, now find how many and what it yields */
		2571	if (isdigit (*(find)))
		2572	{
		2573	yield = atoi (find);
		2574	if (yield < 1)
		2575	{
		2576	LOG (llevDebug, "apply_item_transformer: item %s has slaying-yield %d.", query_base_name (marked, 0), yield);
		2577	yield = 1;
		2578	}
		2579	}
		2580	else
		2581	yield = 1;
		2582
		2583	while (isdigit (*find))
		2584	find++;
		2585
		2586	while (*find == ' ')
		2587	find++;
		2588
		2589	memset (got, 0, MAX_BUF);
		2590
		2591	if ((separator = (char *) strchr (find, ';')))
		2592	len = separator - find;
		2593	else
		2594	len = strlen (find);
		2595
		2596	min_it (len, MAX_BUF - 1);
		2597
		2598	strcpy (got, find);
		2599	got[len] = '\0';
		2600
		2601	/* Now create new item, remove used ones when required. */
		2602	new_item = get_archetype (got);
		2603	if (!new_item)
		2604	{
		2605	pl->failmsg (format ("This %s is strange, better to not use it.", query_base_name (marked, 0)));
		2606	return;
		2607	}
		2608
		2609	new_item->nrof = yield;
		2610
		2611	pl->statusmsg (format ("You %s the %s.", &transformer->slaying, query_base_name (marked, 0)));
		2612
		2613	pl->insert (new_item);
		2614	/* Eat up one item */
		2615	marked->decrease ();
		2616
		2617	/* Eat one transformer if needed */
		2618	if (transformer->stats.food)
		2619	if (--transformer->stats.food == 0)
		2620	transformer->decrease ();
2554	}	2621	}
2555		2622
2556	/**	2623	/**
2557	* Main apply handler.	2624	* Main apply handler.
2558	*	2625	*
…		…
2576		2643
2577	if (QUERY_FLAG (op, FLAG_UNPAID) && !QUERY_FLAG (op, FLAG_APPLIED))	2644	if (QUERY_FLAG (op, FLAG_UNPAID) && !QUERY_FLAG (op, FLAG_APPLIED))
2578	{	2645	{
2579	if (who->type == PLAYER)	2646	if (who->type == PLAYER)
2580	{	2647	{
		2648	examine (who, op);
2581	who->failmsg ("You should pay for it first! H<You cannot use items marked as unpaid.>");	2649	//who->failmsg ("You should pay for it first! H<You cannot use items marked as unpaid.>");//TODO remove
2582	return 1;	2650	return 1;
2583	}	2651	}
2584	else	2652	else
2585	return 0; /* monsters just skip unpaid items */	2653	return 0; /* monsters just skip unpaid items */
2586	}	2654	}
…		…
2588	if (INVOKE_OBJECT (APPLY, op, ARG_OBJECT (who)))	2656	if (INVOKE_OBJECT (APPLY, op, ARG_OBJECT (who)))
2589	return RESULT_INT (0);	2657	return RESULT_INT (0);
2590		2658
2591	switch (op->type)	2659	switch (op->type)
2592	{	2660	{
2593	case CF_HANDLE:	2661	case T_HANDLE:
2594	who->play_sound (sound_find ("turn_handle"));	2662	who->play_sound (sound_find ("turn_handle"));
2595	who->statusmsg ("You turn the handle.");	2663	who->statusmsg ("You turn the handle.");
2596	op->value = op->value ? 0 : 1;	2664	op->value = op->value ? 0 : 1;
2597	SET_ANIMATION (op, op->value);	2665	SET_ANIMATION (op, op->value);
2598	update_object (op, UP_OBJ_FACE);	2666	update_object (op, UP_OBJ_FACE);
2599	push_button (op, who);	2667	push_button (op, who);
2600	return 1;	2668	return 1;
2601		2669
2602	case TRIGGER:	2670	case TRIGGER:
2603	if (check_trigger (op, who))	2671	if (check_trigger (op, who, who))
2604	{	2672	{
2605	who->statusmsg ("You turn the handle.");	2673	who->statusmsg ("You turn the handle.");
2606	who->play_sound (sound_find ("turn_handle"));	2674	who->play_sound (sound_find ("turn_handle"));
2607	}	2675	}
2608	else	2676	else
…		…
2612		2680
2613	case EXIT:	2681	case EXIT:
2614	if (who->type != PLAYER)	2682	if (who->type != PLAYER)
2615	return 0;	2683	return 0;
2616		2684
2617	if (!EXIT_PATH (op) || !is_legal_2ways_exit (who, op))	2685	if (!EXIT_PATH (op))
2618	who->failmsg (format ("The %s is closed.", query_name (op)));	2686	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)));
2619	else	2687	else
2620	{	2688	{
2621	/* Don't display messages for random maps. */	2689	/* Don't display messages for random maps. */
2622	if (op->msg && !EXIT_PATH (op).starts_with ("/!"))	2690	if (op->msg && EXIT_PATH (op) != shstr_random_map_exit)
2623	who->statusmsg (op->msg, NDI_NAVY);	2691	who->statusmsg (op->msg, NDI_NAVY);
2624		2692
2625	who->enter_exit (op);	2693	who->enter_exit (op);
2626	}	2694	}
2627		2695
…		…
2846	* we don't use a corrupt pointer for the next object, so we get the	2914	* we don't use a corrupt pointer for the next object, so we get the
2847	* next object in the stack before applying. This is can only be a	2915	* next object in the stack before applying. This is can only be a
2848	* problem if player_apply() has a bug in that it uses the object but does	2916	* problem if player_apply() has a bug in that it uses the object but does
2849	* not return a proper value.	2917	* not return a proper value.
2850	*/	2918	*/
2851	for (object *next, *tmp = pl->container ? pl->container->inv : pl->below; tmp; tmp = next)	2919	for (object *next, *tmp = pl->container_ () ? pl->container_ ()->inv : pl->below; tmp; tmp = next)
2852	{	2920	{
2853	next = tmp->below;	2921	next = tmp->below;
2854		2922
2855	if (QUERY_FLAG (tmp, FLAG_IS_FLOOR))	2923	if (QUERY_FLAG (tmp, FLAG_IS_FLOOR))
2856	floors++;	2924	floors++;
…		…
3034	#define CANNOT_REMOVE_CURSED \	3102	#define CANNOT_REMOVE_CURSED \
3035	"H<You cannot remove cursed or damned items, you first have to remove the curse. " \	3103	"H<You cannot remove cursed or damned items, you first have to remove the curse. " \
3036	"Praying over an altar, scrolls of remove curse/damnation, " \	3104	"Praying over an altar, scrolls of remove curse/damnation, " \
3037	"priests or even other players might help.>"	3105	"priests or even other players might help.>"
3038		3106
3039	int	3107	static int
3040	unapply_for_ob (object *who, object *op, int aflags)	3108	unapply_for_ob (object *who, object *op, int aflags)
3041	{	3109	{
3042	if (op->is_range ())	3110	if (op->is_range ())
3043	for (object *tmp = who->inv; tmp; tmp = tmp->below)	3111	for (object *tmp = who->inv; tmp; tmp = tmp->below)
3044	if (QUERY_FLAG (tmp, FLAG_APPLIED) && tmp->is_range ())	3112	if (QUERY_FLAG (tmp, FLAG_APPLIED) && tmp->is_range ())
…		…
3362	* skill so that the dam and wc get updated	3430	* skill so that the dam and wc get updated
3363	*/	3431	*/
3364	who->change_skill (skop);	3432	who->change_skill (skop);
3365	}	3433	}
3366		3434
3367	if (who->type == PLAYER	3435	if (!check_item_power (who, op->item_power))
3368	&& op->item_power
3369	&& op->item_power + who->contr->item_power > settings.item_power_factor * who->level)
3370	{	3436	{
3371	who->failmsg ("Equipping that combined with other items would consume your soul!" LACK_ITEM_POWER);	3437	who->failmsg ("Equipping that combined with other items would consume your soul!" LACK_ITEM_POWER);
3372	return 1;	3438	return 1;
3373	}	3439	}
3374		3440
…		…
3382	return RESULT_INT (0);	3448	return RESULT_INT (0);
3383		3449
3384	switch (op->type)	3450	switch (op->type)
3385	{	3451	{
3386	case WEAPON:	3452	case WEAPON:
3387	if (!check_weapon_power (who, op->last_eat))
3388	{
3389	op->failmsg ("This weapon is too powerful for you to use. It would consume your soul!" LACK_ITEM_POWER);
3390
3391	if (tmp)
3392	insert_ob_in_ob (tmp, who);
3393
3394	return 1;
3395	}
3396
3397	//TODO: this obviously fails for players using a shorter prefix	3453	//TODO: this obviously fails for players using a shorter prefix
3398	// i.e. "R" can use Ragnarok's sword.	3454	// i.e. "R" can use Ragnarok's sword.
3399	if (op->level && !op->name.starts_with (who->name))	3455	if (op->level && !op->name.starts_with (who->name))
3400	{	3456	{
3401	/* if the weapon does not have the name as the character, can't use it. */	3457	/* if the weapon does not have the name as the character, can't use it. */
…		…
3456	case SKILL:	3512	case SKILL:
3457	if (player *pl = who->contr)	3513	if (player *pl = who->contr)
3458	{	3514	{
3459	if (IS_COMBAT_SKILL (op->subtype))	3515	if (IS_COMBAT_SKILL (op->subtype))
3460	{	3516	{
3461	if (skill_flags [op->subtype] & SF_NEED_WEAPON)	3517	if (skill_flags [op->subtype] & SF_NEED_ITEM)
3462	{	3518	{
3463	for (object *item = who->inv; item; item = item->below)	3519	for (object *item = who->inv; item; item = item->below)
3464	if (item->type == WEAPON && item->flag [FLAG_APPLIED])	3520	if (item->type == item->weapontype && item->flag [FLAG_APPLIED])
3465	{	3521	{
3466	if (item->skill == op->skill)	3522	if (item->skill == op->skill)
3467	{	3523	{
3468	who->change_weapon (pl->combat_ob = item);	3524	who->change_weapon (pl->combat_ob = item);
3469	goto found_weapon;	3525	goto found_weapon;
…		…
3482	else	3538	else
3483	who->change_weapon (pl->combat_ob = op);	3539	who->change_weapon (pl->combat_ob = op);
3484	}	3540	}
3485	else if (IS_RANGED_SKILL (op->subtype))	3541	else if (IS_RANGED_SKILL (op->subtype))
3486	{	3542	{
3487	if (skill_flags [op->subtype] & SF_NEED_BOW)	3543	if (skill_flags [op->subtype] & SF_NEED_ITEM)
3488	{	3544	{
3489	for (object *item = who->inv; item; item = item->below)	3545	for (object *item = who->inv; item; item = item->below)
3490	if (item->type == BOW && item->flag [FLAG_APPLIED])	3546	if (item->type == item->weapontype && item->flag [FLAG_APPLIED])
3491	{	3547	{
3492	//TODO: bows should/must all have skill missile weapon right now	3548	//TODO: bows should/must all have skill missile weapon right now
3493	who->change_weapon (pl->ranged_ob = item);	3549	who->change_weapon (pl->ranged_ob = item);
3494	goto found_bow;	3550	goto found_bow;
3495	}	3551	}
…		…
3527	}	3583	}
3528		3584
3529	break;	3585	break;
3530		3586
3531	case BOW:	3587	case BOW:
3532	if (!check_weapon_power (who, op->last_eat))
3533	{
3534	who->failmsg ("That weapon is too powerful for you to use. It would consume your soul!" LACK_ITEM_POWER);
3535
3536	if (tmp)
3537	insert_ob_in_ob (tmp, who);
3538
3539	return 1;
3540	}
3541
3542	if (op->level && !op->name.starts_with (who->name))	3588	if (op->level && !op->name.starts_with (who->name))
3543	{	3589	{
3544	who->failmsg ("The weapon does not recognize you as its owner. "	3590	who->failmsg ("The weapon does not recognize you as its owner. "
3545	"H<Its name indicates that it belongs to somebody else.>");	3591	"H<Its name indicates that it belongs to somebody else.>");
3546	if (tmp)	3592	if (tmp)
…		…
3632	esrv_send_item (pl, op);	3678	esrv_send_item (pl, op);
3633		3679
3634	return 0;	3680	return 0;
3635	}	3681	}
3636		3682
3637	int
3638	monster_apply_special (object *who, object *op, int aflags)
3639	{
3640	if (QUERY_FLAG (op, FLAG_UNPAID) && !QUERY_FLAG (op, FLAG_APPLIED))
3641	return 1;
3642
3643	return apply_special (who, op, aflags);
3644	}
3645
3646	/**	3683	/**
3647	* Map was just loaded, handle op's initialisation.	3684	* Map was just loaded, handle op's initialisation.
3648	*	3685	*
3649	* Generates shop floor's item, and treasures.	3686	* Generates shop floor's item, and treasures.
3650	*/	3687	*/
…		…
3755	* treasure again for this object	3792	* treasure again for this object
3756	*/	3793	*/
3757	invtmp->randomitems = NULL;	3794	invtmp->randomitems = NULL;
3758	}	3795	}
3759	}	3796	}
		3797
3760	/* This is really temporary - the code at the bottom will	3798	/* This is really temporary - the code at the bottom will
3761	* also set randomitems to null. The problem is there are bunches	3799	* also set randomitems to null. The problem is there are bunches
3762	* of maps/players already out there with items that have spells	3800	* of maps/players already out there with items that have spells
3763	* which haven't had the randomitems set to null yet.	3801	* which haven't had the randomitems set to null yet.
3764	* MSW 2004-05-13	3802	* MSW 2004-05-13
…		…
3768	* Ryo 2004-08-16	3806	* Ryo 2004-08-16
3769	*/	3807	*/
3770	if (tmp->type == WAND || tmp->type == ROD || tmp->type == SCROLL	3808	if (tmp->type == WAND || tmp->type == ROD || tmp->type == SCROLL
3771	|| tmp->type == HORN || tmp->type == FIREWALL || tmp->type == POTION || tmp->type == ALTAR || tmp->type == SPELLBOOK)	3809	|| tmp->type == HORN || tmp->type == FIREWALL || tmp->type == POTION || tmp->type == ALTAR || tmp->type == SPELLBOOK)
3772	tmp->randomitems = NULL;	3810	tmp->randomitems = NULL;
3773
3774	}	3811	}
3775		3812
3776	if (QUERY_FLAG (tmp, FLAG_AUTO_APPLY))	3813	if (QUERY_FLAG (tmp, FLAG_AUTO_APPLY))
3777	auto_apply (tmp);	3814	auto_apply (tmp);
3778	else if ((tmp->type == TREASURE || (tmp->type == CONTAINER)) && tmp->has_random_items ())	3815	else if ((tmp->type == TREASURE || (tmp->type == CONTAINER)) && tmp->has_random_items ())
…		…
3811	}	3848	}
3812		3849
3813	for (mapspace *ms = spaces + size (); ms-- > spaces; )	3850	for (mapspace *ms = spaces + size (); ms-- > spaces; )
3814	for (object *tmp = ms->bot; tmp; tmp = tmp->above)	3851	for (object *tmp = ms->bot; tmp; tmp = tmp->above)
3815	if (tmp->above && (tmp->type == TRIGGER_BUTTON || tmp->type == TRIGGER_PEDESTAL))	3852	if (tmp->above && (tmp->type == TRIGGER_BUTTON || tmp->type == TRIGGER_PEDESTAL))
3816	check_trigger (tmp, tmp->above);	3853	check_trigger (tmp, tmp->above, tmp->above);
3817	}	3854	}
3818		3855
3819	/**	3856	/**
3820	* Handles player eating food that temporarily changes status (resistances, stats).	3857	* Handles player eating food that temporarily changes status (resistances, stats).
3821	* This used to call cast_change_attr(), but	3858	* This used to call cast_change_attr(), but
…		…
3826	eat_special_food (object *who, object *food)	3863	eat_special_food (object *who, object *food)
3827	{	3864	{
3828	object *force;	3865	object *force;
3829	int i, did_one = 0;	3866	int i, did_one = 0;
3830		3867
3831	force = get_archetype (FORCE_NAME);	3868	char buf[64];
		3869	snprintf (buf, sizeof(buf), "sp_food_%s", &food->title);
		3870	shstr key (buf);
3832		3871
3833	for (i = 0; i < NUM_STATS; i++)
3834	if (sint8 k = food->stats.stat (i))
3835	{
3836	force->stats.stat (i) = k;
3837	did_one = 1;
3838	}
3839
3840	/* check if we can protect the eater */
3841	for (i = 0; i < NROFATTACKS; i++)
3842	{
3843	if (food->resist[i] > 0)
3844	{
3845	force->resist[i] = food->resist[i] / 2;
3846	did_one = 1;
3847	}
3848	}
3849
3850	if (did_one)
3851	{
3852	force->set_speed (0.1);
3853	/* bigger morsel of food = longer effect time */	3872	/* bigger morsel of food = longer effect time */
3854	force->duration = food->stats.food / 5;	3873	int duration = TIME2TICK (food->stats.food);
3855	SET_FLAG (force, FLAG_APPLIED);	3874
3856	change_abil (who, force);	3875	if (force = who->force_find (key))
3857	insert_ob_in_ob (force, who);	3876	{
		3877	if (duration > fabs (force->speed_left / force->speed))
		3878	{
		3879	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));
		3880	force->force_set_timer (duration);
		3881	}
		3882	else
		3883	new_draw_info (NDI_UNIQUE, 0, who, "It had no additional effect.");
		3884
		3885	return;
3858	}	3886	}
3859	else	3887	else
		3888	{
		3889	force = who->force_add (key, duration);
		3890	force->name = key;
		3891
		3892	/* check if the food affects a stat */
		3893	for (i = 0; i < NUM_STATS; i++)
		3894	if (sint8 k = food->stats.stat (i))
		3895	{
		3896	force->stats.stat (i) = k;
		3897	did_one = 1;
		3898	}
		3899
		3900	/* check if we can protect the eater */
		3901	for (i = 0; i < NROFATTACKS; i++)
		3902	{
		3903	if (food->resist[i] > 0)
		3904	{
		3905	force->resist[i] = food->resist[i];
		3906	did_one = 1;
		3907	}
		3908	}
		3909
		3910	if (did_one)
		3911	{
		3912	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));
		3913
		3914	/* make the force take effect and report effects to user */
		3915	change_abil (who, force);
		3916	}
		3917	else
3860	force->destroy ();	3918	force->destroy ();
		3919	}
3861		3920
3862	/* check for hp, sp change */	3921	/* check for hp, sp change */
3863	if (food->stats.hp != 0)	3922	if (food->stats.hp != 0)
3864	{	3923	{
3865	if (QUERY_FLAG (food, FLAG_CURSED))	3924	if (QUERY_FLAG (food, FLAG_CURSED))
…		…
3895	/* place limit on max sp from food? */	3954	/* place limit on max sp from food? */
3896	}	3955	}
3897	}	3956	}
3898		3957
3899	who->update_stats ();	3958	who->update_stats ();
3900	}
3901
3902
3903	/**
3904	* op made some mistake with a scroll, this takes care of punishment.
3905	* scroll_failure()- hacked directly from spell_failure
3906	*/
3907	void
3908	scroll_failure (object *op, int failure, int power)
3909	{
3910	if (abs (failure / 4) > power)
3911	power = abs (failure / 4); /* set minimum effect */
3912
3913	if (failure <= -1 && failure > -15)
3914	{ /* wonder */
3915	object *tmp;
3916
3917	op->failmsg ("Your spell warps!");
3918	tmp = get_archetype (SPELL_WONDER);
3919	cast_wonder (op, op, 0, tmp);
3920	tmp->destroy ();
3921	}
3922	else if (failure <= -15 && failure > -35)
3923	{ /* drain mana */
3924	op->failmsg ("Your mana is drained!");
3925	op->stats.sp -= random_roll (0, power - 1, op, PREFER_LOW);
3926	if (op->stats.sp < 0)
3927	op->stats.sp = 0;
3928	}
3929	else if (settings.spell_failure_effects == TRUE)
3930	{
3931	if (failure <= -35 && failure > -60)
3932	{ /* confusion */
3933	op->failmsg ("The magic recoils on you!");
3934	confuse_player (op, op, power);
3935	}
3936	else if (failure <= -60 && failure > -70)
3937	{ /* paralysis */
3938	op->failmsg ("The magic recoils and paralyzes you!");
3939	paralyze_player (op, op, power);
3940	}
3941	else if (failure <= -70 && failure > -80)
3942	{ /* blind */
3943	op->failmsg ("The magic recoils on you!");
3944	blind_player (op, op, power);
3945	}
3946	else if (failure <= -80)
3947	{ /* blast the immediate area */
3948	object *tmp = get_archetype (LOOSE_MANA);
3949	cast_magic_storm (op, tmp, power);
3950	op->failmsg ("You unleash uncontrolled mana!");
3951	tmp->destroy ();
3952	}
3953	}
3954	}	3959	}
3955		3960
3956	void	3961	void
3957	apply_changes_to_player (object *pl, object *change)	3962	apply_changes_to_player (object *pl, object *change)
3958	{	3963	{
…		…
4035	break;	4040	break;
4036	}	4041	}
4037	}	4042	}
4038	}	4043	}
4039		4044
4040	/**
4041	* This handles items of type 'transformer'.
4042	* Basically those items, used with a marked item, transform both items into something
4043	* else.
4044	* "Transformer" item has food decreased by 1, removed if 0 (0 at start means illimited)..
4045	* Change information is contained in the 'slaying' field of the marked item.
4046	* The format is as follow: transformer:[number ]yield[;transformer:...].
4047	* This way an item can be transformed in many things, and/or many objects.
4048	* The 'slaying' field for transformer is used as verb for the action.
4049	*/
4050	void
4051	apply_item_transformer (object *pl, object *transformer)
4052	{
4053	object *marked;
4054	object *new_item;
4055	char *find;
4056	char *separator;
4057	int yield;
4058	char got[MAX_BUF];
4059	int len;
4060
4061	if (!pl || !transformer)
4062	return;
4063
4064	marked = find_marked_object (pl);
4065
4066	if (!marked)
4067	{
4068	pl->failmsg (format ("Use the %s with what item?", query_name (transformer)));
4069	return;
4070	}
4071
4072	if (!marked->slaying)
4073	{
4074	pl->failmsg (format ("You can't use the %s with your %s!", query_name (transformer), query_name (marked)));
4075	return;
4076	}
4077
4078	/* check whether they are compatible or not */
4079	find = strstr (&marked->slaying, transformer->arch->archname);
4080	if (!find || (*(find + strlen (transformer->arch->archname)) != ':'))
4081	{
4082	pl->failmsg (format ("You can't use the %s with your %s!", query_name (transformer), query_name (marked)));
4083	return;
4084	}
4085
4086	find += strlen (transformer->arch->archname) + 1;
4087	/* Item can be used, now find how many and what it yields */
4088	if (isdigit (*(find)))
4089	{
4090	yield = atoi (find);
4091	if (yield < 1)
4092	{
4093	LOG (llevDebug, "apply_item_transformer: item %s has slaying-yield %d.", query_base_name (marked, 0), yield);
4094	yield = 1;
4095	}
4096	}
4097	else
4098	yield = 1;
4099
4100	while (isdigit (*find))
4101	find++;
4102
4103	while (*find == ' ')
4104	find++;
4105
4106	memset (got, 0, MAX_BUF);
4107
4108	if ((separator = strchr (find, ';')) != NULL)
4109	len = separator - find;
4110	else
4111	len = strlen (find);
4112
4113	if (len > MAX_BUF - 1)
4114	len = MAX_BUF - 1;
4115
4116	strcpy (got, find);
4117	got[len] = '\0';
4118
4119	/* Now create new item, remove used ones when required. */
4120	new_item = get_archetype (got);
4121	if (!new_item)
4122	{
4123	pl->failmsg (format ("This %s is strange, better to not use it.", query_base_name (marked, 0)));
4124	return;
4125	}
4126
4127	new_item->nrof = yield;
4128
4129	pl->statusmsg (format ("You %s the %s.", &transformer->slaying, query_base_name (marked, 0)));
4130
4131	pl->insert (new_item);
4132	/* Eat up one item */
4133	marked->decrease ();
4134
4135	/* Eat one transformer if needed */
4136	if (transformer->stats.food)
4137	if (--transformer->stats.food == 0)
4138	transformer->decrease ();
4139	}
4140

Diff Legend

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