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.127 by root, Fri Aug 17 21:18:01 2007 UTC vs.
Revision 1.183 by root, Thu Jan 8 04:35:04 2009 UTC

1	/*	1	/*
2	* This file is part of Crossfire TRT, the Roguelike Realtime MORPG.	2	* This file is part of Deliantra, the Roguelike Realtime MMORPG.
3	*	3	*
4	* Copyright (©) 2005,2006,2007 Marc Alexander Lehmann / Robin Redeker / the Crossfire TRT 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	* Crossfire TRT is free software: you can redistribute it and/or modify	8	* Deliantra is free software: you can redistribute it and/or modify
9	* it under the terms of the GNU General Public License as published by	9	* it under the terms of the GNU General Public License as published by
10	* the Free Software Foundation, either version 3 of the License, or	10	* the Free Software Foundation, either version 3 of the License, or
11	* (at your option) any later version.	11	* (at your 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,
…		…
16	* GNU General Public License for more details.	16	* GNU General Public License for more details.
17	*	17	*
18	* You should have received a copy of the GNU General Public License	18	* You should have received a copy of the GNU General Public License
19	* along with this program. If not, see <http://www.gnu.org/licenses/>.	19	* along with this program. If not, see <http://www.gnu.org/licenses/>.
20	*	20	*
21	* The authors can be reached via e-mail to <crossfire@schmorp.de>	21	* The authors can be reached via e-mail to <support@deliantra.net>
22	*/	22	*/
23		23
24	#include <cmath>	24	#include <cmath>
25		25
26	#include <global.h>	26	#include <global.h>
…		…
53	* subtype 5: arch or race	53	* subtype 5: arch or race
54	* subtype 7: all three	54	* subtype 7: all three
55	*/	55	*/
56	if (op->subtype)	56	if (op->subtype)
57	{	57	{
58	arch_flag = (op->subtype & 1);	58	arch_flag = op->subtype & 1;
59	name_flag = (op->subtype & 2);	59	name_flag = op->subtype & 2;
60	race_flag = (op->subtype & 4);	60	race_flag = op->subtype & 4;
61	}	61	}
62	else	62	else
63	{	63	{
64	arch_flag = 1;	64	arch_flag = 1;
65	name_flag = 1;	65	name_flag = 1;
…		…
113	{	113	{
114	if (operate_altar (altar, &money))	114	if (operate_altar (altar, &money))
115	{	115	{
116	identify (marked);	116	identify (marked);
117		117
118	buf.printf ("You have %s.", long_desc (marked, pl));	118	buf.printf ("You have %s.\r", long_desc (marked, pl));
119	if (marked->msg)	119	if (marked->msg)
120	buf << "The item has a story:\n" << marked->msg;	120	buf << "The item has a story:\r" << marked->msg << "\n\n";
121		121
122	return !money;	122	return !money;
123	}	123	}
124	}	124	}
125		125
…		…
129	{	129	{
130	if (operate_altar (altar, &money))	130	if (operate_altar (altar, &money))
131	{	131	{
132	identify (id);	132	identify (id);
133		133
134	buf.printf ("You have %s.", long_desc (id, pl));	134	buf.printf ("You have %s.\r", long_desc (id, pl));
135	if (id->msg)	135	if (id->msg)
136	buf << "The item has a story:\n" << id->msg;	136	buf << "The item has a story:\r" << id->msg << "\n\n";
137		137
138	/* If no more money, might as well quit now */	138	/* If no more money, might as well quit now */
139	if (!money || !check_altar_sacrifice (altar, money))	139	if (!money || !check_altar_sacrifice (altar, money))
140	break;	140	break;
141	}	141	}
…		…
146	}	146	}
147	}	147	}
148	}	148	}
149		149
150	if (buf.empty ())	150	if (buf.empty ())
151	buf << ("You have nothing that needs identifying");	151	pl->failmsg ("You have nothing that needs identifying");
152		152	else
153	pl->contr->infobox ("Identify", buf);	153	pl->contr->infobox (MSG_CHANNEL ("identify"), buf);
154		154
155	return !money;	155	return !money;
156	}	156	}
157		157
158	/**	158	/**
…		…
160	* matching item.	160	* matching item.
161	**/	161	**/
162	void	162	void
163	handle_apply_yield (object *tmp)	163	handle_apply_yield (object *tmp)
164	{	164	{
165	const char *yield;	165	if (shstr_tmp yield = tmp->kv (shstr_on_use_yield))
166		166	archetype::get (yield)->insert_at (tmp, tmp, INS_BELOW_ORIGINATOR);
167	yield = get_ob_key_value (tmp, "on_use_yield");
168	if (yield != NULL)
169	{
170	object *drop = get_archetype (yield);
171
172	if (tmp->env)
173	{
174	drop = insert_ob_in_ob (drop, tmp->env);
175	if (tmp->env->type == PLAYER)
176	esrv_send_item (tmp->env, drop);
177	}
178	else
179	{
180	drop->x = tmp->x;
181	drop->y = tmp->y;
182	insert_ob_in_map (drop, tmp->map, tmp, INS_BELOW_ORIGINATOR);
183	}
184	}
185	}	167	}
186		168
187	/**	169	/**
188	* Handles applying a potion.	170	* Handles applying a potion.
189	*/	171	*/
…		…
217		199
218	if (QUERY_FLAG (tmp, FLAG_CURSED) || QUERY_FLAG (tmp, FLAG_DAMNED))	200	if (QUERY_FLAG (tmp, FLAG_CURSED) || QUERY_FLAG (tmp, FLAG_DAMNED))
219	{	201	{
220	op->drain_stat ();	202	op->drain_stat ();
221	op->update_stats ();	203	op->update_stats ();
222	decrease_ob (tmp);	204	tmp->decrease ();
223	return 1;	205	return 1;
224	}	206	}
225		207
226	if (!(at = archetype::find (ARCH_DEPLETION)))	208	if (!(at = archetype::find (ARCH_DEPLETION)))
227	{	209	{
228	LOG (llevError, "Could not find archetype depletion\n");	210	LOG (llevError, "Could not find archetype depletion\n");
229	return 0;	211	return 0;
230	}	212	}
		213
231	depl = present_arch_in_ob (at, op);	214	depl = present_arch_in_ob (at, op);
232		215
233	if (depl)	216	if (depl)
234	{	217	{
235	for (i = 0; i < NUM_STATS; i++)	218	for (i = 0; i < NUM_STATS; i++)
…		…
240	op->update_stats ();	223	op->update_stats ();
241	}	224	}
242	else	225	else
243	op->statusmsg ("Your potion had no effect.");	226	op->statusmsg ("Your potion had no effect.");
244		227
245	decrease_ob (tmp);	228	tmp->decrease ();
246	return 1;	229	return 1;
247	}	230	}
248		231
249	/* improvement potion - only for players */	232	/* improvement potion - only for players */
250	if (op->type == PLAYER && (tmp->attacktype & AT_GODPOWER))	233	if (op->type == PLAYER && (tmp->attacktype & AT_GODPOWER))
…		…
318	}	301	}
319	else	302	else
320	op->statusmsg ("You are fortunate that you are so pathetic.", NDI_DK_ORANGE);	303	op->statusmsg ("You are fortunate that you are so pathetic.", NDI_DK_ORANGE);
321	}	304	}
322		305
323	decrease_ob (tmp);	306	tmp->decrease ();
324	return 1;	307	return 1;
325	}	308	}
326		309
327		310
328	/* A potion that casts a spell. Healing, restore spellpoint (power potion)	311	/* A potion that casts a spell. Healing, restore spellpoint (power potion)
…		…
347	insert_ob_in_map (fball, op->map, NULL, 0);	330	insert_ob_in_map (fball, op->map, NULL, 0);
348	}	331	}
349	else	332	else
350	cast_spell (op, tmp, op->facing, tmp->inv, NULL);	333	cast_spell (op, tmp, op->facing, tmp->inv, NULL);
351		334
352	decrease_ob (tmp);	335	tmp->decrease ();
353		336
354	/* if youre dead, no point in doing this... */	337	/* if youre dead, no point in doing this... */
355	if (!QUERY_FLAG (op, FLAG_REMOVED))	338	if (!QUERY_FLAG (op, FLAG_REMOVED))
356	op->update_stats ();	339	op->update_stats ();
357		340
…		…
388	force->speed_left = -1;	371	force->speed_left = -1;
389	force = insert_ob_in_ob (force, op);	372	force = insert_ob_in_ob (force, op);
390	CLEAR_FLAG (tmp, FLAG_APPLIED);	373	CLEAR_FLAG (tmp, FLAG_APPLIED);
391	SET_FLAG (force, FLAG_APPLIED);	374	SET_FLAG (force, FLAG_APPLIED);
392	change_abil (op, force);	375	change_abil (op, force);
393	decrease_ob (tmp);	376	tmp->decrease ();
394	return 1;	377	return 1;
395	}	378	}
396		379
397	/* Only thing left are the stat potions */	380	/* Only thing left are the stat potions */
398	if (op->type == PLAYER)	381	if (op->type == PLAYER)
…		…
411	* stat will not be raised by them. fix_player just clears	394	* stat will not be raised by them. fix_player just clears
412	* up all the stats.	395	* up all the stats.
413	*/	396	*/
414	CLEAR_FLAG (tmp, FLAG_APPLIED);	397	CLEAR_FLAG (tmp, FLAG_APPLIED);
415	op->update_stats ();	398	op->update_stats ();
416	decrease_ob (tmp);	399	tmp->decrease ();
417	return 1;	400	return 1;
418	}	401	}
419		402
420	/****************************************************************************	403	/****************************************************************************
421	* Weapon improvement code follows	404	* Weapon improvement code follows
…		…
423		406
424	/**	407	/**
425	* This returns the sum of nrof of item (arch name).	408	* This returns the sum of nrof of item (arch name).
426	*/	409	*/
427	static int	410	static int
428	check_item (object *op, const char *item)	411	check_item (object *op, shstr_cmp item)
429	{	412	{
430	int count = 0;	413	int count = 0;
431		414
432	if (!item)	415	if (!item)
433	return 0;	416	return 0;
434		417
435	for (op = op->below; op; op = op->below)	418	for (op = op->below; op; op = op->below)
436	{
437	if (strcmp (op->arch->archname, item) == 0)	419	if (op->arch->archname == item)
438	{
439	if (!QUERY_FLAG (op, FLAG_CURSED) && !QUERY_FLAG (op, FLAG_DAMNED)	420	if (!QUERY_FLAG (op, FLAG_CURSED) && !QUERY_FLAG (op, FLAG_DAMNED)
440	/* Loophole bug? -FD- */ && !QUERY_FLAG (op, FLAG_UNPAID))	421	&& /* Loophole bug? -FD- */ !QUERY_FLAG (op, FLAG_UNPAID))
441	{
442	if (op->nrof == 0) /* this is necessary for artifact sacrifices --FD-- */
443	count++;
444	else
445	count += op->nrof;	422	count += op->number_of ();
446	}
447	}
448	}
449		423
450	return count;	424	return count;
451	}	425	}
452		426
453	/**	427	/**
…		…
455	* op is typically the player, which is only	429	* op is typically the player, which is only
456	* really used to determine what space to look at.	430	* really used to determine what space to look at.
457	* Modified to only eat 'nrof' of objects.	431	* Modified to only eat 'nrof' of objects.
458	*/	432	*/
459	static void	433	static void
460	eat_item (object *op, const char *item, uint32 nrof)	434	eat_item (object *op, shstr_cmp item, uint32 nrof)
461	{	435	{
462	object *prev;	436	object *prev;
463		437
464	prev = op;	438	prev = op;
465	op = op->below;	439	op = op->below;
466		440
467	while (op)	441	while (op)
468	{	442	{
469	if (strcmp (op->arch->archname, item) == 0)	443	if (op->arch->archname == item)
470	{	444	{
471	if (op->nrof >= nrof)	445	if (op->nrof >= nrof)
472	{	446	{
473	decrease_ob_nr (op, nrof);	447	op->decrease (nrof);
474	return;	448	return;
475	}	449	}
476	else	450	else
477	{	451	{
478	decrease_ob_nr (op, op->nrof);	452	op->decrease (nrof);
479	nrof -= op->nrof;	453	nrof -= op->nrof;
480	}	454	}
481		455
482	op = prev;	456	op = prev;
483	}	457	}
…		…
568	static int	542	static int
569	improve_weapon_stat (object *op, object *improver, object *weapon, sint8 &stat, int sacrifice_count, const char *statname)	543	improve_weapon_stat (object *op, object *improver, object *weapon, sint8 &stat, int sacrifice_count, const char *statname)
570	{	544	{
571	stat += sacrifice_count;	545	stat += sacrifice_count;
572	weapon->last_eat++;	546	weapon->last_eat++;
573	decrease_ob (improver);	547	improver->decrease ();
574		548
575	/* So it updates the players stats and the window */	549	/* So it updates the players stats and the window */
576	op->update_stats ();	550	op->update_stats ();
577		551
578	op->statusmsg (format (	552	op->statusmsg (format (
…		…
623	if (i < NROFATTACKS || weapon->stats.hp || /* regeneration */	597	if (i < NROFATTACKS || weapon->stats.hp || /* regeneration */
624	(weapon->stats.sp && weapon->type == WEAPON) || /* sp regeneration */	598	(weapon->stats.sp && weapon->type == WEAPON) || /* sp regeneration */
625	weapon->stats.exp || /* speed */	599	weapon->stats.exp || /* speed */
626	weapon->stats.ac) /* AC - only taifu's I think */	600	weapon->stats.ac) /* AC - only taifu's I think */
627	{	601	{
628	op->failmsg ("You cannot prepare magic weapons.");	602	op->failmsg ("You cannot prepare magic weapons. "
		603	"H<A weapon is considered magical if it changes regeneration, "
		604	"speed or ac, or has other protections.>");
629	return 0;	605	return 0;
630	}	606	}
631		607
632	sacrifice_count = check_sacrifice (op, improver);	608	sacrifice_count = check_sacrifice (op, improver);
633	if (sacrifice_count <= 0)	609	if (sacrifice_count <= 0)
…		…
644		620
645	sprintf (buf, "%s's %s", &op->name, &weapon->name);	621	sprintf (buf, "%s's %s", &op->name, &weapon->name);
646	weapon->name = weapon->name_pl = buf;	622	weapon->name = weapon->name_pl = buf;
647	weapon->nrof = 0; /* prevents preparing n weapons in the same	623	weapon->nrof = 0; /* prevents preparing n weapons in the same
648	slot at once! */	624	slot at once! */
649	decrease_ob (improver);	625	improver->decrease ();
650	weapon->last_eat = 0;	626	weapon->last_eat = 0;
651	return 1;	627	return 1;
652	}	628	}
653
654		629
655	/**	630	/**
656	* Does the dirty job for 'improve weapon' scroll, prepare or add something.	631	* Does the dirty job for 'improve weapon' scroll, prepare or add something.
657	* This is the new improve weapon code.	632	* This is the new improve weapon code.
658	* Returns 0 if it was not able to work for some reason.	633	* Returns 0 if it was not able to work for some reason.
…		…
702	weapon->weight += 5000; /* 5 KG's */	677	weapon->weight += 5000; /* 5 KG's */
703	op->statusmsg (format ("Damage has been increased by 5 to %d.", weapon->stats.dam));	678	op->statusmsg (format ("Damage has been increased by 5 to %d.", weapon->stats.dam));
704	weapon->last_eat++;	679	weapon->last_eat++;
705		680
706	weapon->item_power++;	681	weapon->item_power++;
707	decrease_ob (improver);	682	improver->decrease ();
708	return 1;	683	return 1;
709	}	684	}
710		685
711	if (improver->stats.sp == IMPROVE_WEIGHT)	686	if (improver->stats.sp == IMPROVE_WEIGHT)
712	{	687	{
…		…
716	weapon->weight = 1;	691	weapon->weight = 1;
717		692
718	op->statusmsg (format ("Weapon weight reduced to %6.1fkg.", (float) weapon->weight / 1000.0));	693	op->statusmsg (format ("Weapon weight reduced to %6.1fkg.", (float) weapon->weight / 1000.0));
719	weapon->last_eat++;	694	weapon->last_eat++;
720	weapon->item_power++;	695	weapon->item_power++;
721	decrease_ob (improver);	696	improver->decrease ();
722	return 1;	697	return 1;
723	}	698	}
		699
724	if (improver->stats.sp == IMPROVE_ENCHANT)	700	if (improver->stats.sp == IMPROVE_ENCHANT)
725	{	701	{
726	weapon->magic++;	702	weapon->magic++;
727	weapon->last_eat++;	703	weapon->last_eat++;
728	op->statusmsg (format ("Weapon magic increased to %d.", weapon->magic));	704	op->statusmsg (format ("Weapon magic increased to %d.", weapon->magic));
729	decrease_ob (improver);	705	improver->decrease ();
730	weapon->item_power++;	706	weapon->item_power++;
731	return 1;	707	return 1;
732	}	708	}
733		709
734	sacrifice_needed = weapon->stats.Str + weapon->stats.Int + weapon->stats.Dex +	710	sacrifice_needed = weapon->stats.Str + weapon->stats.Int + weapon->stats.Dex +
…		…
783	op->failmsg ("Something blocks the magic of the scroll!");	759	op->failmsg ("Something blocks the magic of the scroll!");
784	return 0;	760	return 0;
785	}	761	}
786		762
787	otmp = find_marked_object (op);	763	otmp = find_marked_object (op);
		764
788	if (!otmp)	765	if (!otmp)
789	{	766	{
790	op->failmsg ("You need to mark a weapon object. H<Use the mark command or the mark option from the item popup menu.>");	767	op->failmsg ("You need to mark a weapon object. H<Use the mark command or the mark option from the item popup menu.>");
791	return 0;	768	return 0;
792	}	769	}
…		…
834	if (armour->magic >= settings.armor_max_enchant)	811	if (armour->magic >= settings.armor_max_enchant)
835	{	812	{
836	op->failmsg ("This armour can not be enchanted any further!");	813	op->failmsg ("This armour can not be enchanted any further!");
837	return 0;	814	return 0;
838	}	815	}
		816
839	/* Dealing with random artifact armor is a lot trickier (in terms of value, weight,	817	/* Dealing with random artifact armor is a lot trickier (in terms of value, weight,
840	* etc), so take the easy way out and don't worry about it.	818	* etc), so take the easy way out and don't worry about it.
841	* Note - maybe add scrolls which make the random artifact versions (eg, armour	819	* Note - maybe add scrolls which make the random artifact versions (eg, armour
842	* of gnarg and what not?)	820	* of gnarg and what not?)
843	*/	821	*/
…		…
845	{	823	{
846	op->failmsg ("This armour will not accept further enchantment.");	824	op->failmsg ("This armour will not accept further enchantment.");
847	return 0;	825	return 0;
848	}	826	}
849		827
850	/* Split objects if needed. Can't insert tmp until the	828	/* Split objects if needed. Can't insert tmp until the
851	* end of this function - otherwise it will just re-merge.	829	* end of this function - otherwise it will just re-merge.
852	*/	830	*/
853	if (armour->nrof > 1)	831	tmp = armour->nrof > 1 ? armour->split (armour->nrof - 1) : 0;
854	tmp = get_split_ob (armour, armour->nrof - 1);
855	else
856	tmp = NULL;
857		832
858	armour->magic++;	833	armour->magic++;
859		834
860	if (!settings.armor_speed_linear)	835	if (!settings.armor_speed_linear)
861	{	836	{
…		…
898	armour->item_power = get_power_from_ench (armour->arch->item_power + armour->magic);	873	armour->item_power = get_power_from_ench (armour->arch->item_power + armour->magic);
899		874
900	if (op->type == PLAYER)	875	if (op->type == PLAYER)
901	{	876	{
902	esrv_send_item (op, armour);	877	esrv_send_item (op, armour);
		878
903	if (QUERY_FLAG (armour, FLAG_APPLIED))	879	if (QUERY_FLAG (armour, FLAG_APPLIED))
904	op->update_stats ();	880	op->update_stats ();
905	}	881	}
906		882
907	decrease_ob (improver);	883	improver->decrease ();
908		884
909	if (tmp)	885	if (tmp)
910	{	886	op->insert (tmp);
911	insert_ob_in_ob (tmp, op);
912	esrv_send_item (op, tmp);
913	}
914		887
915	return 1;	888	return 1;
916	}	889	}
917		890
918	/*	891	/*
919	* convert_item() returns 1 if anything was converted, 0 if the item was not	892	* convert_item() returns 1 if anything was converted, 0 if the item was not
920	* what the converter wants, -1 if the converter is broken.	893	* what the converter wants, -1 if the converter is broken.
921	*/	894	*
922	#define CONV_FROM(xyz) xyz->slaying
923	#define CONV_TO(xyz) xyz->other_arch
924	#define CONV_NR(xyz) xyz->stats.sp
925	#define CONV_NEED(xyz) xyz->stats.food
926
927	/* Takes one items and makes another.	895	* Takes one type of items and makes another.
928	* converter is the object that is doing the conversion.	896	* converter is the object that is doing the conversion.
929	* item is the object that triggered the converter - if it is not	897	* item is the object that triggered the converter - if it is not
930	* what the converter wants, this will not do anything.	898	* what the converter wants, this will not do anything.
931	*/	899	*/
932	int	900	static int
933	convert_item (object *item, object *converter)	901	convert_item (object *item, object *converter)
934	{	902	{
935	int nr = 0;
936	uint32 price_in;	903	sint64 nr, price_in;
		904
		905	if (item->flag [FLAG_UNPAID])
		906	return 0;
		907
		908	shstr conv_from = converter->slaying;
		909	archetype *conv_to = converter->other_arch;
		910	sint64 need = converter->stats.food;
		911	sint64 give = converter->stats.sp;
937		912
938	/* We make some assumptions - we assume if it takes money as it type,	913	/* We make some assumptions - we assume if it takes money as it type,
939	* it wants some amount. We don't make change (ie, if something costs	914	* it wants some amount. We don't make change (ie, if something costs
940	* 3 gp and player drops a platinum, tough luck)	915	* 3 gp and player drops a platinum, tough luck)
941	*/	916	*/
942	if (CONV_FROM (converter) == shstr_money)	917	if (conv_from == shstr_money)
943	{	918	{
944	if (item->type != MONEY)	919	if (item->type != MONEY)
945	return 0;	920	return 0;
946		921
947	nr = (item->nrof * item->value) / CONV_NEED (converter);	922	nr = sint64 (item->nrof) * item->value / need;
948	if (!nr)	923	if (!nr)
949	return 0;	924	return 0;
950		925
951	converter->play_sound (sound_find ("shop_buy"));	926	converter->play_sound (sound_find ("shop_buy"));
952		927
953	int cost = nr * CONV_NEED (converter) / item->value;	928	sint64 cost = (nr * need + item->value - 1) / item->value;
954	/* take into account rounding errors */
955	if (nr * CONV_NEED (converter) % item->value)
956	cost++;
957		929
958	decrease_ob_nr (item, cost);	930	item->decrease (cost);
959		931
960	price_in = cost * item->value;	932	price_in = cost * item->value;
961	}	933	}
962	else	934	else
963	{	935	{
964	if (item->type == PLAYER || CONV_FROM (converter) != item->arch->archname ||	936	if (item->type == PLAYER
965	(CONV_NEED (converter) && CONV_NEED (converter) > (uint16) item->nrof))	937	|| conv_from != item->arch->archname
		938	|| (need && need > (uint16) item->nrof))
966	return 0;	939	return 0;
967		940
968	converter->play_sound (sound_find ("convert_item"));	941	converter->play_sound (sound_find ("convert_item"));
969		942
970	if (CONV_NEED (converter))	943	if (need)
971	{	944	{
972	nr = item->nrof / CONV_NEED (converter);	945	nr = sint64 (item->nrof) / need;
973	decrease_ob_nr (item, nr * CONV_NEED (converter));	946	item->decrease (nr * need);
974	price_in = nr * CONV_NEED (converter) * item->value;	947	price_in = nr * need * item->value;
975	}	948	}
976	else	949	else
977	{	950	{
978	price_in = item->value;	951	price_in = item->value;
979	item->destroy ();	952	item->destroy ();
…		…
990	ob_to_copy = converter->inv;	963	ob_to_copy = converter->inv;
991	for (ob = converter->inv->below, i = 1; ob; ob = ob->below, i++)	964	for (ob = converter->inv->below, i = 1; ob; ob = ob->below, i++)
992	if (rndm (0, i) == 0)	965	if (rndm (0, i) == 0)
993	ob_to_copy = ob;	966	ob_to_copy = ob;
994		967
995	item = object_create_clone (ob_to_copy);	968	item = ob_to_copy->deep_clone ();
996	CLEAR_FLAG (item, FLAG_IS_A_TEMPLATE);	969	CLEAR_FLAG (item, FLAG_IS_A_TEMPLATE);
997	unflag_inv (item, FLAG_IS_A_TEMPLATE);	970	unflag_inv (item, FLAG_IS_A_TEMPLATE);
998	}	971	}
999	else	972	else
1000	{	973	{
1001	if (converter->other_arch == NULL)	974	if (!conv_to)
1002	{	975	{
1003	LOG (llevError, "move_creator: Converter doesn't have other arch set: %s (%s, %d, %d)\n",	976	LOG (llevError, "move_creator: Converter doesn't have other arch set: %s (%s, %d, %d)\n",
1004	&converter->name, &converter->map->path, converter->x, converter->y);	977	&converter->name, &converter->map->path, converter->x, converter->y);
1005	return -1;	978	return -1;
1006	}	979	}
1007		980
1008	item = object_create_arch (converter->other_arch);	981	item = object_create_arch (conv_to);
1009	fix_generated_item (item, converter, 0, 0, GT_MINIMAL);	982	fix_generated_item (item, converter, 0, 0, GT_MINIMAL);
1010	}	983	}
1011		984
1012	if (CONV_NR (converter))	985	if (give)
1013	item->nrof = CONV_NR (converter);	986	item->nrof = give;
1014		987
1015	if (nr)	988	if (nr)
1016	item->nrof *= nr;	989	item->nrof *= nr;
1017		990
1018	if (is_in_shop (converter))	991	if (converter->flag [FLAG_PRECIOUS])
1019	SET_FLAG (item, FLAG_UNPAID);	992	SET_FLAG (item, FLAG_UNPAID);
		993
		994	if (is_in_shop (converter))
		995	{
		996	// converters on shop floors don't work anymore, bug lets check for it
		997	// and report in case someone still does it.
		998	LOG (llevDebug, "ITEMBUG: broken converter, converters on shop floor don't work: %s\n",
		999	converter->debug_desc ());
		1000	SET_FLAG (item, FLAG_UNPAID);
		1001	}
1020	else if (price_in < item->nrof * item->value)	1002	else if (price_in < sint64 (item->nrof) * item->value)
1021	{	1003	{
1022	LOG (llevDebug, "converter output price higher than input: %s at %s (%d, %d) in value %d, out value %d for %s\n",	1004	LOG (llevDebug, "converter output price higher than input: %s at %s (%d, %d) in value %d, out value %d for %s\n",
1023	&converter->name, &converter->map->path, converter->x, converter->y, price_in, item->nrof * item->value, &item->name);	1005	&converter->name, &converter->map->path, converter->x, converter->y, price_in, item->nrof * item->value, &item->name);
1024	/**	1006	/**
1025	* elmex: we are going to let the game continue, as the mapcreator	1007	* elmex: we are going to let the game continue, as the mapcreator
1026	* hopefully had something in mind when doing this.	1008	* hopefully had something in mind when doing this.
1027	*/	1009	*/
1028	}	1010	}
1029		1011
1030	SET_FLAG (item, FLAG_IDENTIFIED);	1012	// elmex: only identify if we need to, for example so that generated money doesn't
		1013	// get an 'identified' flag so easily.
		1014	if (need_identify (item))
		1015	identify (item);
		1016
1031	insert_ob_in_map_at (item, converter->map, converter, 0, converter->x, converter->y);	1017	insert_ob_in_map_at (item, converter->map, converter, 0, converter->x, converter->y);
1032	return 1;	1018	return 1;
1033	}	1019	}
1034		1020
1035	/**	1021	/**
…		…
1131	/* push_button (altar);*/	1117	/* push_button (altar);*/
1132	}	1118	}
1133	else	1119	else
1134	{	1120	{
1135	altar->value = 1; /* works only once */	1121	altar->value = 1; /* works only once */
1136	push_button (altar);	1122	push_button (altar, originator);
1137	}	1123	}
1138		1124
1139	return !sacrifice;	1125	return !sacrifice;
1140	}	1126	}
1141	else	1127	else
…		…
1167	{	1153	{
1168	has_unpaid = true;	1154	has_unpaid = true;
1169	break;	1155	break;
1170	}	1156	}
1171		1157
1172	if (op->type != PLAYER)	1158	if (!op->is_player ())
1173	{	1159	{
1174	/* Remove all the unpaid objects that may be carried here.	1160	/* Remove all the unpaid objects that may be carried here.
1175	* This could be pets or monsters that are somehow in	1161	* This could be pets or monsters that are somehow in
1176	* the shop.	1162	* the shop.
1177	*/	1163	*/
…		…
1181		1167
1182	if (QUERY_FLAG (tmp, FLAG_UNPAID))	1168	if (QUERY_FLAG (tmp, FLAG_UNPAID))
1183	{	1169	{
1184	int i = find_free_spot (tmp, op->map, op->x, op->y, 1, 9);	1170	int i = find_free_spot (tmp, op->map, op->x, op->y, 1, 9);
1185		1171
		1172	if (i >= 0)
1186	tmp->remove ();	1173	tmp->move (i);
1187
1188	if (i == -1)
1189	i = 0;
1190
1191	tmp->map = op->map;
1192	tmp->x = op->x + freearr_x[i];
1193	tmp->y = op->y + freearr_y[i];
1194	insert_ob_in_map (tmp, op->map, op, 0);
1195	}	1174	}
1196	}	1175	}
1197		1176
1198	/* Don't teleport things like spell effects */	1177	/* Don't teleport things like spell effects */
1199	if (QUERY_FLAG (op, FLAG_NO_PICK))	1178	if (QUERY_FLAG (op, FLAG_NO_PICK))
…		…
1210	if (i != -1)	1189	if (i != -1)
1211	rv = transfer_ob (op, op->x + freearr_x[i], op->y + freearr_y[i], 0, shop_mat);	1190	rv = transfer_ob (op, op->x + freearr_x[i], op->y + freearr_y[i], 0, shop_mat);
1212		1191
1213	return 0;	1192	return 0;
1214	}	1193	}
		1194
1215	/* Removed code that checked for multipart objects - it appears that	1195	/* Removed code that checked for multipart objects - it appears that
1216	* the teleport function should be able to handle this just fine.	1196	* the teleport function should be able to handle this just fine.
1217	*/	1197	*/
1218	rv = teleport (shop_mat, SHOP_MAT, op);	1198	rv = teleport (shop_mat, SHOP_MAT, op);
1219	}	1199	}
…		…
1274	* Handles applying a sign.	1254	* Handles applying a sign.
1275	*/	1255	*/
1276	static void	1256	static void
1277	apply_sign (object *op, object *sign, int autoapply)	1257	apply_sign (object *op, object *sign, int autoapply)
1278	{	1258	{
1279	readable_message_type *msgType;	1259	if (!op->is_player())
		1260	return;
		1261
		1262	if (sign->has_dialogue ())
		1263	{
		1264	op->statusmsg (format ("Maybe you should I<talk> to the %s instead?", &sign->name));
		1265	return;
		1266	}
1280		1267
1281	if (!sign->msg)	1268	if (!sign->msg)
1282	{	1269	{
1283	op->statusmsg ("Nothing is written on it.");	1270	op->contr->infobox (MSG_CHANNEL ("examine"),
		1271	format ("T<%s>\n\n Nothing %sis written on it.",
		1272	&sign->name,
		1273	sign->name == sign->arch->name ? "" : "else "));
1284	return;	1274	return;
1285	}	1275	}
1286		1276
1287	if (sign->stats.food)	1277	if (sign->stats.food)
1288	{	1278	{
1289	if (sign->last_eat >= sign->stats.food)	1279	if (sign->last_eat >= sign->stats.food)
1290	{	1280	{
1291	if (!sign->move_on)	1281	if (!sign->move_on)
1292	op->statusmsg ("You cannot read it anymore.");	1282	op->failmsg ("You cannot read it anymore.");
1293		1283
1294	return;	1284	return;
1295	}	1285	}
1296		1286
1297	if (!QUERY_FLAG (op, FLAG_WIZPASS))	1287	if (!QUERY_FLAG (op, FLAG_WIZPASS))
…		…
1310	}	1300	}
1311		1301
1312	if (op->contr)	1302	if (op->contr)
1313	if (client *ns = op->contr->ns)	1303	if (client *ns = op->contr->ns)
1314	{	1304	{
		1305	if (sign->sound)
1315	ns->play_sound (sign->sound);	1306	ns->play_sound (sign->sound);
1316	msgType = get_readable_message_type (sign);	1307	else if (autoapply)
		1308	ns->play_sound (sound_find ("msg_voice"));
1317		1309
1318	if (ns->can_msg)	1310	op->contr->infobox (MSG_CHANNEL ("examine"), format ("T<%s>\n\n%s", &sign->name, &sign->msg));
1319	ns->send_msg (NDI_NAVY, msgType->msgtype, &sign->msg);
1320	else
1321	{
1322	char newbuf[HUGE_BUF];
1323	snprintf (newbuf, sizeof (newbuf), "%u %s", autoapply ? 1 : 0, &sign->msg);
1324	draw_ext_info (NDI_UNIQUE | NDI_NAVY, 0, op, msgType->message_type, msgType->message_subtype, newbuf, &sign->msg);
1325	}
1326	}	1311	}
		1312	}
		1313
		1314	static void
		1315	move_apply_hole (object *trap, object *victim)
		1316	{
		1317	/* Hole not open? */
		1318	if (trap->stats.wc > 0)
		1319	return;
		1320
		1321	/* Is this a multipart monster and not the head? If so, return.
		1322	* Processing will happen if the head runs into the pit
		1323	*/
		1324	if (victim->head)
		1325	return;
		1326
		1327	// now find all possible locations and randomly pick one
		1328	int dir = find_free_spot (victim, trap->map, EXIT_X (trap), EXIT_Y (trap), 0,
		1329	trap->range >= 3 ? SIZEOFFREE3 + 1
		1330	: trap->range >= 2 ? SIZEOFFREE2 + 1
		1331	: trap->range >= 1 ? SIZEOFFREE1 + 1
		1332	: SIZEOFFREE0 + 1);
		1333
		1334	if (dir < 0)
		1335	return;
		1336
		1337	victim->play_sound (trap->sound ? trap->sound : sound_find ("fall_hole"));
		1338	victim->statusmsg ("You fall through the hole!", NDI_RED);
		1339
		1340	transfer_ob (victim,
		1341	EXIT_X (trap) + freearr_x[dir],
		1342	EXIT_Y (trap) + freearr_y[dir],
		1343	0, victim);
1327	}	1344	}
1328		1345
1329	/**	1346	/**
1330	* 'victim' moves onto 'trap'	1347	* 'victim' moves onto 'trap'
1331	* 'victim' leaves 'trap'	1348	* 'victim' leaves 'trap'
…		…
1406	}	1423	}
1407	goto leave;	1424	goto leave;
1408		1425
1409	case BUTTON:	1426	case BUTTON:
1410	case PEDESTAL:	1427	case PEDESTAL:
1411	update_button (trap);	1428	update_button (trap, originator);
1412	goto leave;	1429	goto leave;
1413		1430
1414	case ALTAR:	1431	case ALTAR:
1415	/* sacrifice victim on trap */	1432	/* sacrifice victim on trap */
1416	apply_altar (trap, victim, originator);	1433	apply_altar (trap, victim, originator);
…		…
1443		1460
1444	if (!trap->value)	1461	if (!trap->value)
1445	{	1462	{
1446	int tot;	1463	int tot;
1447		1464
1448	for (ab = trap->above, tot = 0; ab != NULL; ab = ab->above)	1465	for (ab = trap->above, tot = 0; ab; ab = ab->above)
1449	if ((ab->move_type && trap->move_on) || ab->move_type == 0)	1466	if ((ab->move_type && trap->move_on) || ab->move_type == 0)
1450	tot += (ab->nrof ? ab->nrof : 1) * ab->weight + ab->carrying;	1467	tot += ab->head_ ()->total_weight ();
1451		1468
1452	if (!(trap->value = (tot > trap->weight) ? 1 : 0))	1469	if (!(trap->value = (tot > trap->weight) ? 1 : 0))
1453	goto leave;	1470	goto leave;
1454		1471
1455	SET_ANIMATION (trap, trap->value);	1472	SET_ANIMATION (trap, trap->value);
…		…
1480		1497
1481	case CONVERTER:	1498	case CONVERTER:
1482	if (convert_item (victim, trap) < 0)	1499	if (convert_item (victim, trap) < 0)
1483	{	1500	{
1484	originator->failmsg (format ("The %s seems to be broken!", query_name (trap)));	1501	originator->failmsg (format ("The %s seems to be broken!", query_name (trap)));
1485	get_archetype ("burnout")->insert_at (trap, trap);	1502	archetype::get (shstr_burnout)->insert_at (trap, trap);
1486	}	1503	}
1487		1504
1488	goto leave;	1505	goto leave;
1489		1506
1490	case TRIGGER_BUTTON:	1507	case TRIGGER_BUTTON:
…		…
1500	case CHECK_INV:	1517	case CHECK_INV:
1501	check_inv (victim, trap);	1518	check_inv (victim, trap);
1502	goto leave;	1519	goto leave;
1503		1520
1504	case HOLE:	1521	case HOLE:
1505	/* Hole not open? */	1522	move_apply_hole (trap, victim);
1506	if (trap->stats.wc > 0)
1507	goto leave;
1508
1509	/* Is this a multipart monster and not the head? If so, return.
1510	* Processing will happen if the head runs into the pit
1511	*/
1512	if (victim->head)
1513	goto leave;
1514
1515	victim->play_sound (trap->sound ? trap->sound : sound_find ("fall_hole"));
1516	victim->statusmsg ("You fall through the hole!", NDI_RED);
1517	transfer_ob (victim, EXIT_X (trap), EXIT_Y (trap), 1, victim);
1518	goto leave;	1523	goto leave;
1519		1524
1520	case EXIT:	1525	case EXIT:
1521	if (victim->type == PLAYER && EXIT_PATH (trap))	1526	if (victim->type == PLAYER && EXIT_PATH (trap))
1522	{	1527	{
1523	/* Basically, don't show exits leading to random maps the	1528	/* Basically, don't show exits leading to random maps the
1524	* players output.	1529	* players output.
1525	*/	1530	*/
1526	if (trap->msg && strncmp (EXIT_PATH (trap), "/!", 2))	1531	if (trap->msg && !EXIT_PATH (trap).starts_with ("/!"))
1527	victim->statusmsg (trap->msg, NDI_NAVY);	1532	victim->statusmsg (trap->msg, NDI_NAVY);
1528		1533
		1534	trap->play_sound (trap->sound);
1529	victim->enter_exit (trap);	1535	victim->enter_exit (trap);
1530	}	1536	}
1531	goto leave;	1537	goto leave;
1532		1538
1533	case ENCOUNTER:	1539	case ENCOUNTER:
…		…
1600	}	1606	}
1601		1607
1602	lev_diff = tmp->level - (skill_ob->level + 5);	1608	lev_diff = tmp->level - (skill_ob->level + 5);
1603	if (!QUERY_FLAG (op, FLAG_WIZ) && lev_diff > 0)	1609	if (!QUERY_FLAG (op, FLAG_WIZ) && lev_diff > 0)
1604	{	1610	{
1605	op->failmsg (lev_diff < 2 ? "This book is just barely beyond your comprehension."	1611	op->failmsg (lev_diff < 2 ? "This book is just barely beyond your comprehension."
1606	: lev_diff < 3 ? "This book is slightly beyond your comprehension."	1612	: lev_diff < 3 ? "This book is slightly beyond your comprehension."
1607	: lev_diff < 5 ? "This book is beyond your comprehension."	1613	: lev_diff < 5 ? "This book is beyond your comprehension."
1608	: lev_diff < 8 ? "This book is quite a bit beyond your comprehension."	1614	: lev_diff < 8 ? "This book is quite a bit beyond your comprehension."
1609	: lev_diff < 15 ? "This book is way beyond your comprehension."	1615	: lev_diff < 15 ? "This book is way beyond your comprehension."
1610	: "This book is totally beyond your comprehension.");	1616	: "This book is totally beyond your comprehension.");
…		…
1613		1619
1614	readable_message_type *msgType = get_readable_message_type (tmp);	1620	readable_message_type *msgType = get_readable_message_type (tmp);
1615		1621
1616	if (player *pl = op->contr)	1622	if (player *pl = op->contr)
1617	if (client *ns = pl->ns)	1623	if (client *ns = pl->ns)
1618	if (ns->can_msg)	1624	pl->infobox (MSG_CHANNEL ("book"), format ("T<%s>\n\n%s", (char *)long_desc (tmp, op), &tmp->msg));
1619	{
1620	dynbuf_text buf;
1621	buf << long_desc (tmp, op)
1622	<< "\n\n"
1623	<< tmp->msg
1624	<< '\0';
1625	ns->send_msg (NDI_NAVY, msgType->msgtype, buf.linearise ());
1626	}
1627	else
1628	draw_ext_info_format (NDI_UNIQUE | NDI_NAVY, 0, op,
1629	msgType->message_type, msgType->message_subtype,
1630	"You open the %s and start reading.\n%s", (char *)"%s\n%s",
1631	long_desc (tmp, op), &tmp->msg);
1632		1625
1633	/* gain xp from reading */	1626	/* gain xp from reading */
1634	if (!QUERY_FLAG (tmp, FLAG_NO_SKILL_IDENT))	1627	if (!QUERY_FLAG (tmp, FLAG_NO_SKILL_IDENT))
1635	{ /* only if not read before */	1628	{ /* only if not read before */
1636	int exp_gain = calc_skill_exp (op, tmp, skill_ob);	1629	int exp_gain = calc_skill_exp (op, tmp, skill_ob);
…		…
1638	if (!QUERY_FLAG (tmp, FLAG_IDENTIFIED))	1631	if (!QUERY_FLAG (tmp, FLAG_IDENTIFIED))
1639	{	1632	{
1640	/*exp_gain *= 2; because they just identified it too */	1633	/*exp_gain *= 2; because they just identified it too */
1641	SET_FLAG (tmp, FLAG_IDENTIFIED);	1634	SET_FLAG (tmp, FLAG_IDENTIFIED);
1642		1635
1643	/* If in a container, update how it looks */	1636	if (object *pl = tmp->visible_to ())
1644	if (tmp->env)
1645	esrv_update_item (UPD_FLAGS | UPD_NAME, op, tmp);	1637	esrv_update_item (UPD_FLAGS | UPD_NAME, pl, tmp);
1646	else
1647	op->contr->ns->floorbox_update ();
1648	}	1638	}
1649		1639
1650	change_exp (op, exp_gain, skill_ob->skill, 0);	1640	change_exp (op, exp_gain, skill_ob->skill, 0);
1651	SET_FLAG (tmp, FLAG_NO_SKILL_IDENT); /* so no more xp gained from this book */	1641	SET_FLAG (tmp, FLAG_NO_SKILL_IDENT); /* so no more xp gained from this book */
1652	}	1642	}
…		…
1665	op->play_sound (sound_find ("generic_fail"));	1655	op->play_sound (sound_find ("generic_fail"));
1666	op->failmsg (format ("You already possess the knowledge held within the %s.", query_name (tmp)));	1656	op->failmsg (format ("You already possess the knowledge held within the %s.", query_name (tmp)));
1667	break;	1657	break;
1668		1658
1669	case 1:	1659	case 1:
1670	decrease_ob (tmp);	1660	tmp->decrease ();
1671	op->play_sound (sound_find ("skill_learn"));	1661	op->play_sound (sound_find ("skill_learn"));
1672	op->statusmsg (format ("You succeed in learning %s", &tmp->skill));	1662	op->statusmsg (format ("You succeed in learning %s", &tmp->skill));
1673	break;	1663	break;
1674		1664
1675	default:	1665	default:
1676	decrease_ob (tmp);	1666	tmp->decrease ();
1677	op->play_sound (sound_find ("generic_fail"));	1667	op->play_sound (sound_find ("generic_fail"));
1678	op->failmsg (format ("You fail to learn the knowledge of the %s.\n", query_name (tmp)));	1668	op->failmsg (format ("You fail to learn the knowledge of the %s.\n", query_name (tmp)));
1679	break;	1669	break;
1680	}	1670	}
1681	}	1671	}
…		…
1802	}	1792	}
1803		1793
1804	op->statusmsg (format ("The spellbook contains the %s level spell %s.", get_levelnumber (spell->level), &spell->name));	1794	op->statusmsg (format ("The spellbook contains the %s level spell %s.", get_levelnumber (spell->level), &spell->name));
1805		1795
1806	if (!QUERY_FLAG (tmp, FLAG_IDENTIFIED))	1796	if (!QUERY_FLAG (tmp, FLAG_IDENTIFIED))
1807	{
1808	identify (tmp);	1797	identify (tmp);
1809
1810	if (tmp->env)
1811	esrv_update_item (UPD_FLAGS | UPD_NAME, op, tmp);
1812	else
1813	op->contr->ns->floorbox_update ();
1814	}
1815		1798
1816	/* I removed the check for special_prayer_mark here - it didn't make	1799	/* I removed the check for special_prayer_mark here - it didn't make
1817	* a lot of sense - special prayers are not found in spellbooks, and	1800	* a lot of sense - special prayers are not found in spellbooks, and
1818	* if the player doesn't know the spell, doesn't make a lot of sense that	1801	* if the player doesn't know the spell, doesn't make a lot of sense that
1819	* they would have a special prayer mark.	1802	* they would have a special prayer mark.
…		…
1872	{	1855	{
1873	op->contr->play_sound (sound_find ("fumble_spell"));	1856	op->contr->play_sound (sound_find ("fumble_spell"));
1874	op->failmsg ("You fail to learn the spell. H<Wis (priests) or Int (wizards) governs the chance of learning a prayer or spell.>\n");	1857	op->failmsg ("You fail to learn the spell. H<Wis (priests) or Int (wizards) governs the chance of learning a prayer or spell.>\n");
1875	}	1858	}
1876		1859
1877	decrease_ob (tmp);	1860	tmp->decrease ();
1878	}	1861	}
1879		1862
1880	/**	1863	/**
1881	* Handles applying a spell scroll.	1864	* Handles applying a spell scroll.
1882	*/	1865	*/
…		…
1921	identify (tmp);	1904	identify (tmp);
1922		1905
1923	op->statusmsg (format ("The scroll of %s turns to dust.", &tmp->inv->name));	1906	op->statusmsg (format ("The scroll of %s turns to dust.", &tmp->inv->name));
1924		1907
1925	cast_spell (op, tmp, dir, tmp->inv, NULL);	1908	cast_spell (op, tmp, dir, tmp->inv, NULL);
1926	decrease_ob (tmp);	1909	tmp->decrease ();
1927	}	1910	}
1928		1911
1929	/**	1912	/**
1930	* Applies a treasure object - by default, chest. op	1913	* Applies a treasure object - by default, chest. op
1931	* is the person doing the applying, tmp is the treasure	1914	* is the person doing the applying, tmp is the treasure
…		…
1943	object *treas = tmp->inv;	1926	object *treas = tmp->inv;
1944		1927
1945	if (!treas)	1928	if (!treas)
1946	{	1929	{
1947	op->statusmsg ("The chest was empty.");	1930	op->statusmsg ("The chest was empty.");
1948	decrease_ob (tmp);	1931	tmp->decrease ();
1949	return;	1932	return;
1950	}	1933	}
1951		1934
1952	while (tmp->inv)	1935	while (tmp->inv)
1953	{	1936	{
…		…
1969	if (op->destroyed () || tmp->destroyed ())	1952	if (op->destroyed () || tmp->destroyed ())
1970	break;	1953	break;
1971	}	1954	}
1972		1955
1973	if (!tmp->destroyed () && !tmp->inv)	1956	if (!tmp->destroyed () && !tmp->inv)
1974	decrease_ob (tmp);	1957	tmp->decrease (true);
1975	}	1958	}
1976		1959
1977	/**	1960	/**
1978	* op eats food.	1961	* op eats food.
1979	* If player, takes care of messages and dragon special food.	1962	* If player, takes care of messages and dragon special food.
…		…
1998	if (tmp->type == FOOD || tmp->type == FLESH)	1981	if (tmp->type == FOOD || tmp->type == FLESH)
1999	op->failmsg ("You feel full, but what a waste of food!");	1982	op->failmsg ("You feel full, but what a waste of food!");
2000	else	1983	else
2001	op->statusmsg ("Most of the drink goes down your face not your throat!");	1984	op->statusmsg ("Most of the drink goes down your face not your throat!");
2002	}	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	);
2003		1994
2004	if (!QUERY_FLAG (tmp, FLAG_CURSED))	1995	if (!QUERY_FLAG (tmp, FLAG_CURSED))
2005	{	1996	{
2006	const char *buf;	1997	const char *buf;
2007		1998
…		…
2037	eat_special_food (op, tmp);	2028	eat_special_food (op, tmp);
2038	}	2029	}
2039	}	2030	}
2040		2031
2041	handle_apply_yield (tmp);	2032	handle_apply_yield (tmp);
2042	decrease_ob (tmp);	2033	tmp->decrease ();
2043	}	2034	}
2044		2035
2045	/**	2036	/**
2046	* A dragon is eating some flesh. If the flesh contains resistances,	2037	* A dragon is eating some flesh. If the flesh contains resistances,
2047	* there is a chance for the dragon's skin to get improved.	2038	* there is a chance for the dragon's skin to get improved.
…		…
2166	op->statusmsg (buf);	2157	op->statusmsg (buf);
2167		2158
2168	/* now choose a winner if we have any */	2159	/* now choose a winner if we have any */
2169	i = -1;	2160	i = -1;
2170	if (winners > 0)	2161	if (winners > 0)
2171	i = atnr_winner[RANDOM () % winners];	2162	i = atnr_winner [rndm (winners)];
2172		2163
2173	if (i >= 0 && i < NROFATTACKS && skin->resist[i] < 95)	2164	if (i >= 0 && i < NROFATTACKS && skin->resist[i] < 95)
2174	{	2165	{
2175	/* resistance increased! */	2166	/* resistance increased! */
2176	skin->resist[i]++;	2167	skin->resist[i]++;
…		…
2235		2226
2236	op->statusmsg ("Applying armour enchantment.");	2227	op->statusmsg ("Applying armour enchantment.");
2237	improve_armour (op, tmp, armor);	2228	improve_armour (op, tmp, armor);
2238	}	2229	}
2239		2230
2240	extern void	2231	void
2241	apply_poison (object *op, object *tmp)	2232	apply_poison (object *op, object *tmp)
2242	{	2233	{
		2234	// need to do it now when it is still on the map
		2235	handle_apply_yield (tmp);
		2236
		2237	object *poison = tmp->split (1);
		2238
2243	if (op->type == PLAYER)	2239	if (op->type == PLAYER)
2244	{	2240	{
2245	op->contr->play_sound (sound_find ("drink_poison"));	2241	op->contr->play_sound (sound_find ("drink_poison"));
2246	op->failmsg ("Yech! That tasted poisonous!");	2242	op->failmsg ("Yech! That tasted poisonous!");
2247	strcpy (op->contr->killer, "poisonous booze");	2243	op->contr->killer = poison;
2248	}	2244	}
2249		2245
2250	if (tmp->stats.hp > 0)	2246	if (poison->stats.hp > 0)
2251	{	2247	{
2252	LOG (llevDebug, "Trying to poison player/monster for %d hp\n", tmp->stats.hp);	2248	LOG (llevDebug, "Trying to poison player/monster for %d hp\n", poison->stats.hp);
2253	hit_player (op, tmp->stats.hp, tmp, AT_POISON, 1);	2249	hit_player (op, poison->stats.hp, tmp, AT_POISON, 1);
2254	}	2250	}
2255		2251
2256	op->stats.food -= op->stats.food / 4;	2252	op->stats.food -= op->stats.food / 4;
2257	handle_apply_yield (tmp);	2253	poison->destroy ();
2258	decrease_ob (tmp);
2259	}	2254	}
2260		2255
2261	/**	2256	/**
2262	* This function return true if the exit is not a 2 ways one or it is 2 ways, valid exit.	2257	* This function return true if the exit is not a 2 ways one or it is 2 ways, valid exit.
2263	* A valid 2 way exit means:	2258	* A valid 2 way exit means:
…		…
2278		2273
2279	#if 0 //TODO	2274	#if 0 //TODO
2280	if (!has_been_loaded (EXIT_PATH (exit)) && exit->race)	2275	if (!has_been_loaded (EXIT_PATH (exit)) && exit->race)
2281	return 0; /* This is a reset town portal */	2276	return 0; /* This is a reset town portal */
2282	#endif	2277	#endif
		2278
		2279	LOG (llevError | logBacktrace, "sync map load due to %s\n", exit->debug_desc ());
2283		2280
2284	maptile *exitmap = maptile::find_sync (EXIT_PATH (exit), exit->map);	2281	maptile *exitmap = maptile::find_sync (EXIT_PATH (exit), exit->map);
2285		2282
2286	if (exitmap)	2283	if (exitmap)
2287	{	2284	{
…		…
2363	* them in this function - they are passed to apply_special	2360	* them in this function - they are passed to apply_special
2364	*/	2361	*/
2365	int	2362	int
2366	manual_apply (object *op, object *tmp, int aflag)	2363	manual_apply (object *op, object *tmp, int aflag)
2367	{	2364	{
2368	if (tmp->head)
2369	tmp = tmp->head;	2365	tmp = tmp->head_ ();
2370		2366
2371	if (QUERY_FLAG (tmp, FLAG_UNPAID) && !QUERY_FLAG (tmp, FLAG_APPLIED))	2367	if (QUERY_FLAG (tmp, FLAG_UNPAID) && !QUERY_FLAG (tmp, FLAG_APPLIED))
2372	{	2368	{
2373	if (op->type == PLAYER)	2369	if (op->type == PLAYER)
2374	{	2370	{
…		…
2388	op->play_sound (sound_find ("turn_handle"));	2384	op->play_sound (sound_find ("turn_handle"));
2389	op->statusmsg ("You turn the handle.");	2385	op->statusmsg ("You turn the handle.");
2390	tmp->value = tmp->value ? 0 : 1;	2386	tmp->value = tmp->value ? 0 : 1;
2391	SET_ANIMATION (tmp, tmp->value);	2387	SET_ANIMATION (tmp, tmp->value);
2392	update_object (tmp, UP_OBJ_FACE);	2388	update_object (tmp, UP_OBJ_FACE);
2393	push_button (tmp);	2389	push_button (tmp, op);
2394	return 1;	2390	return 1;
2395		2391
2396	case TRIGGER:	2392	case TRIGGER:
2397	if (check_trigger (tmp, op))	2393	if (check_trigger (tmp, op))
2398	{	2394	{
…		…
2411	if (!EXIT_PATH (tmp) || !is_legal_2ways_exit (op, tmp))	2407	if (!EXIT_PATH (tmp) || !is_legal_2ways_exit (op, tmp))
2412	op->failmsg (format ("The %s is closed.", query_name (tmp)));	2408	op->failmsg (format ("The %s is closed.", query_name (tmp)));
2413	else	2409	else
2414	{	2410	{
2415	/* Don't display messages for random maps. */	2411	/* Don't display messages for random maps. */
2416	if (tmp->msg && strncmp (EXIT_PATH (tmp), "/!", 2))	2412	if (tmp->msg && !EXIT_PATH (tmp).starts_with ("/!"))
2417	op->statusmsg (tmp->msg, NDI_NAVY);	2413	op->statusmsg (tmp->msg, NDI_NAVY);
2418		2414
2419	op->enter_exit (tmp);	2415	op->enter_exit (tmp);
2420	}	2416	}
2421		2417
…		…
2582	default:	2578	default:
2583	return 0;	2579	return 0;
2584	}	2580	}
2585	}	2581	}
2586		2582
2587
2588	/* quiet suppresses the "don't know how to apply" and "you must get it first"	2583	/* quiet suppresses the "don't know how to apply" and "you must get it first"
2589	* messages as needed by player_apply_below(). But there can still be	2584	* messages as needed by player_apply_below(). But there can still be
2590	* "but you are floating high above the ground" messages.	2585	* "but you are floating high above the ground" messages.
2591	*	2586	*
2592	* Same return value as apply() function.	2587	* Same return value as apply() function.
2593	*/	2588	*/
2594	int	2589	int
2595	player_apply (object *pl, object *op, int aflag, int quiet)	2590	player_apply (object *pl, object *op, int aflag, int quiet)
2596	{	2591	{
2597	int tmp;
2598
2599	if (op->env && (pl->move_type & MOVE_FLYING))	2592	if (!op->env && (pl->move_type & MOVE_FLYING))
2600	{	2593	{
2601	/* player is flying and applying object not in inventory */	2594	/* player is flying and applying object not in inventory */
2602	if (!QUERY_FLAG (pl, FLAG_WIZ) && !(op->move_type & MOVE_FLYING))	2595	if (!QUERY_FLAG (pl, FLAG_WIZ) && !(op->move_type & MOVE_FLYING))
2603	{	2596	{
2604	op->failmsg ("But you are floating high above the ground! H<You have to stop levitating first, if you can.>");	2597	pl->failmsg ("But you are floating high above the ground! "
		2598	"H<You have to stop levitating first, if you can, either by using your levitation skill, "
		2599	"or waiting till the levitation effect wears off.>");
2605	return 0;	2600	return 0;
2606	}	2601	}
2607	}	2602	}
2608		2603
2609	pl->contr->last_used = op;	2604	pl->contr->last_used = op;
2610		2605
2611	tmp = manual_apply (pl, op, aflag);	2606	int tmp = manual_apply (pl, op, aflag);
		2607
2612	if (!quiet)	2608	if (!quiet)
2613	{	2609	{
2614	if (tmp == 0)	2610	if (tmp == 0)
2615	op->statusmsg (format ("I don't know how to apply the %s.", query_name (op)));	2611	pl->statusmsg (format ("I don't know how to apply the %s.", query_name (op)));
2616	else if (tmp == 2)	2612	else if (tmp == 2)
2617	op->failmsg ("You must get it first!\n");	2613	pl->failmsg ("You must get it first!\n");
2618	}	2614	}
2619		2615
2620	return tmp;	2616	return tmp;
2621	}	2617	}
2622		2618
…		…
2651	* person moving on it, also activate. Added code to make it	2647	* person moving on it, also activate. Added code to make it
2652	* so that at least one of players movement types be that which	2648	* so that at least one of players movement types be that which
2653	* the item needs.	2649	* the item needs.
2654	*/	2650	*/
2655	if (!tmp->invisible || (tmp->move_on & pl->move_type))	2651	if (!tmp->invisible || (tmp->move_on & pl->move_type))
2656	{
2657	if (player_apply (pl, tmp, 0, 1) == 1)	2652	if (player_apply (pl, tmp, 0, 1) == 1)
2658	return;	2653	return;
2659	}	2654
2660	if (floors >= 2)	2655	if (floors >= 2)
2661	return; /* process at most two floor objects */	2656	return; /* process at most two floor objects */
2662	}	2657	}
2663	}	2658	}
2664		2659
…		…
2708	break;	2703	break;
2709		2704
2710	case SKILL:	2705	case SKILL:
2711	if (who->contr)	2706	if (who->contr)
2712	{	2707	{
		2708	if (IS_COMBAT_SKILL (op->subtype))
		2709	who->change_weapon (who->contr->combat_ob = 0);
		2710	else if (IS_RANGED_SKILL (op->subtype))
		2711	who->change_weapon (who->contr->ranged_ob = 0);
		2712
2713	if (!op->invisible)	2713	if (op->invisible)
		2714	who->statusmsg (format ("You can no longer use the skill: %s.", &op->skill));
		2715	else
2714	who->statusmsg (format ("You stop using the %s.", query_name (op)));	2716	who->statusmsg (format ("You stop using the %s.", query_name (op)));
2715	else
2716	who->statusmsg (format ("You can no longer use the skill: %s.", &op->skill));
2717	}	2717	}
2718		2718
2719	change_abil (who, op);	2719	change_abil (who, op);
2720	CLEAR_FLAG (who, FLAG_READY_SKILL);	2720	CLEAR_FLAG (who, FLAG_READY_SKILL);
2721	break;	2721	break;
…		…
2748	CLEAR_FLAG (tmp2, FLAG_APPLIED);	2748	CLEAR_FLAG (tmp2, FLAG_APPLIED);
2749		2749
2750	if (QUERY_FLAG (op, FLAG_INV_LOCKED))	2750	if (QUERY_FLAG (op, FLAG_INV_LOCKED))
2751	SET_FLAG (tmp2, FLAG_INV_LOCKED);	2751	SET_FLAG (tmp2, FLAG_INV_LOCKED);
2752		2752
		2753	op->destroy ();
		2754	who->insert (tmp2);
		2755	who->update_stats ();
		2756
2753	if (who->contr)	2757	if (who->contr)
2754	esrv_del_item (who->contr, op->count);
2755
2756	op->destroy ();
2757	insert_ob_in_ob (tmp2, who);
2758	who->update_stats ();
2759
2760	if (QUERY_FLAG (op, FLAG_CURSED) || QUERY_FLAG (op, FLAG_DAMNED))	2758	if (QUERY_FLAG (op, FLAG_CURSED) || QUERY_FLAG (op, FLAG_DAMNED))
2761	{
2762	if (who->contr)
2763	{	2759	{
2764	who->failmsg ("Oops, it feels deadly cold!");	2760	who->failmsg ("Oops, it feels deadly cold!");
2765	SET_FLAG (tmp2, FLAG_KNOWN_CURSED);	2761	SET_FLAG (tmp2, FLAG_KNOWN_CURSED);
2766	}	2762	}
2767	}
2768
2769	if (who->contr)
2770	esrv_send_item (who, tmp2);
2771	}	2763	}
2772		2764
2773	return 1; /* otherwise, an attempt to drop causes problems */	2765	return 1; /* otherwise, an attempt to drop causes problems */
2774		2766
2775	case BOW:	2767	case BOW:
…		…
2806	default:	2798	default:
2807	who->statusmsg (format ("You unapply %s.", query_name (op)));	2799	who->statusmsg (format ("You unapply %s.", query_name (op)));
2808	break;	2800	break;
2809	}	2801	}
2810		2802
		2803	if (aflags & AP_NO_MERGE || !merge_ob (op, 0))
		2804	if (object *pl = op->visible_to ())
		2805	esrv_send_item (pl, op);
		2806
2811	who->update_stats ();	2807	who->update_stats ();
2812
2813	if (!(aflags & AP_NO_MERGE))
2814	{
2815	object *tmp = merge_ob (op, 0);
2816
2817	if (who->contr)
2818	{
2819	if (tmp)
2820	{ /* it was merged */
2821	esrv_del_item (who->contr, op->count);
2822	op = tmp;
2823	}
2824
2825	esrv_send_item (who, op);
2826	}
2827	}
2828		2808
2829	return 0;	2809	return 0;
2830	}	2810	}
2831		2811
2832	/**	2812	/**
…		…
3130	return 1;	3110	return 1;
3131	}	3111	}
3132		3112
3133	return unapply_special (who, op, aflags);	3113	return unapply_special (who, op, aflags);
3134	}	3114	}
3135
3136	if (basic_flag == AP_UNAPPLY)	3115	else if (basic_flag == AP_UNAPPLY)
3137	return 0;	3116	return 0;
3138		3117
3139	// if the item is combat/ranged, wield the relevant slot first	3118	// if the item is combat/ranged, wield the relevant slot first
3140	// to resolve conflicts.	3119	// to resolve conflicts.
3141	if (player *pl = who->contr)	3120	if (player *pl = who->contr)
…		…
3211		3190
3212	/* Ok. We are now at the state where we can apply the new object.	3191	/* Ok. We are now at the state where we can apply the new object.
3213	* Note that we don't have the checks for can_use_...	3192	* Note that we don't have the checks for can_use_...
3214	* below - that is already taken care of by can_apply_object.	3193	* below - that is already taken care of by can_apply_object.
3215	*/	3194	*/
3216	if (op->nrof > 1)	3195	tmp = op->nrof > 1 ? op->split (op->nrof - 1) : 0;
3217	tmp = get_split_ob (op, op->nrof - 1);
3218	else
3219	tmp = 0;
3220		3196
3221	if (INVOKE_OBJECT (BE_READY, op, ARG_OBJECT (who)) || INVOKE_OBJECT (READY, who, ARG_OBJECT (op)))	3197	if (INVOKE_OBJECT (BE_READY, op, ARG_OBJECT (who)) || INVOKE_OBJECT (READY, who, ARG_OBJECT (op)))
3222	return RESULT_INT (0);	3198	return RESULT_INT (0);
3223		3199
3224	switch (op->type)	3200	switch (op->type)
3225	{	3201	{
3226	case WEAPON:	3202	case WEAPON:
3227	if (!check_weapon_power (who, op->last_eat))	3203	if (!check_weapon_power (who, op->last_eat))
3228	{	3204	{
3229	op->failmsg ("This weapon is too powerful for you to use. It would consume your soul!." LACK_ITEM_POWER);	3205	op->failmsg ("This weapon is too powerful for you to use. It would consume your soul!" LACK_ITEM_POWER);
3230		3206
3231	if (tmp)	3207	if (tmp)
3232	insert_ob_in_ob (tmp, who);	3208	insert_ob_in_ob (tmp, who);
3233		3209
3234	return 1;	3210	return 1;
3235	}	3211	}
3236		3212
3237	//TODO: this obviously fails for players using a shorter prefix	3213	//TODO: this obviously fails for players using a shorter prefix
3238	// i.e. "R" can use Ragnarok's sword.	3214	// i.e. "R" can use Ragnarok's sword.
3239	if (op->level && (strncmp (op->name, who->name, strlen (who->name))))	3215	if (op->level && !op->name.starts_with (who->name))
3240	{	3216	{
3241	/* if the weapon does not have the name as the character, can't use it. */	3217	/* if the weapon does not have the name as the character, can't use it. */
3242	/* (Ragnarok's sword attempted to be used by Foo: won't work) */	3218	/* (Ragnarok's sword attempted to be used by Foo: won't work) */
3243	who->failmsg ("The weapon does not recognize you as its owner. H<Its name indicates that it belongs to somebody else.>");	3219	who->failmsg ("The weapon does not recognize you as its owner. H<Its name indicates that it belongs to somebody else.>");
3244		3220
…		…
3299	SET_FLAG (tmp2, FLAG_APPLIED);	3275	SET_FLAG (tmp2, FLAG_APPLIED);
3300		3276
3301	if (QUERY_FLAG (op, FLAG_INV_LOCKED))	3277	if (QUERY_FLAG (op, FLAG_INV_LOCKED))
3302	SET_FLAG (tmp2, FLAG_INV_LOCKED);	3278	SET_FLAG (tmp2, FLAG_INV_LOCKED);
3303		3279
3304	insert_ob_in_ob (tmp2, who);	3280	who->insert (tmp2);
3305		3281
3306	/* Remove the old lantern */	3282	/* Remove the old lantern */
3307	if (who->type == PLAYER)
3308	esrv_del_item (who->contr, op->count);
3309
3310	op->destroy ();	3283	op->destroy ();
3311		3284
3312	/* insert the portion that was split off */	3285	/* insert the portion that was split off */
3313	if (tmp)	3286	if (tmp)
3314	{	3287	who->insert (tmp);
3315	insert_ob_in_ob (tmp, who);
3316	if (who->type == PLAYER)
3317	esrv_send_item (who, tmp);
3318	}
3319		3288
3320	who->update_stats ();	3289	who->update_stats ();
3321		3290
3322	if (QUERY_FLAG (op, FLAG_CURSED) || QUERY_FLAG (op, FLAG_DAMNED))	3291	if (QUERY_FLAG (op, FLAG_CURSED) || QUERY_FLAG (op, FLAG_DAMNED))
3323	if (who->type == PLAYER)	3292	if (who->type == PLAYER)
3324	{	3293	{
3325	who->failmsg ("Oops, it feels deadly cold! H<Maybe it wasn't such a bright idea to apply this cursed/damned item.>");	3294	who->failmsg ("Oops, it feels deadly cold! H<Maybe it wasn't such a bright (hrhrhr) idea to apply this cursed or damned item.>");
3326	SET_FLAG (tmp2, FLAG_KNOWN_CURSED);	3295	SET_FLAG (tmp2, FLAG_KNOWN_CURSED);
3327	}	3296	}
3328
3329	if (who->type == PLAYER)
3330	esrv_send_item (who, tmp2);
3331		3297
3332	return 0;	3298	return 0;
3333		3299
3334	case SKILL_TOOL:	3300	case SKILL_TOOL:
3335	// applying a skill tool also readies the skill	3301	// applying a skill tool also readies the skill
…		…
3427	insert_ob_in_ob (tmp, who);	3393	insert_ob_in_ob (tmp, who);
3428		3394
3429	return 1;	3395	return 1;
3430	}	3396	}
3431		3397
3432	if (op->level && (strncmp (op->name, who->name, strlen (who->name))))	3398	if (op->level && !op->name.starts_with (who->name))
3433	{	3399	{
3434	who->failmsg ("The weapon does not recognize you as its owner. "	3400	who->failmsg ("The weapon does not recognize you as its owner. "
3435	"H<Its name indicates that it belongs to somebody else.>");	3401	"H<Its name indicates that it belongs to somebody else.>");
3436	if (tmp)	3402	if (tmp)
3437	insert_ob_in_ob (tmp, who);	3403	insert_ob_in_ob (tmp, who);
…		…
3495	}	3461	}
3496		3462
3497	SET_FLAG (op, FLAG_APPLIED);	3463	SET_FLAG (op, FLAG_APPLIED);
3498		3464
3499	if (tmp)	3465	if (tmp)
3500	tmp = insert_ob_in_ob (tmp, who);	3466	who->insert (tmp);
3501		3467
3502	who->update_stats ();	3468	who->update_stats ();
3503		3469
3504	/* We exclude spell casting objects. The fire code will set the	3470	/* We exclude spell casting objects. The fire code will set the
3505	* been applied flag when they are used - until that point,	3471	* been applied flag when they are used - until that point,
…		…
3511	if (QUERY_FLAG (op, FLAG_CURSED) || QUERY_FLAG (op, FLAG_DAMNED))	3477	if (QUERY_FLAG (op, FLAG_CURSED) || QUERY_FLAG (op, FLAG_DAMNED))
3512	if (who->type == PLAYER)	3478	if (who->type == PLAYER)
3513	{	3479	{
3514	who->failmsg (	3480	who->failmsg (
3515	"Oops, it feels deadly cold! "	3481	"Oops, it feels deadly cold! "
3516	"H<Maybe it wasn't such a bright idea to apply this cursed/damned item.>"	3482	"H<Maybe it wasn't such a bright idea to apply this cursed or damned item.>"
3517	);	3483	);
3518	SET_FLAG (op, FLAG_KNOWN_CURSED);	3484	SET_FLAG (op, FLAG_KNOWN_CURSED);
3519	}	3485	}
3520		3486
3521	if (who->type == PLAYER)	3487	if (object *pl = op->visible_to ())
3522	{
3523	/* if multiple objects were applied, update both slots */
3524	if (tmp)
3525	esrv_send_item (who, tmp);
3526
3527	esrv_send_item (who, op);	3488	esrv_send_item (pl, op);
3528	}
3529		3489
3530	return 0;	3490	return 0;
3531	}	3491	}
3532		3492
3533	int	3493	int
…		…
3547	int	3507	int
3548	auto_apply (object *op)	3508	auto_apply (object *op)
3549	{	3509	{
3550	object *tmp = NULL, *tmp2;	3510	object *tmp = NULL, *tmp2;
3551	int i;	3511	int i;
		3512
		3513	CLEAR_FLAG (op, FLAG_AUTO_APPLY);
3552		3514
3553	switch (op->type)	3515	switch (op->type)
3554	{	3516	{
3555	case SHOP_FLOOR:	3517	case SHOP_FLOOR:
3556	if (!op->has_random_items ())	3518	if (!op->has_random_items ())
…		…
3558		3520
3559	do	3521	do
3560	{	3522	{
3561	i = 10; /* let's give it 10 tries */	3523	i = 10; /* let's give it 10 tries */
3562	while ((tmp = generate_treasure (op->randomitems,	3524	while ((tmp = generate_treasure (op->randomitems,
3563	op->stats.exp ? (int) op->stats.exp : MAX (op->map->difficulty, 5))) == NULL && --i);	3525	op->stats.exp
		3526	? (int) op->stats.exp
		3527	: max (op->map->difficulty, 5)))
		3528	== NULL && --i);
		3529
3564	if (tmp == NULL)	3530	if (tmp == NULL)
3565	return 0;	3531	return 0;
		3532
3566	if (QUERY_FLAG (tmp, FLAG_CURSED) || QUERY_FLAG (tmp, FLAG_DAMNED))	3533	if (QUERY_FLAG (tmp, FLAG_CURSED) || QUERY_FLAG (tmp, FLAG_DAMNED))
3567	{	3534	{
3568	tmp->destroy ();	3535	tmp->destroy ();
3569	tmp = NULL;	3536	tmp = NULL;
3570	}	3537	}
…		…
3573		3540
3574	tmp->x = op->x;	3541	tmp->x = op->x;
3575	tmp->y = op->y;	3542	tmp->y = op->y;
3576	SET_FLAG (tmp, FLAG_UNPAID);	3543	SET_FLAG (tmp, FLAG_UNPAID);
3577	insert_ob_in_map (tmp, op->map, NULL, 0);	3544	insert_ob_in_map (tmp, op->map, NULL, 0);
3578	CLEAR_FLAG (op, FLAG_AUTO_APPLY);
3579	identify (tmp);	3545	identify (tmp);
3580	break;	3546	break;
3581		3547
3582	case TREASURE:	3548	case TREASURE:
3583	if (QUERY_FLAG (op, FLAG_IS_A_TEMPLATE))	3549	if (QUERY_FLAG (op, FLAG_IS_A_TEMPLATE))
…		…
3590	/* If we generated an object and put it in this object inventory,	3556	/* If we generated an object and put it in this object inventory,
3591	* move it to the parent object as the current object is about	3557	* move it to the parent object as the current object is about
3592	* to disappear. An example of this item is the random_* stuff	3558	* to disappear. An example of this item is the random_* stuff
3593	* that is put inside other objects.	3559	* that is put inside other objects.
3594	*/	3560	*/
3595	for (tmp = op->inv; tmp; tmp = tmp2)
3596	{
3597	tmp2 = tmp->below;
3598	tmp->remove ();
3599
3600	if (op->env)	3561	if (op->env)
3601	insert_ob_in_ob (tmp, op->env);	3562	while (op->inv)
3602	else	3563	op->env->insert (op->inv);
3603	tmp->destroy ();
3604	}
3605		3564
3606	op->destroy ();	3565	op->destroy ();
3607	break;	3566	break;
3608	}	3567	}
3609	return tmp ? 1 : 0;	3568
		3569	return !!tmp;
3610	}	3570	}
3611		3571
3612	/**	3572	/**
3613	* fix_auto_apply goes through the entire map every time a map	3573	* fix_auto_apply goes through the entire map every time a map
3614	* is loaded or swapped in and performs special actions for	3574	* is loaded or swapped in and performs special actions for
…		…
3628		3588
3629	if (tmp->inv)	3589	if (tmp->inv)
3630	{	3590	{
3631	object *invtmp, *invnext;	3591	object *invtmp, *invnext;
3632		3592
3633	for (invtmp = tmp->inv; invtmp != NULL; invtmp = invnext)	3593	for (invtmp = tmp->inv; invtmp; invtmp = invnext)
3634	{	3594	{
3635	invnext = invtmp->below;	3595	invnext = invtmp->below;
3636		3596
3637	if (QUERY_FLAG (invtmp, FLAG_AUTO_APPLY))	3597	if (QUERY_FLAG (invtmp, FLAG_AUTO_APPLY))
3638	auto_apply (invtmp);	3598	auto_apply (invtmp);
3639	else if (invtmp->type == TREASURE && invtmp->has_random_items ())	3599	else if (invtmp->type == TREASURE && invtmp->has_random_items ())
3640	{	3600	{
3641	while ((invtmp->stats.hp--) > 0)	3601	while (invtmp->stats.hp-- > 0)
3642	create_treasure (invtmp->randomitems, invtmp, 0, difficulty, 0);	3602	create_treasure (invtmp->randomitems, invtmp, 0, difficulty, 0);
3643		3603
3644	invtmp->randomitems = NULL;	3604	invtmp->randomitems = NULL;
3645	}	3605	}
3646	else if (invtmp && invtmp->arch	3606	else if (invtmp && invtmp->arch
…		…
3758	/* check for hp, sp change */	3718	/* check for hp, sp change */
3759	if (food->stats.hp != 0)	3719	if (food->stats.hp != 0)
3760	{	3720	{
3761	if (QUERY_FLAG (food, FLAG_CURSED))	3721	if (QUERY_FLAG (food, FLAG_CURSED))
3762	{	3722	{
3763	assign (who->contr->killer, food->name);	3723	who->contr->killer = food;
3764	hit_player (who, food->stats.hp, food, AT_POISON, 1);	3724	hit_player (who, food->stats.hp, food, AT_POISON, 1);
3765	who->failmsg ("Eck!...that was poisonous!");	3725	who->failmsg ("Eck!...that was poisonous!");
3766	}	3726	}
3767	else	3727	else
3768	{	3728	{
…		…
3772	who->failmsg ("Eck!...that was poisonous!");	3732	who->failmsg ("Eck!...that was poisonous!");
3773		3733
3774	who->stats.hp += food->stats.hp;	3734	who->stats.hp += food->stats.hp;
3775	}	3735	}
3776	}	3736	}
		3737
3777	if (food->stats.sp != 0)	3738	if (food->stats.sp != 0)
3778	{	3739	{
3779	if (QUERY_FLAG (food, FLAG_CURSED))	3740	if (QUERY_FLAG (food, FLAG_CURSED))
3780	{	3741	{
3781	who->failmsg ("You are drained of mana!");	3742	who->failmsg ("You are drained of mana!");
…		…
3808	item = find_marked_object (who);	3769	item = find_marked_object (who);
3809	if (item)	3770	if (item)
3810	{	3771	{
3811	if (lighter->last_eat && lighter->stats.food)	3772	if (lighter->last_eat && lighter->stats.food)
3812	{ /* lighter gets used up */	3773	{ /* lighter gets used up */
3813	/* Split multiple lighters if they're being used up. Otherwise *
3814	* one charge from each would be used up. --DAMN */
3815	if (lighter->nrof > 1)
3816	{
3817	object *oneLighter = lighter->clone ();	3774	object *oneLighter = lighter->split ();
3818
3819	lighter->nrof -= 1;
3820	oneLighter->nrof = 1;
3821	oneLighter->stats.food--;	3775	oneLighter->stats.food--;
3822	esrv_send_item (who, lighter);	3776	who->insert (oneLighter);
3823	oneLighter = insert_ob_in_ob (oneLighter, who);
3824	esrv_send_item (who, oneLighter);
3825	}
3826	else
3827	lighter->stats.food--;
3828	}	3777	}
3829	else if (lighter->last_eat)	3778	else if (lighter->last_eat)
3830	{	3779	{
3831	/* no charges left in lighter */	3780	/* no charges left in lighter */
3832	who->failmsg (format ("You attempt to light the %s with a used up %s.", &item->name, &lighter->name));	3781	who->failmsg (format ("You attempt to light the %s with a used up %s.", &item->name, &lighter->name));
…		…
3965	}	3914	}
3966		3915
3967	/* insert the randomitems from the change's treasurelist into	3916	/* insert the randomitems from the change's treasurelist into
3968	* the player ref: player.c	3917	* the player ref: player.c
3969	*/	3918	*/
3970	if (change->randomitems != NULL)	3919	if (change->randomitems)
3971	give_initial_items (pl, change->randomitems);	3920	give_initial_items (pl, change->randomitems);
3972		3921
3973	/* set up the face, for some races. */	3922	/* set up the face, for some races. */
3974		3923
3975	/* first, look for the force object banning	3924	/* first, look for the force object banning
3976	* changing the face. Certain races never change face with class.	3925	* changing the face. Certain races never change face with class.
3977	*/	3926	*/
3978	for (walk = pl->inv; walk != NULL; walk = walk->below)	3927	for (walk = pl->inv; walk; walk = walk->below)
3979	if (!strcmp (walk->name, "NOCLASSFACECHANGE"))	3928	if (walk->name == shstr_NOCLASSFACECHANGE)
3980	flag_change_face = 0;	3929	flag_change_face = 0;
3981		3930
3982	if (flag_change_face)	3931	if (flag_change_face)
3983	{	3932	{
3984	pl->animation_id = GET_ANIM_ID (change);
3985	pl->face = change->face;	3933	pl->face = change->face;
3986		3934	pl->animation_id = change->animation_id;
3987	if (QUERY_FLAG (change, FLAG_ANIMATE))	3935	pl->flag [FLAG_ANIMATE] = change->flag [FLAG_ANIMATE];
3988	SET_FLAG (pl, FLAG_ANIMATE);
3989	else
3990	CLEAR_FLAG (pl, FLAG_ANIMATE);
3991	}	3936	}
3992		3937
3993	/* check the special case of can't use weapons */	3938	/* check the special case of can't use weapons */
3994	/*if(QUERY_FLAG(change,FLAG_USE_WEAPON)) CLEAR_FLAG(pl,FLAG_USE_WEAPON); */	3939	/*if(QUERY_FLAG(change,FLAG_USE_WEAPON)) CLEAR_FLAG(pl,FLAG_USE_WEAPON); */
3995	if (!strcmp (change->name, "monk"))	3940	if (change->name == shstr_monk)
3996	CLEAR_FLAG (pl, FLAG_USE_WEAPON);	3941	CLEAR_FLAG (pl, FLAG_USE_WEAPON);
3997		3942
3998	break;	3943	break;
3999	}	3944	}
4000	}	3945	}
…		…
4037	pl->failmsg (format ("You can't use the %s with your %s!", query_name (transformer), query_name (marked)));	3982	pl->failmsg (format ("You can't use the %s with your %s!", query_name (transformer), query_name (marked)));
4038	return;	3983	return;
4039	}	3984	}
4040		3985
4041	/* check whether they are compatible or not */	3986	/* check whether they are compatible or not */
4042	find = strstr (marked->slaying, transformer->arch->archname);	3987	find = strstr (&marked->slaying, transformer->arch->archname);
4043	if (!find || (*(find + strlen (transformer->arch->archname)) != ':'))	3988	if (!find || (*(find + strlen (transformer->arch->archname)) != ':'))
4044	{	3989	{
4045	pl->failmsg (format ("You can't use the %s with your %s!", query_name (transformer), query_name (marked)));	3990	pl->failmsg (format ("You can't use the %s with your %s!", query_name (transformer), query_name (marked)));
4046	return;	3991	return;
4047	}	3992	}
…		…
4089		4034
4090	new_item->nrof = yield;	4035	new_item->nrof = yield;
4091		4036
4092	pl->statusmsg (format ("You %s the %s.", &transformer->slaying, query_base_name (marked, 0)));	4037	pl->statusmsg (format ("You %s the %s.", &transformer->slaying, query_base_name (marked, 0)));
4093		4038
4094	insert_ob_in_ob (new_item, pl);	4039	pl->insert (new_item);
4095	esrv_send_inventory (pl, pl);
4096	/* Eat up one item */	4040	/* Eat up one item */
4097	decrease_ob_nr (marked, 1);	4041	marked->decrease ();
4098		4042
4099	/* Eat one transformer if needed */	4043	/* Eat one transformer if needed */
4100	if (transformer->stats.food)	4044	if (transformer->stats.food)
4101	if (--transformer->stats.food == 0)	4045	if (--transformer->stats.food == 0)
4102	decrease_ob_nr (transformer, 1);	4046	transformer->decrease ();
4103	}	4047	}
4104		4048

Diff Legend

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