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.142 by root, Sun Apr 13 20:21:50 2008 UTC vs.
Revision 1.185 by root, Mon Jan 12 19:12:16 2009 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 Marc Alexander Lehmann / Robin Redeker / the Deliantra team	4	* Copyright (©) 2005,2006,2007,2008 Marc Alexander Lehmann / Robin Redeker / the Deliantra team
5	* Copyright (©) 2001,2007 Mark Wedel & Crossfire Development Team	5	* Copyright (©) 2001,2007 Mark Wedel & Crossfire Development Team
6	* Copyright (©) 1992,2007 Frank Tore Johansen	6	* Copyright (©) 1992,2007 Frank Tore Johansen
7	*	7	*
8	* Deliantra is free software: you can redistribute it and/or modify	8	* Deliantra is free software: you can redistribute it and/or modify
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
…		…
15	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the	15	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16	* GNU General Public License for more details.	16	* GNU General Public License for more details.
17	*	17	*
18	* You should have received a copy of the GNU General Public License	18	* You should have received a copy of the GNU General Public License
19	* along with this program. If not, see <http://www.gnu.org/licenses/>.	19	* along with this program. If not, see <http://www.gnu.org/licenses/>.
20	*	20	*
21	* The authors can be reached via e-mail to <support@deliantra.net>	21	* The authors can be reached via e-mail to <support@deliantra.net>
22	*/	22	*/
23		23
24	#include <cmath>	24	#include <cmath>
25		25
…		…
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.\n\n", 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\n" << marked->msg << "\n\n";	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.\n\n", 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\n" << id->msg << "\n\n";	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	}
…		…
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 (
…		…
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. "
629	"H<A weapon is considered magical if it changes regeneration, "	603	"H<A weapon is considered magical if it changes regeneration, "
630	"speed or ac.>");	604	"speed or ac, or has other protections.>");
631	return 0;	605	return 0;
632	}	606	}
633		607
634	sacrifice_count = check_sacrifice (op, improver);	608	sacrifice_count = check_sacrifice (op, improver);
635	if (sacrifice_count <= 0)	609	if (sacrifice_count <= 0)
…		…
646		620
647	sprintf (buf, "%s's %s", &op->name, &weapon->name);	621	sprintf (buf, "%s's %s", &op->name, &weapon->name);
648	weapon->name = weapon->name_pl = buf;	622	weapon->name = weapon->name_pl = buf;
649	weapon->nrof = 0; /* prevents preparing n weapons in the same	623	weapon->nrof = 0; /* prevents preparing n weapons in the same
650	slot at once! */	624	slot at once! */
651	decrease_ob (improver);	625	improver->decrease ();
652	weapon->last_eat = 0;	626	weapon->last_eat = 0;
653	return 1;	627	return 1;
654	}	628	}
655
656		629
657	/**	630	/**
658	* 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.
659	* This is the new improve weapon code.	632	* This is the new improve weapon code.
660	* 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.
…		…
704	weapon->weight += 5000; /* 5 KG's */	677	weapon->weight += 5000; /* 5 KG's */
705	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));
706	weapon->last_eat++;	679	weapon->last_eat++;
707		680
708	weapon->item_power++;	681	weapon->item_power++;
709	decrease_ob (improver);	682	improver->decrease ();
710	return 1;	683	return 1;
711	}	684	}
712		685
713	if (improver->stats.sp == IMPROVE_WEIGHT)	686	if (improver->stats.sp == IMPROVE_WEIGHT)
714	{	687	{
…		…
718	weapon->weight = 1;	691	weapon->weight = 1;
719		692
720	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));
721	weapon->last_eat++;	694	weapon->last_eat++;
722	weapon->item_power++;	695	weapon->item_power++;
723	decrease_ob (improver);	696	improver->decrease ();
724	return 1;	697	return 1;
725	}	698	}
		699
726	if (improver->stats.sp == IMPROVE_ENCHANT)	700	if (improver->stats.sp == IMPROVE_ENCHANT)
727	{	701	{
728	weapon->magic++;	702	weapon->magic++;
729	weapon->last_eat++;	703	weapon->last_eat++;
730	op->statusmsg (format ("Weapon magic increased to %d.", weapon->magic));	704	op->statusmsg (format ("Weapon magic increased to %d.", weapon->magic));
731	decrease_ob (improver);	705	improver->decrease ();
732	weapon->item_power++;	706	weapon->item_power++;
733	return 1;	707	return 1;
734	}	708	}
735		709
736	sacrifice_needed = weapon->stats.Str + weapon->stats.Int + weapon->stats.Dex +	710	sacrifice_needed = weapon->stats.Str + weapon->stats.Int + weapon->stats.Dex +
…		…
785	op->failmsg ("Something blocks the magic of the scroll!");	759	op->failmsg ("Something blocks the magic of the scroll!");
786	return 0;	760	return 0;
787	}	761	}
788		762
789	otmp = find_marked_object (op);	763	otmp = find_marked_object (op);
		764
790	if (!otmp)	765	if (!otmp)
791	{	766	{
792	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.>");
793	return 0;	768	return 0;
794	}	769	}
…		…
851	}	826	}
852		827
853	/* Split objects if needed. Can't insert tmp until the	828	/* Split objects if needed. Can't insert tmp until the
854	* end of this function - otherwise it will just re-merge.	829	* end of this function - otherwise it will just re-merge.
855	*/	830	*/
856	if (armour->nrof > 1)	831	tmp = armour->nrof > 1 ? armour->split (armour->nrof - 1) : 0;
857	tmp = get_split_ob (armour, armour->nrof - 1);
858	else
859	tmp = NULL;
860		832
861	armour->magic++;	833	armour->magic++;
862		834
863	if (!settings.armor_speed_linear)	835	if (!settings.armor_speed_linear)
864	{	836	{
…		…
901	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);
902		874
903	if (op->type == PLAYER)	875	if (op->type == PLAYER)
904	{	876	{
905	esrv_send_item (op, armour);	877	esrv_send_item (op, armour);
		878
906	if (QUERY_FLAG (armour, FLAG_APPLIED))	879	if (QUERY_FLAG (armour, FLAG_APPLIED))
907	op->update_stats ();	880	op->update_stats ();
908	}	881	}
909		882
910	decrease_ob (improver);	883	improver->decrease ();
911		884
912	if (tmp)	885	if (tmp)
913	{	886	op->insert (tmp);
914	insert_ob_in_ob (tmp, op);
915	esrv_send_item (op, tmp);
916	}
917		887
918	return 1;	888	return 1;
919	}	889	}
920		890
921	/*	891	/*
…		…
955		925
956	converter->play_sound (sound_find ("shop_buy"));	926	converter->play_sound (sound_find ("shop_buy"));
957		927
958	sint64 cost = (nr * need + item->value - 1) / item->value;	928	sint64 cost = (nr * need + item->value - 1) / item->value;
959		929
960	decrease_ob_nr (item, cost);	930	item->decrease (cost);
961		931
962	price_in = cost * item->value;	932	price_in = cost * item->value;
963	}	933	}
964	else	934	else
965	{	935	{
…		…
971	converter->play_sound (sound_find ("convert_item"));	941	converter->play_sound (sound_find ("convert_item"));
972		942
973	if (need)	943	if (need)
974	{	944	{
975	nr = sint64 (item->nrof) / need;	945	nr = sint64 (item->nrof) / need;
976	decrease_ob_nr (item, nr * need);	946	item->decrease (nr * need);
977	price_in = nr * need * item->value;	947	price_in = nr * need * item->value;
978	}	948	}
979	else	949	else
980	{	950	{
981	price_in = item->value;	951	price_in = item->value;
…		…
993	ob_to_copy = converter->inv;	963	ob_to_copy = converter->inv;
994	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++)
995	if (rndm (0, i) == 0)	965	if (rndm (0, i) == 0)
996	ob_to_copy = ob;	966	ob_to_copy = ob;
997		967
998	item = object_create_clone (ob_to_copy);	968	item = ob_to_copy->deep_clone ();
999	CLEAR_FLAG (item, FLAG_IS_A_TEMPLATE);	969	CLEAR_FLAG (item, FLAG_IS_A_TEMPLATE);
1000	unflag_inv (item, FLAG_IS_A_TEMPLATE);	970	unflag_inv (item, FLAG_IS_A_TEMPLATE);
1001	}	971	}
1002	else	972	else
1003	{	973	{
…		…
1016	item->nrof = give;	986	item->nrof = give;
1017		987
1018	if (nr)	988	if (nr)
1019	item->nrof *= nr;	989	item->nrof *= nr;
1020		990
1021	if (is_in_shop (converter))	991	if (converter->flag [FLAG_PRECIOUS])
1022	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	}
1023	else if (price_in < sint64 (item->nrof) * item->value)	1002	else if (price_in < sint64 (item->nrof) * item->value)
1024	{	1003	{
1025	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",
1026	&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);
1027	/**	1006	/**
1028	* 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
1029	* hopefully had something in mind when doing this.	1008	* hopefully had something in mind when doing this.
1030	*/	1009	*/
1031	}	1010	}
1032		1011
1033	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
1034	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);
1035	return 1;	1018	return 1;
1036	}	1019	}
1037		1020
1038	/**	1021	/**
…		…
1134	/* push_button (altar);*/	1117	/* push_button (altar);*/
1135	}	1118	}
1136	else	1119	else
1137	{	1120	{
1138	altar->value = 1; /* works only once */	1121	altar->value = 1; /* works only once */
1139	push_button (altar);	1122	push_button (altar, originator);
1140	}	1123	}
1141		1124
1142	return !sacrifice;	1125	return !sacrifice;
1143	}	1126	}
1144	else	1127	else
…		…
1170	{	1153	{
1171	has_unpaid = true;	1154	has_unpaid = true;
1172	break;	1155	break;
1173	}	1156	}
1174		1157
1175	if (op->type != PLAYER)	1158	if (!op->is_player ())
1176	{	1159	{
1177	/* Remove all the unpaid objects that may be carried here.	1160	/* Remove all the unpaid objects that may be carried here.
1178	* This could be pets or monsters that are somehow in	1161	* This could be pets or monsters that are somehow in
1179	* the shop.	1162	* the shop.
1180	*/	1163	*/
…		…
1184		1167
1185	if (QUERY_FLAG (tmp, FLAG_UNPAID))	1168	if (QUERY_FLAG (tmp, FLAG_UNPAID))
1186	{	1169	{
1187	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);
1188		1171
		1172	if (i >= 0)
1189	tmp->remove ();	1173	tmp->move (i);
1190
1191	if (i == -1)
1192	i = 0;
1193
1194	tmp->map = op->map;
1195	tmp->x = op->x + freearr_x[i];
1196	tmp->y = op->y + freearr_y[i];
1197	insert_ob_in_map (tmp, op->map, op, 0);
1198	}	1174	}
1199	}	1175	}
1200		1176
1201	/* Don't teleport things like spell effects */	1177	/* Don't teleport things like spell effects */
1202	if (QUERY_FLAG (op, FLAG_NO_PICK))	1178	if (QUERY_FLAG (op, FLAG_NO_PICK))
…		…
1213	if (i != -1)	1189	if (i != -1)
1214	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);
1215		1191
1216	return 0;	1192	return 0;
1217	}	1193	}
		1194
1218	/* Removed code that checked for multipart objects - it appears that	1195	/* Removed code that checked for multipart objects - it appears that
1219	* the teleport function should be able to handle this just fine.	1196	* the teleport function should be able to handle this just fine.
1220	*/	1197	*/
1221	rv = teleport (shop_mat, SHOP_MAT, op);	1198	rv = teleport (shop_mat, SHOP_MAT, op);
1222	}	1199	}
…		…
1277	* Handles applying a sign.	1254	* Handles applying a sign.
1278	*/	1255	*/
1279	static void	1256	static void
1280	apply_sign (object *op, object *sign, int autoapply)	1257	apply_sign (object *op, object *sign, int autoapply)
1281	{	1258	{
1282	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	}
1283		1267
1284	if (!sign->msg)	1268	if (!sign->msg)
1285	{	1269	{
1286	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 "));
1287	return;	1274	return;
1288	}	1275	}
1289		1276
1290	if (sign->stats.food)	1277	if (sign->stats.food)
1291	{	1278	{
1292	if (sign->last_eat >= sign->stats.food)	1279	if (sign->last_eat >= sign->stats.food)
1293	{	1280	{
1294	if (!sign->move_on)	1281	if (!sign->move_on)
1295	op->statusmsg ("You cannot read it anymore.");	1282	op->failmsg ("You cannot read it anymore.");
1296		1283
1297	return;	1284	return;
1298	}	1285	}
1299		1286
1300	if (!QUERY_FLAG (op, FLAG_WIZPASS))	1287	if (!QUERY_FLAG (op, FLAG_WIZPASS))
…		…
1318	if (sign->sound)	1305	if (sign->sound)
1319	ns->play_sound (sign->sound);	1306	ns->play_sound (sign->sound);
1320	else if (autoapply)	1307	else if (autoapply)
1321	ns->play_sound (sound_find ("msg_voice"));	1308	ns->play_sound (sound_find ("msg_voice"));
1322		1309
1323	if (ns->can_msg)
1324	op->contr->infobox (MSG_CHANNEL ("examine"), format ("T<%s>\n\n\n\n%s", &sign->name, &sign->msg));	1310	op->contr->infobox (MSG_CHANNEL ("examine"), format ("T<%s>\n\n%s", &sign->name, &sign->msg));
1325	else
1326	{
1327	msgType = get_readable_message_type (sign);
1328	const char *somemsg = format ("%u %s", autoapply ? 1 : 0, &sign->msg);
1329	draw_ext_info (NDI_UNIQUE | NDI_NAVY, 0, op, msgType->message_type, msgType->message_subtype, somemsg, &sign->msg);
1330	}
1331	}	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);
1332	}	1344	}
1333		1345
1334	/**	1346	/**
1335	* 'victim' moves onto 'trap'	1347	* 'victim' moves onto 'trap'
1336	* 'victim' leaves 'trap'	1348	* 'victim' leaves 'trap'
…		…
1411	}	1423	}
1412	goto leave;	1424	goto leave;
1413		1425
1414	case BUTTON:	1426	case BUTTON:
1415	case PEDESTAL:	1427	case PEDESTAL:
1416	update_button (trap);	1428	update_button (trap, originator);
1417	goto leave;	1429	goto leave;
1418		1430
1419	case ALTAR:	1431	case ALTAR:
1420	/* sacrifice victim on trap */	1432	/* sacrifice victim on trap */
1421	apply_altar (trap, victim, originator);	1433	apply_altar (trap, victim, originator);
…		…
1448		1460
1449	if (!trap->value)	1461	if (!trap->value)
1450	{	1462	{
1451	int tot;	1463	int tot;
1452		1464
1453	for (ab = trap->above, tot = 0; ab != NULL; ab = ab->above)	1465	for (ab = trap->above, tot = 0; ab; ab = ab->above)
1454	if ((ab->move_type && trap->move_on) || ab->move_type == 0)	1466	if ((ab->move_type && trap->move_on) || ab->move_type == 0)
1455	tot += (ab->nrof ? ab->nrof : 1) * ab->weight + ab->carrying;	1467	tot += ab->head_ ()->total_weight ();
1456		1468
1457	if (!(trap->value = (tot > trap->weight) ? 1 : 0))	1469	if (!(trap->value = (tot > trap->weight) ? 1 : 0))
1458	goto leave;	1470	goto leave;
1459		1471
1460	SET_ANIMATION (trap, trap->value);	1472	SET_ANIMATION (trap, trap->value);
…		…
1485		1497
1486	case CONVERTER:	1498	case CONVERTER:
1487	if (convert_item (victim, trap) < 0)	1499	if (convert_item (victim, trap) < 0)
1488	{	1500	{
1489	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)));
1490	get_archetype ("burnout")->insert_at (trap, trap);	1502	archetype::get (shstr_burnout)->insert_at (trap, trap);
1491	}	1503	}
1492		1504
1493	goto leave;	1505	goto leave;
1494		1506
1495	case TRIGGER_BUTTON:	1507	case TRIGGER_BUTTON:
…		…
1505	case CHECK_INV:	1517	case CHECK_INV:
1506	check_inv (victim, trap);	1518	check_inv (victim, trap);
1507	goto leave;	1519	goto leave;
1508		1520
1509	case HOLE:	1521	case HOLE:
1510	/* Hole not open? */	1522	move_apply_hole (trap, victim);
1511	if (trap->stats.wc > 0)
1512	goto leave;
1513
1514	/* Is this a multipart monster and not the head? If so, return.
1515	* Processing will happen if the head runs into the pit
1516	*/
1517	if (victim->head)
1518	goto leave;
1519
1520	victim->play_sound (trap->sound ? trap->sound : sound_find ("fall_hole"));
1521	victim->statusmsg ("You fall through the hole!", NDI_RED);
1522	transfer_ob (victim, EXIT_X (trap), EXIT_Y (trap), 1, victim);
1523	goto leave;	1523	goto leave;
1524		1524
1525	case EXIT:	1525	case EXIT:
1526	if (victim->type == PLAYER && EXIT_PATH (trap))	1526	if (victim->type == PLAYER && EXIT_PATH (trap))
1527	{	1527	{
1528	/* Basically, don't show exits leading to random maps the	1528	/* Basically, don't show exits leading to random maps the
1529	* players output.	1529	* players output.
1530	*/	1530	*/
1531	if (trap->msg && strncmp (EXIT_PATH (trap), "/!", 2))	1531	if (trap->msg && !EXIT_PATH (trap).starts_with ("/!"))
1532	victim->statusmsg (trap->msg, NDI_NAVY);	1532	victim->statusmsg (trap->msg, NDI_NAVY);
1533		1533
1534	trap->play_sound (trap->sound);	1534	trap->play_sound (trap->sound);
1535	victim->enter_exit (trap);	1535	victim->enter_exit (trap);
1536	}	1536	}
…		…
1619		1619
1620	readable_message_type *msgType = get_readable_message_type (tmp);	1620	readable_message_type *msgType = get_readable_message_type (tmp);
1621		1621
1622	if (player *pl = op->contr)	1622	if (player *pl = op->contr)
1623	if (client *ns = pl->ns)	1623	if (client *ns = pl->ns)
1624	if (ns->can_msg)
1625	pl->infobox (MSG_CHANNEL ("book"), format ("T<%s>\n\n\n\n%s", (char *)long_desc (tmp, op), &tmp->msg));	1624	pl->infobox (MSG_CHANNEL ("book"), format ("T<%s>\n\n%s", (char *)long_desc (tmp, op), &tmp->msg));
1626	else
1627	draw_ext_info_format (NDI_UNIQUE | NDI_NAVY, 0, op,
1628	msgType->message_type, msgType->message_subtype,
1629	"You open the %s and start reading.\n%s", (char *)"%s\n%s",
1630	long_desc (tmp, op), &tmp->msg);
1631		1625
1632	/* gain xp from reading */	1626	/* gain xp from reading */
1633	if (!QUERY_FLAG (tmp, FLAG_NO_SKILL_IDENT))	1627	if (!QUERY_FLAG (tmp, FLAG_NO_SKILL_IDENT))
1634	{ /* only if not read before */	1628	{ /* only if not read before */
1635	int exp_gain = calc_skill_exp (op, tmp, skill_ob);	1629	int exp_gain = calc_skill_exp (op, tmp, skill_ob);
…		…
1637	if (!QUERY_FLAG (tmp, FLAG_IDENTIFIED))	1631	if (!QUERY_FLAG (tmp, FLAG_IDENTIFIED))
1638	{	1632	{
1639	/*exp_gain *= 2; because they just identified it too */	1633	/*exp_gain *= 2; because they just identified it too */
1640	SET_FLAG (tmp, FLAG_IDENTIFIED);	1634	SET_FLAG (tmp, FLAG_IDENTIFIED);
1641		1635
1642	/* If in a container, update how it looks */	1636	if (object *pl = tmp->visible_to ())
1643	if (tmp->env)
1644	esrv_update_item (UPD_FLAGS | UPD_NAME, op, tmp);	1637	esrv_update_item (UPD_FLAGS | UPD_NAME, pl, tmp);
1645	else
1646	op->contr->ns->floorbox_update ();
1647	}	1638	}
1648		1639
1649	change_exp (op, exp_gain, skill_ob->skill, 0);	1640	change_exp (op, exp_gain, skill_ob->skill, 0);
1650	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 */
1651	}	1642	}
…		…
1664	op->play_sound (sound_find ("generic_fail"));	1655	op->play_sound (sound_find ("generic_fail"));
1665	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)));
1666	break;	1657	break;
1667		1658
1668	case 1:	1659	case 1:
1669	decrease_ob (tmp);	1660	tmp->decrease ();
1670	op->play_sound (sound_find ("skill_learn"));	1661	op->play_sound (sound_find ("skill_learn"));
1671	op->statusmsg (format ("You succeed in learning %s", &tmp->skill));	1662	op->statusmsg (format ("You succeed in learning %s", &tmp->skill));
1672	break;	1663	break;
1673		1664
1674	default:	1665	default:
1675	decrease_ob (tmp);	1666	tmp->decrease ();
1676	op->play_sound (sound_find ("generic_fail"));	1667	op->play_sound (sound_find ("generic_fail"));
1677	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)));
1678	break;	1669	break;
1679	}	1670	}
1680	}	1671	}
…		…
1801	}	1792	}
1802		1793
1803	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));
1804		1795
1805	if (!QUERY_FLAG (tmp, FLAG_IDENTIFIED))	1796	if (!QUERY_FLAG (tmp, FLAG_IDENTIFIED))
1806	{
1807	identify (tmp);	1797	identify (tmp);
1808
1809	if (tmp->env)
1810	esrv_update_item (UPD_FLAGS | UPD_NAME, op, tmp);
1811	else
1812	op->contr->ns->floorbox_update ();
1813	}
1814		1798
1815	/* 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
1816	* 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
1817	* 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
1818	* they would have a special prayer mark.	1802	* they would have a special prayer mark.
…		…
1871	{	1855	{
1872	op->contr->play_sound (sound_find ("fumble_spell"));	1856	op->contr->play_sound (sound_find ("fumble_spell"));
1873	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");
1874	}	1858	}
1875		1859
1876	decrease_ob (tmp);	1860	tmp->decrease ();
1877	}	1861	}
1878		1862
1879	/**	1863	/**
1880	* Handles applying a spell scroll.	1864	* Handles applying a spell scroll.
1881	*/	1865	*/
…		…
1920	identify (tmp);	1904	identify (tmp);
1921		1905
1922	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));
1923		1907
1924	cast_spell (op, tmp, dir, tmp->inv, NULL);	1908	cast_spell (op, tmp, dir, tmp->inv, NULL);
1925	decrease_ob (tmp);	1909	tmp->decrease ();
1926	}	1910	}
1927		1911
1928	/**	1912	/**
1929	* Applies a treasure object - by default, chest. op	1913	* Applies a treasure object - by default, chest. op
1930	* is the person doing the applying, tmp is the treasure	1914	* is the person doing the applying, tmp is the treasure
…		…
1942	object *treas = tmp->inv;	1926	object *treas = tmp->inv;
1943		1927
1944	if (!treas)	1928	if (!treas)
1945	{	1929	{
1946	op->statusmsg ("The chest was empty.");	1930	op->statusmsg ("The chest was empty.");
1947	decrease_ob (tmp);	1931	tmp->decrease ();
1948	return;	1932	return;
1949	}	1933	}
1950		1934
1951	while (tmp->inv)	1935	while (tmp->inv)
1952	{	1936	{
…		…
1968	if (op->destroyed () || tmp->destroyed ())	1952	if (op->destroyed () || tmp->destroyed ())
1969	break;	1953	break;
1970	}	1954	}
1971		1955
1972	if (!tmp->destroyed () && !tmp->inv)	1956	if (!tmp->destroyed () && !tmp->inv)
1973	decrease_ob (tmp);	1957	tmp->decrease (true);
1974	}	1958	}
1975		1959
1976	/**	1960	/**
1977	* op eats food.	1961	* op eats food.
1978	* If player, takes care of messages and dragon special food.	1962	* If player, takes care of messages and dragon special food.
…		…
2044	eat_special_food (op, tmp);	2028	eat_special_food (op, tmp);
2045	}	2029	}
2046	}	2030	}
2047		2031
2048	handle_apply_yield (tmp);	2032	handle_apply_yield (tmp);
2049	decrease_ob (tmp);	2033	tmp->decrease ();
2050	}	2034	}
2051		2035
2052	/**	2036	/**
2053	* A dragon is eating some flesh. If the flesh contains resistances,	2037	* A dragon is eating some flesh. If the flesh contains resistances,
2054	* 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.
…		…
2173	op->statusmsg (buf);	2157	op->statusmsg (buf);
2174		2158
2175	/* now choose a winner if we have any */	2159	/* now choose a winner if we have any */
2176	i = -1;	2160	i = -1;
2177	if (winners > 0)	2161	if (winners > 0)
2178	i = atnr_winner[RANDOM () % winners];	2162	i = atnr_winner [rndm (winners)];
2179		2163
2180	if (i >= 0 && i < NROFATTACKS && skin->resist[i] < 95)	2164	if (i >= 0 && i < NROFATTACKS && skin->resist[i] < 95)
2181	{	2165	{
2182	/* resistance increased! */	2166	/* resistance increased! */
2183	skin->resist[i]++;	2167	skin->resist[i]++;
…		…
2242		2226
2243	op->statusmsg ("Applying armour enchantment.");	2227	op->statusmsg ("Applying armour enchantment.");
2244	improve_armour (op, tmp, armor);	2228	improve_armour (op, tmp, armor);
2245	}	2229	}
2246		2230
2247	extern void	2231	void
2248	apply_poison (object *op, object *tmp)	2232	apply_poison (object *op, object *tmp)
2249	{	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
2250	if (op->type == PLAYER)	2239	if (op->type == PLAYER)
2251	{	2240	{
2252	op->contr->play_sound (sound_find ("drink_poison"));	2241	op->contr->play_sound (sound_find ("drink_poison"));
2253	op->failmsg ("Yech! That tasted poisonous!");	2242	op->failmsg ("Yech! That tasted poisonous!");
2254	strcpy (op->contr->killer, "poisonous booze");	2243	op->contr->killer = poison;
2255	}	2244	}
2256		2245
2257	if (tmp->stats.hp > 0)	2246	if (poison->stats.hp > 0)
2258	{	2247	{
2259	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);
2260	hit_player (op, tmp->stats.hp, tmp, AT_POISON, 1);	2249	hit_player (op, poison->stats.hp, tmp, AT_POISON, 1);
2261	}	2250	}
2262		2251
2263	op->stats.food -= op->stats.food / 4;	2252	op->stats.food -= op->stats.food / 4;
2264	handle_apply_yield (tmp);	2253	poison->destroy ();
2265	decrease_ob (tmp);
2266	}	2254	}
2267		2255
2268	/**	2256	/**
2269	* 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.
2270	* A valid 2 way exit means:	2258	* A valid 2 way exit means:
…		…
2354		2342
2355	return 0;	2343	return 0;
2356	}	2344	}
2357		2345
2358	/**	2346	/**
		2347	* 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,
		2349	* and inform him about this requirement.
		2350	*
		2351	* who - the player
		2352	* op - the item we want to light
		2353	* ligher - the lighter or 0 if a lighter has yet to be found
		2354	*/
		2355	object *auto_apply_lighter (object *who, object *op, object *lighter)
		2356	{
		2357	if (lighter == 0)
		2358	{
		2359	for (object *tmp = who->inv; tmp; tmp = tmp->below)
		2360	{
		2361	if (tmp->type == LIGHTER)
		2362	{
		2363	lighter = tmp;
		2364	break;
		2365	}
		2366	}
		2367
		2368	if (!lighter)
		2369	{
		2370	who->failmsg (format (
		2371	"You can't light up the %s with your bare hands! "
		2372	"H<You need a lighter in your inventory, for example a flint and steel.>",
		2373	&op->name));
		2374	return 0;
		2375	}
		2376	}
		2377
		2378	// last_eat == 0 means the lighter is not being used up!
		2379	if (lighter->last_eat && lighter->stats.food)
		2380	{
		2381	/* lighter gets used up */
		2382	lighter = lighter->split ();
		2383	lighter->stats.food--;
		2384	who->insert (lighter);
		2385	}
		2386	else if (lighter->last_eat)
		2387	{
		2388	/* no charges left in lighter */
		2389	who->failmsg (format (
		2390	"You attempt to light the %s with a used up %s.",
		2391	&op->name, &lighter->name));
		2392	return 0;
		2393	}
		2394
		2395	return lighter;
		2396	}
		2397
		2398	/**
		2399	* Designed primarily to light torches/lanterns/etc.
		2400	* Also burns up burnable material too. First object in the inventory is
		2401	* the selected object to "burn". -b.t.
		2402	*/
		2403	void
		2404	apply_lighter (object *who, object *lighter)
		2405	{
		2406	object *item;
		2407	int is_player_env = 0;
		2408
		2409	item = find_marked_object (who);
		2410	if (item)
		2411	{
		2412	if (!auto_apply_lighter (who, 0, lighter))
		2413	return;
		2414
		2415	/* 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
		2417	* objects at once.
		2418	*/
		2419
		2420	save_throw_object (item, AT_FIRE, who);
		2421
		2422	if (item->destroyed ()
		2423	|| ((item->type == LAMP || item->type == TORCH)
		2424	&& item->glow_radius > 0))
		2425	who->statusmsg (format (
		2426	"You light the %s with the %s.",
		2427	&item->name, &lighter->name));
		2428	else
		2429	who->failmsg (format (
		2430	"You attempt to light the %s with the %s and fail.",
		2431	&item->name, &lighter->name));
		2432	}
		2433	else
		2434	who->failmsg ("You need to mark a lightable object.");
		2435	}
		2436
		2437	/**
		2438	* Apply for players and lamps
		2439	*
		2440	* who - the player
		2441	* op - the lamp
		2442	*/
		2443	void player_apply_lamp (object *who, object *op)
		2444	{
		2445	bool switch_on = op->glow_radius ? false : true;
		2446
		2447	if (switch_on)
		2448	{
		2449	object *lighter = 0;
		2450
		2451	if (op->flag [FLAG_IS_LIGHTABLE]
		2452	&& !(lighter = auto_apply_lighter (who, op, 0)))
		2453	return;
		2454
		2455	if (op->stats.food < 1)
		2456	{
		2457	if (op->type == LAMP)
		2458	who->failmsg (format (
		2459	"The %s is out of fuel! "
		2460	"H<Lamps and similar items need fuel. They cannot be refilled.>",
		2461	&op->name));
		2462	else
		2463	who->failmsg (format (
		2464	"The %s is burnt out! "
		2465	"H<Torches and similar items burn out and become worthless.>",
		2466	&op->name));
		2467	return;
		2468	}
		2469
		2470	if (lighter)
		2471	who->statusmsg (format (
		2472	"You light up the %s with the %s.", &op->name, &lighter->name));
		2473	else
		2474	who->statusmsg (format ("You light up the %s.", &op->name));
		2475	}
		2476	else
		2477	{
		2478	if (op->type == TORCH)
		2479	{
		2480	if (!op->flag [FLAG_IS_LIGHTABLE])
		2481	{
		2482	who->statusmsg (format (
		2483	"You put out the %s. "
		2484	"H<The %s can't be used anymore, as it can't be lighted up again.>",
		2485	&op->name, &op->name));
		2486	}
		2487	else
		2488	who->statusmsg (format (
		2489	"You put out the %s."
		2490	"H<Torches wear out if you put them out.>",
		2491	&op->name));
		2492	}
		2493	else
		2494	who->statusmsg (format ("You turn off the %s.", &op->name));
		2495	}
		2496
		2497	apply_lamp (op, switch_on);
		2498	}
		2499
		2500	void lamp_get_animation_from_arch (object *op, arch_ptr a)
		2501	{
		2502	op->animation_id = a->animation_id;
		2503	op->flag [FLAG_IS_TURNABLE] = a->flag [FLAG_IS_TURNABLE];
		2504	op->flag [FLAG_ANIMATE] = a->flag [FLAG_ANIMATE];
		2505	op->anim_speed = a->anim_speed;
		2506	op->last_anim = 0;
		2507	op->state = 0;
		2508	op->face = a->face;
		2509
		2510	if (NUM_ANIMATIONS(op) > 1)
		2511	{
		2512	SET_ANIMATION(op, 0);
		2513	animate_object (op, op->direction);
		2514	}
		2515	else
		2516	update_object (op, UP_OBJ_FACE);
		2517	}
		2518
		2519	/**
		2520	* Apply for LAMPs and TORCHes.
		2521	*
		2522	* op - the lamp
		2523	* switch_on - a flag which says whether the lamp should be switched on or off
		2524	*/
		2525	void apply_lamp (object *op, bool switch_on)
		2526	{
		2527	op->set_glow_radius (switch_on ? op->range : 0);
		2528	op->set_speed (switch_on ? op->arch->speed : 0);
		2529
		2530	// torches wear out if you put them out
		2531	if (op->type == TORCH && !switch_on)
		2532	{
		2533	if (op->flag [FLAG_IS_LIGHTABLE])
		2534	{
		2535	op->stats.food -= (double) op->arch->stats.food / 15;
		2536	if (op->stats.food < 0)
		2537	op->stats.food = 0;
		2538	}
		2539	else
		2540	op->stats.food = 0;
		2541	}
		2542
		2543	// lamps and torched get worthless when used up
		2544	if (op->stats.food <= 0)
		2545	op->value = 0;
		2546
		2547	// FIXME: This is a hack to make the more sane torches and lamps
		2548	// still animated ;-/
		2549	if (op->other_arch)
		2550	lamp_get_animation_from_arch (op, switch_on ? op->other_arch : op->arch);
		2551
		2552	if (object *pl = op->visible_to ())
		2553	esrv_update_item (UPD_ANIM | UPD_FACE | UPD_NAME, pl, op);
		2554	}
		2555
		2556	/**
2359	* Main apply handler.	2557	* Main apply handler.
2360	*	2558	*
2361	* Checks for unpaid items before applying.	2559	* Checks for unpaid items before applying.
2362	*	2560	*
2363	* Return value:	2561	* Return value:
2364	* 0: player or monster can't apply objects of that type	2562	* 0: player or monster can't apply objects of that type
2365	* 1: has been applied, or there was an error applying the object	2563	* 1: has been applied, or there was an error applying the object
2366	* 2: objects of that type can't be applied if not in inventory	2564	* 2: objects of that type can't be applied if not in inventory
2367	*	2565	*
2368	* op is the object that is causing object to be applied, tmp is the object	2566	* who is the object that is causing object to be applied, op is the object
2369	* being applied.	2567	* being applied.
2370	*	2568	*
2371	* aflag is special (always apply/unapply) flags. Nothing is done with	2569	* aflag is special (always apply/unapply) flags. Nothing is done with
2372	* them in this function - they are passed to apply_special	2570	* them in this function - they are passed to apply_special
2373	*/	2571	*/
2374	int	2572	int
2375	manual_apply (object *op, object *tmp, int aflag)	2573	manual_apply (object *who, object *op, int aflag)
2376	{	2574	{
2377	if (tmp->head)	2575	op = op->head_ ();
2378	tmp = tmp->head;
2379		2576
2380	if (QUERY_FLAG (tmp, FLAG_UNPAID) && !QUERY_FLAG (tmp, FLAG_APPLIED))	2577	if (QUERY_FLAG (op, FLAG_UNPAID) && !QUERY_FLAG (op, FLAG_APPLIED))
2381	{	2578	{
2382	if (op->type == PLAYER)	2579	if (who->type == PLAYER)
2383	{	2580	{
		2581	examine (who, op);
2384	op->failmsg ("You should pay for it first! H<You cannot use items marked as unpaid.>");	2582	//who->failmsg ("You should pay for it first! H<You cannot use items marked as unpaid.>");//TODO remove
2385	return 1;	2583	return 1;
2386	}	2584	}
2387	else	2585	else
2388	return 0; /* monsters just skip unpaid items */	2586	return 0; /* monsters just skip unpaid items */
2389	}	2587	}
2390		2588
2391	if (INVOKE_OBJECT (APPLY, tmp, ARG_OBJECT (op)))	2589	if (INVOKE_OBJECT (APPLY, op, ARG_OBJECT (who)))
2392	return RESULT_INT (0);	2590	return RESULT_INT (0);
2393		2591
2394	switch (tmp->type)	2592	switch (op->type)
2395	{	2593	{
2396	case CF_HANDLE:	2594	case CF_HANDLE:
2397	op->play_sound (sound_find ("turn_handle"));	2595	who->play_sound (sound_find ("turn_handle"));
2398	op->statusmsg ("You turn the handle.");	2596	who->statusmsg ("You turn the handle.");
2399	tmp->value = tmp->value ? 0 : 1;	2597	op->value = op->value ? 0 : 1;
2400	SET_ANIMATION (tmp, tmp->value);	2598	SET_ANIMATION (op, op->value);
2401	update_object (tmp, UP_OBJ_FACE);	2599	update_object (op, UP_OBJ_FACE);
2402	push_button (tmp);	2600	push_button (op, who);
2403	return 1;	2601	return 1;
2404		2602
2405	case TRIGGER:	2603	case TRIGGER:
2406	if (check_trigger (tmp, op))	2604	if (check_trigger (op, who))
2407	{	2605	{
2408	op->statusmsg ("You turn the handle.");	2606	who->statusmsg ("You turn the handle.");
2409	op->play_sound (sound_find ("turn_handle"));	2607	who->play_sound (sound_find ("turn_handle"));
2410	}	2608	}
2411	else	2609	else
2412	op->failmsg ("The handle doesn't move.");	2610	who->failmsg ("The handle doesn't move.");
2413		2611
2414	return 1;	2612	return 1;
2415		2613
2416	case EXIT:	2614	case EXIT:
2417	if (op->type != PLAYER)	2615	if (who->type != PLAYER)
2418	return 0;	2616	return 0;
2419		2617
2420	if (!EXIT_PATH (tmp) || !is_legal_2ways_exit (op, tmp))	2618	if (!EXIT_PATH (op) || !is_legal_2ways_exit (who, op))
2421	op->failmsg (format ("The %s is closed.", query_name (tmp)));	2619	who->failmsg (format ("The %s is closed.", query_name (op)));
2422	else	2620	else
2423	{	2621	{
2424	/* Don't display messages for random maps. */	2622	/* Don't display messages for random maps. */
2425	if (tmp->msg && strncmp (EXIT_PATH (tmp), "/!", 2))	2623	if (op->msg && !EXIT_PATH (op).starts_with ("/!"))
2426	op->statusmsg (tmp->msg, NDI_NAVY);	2624	who->statusmsg (op->msg, NDI_NAVY);
2427		2625
2428	op->enter_exit (tmp);	2626	who->enter_exit (op);
2429	}	2627	}
2430		2628
2431	return 1;	2629	return 1;
2432		2630
2433	case INSCRIBABLE:	2631	case INSCRIBABLE:
2434	op->statusmsg (tmp->msg);	2632	who->statusmsg (op->msg);
2435	// maybe show a spell menu to chose from or something like that	2633	// maybe show a spell menu to chose from or something like that
2436	return 1;	2634	return 1;
2437		2635
2438	case SIGN:	2636	case SIGN:
2439	apply_sign (op, tmp, 0);	2637	apply_sign (who, op, 0);
2440	return 1;	2638	return 1;
2441		2639
2442	case BOOK:	2640	case BOOK:
2443	if (op->type == PLAYER)	2641	if (who->type == PLAYER)
2444	{	2642	{
2445	apply_book (op, tmp);	2643	apply_book (who, op);
2446	return 1;	2644	return 1;
2447	}	2645	}
2448	else	2646	else
2449	return 0;	2647	return 0;
2450		2648
2451	case SKILLSCROLL:	2649	case SKILLSCROLL:
2452	if (op->type == PLAYER)	2650	if (who->type == PLAYER)
2453	{	2651	{
2454	apply_skillscroll (op, tmp);	2652	apply_skillscroll (who, op);
2455	return 1;	2653	return 1;
2456	}	2654	}
2457	else	2655	else
2458	return 0;	2656	return 0;
2459		2657
2460	case SPELLBOOK:	2658	case SPELLBOOK:
2461	if (op->type == PLAYER)	2659	if (who->type == PLAYER)
2462	{	2660	{
2463	apply_spellbook (op, tmp);	2661	apply_spellbook (who, op);
2464	return 1;	2662	return 1;
2465	}	2663	}
2466	else	2664	else
2467	return 0;	2665	return 0;
2468		2666
2469	case SCROLL:	2667	case SCROLL:
2470	apply_scroll (op, tmp, 0);	2668	apply_scroll (who, op, 0);
2471	return 1;	2669	return 1;
2472		2670
2473	case POTION:	2671	case POTION:
2474	apply_potion (op, tmp);	2672	apply_potion (who, op);
2475	return 1;	2673	return 1;
2476		2674
2477	/* Eneq(@csd.uu.se): Handle apply on containers. */	2675	/* Eneq(@csd.uu.se): Handle apply on containers. */
2478	//TODO: remove, as it is unsed?	2676	//TODO: remove, as it is unsed?
2479	case CLOSE_CON:	2677	case CLOSE_CON:
2480	apply_container (op, tmp->env);	2678	apply_container (who, op->env);
2481	return 1;	2679	return 1;
2482		2680
2483	case CONTAINER:	2681	case CONTAINER:
2484	apply_container (op, tmp);	2682	apply_container (who, op);
2485	return 1;	2683	return 1;
2486		2684
2487	case TREASURE:	2685	case TREASURE:
2488	if (op->type == PLAYER)	2686	if (who->type == PLAYER)
2489	{	2687	{
2490	apply_treasure (op, tmp);	2688	apply_treasure (who, op);
2491	return 1;	2689	return 1;
2492	}	2690	}
2493	else	2691	else
2494	return 0;	2692	return 0;
		2693
		2694	case LAMP:
		2695	case TORCH:
		2696	player_apply_lamp (who, op);
		2697	return 1;
2495		2698
2496	case WEAPON:	2699	case WEAPON:
2497	case ARMOUR:	2700	case ARMOUR:
2498	case BOOTS:	2701	case BOOTS:
2499	case GLOVES:	2702	case GLOVES:
…		…
2507	case WAND:	2710	case WAND:
2508	case ROD:	2711	case ROD:
2509	case HORN:	2712	case HORN:
2510	case SKILL:	2713	case SKILL:
2511	case BOW:	2714	case BOW:
2512	case LAMP:
2513	case BUILDER:	2715	case BUILDER:
2514	case SKILL_TOOL:	2716	case SKILL_TOOL:
2515	if (tmp->env != op)	2717	if (op->env != who)
2516	return 2; /* not in inventory */	2718	return 2; /* not in inventory */
2517		2719
2518	apply_special (op, tmp, aflag);	2720	apply_special (who, op, aflag);
2519	return 1;	2721	return 1;
2520		2722
2521	case DRINK:	2723	case DRINK:
2522	case FOOD:	2724	case FOOD:
2523	case FLESH:	2725	case FLESH:
2524	apply_food (op, tmp);	2726	apply_food (who, op);
2525	return 1;	2727	return 1;
2526		2728
2527	case POISON:	2729	case POISON:
2528	apply_poison (op, tmp);	2730	apply_poison (who, op);
2529	return 1;	2731	return 1;
2530		2732
2531	case SAVEBED:	2733	case SAVEBED:
2532	return 1;	2734	return 1;
2533		2735
2534	case ARMOUR_IMPROVER:	2736	case ARMOUR_IMPROVER:
2535	if (op->type == PLAYER)	2737	if (who->type == PLAYER)
2536	{	2738	{
2537	apply_armour_improver (op, tmp);	2739	apply_armour_improver (who, op);
2538	return 1;	2740	return 1;
2539	}	2741	}
2540	else	2742	else
2541	return 0;	2743	return 0;
2542		2744
2543	case WEAPON_IMPROVER:	2745	case WEAPON_IMPROVER:
2544	check_improve_weapon (op, tmp);	2746	check_improve_weapon (who, op);
2545	return 1;	2747	return 1;
2546		2748
2547	case CLOCK:	2749	case CLOCK:
2548	if (op->type == PLAYER)	2750	if (who->type == PLAYER)
2549	{	2751	{
2550	char buf[MAX_BUF];	2752	char buf[MAX_BUF];
2551	timeofday_t tod;	2753	timeofday_t tod;
2552		2754
2553	get_tod (&tod);	2755	get_tod (&tod);
2554	op->play_sound (sound_find ("sound_clock"));	2756	who->play_sound (sound_find ("sound_clock"));
2555	op->statusmsg (format (	2757	who->statusmsg (format (
2556	"It is %d minute%s past %d o'clock %s",	2758	"It is %d minute%s past %d o'clock %s",
2557	tod.minute + 1, ((tod.minute + 1 < 2) ? "" : "s"),	2759	tod.minute + 1, ((tod.minute + 1 < 2) ? "" : "s"),
2558	((tod.hour % 14 == 0) ? 14 : ((tod.hour) % 14)), ((tod.hour >= 14) ? "pm" : "am")	2760	((tod.hour % 14 == 0) ? 14 : ((tod.hour) % 14)), ((tod.hour >= 14) ? "pm" : "am")
2559	));	2761	));
2560	return 1;	2762	return 1;
2561	}	2763	}
2562	else	2764	else
2563	return 0;	2765	return 0;
2564		2766
2565	case MENU:	2767	case MENU:
2566	if (op->type == PLAYER)	2768	if (who->type == PLAYER)
2567	{	2769	{
2568	shop_listing (tmp, op);	2770	shop_listing (op, who);
2569	return 1;	2771	return 1;
2570	}	2772	}
2571	else	2773	else
2572	return 0;	2774	return 0;
2573		2775
2574	case POWER_CRYSTAL:	2776	case POWER_CRYSTAL:
2575	apply_power_crystal (op, tmp); /* see egoitem.c */	2777	apply_power_crystal (who, op); /* see egoitem.c */
2576	return 1;	2778	return 1;
2577		2779
2578	case LIGHTER: /* for lighting torches/lanterns/etc */	2780	case LIGHTER: /* for lighting torches/lanterns/etc */
2579	if (op->type == PLAYER)	2781	if (who->type == PLAYER)
2580	{	2782	{
2581	apply_lighter (op, tmp);	2783	apply_lighter (who, op);
2582	return 1;	2784	return 1;
2583	}	2785	}
2584	else	2786	else
2585	return 0;	2787	return 0;
2586		2788
2587	case ITEM_TRANSFORMER:	2789	case ITEM_TRANSFORMER:
2588	apply_item_transformer (op, tmp);	2790	apply_item_transformer (who, op);
2589	return 1;	2791	return 1;
2590		2792
2591	default:	2793	default:
2592	return 0;	2794	return 0;
2593	}	2795	}
2594	}	2796	}
2595
2596		2797
2597	/* quiet suppresses the "don't know how to apply" and "you must get it first"	2798	/* quiet suppresses the "don't know how to apply" and "you must get it first"
2598	* messages as needed by player_apply_below(). But there can still be	2799	* messages as needed by player_apply_below(). But there can still be
2599	* "but you are floating high above the ground" messages.	2800	* "but you are floating high above the ground" messages.
2600	*	2801	*
2601	* Same return value as apply() function.	2802	* Same return value as apply() function.
2602	*/	2803	*/
2603	int	2804	int
2604	player_apply (object *pl, object *op, int aflag, int quiet)	2805	player_apply (object *pl, object *op, int aflag, int quiet)
2605	{	2806	{
2606	int tmp;
2607
2608	if (op->env && (pl->move_type & MOVE_FLYING))	2807	if (!op->env && (pl->move_type & MOVE_FLYING))
2609	{	2808	{
2610	/* player is flying and applying object not in inventory */	2809	/* player is flying and applying object not in inventory */
2611	if (!QUERY_FLAG (pl, FLAG_WIZ) && !(op->move_type & MOVE_FLYING))	2810	if (!QUERY_FLAG (pl, FLAG_WIZ) && !(op->move_type & MOVE_FLYING))
2612	{	2811	{
2613	pl->failmsg ("But you are floating high above the ground! H<You have to stop levitating first, if you can.>");	2812	pl->failmsg ("But you are floating high above the ground! "
		2813	"H<You have to stop levitating first, if you can, either by using your levitation skill, "
		2814	"or waiting till the levitation effect wears off.>");
2614	return 0;	2815	return 0;
2615	}	2816	}
2616	}	2817	}
2617		2818
2618	pl->contr->last_used = op;	2819	pl->contr->last_used = op;
2619		2820
2620	tmp = manual_apply (pl, op, aflag);	2821	int tmp = manual_apply (pl, op, aflag);
		2822
2621	if (!quiet)	2823	if (!quiet)
2622	{	2824	{
2623	if (tmp == 0)	2825	if (tmp == 0)
2624	pl->statusmsg (format ("I don't know how to apply the %s.", query_name (op)));	2826	pl->statusmsg (format ("I don't know how to apply the %s.", query_name (op)));
2625	else if (tmp == 2)	2827	else if (tmp == 2)
…		…
2660	* person moving on it, also activate. Added code to make it	2862	* person moving on it, also activate. Added code to make it
2661	* so that at least one of players movement types be that which	2863	* so that at least one of players movement types be that which
2662	* the item needs.	2864	* the item needs.
2663	*/	2865	*/
2664	if (!tmp->invisible || (tmp->move_on & pl->move_type))	2866	if (!tmp->invisible || (tmp->move_on & pl->move_type))
2665	{
2666	if (player_apply (pl, tmp, 0, 1) == 1)	2867	if (player_apply (pl, tmp, 0, 1) == 1)
2667	return;	2868	return;
2668	}	2869
2669	if (floors >= 2)	2870	if (floors >= 2)
2670	return; /* process at most two floor objects */	2871	return; /* process at most two floor objects */
2671	}	2872	}
2672	}	2873	}
2673		2874
…		…
2717	break;	2918	break;
2718		2919
2719	case SKILL:	2920	case SKILL:
2720	if (who->contr)	2921	if (who->contr)
2721	{	2922	{
		2923	if (IS_COMBAT_SKILL (op->subtype))
		2924	who->change_weapon (who->contr->combat_ob = 0);
		2925	else if (IS_RANGED_SKILL (op->subtype))
		2926	who->change_weapon (who->contr->ranged_ob = 0);
		2927
2722	if (!op->invisible)	2928	if (op->invisible)
		2929	who->statusmsg (format ("You can no longer use the skill: %s.", &op->skill));
		2930	else
2723	who->statusmsg (format ("You stop using the %s.", query_name (op)));	2931	who->statusmsg (format ("You stop using the %s.", query_name (op)));
2724	else
2725	who->statusmsg (format ("You can no longer use the skill: %s.", &op->skill));
2726	}	2932	}
2727		2933
2728	change_abil (who, op);	2934	change_abil (who, op);
2729	CLEAR_FLAG (who, FLAG_READY_SKILL);	2935	CLEAR_FLAG (who, FLAG_READY_SKILL);
2730	break;	2936	break;
…		…
2741	case CLOAK:	2947	case CLOAK:
2742	who->statusmsg (format ("You unwear %s.", query_name (op)));	2948	who->statusmsg (format ("You unwear %s.", query_name (op)));
2743	change_abil (who, op);	2949	change_abil (who, op);
2744	break;	2950	break;
2745		2951
2746	case LAMP:
2747	{
2748	who->statusmsg (format ("You turn off your %s.", &op->name));
2749
2750	object *tmp2 = arch_to_object (op->other_arch);
2751	tmp2->x = op->x;
2752	tmp2->y = op->y;
2753	tmp2->map = op->map;
2754	tmp2->below = op->below;
2755	tmp2->above = op->above;
2756	tmp2->stats.food = op->stats.food;
2757	CLEAR_FLAG (tmp2, FLAG_APPLIED);
2758
2759	if (QUERY_FLAG (op, FLAG_INV_LOCKED))
2760	SET_FLAG (tmp2, FLAG_INV_LOCKED);
2761
2762	if (who->contr)
2763	esrv_del_item (who->contr, op->count);
2764
2765	op->destroy ();
2766	insert_ob_in_ob (tmp2, who);
2767	who->update_stats ();
2768
2769	if (QUERY_FLAG (op, FLAG_CURSED) || QUERY_FLAG (op, FLAG_DAMNED))
2770	{
2771	if (who->contr)
2772	{
2773	who->failmsg ("Oops, it feels deadly cold!");
2774	SET_FLAG (tmp2, FLAG_KNOWN_CURSED);
2775	}
2776	}
2777
2778	if (who->contr)
2779	esrv_send_item (who, tmp2);
2780	}
2781
2782	return 1; /* otherwise, an attempt to drop causes problems */
2783
2784	case BOW:	2952	case BOW:
2785	case WAND:	2953	case WAND:
2786	case ROD:	2954	case ROD:
2787	case HORN:	2955	case HORN:
2788	if (player *pl = who->contr)	2956	if (player *pl = who->contr)
…		…
2815	default:	2983	default:
2816	who->statusmsg (format ("You unapply %s.", query_name (op)));	2984	who->statusmsg (format ("You unapply %s.", query_name (op)));
2817	break;	2985	break;
2818	}	2986	}
2819		2987
		2988	if (aflags & AP_NO_MERGE || !merge_ob (op, 0))
		2989	if (object *pl = op->visible_to ())
		2990	esrv_send_item (pl, op);
		2991
2820	who->update_stats ();	2992	who->update_stats ();
2821
2822	if (!(aflags & AP_NO_MERGE))
2823	{
2824	object *tmp = merge_ob (op, 0);
2825
2826	if (who->contr)
2827	{
2828	if (tmp)
2829	{ /* it was merged */
2830	esrv_del_item (who->contr, op->count);
2831	op = tmp;
2832	}
2833
2834	esrv_send_item (who, op);
2835	}
2836	}
2837		2993
2838	return 0;	2994	return 0;
2839	}	2995	}
2840		2996
2841	/**	2997	/**
…		…
3139	return 1;	3295	return 1;
3140	}	3296	}
3141		3297
3142	return unapply_special (who, op, aflags);	3298	return unapply_special (who, op, aflags);
3143	}	3299	}
3144
3145	if (basic_flag == AP_UNAPPLY)	3300	else if (basic_flag == AP_UNAPPLY)
3146	return 0;	3301	return 0;
3147		3302
3148	// if the item is combat/ranged, wield the relevant slot first	3303	// if the item is combat/ranged, wield the relevant slot first
3149	// to resolve conflicts.	3304	// to resolve conflicts.
3150	if (player *pl = who->contr)	3305	if (player *pl = who->contr)
…		…
3220		3375
3221	/* Ok. We are now at the state where we can apply the new object.	3376	/* Ok. We are now at the state where we can apply the new object.
3222	* Note that we don't have the checks for can_use_...	3377	* Note that we don't have the checks for can_use_...
3223	* below - that is already taken care of by can_apply_object.	3378	* below - that is already taken care of by can_apply_object.
3224	*/	3379	*/
3225	if (op->nrof > 1)	3380	tmp = op->nrof > 1 ? op->split (op->nrof - 1) : 0;
3226	tmp = get_split_ob (op, op->nrof - 1);
3227	else
3228	tmp = 0;
3229		3381
3230	if (INVOKE_OBJECT (BE_READY, op, ARG_OBJECT (who)) || INVOKE_OBJECT (READY, who, ARG_OBJECT (op)))	3382	if (INVOKE_OBJECT (BE_READY, op, ARG_OBJECT (who)) || INVOKE_OBJECT (READY, who, ARG_OBJECT (op)))
3231	return RESULT_INT (0);	3383	return RESULT_INT (0);
3232		3384
3233	switch (op->type)	3385	switch (op->type)
3234	{	3386	{
3235	case WEAPON:	3387	case WEAPON:
3236	if (!check_weapon_power (who, op->last_eat))	3388	if (!check_weapon_power (who, op->last_eat))
3237	{	3389	{
3238	op->failmsg ("This weapon is too powerful for you to use. It would consume your soul!." LACK_ITEM_POWER);	3390	op->failmsg ("This weapon is too powerful for you to use. It would consume your soul!" LACK_ITEM_POWER);
3239		3391
3240	if (tmp)	3392	if (tmp)
3241	insert_ob_in_ob (tmp, who);	3393	insert_ob_in_ob (tmp, who);
3242		3394
3243	return 1;	3395	return 1;
3244	}	3396	}
3245		3397
3246	//TODO: this obviously fails for players using a shorter prefix	3398	//TODO: this obviously fails for players using a shorter prefix
3247	// i.e. "R" can use Ragnarok's sword.	3399	// i.e. "R" can use Ragnarok's sword.
3248	if (op->level && (strncmp (op->name, who->name, strlen (who->name))))	3400	if (op->level && !op->name.starts_with (who->name))
3249	{	3401	{
3250	/* if the weapon does not have the name as the character, can't use it. */	3402	/* if the weapon does not have the name as the character, can't use it. */
3251	/* (Ragnarok's sword attempted to be used by Foo: won't work) */	3403	/* (Ragnarok's sword attempted to be used by Foo: won't work) */
3252	who->failmsg ("The weapon does not recognize you as its owner. H<Its name indicates that it belongs to somebody else.>");	3404	who->failmsg ("The weapon does not recognize you as its owner. H<Its name indicates that it belongs to somebody else.>");
3253		3405
…		…
3287	case AMULET:	3439	case AMULET:
3288	SET_FLAG (op, FLAG_APPLIED);	3440	SET_FLAG (op, FLAG_APPLIED);
3289	who->statusmsg (format ("You wear %s.", query_name (op)));	3441	who->statusmsg (format ("You wear %s.", query_name (op)));
3290	change_abil (who, op);	3442	change_abil (who, op);
3291	break;	3443	break;
3292
3293	case LAMP:
3294	if (op->stats.food < 1)
3295	{
3296	who->failmsg (format (
3297	"Your %s is out of fuel! "
3298	"H<Lamps and similar items need fuel. They cannot be refilled.>",
3299	&op->name
3300	));
3301	return 1;
3302	}
3303
3304	who->statusmsg (format ("You turn on your %s.", &op->name));
3305
3306	tmp2 = arch_to_object (op->other_arch);
3307	tmp2->stats.food = op->stats.food;
3308	SET_FLAG (tmp2, FLAG_APPLIED);
3309
3310	if (QUERY_FLAG (op, FLAG_INV_LOCKED))
3311	SET_FLAG (tmp2, FLAG_INV_LOCKED);
3312
3313	insert_ob_in_ob (tmp2, who);
3314
3315	/* Remove the old lantern */
3316	if (who->type == PLAYER)
3317	esrv_del_item (who->contr, op->count);
3318
3319	op->destroy ();
3320
3321	/* insert the portion that was split off */
3322	if (tmp)
3323	{
3324	insert_ob_in_ob (tmp, who);
3325	if (who->type == PLAYER)
3326	esrv_send_item (who, tmp);
3327	}
3328
3329	who->update_stats ();
3330
3331	if (QUERY_FLAG (op, FLAG_CURSED) || QUERY_FLAG (op, FLAG_DAMNED))
3332	if (who->type == PLAYER)
3333	{
3334	who->failmsg ("Oops, it feels deadly cold! H<Maybe it wasn't such a bright idea to apply this cursed/damned item.>");
3335	SET_FLAG (tmp2, FLAG_KNOWN_CURSED);
3336	}
3337
3338	if (who->type == PLAYER)
3339	esrv_send_item (who, tmp2);
3340
3341	return 0;
3342		3444
3343	case SKILL_TOOL:	3445	case SKILL_TOOL:
3344	// applying a skill tool also readies the skill	3446	// applying a skill tool also readies the skill
3345	SET_FLAG (op, FLAG_APPLIED);	3447	SET_FLAG (op, FLAG_APPLIED);
3346		3448
…		…
3436	insert_ob_in_ob (tmp, who);	3538	insert_ob_in_ob (tmp, who);
3437		3539
3438	return 1;	3540	return 1;
3439	}	3541	}
3440		3542
3441	if (op->level && (strncmp (op->name, who->name, strlen (who->name))))	3543	if (op->level && !op->name.starts_with (who->name))
3442	{	3544	{
3443	who->failmsg ("The weapon does not recognize you as its owner. "	3545	who->failmsg ("The weapon does not recognize you as its owner. "
3444	"H<Its name indicates that it belongs to somebody else.>");	3546	"H<Its name indicates that it belongs to somebody else.>");
3445	if (tmp)	3547	if (tmp)
3446	insert_ob_in_ob (tmp, who);	3548	insert_ob_in_ob (tmp, who);
…		…
3504	}	3606	}
3505		3607
3506	SET_FLAG (op, FLAG_APPLIED);	3608	SET_FLAG (op, FLAG_APPLIED);
3507		3609
3508	if (tmp)	3610	if (tmp)
3509	tmp = insert_ob_in_ob (tmp, who);	3611	who->insert (tmp);
3510		3612
3511	who->update_stats ();	3613	who->update_stats ();
3512		3614
3513	/* We exclude spell casting objects. The fire code will set the	3615	/* We exclude spell casting objects. The fire code will set the
3514	* been applied flag when they are used - until that point,	3616	* been applied flag when they are used - until that point,
…		…
3520	if (QUERY_FLAG (op, FLAG_CURSED) || QUERY_FLAG (op, FLAG_DAMNED))	3622	if (QUERY_FLAG (op, FLAG_CURSED) || QUERY_FLAG (op, FLAG_DAMNED))
3521	if (who->type == PLAYER)	3623	if (who->type == PLAYER)
3522	{	3624	{
3523	who->failmsg (	3625	who->failmsg (
3524	"Oops, it feels deadly cold! "	3626	"Oops, it feels deadly cold! "
3525	"H<Maybe it wasn't such a bright idea to apply this cursed/damned item.>"	3627	"H<Maybe it wasn't such a bright idea to apply this cursed or damned item.>"
3526	);	3628	);
3527	SET_FLAG (op, FLAG_KNOWN_CURSED);	3629	SET_FLAG (op, FLAG_KNOWN_CURSED);
3528	}	3630	}
3529		3631
3530	if (who->type == PLAYER)	3632	if (object *pl = op->visible_to ())
3531	{
3532	/* if multiple objects were applied, update both slots */
3533	if (tmp)
3534	esrv_send_item (who, tmp);
3535
3536	esrv_send_item (who, op);	3633	esrv_send_item (pl, op);
3537	}
3538		3634
3539	return 0;	3635	return 0;
3540	}	3636	}
3541		3637
3542	int	3638	int
…		…
3556	int	3652	int
3557	auto_apply (object *op)	3653	auto_apply (object *op)
3558	{	3654	{
3559	object *tmp = NULL, *tmp2;	3655	object *tmp = NULL, *tmp2;
3560	int i;	3656	int i;
		3657
		3658	CLEAR_FLAG (op, FLAG_AUTO_APPLY);
3561		3659
3562	switch (op->type)	3660	switch (op->type)
3563	{	3661	{
3564	case SHOP_FLOOR:	3662	case SHOP_FLOOR:
3565	if (!op->has_random_items ())	3663	if (!op->has_random_items ())
…		…
3567		3665
3568	do	3666	do
3569	{	3667	{
3570	i = 10; /* let's give it 10 tries */	3668	i = 10; /* let's give it 10 tries */
3571	while ((tmp = generate_treasure (op->randomitems,	3669	while ((tmp = generate_treasure (op->randomitems,
3572	op->stats.exp ? (int) op->stats.exp : MAX (op->map->difficulty, 5))) == NULL && --i);	3670	op->stats.exp
		3671	? (int) op->stats.exp
		3672	: max (op->map->difficulty, 5)))
		3673	== NULL && --i);
		3674
3573	if (tmp == NULL)	3675	if (tmp == NULL)
3574	return 0;	3676	return 0;
		3677
3575	if (QUERY_FLAG (tmp, FLAG_CURSED) || QUERY_FLAG (tmp, FLAG_DAMNED))	3678	if (QUERY_FLAG (tmp, FLAG_CURSED) || QUERY_FLAG (tmp, FLAG_DAMNED))
3576	{	3679	{
3577	tmp->destroy ();	3680	tmp->destroy ();
3578	tmp = NULL;	3681	tmp = NULL;
3579	}	3682	}
…		…
3582		3685
3583	tmp->x = op->x;	3686	tmp->x = op->x;
3584	tmp->y = op->y;	3687	tmp->y = op->y;
3585	SET_FLAG (tmp, FLAG_UNPAID);	3688	SET_FLAG (tmp, FLAG_UNPAID);
3586	insert_ob_in_map (tmp, op->map, NULL, 0);	3689	insert_ob_in_map (tmp, op->map, NULL, 0);
3587	CLEAR_FLAG (op, FLAG_AUTO_APPLY);
3588	identify (tmp);	3690	identify (tmp);
3589	break;	3691	break;
3590		3692
3591	case TREASURE:	3693	case TREASURE:
3592	if (QUERY_FLAG (op, FLAG_IS_A_TEMPLATE))	3694	if (QUERY_FLAG (op, FLAG_IS_A_TEMPLATE))
…		…
3599	/* If we generated an object and put it in this object inventory,	3701	/* If we generated an object and put it in this object inventory,
3600	* move it to the parent object as the current object is about	3702	* move it to the parent object as the current object is about
3601	* to disappear. An example of this item is the random_* stuff	3703	* to disappear. An example of this item is the random_* stuff
3602	* that is put inside other objects.	3704	* that is put inside other objects.
3603	*/	3705	*/
3604	for (tmp = op->inv; tmp; tmp = tmp2)
3605	{
3606	tmp2 = tmp->below;
3607	tmp->remove ();
3608
3609	if (op->env)	3706	if (op->env)
3610	insert_ob_in_ob (tmp, op->env);	3707	while (op->inv)
3611	else	3708	op->env->insert (op->inv);
3612	tmp->destroy ();
3613	}
3614		3709
3615	op->destroy ();	3710	op->destroy ();
3616	break;	3711	break;
3617	}	3712	}
3618	return tmp ? 1 : 0;	3713
		3714	return !!tmp;
3619	}	3715	}
3620		3716
3621	/**	3717	/**
3622	* fix_auto_apply goes through the entire map every time a map	3718	* fix_auto_apply goes through the entire map every time a map
3623	* is loaded or swapped in and performs special actions for	3719	* is loaded or swapped in and performs special actions for
…		…
3637		3733
3638	if (tmp->inv)	3734	if (tmp->inv)
3639	{	3735	{
3640	object *invtmp, *invnext;	3736	object *invtmp, *invnext;
3641		3737
3642	for (invtmp = tmp->inv; invtmp != NULL; invtmp = invnext)	3738	for (invtmp = tmp->inv; invtmp; invtmp = invnext)
3643	{	3739	{
3644	invnext = invtmp->below;	3740	invnext = invtmp->below;
3645		3741
3646	if (QUERY_FLAG (invtmp, FLAG_AUTO_APPLY))	3742	if (QUERY_FLAG (invtmp, FLAG_AUTO_APPLY))
3647	auto_apply (invtmp);	3743	auto_apply (invtmp);
3648	else if (invtmp->type == TREASURE && invtmp->has_random_items ())	3744	else if (invtmp->type == TREASURE && invtmp->has_random_items ())
3649	{	3745	{
3650	while ((invtmp->stats.hp--) > 0)	3746	while (invtmp->stats.hp-- > 0)
3651	create_treasure (invtmp->randomitems, invtmp, 0, difficulty, 0);	3747	create_treasure (invtmp->randomitems, invtmp, 0, difficulty, 0);
3652		3748
3653	invtmp->randomitems = NULL;	3749	invtmp->randomitems = NULL;
3654	}	3750	}
3655	else if (invtmp && invtmp->arch	3751	else if (invtmp && invtmp->arch
…		…
3767	/* check for hp, sp change */	3863	/* check for hp, sp change */
3768	if (food->stats.hp != 0)	3864	if (food->stats.hp != 0)
3769	{	3865	{
3770	if (QUERY_FLAG (food, FLAG_CURSED))	3866	if (QUERY_FLAG (food, FLAG_CURSED))
3771	{	3867	{
3772	assign (who->contr->killer, food->name);	3868	who->contr->killer = food;
3773	hit_player (who, food->stats.hp, food, AT_POISON, 1);	3869	hit_player (who, food->stats.hp, food, AT_POISON, 1);
3774	who->failmsg ("Eck!...that was poisonous!");	3870	who->failmsg ("Eck!...that was poisonous!");
3775	}	3871	}
3776	else	3872	else
3777	{	3873	{
…		…
3781	who->failmsg ("Eck!...that was poisonous!");	3877	who->failmsg ("Eck!...that was poisonous!");
3782		3878
3783	who->stats.hp += food->stats.hp;	3879	who->stats.hp += food->stats.hp;
3784	}	3880	}
3785	}	3881	}
		3882
3786	if (food->stats.sp != 0)	3883	if (food->stats.sp != 0)
3787	{	3884	{
3788	if (QUERY_FLAG (food, FLAG_CURSED))	3885	if (QUERY_FLAG (food, FLAG_CURSED))
3789	{	3886	{
3790	who->failmsg ("You are drained of mana!");	3887	who->failmsg ("You are drained of mana!");
…		…
3801	}	3898	}
3802		3899
3803	who->update_stats ();	3900	who->update_stats ();
3804	}	3901	}
3805		3902
3806	/**
3807	* Designed primarily to light torches/lanterns/etc.
3808	* Also burns up burnable material too. First object in the inventory is
3809	* the selected object to "burn". -b.t.
3810	*/
3811	void
3812	apply_lighter (object *who, object *lighter)
3813	{
3814	object *item;
3815	int is_player_env = 0;
3816
3817	item = find_marked_object (who);
3818	if (item)
3819	{
3820	if (lighter->last_eat && lighter->stats.food)
3821	{ /* lighter gets used up */
3822	/* Split multiple lighters if they're being used up. Otherwise *
3823	* one charge from each would be used up. --DAMN */
3824	if (lighter->nrof > 1)
3825	{
3826	object *oneLighter = lighter->clone ();
3827
3828	lighter->nrof -= 1;
3829	oneLighter->nrof = 1;
3830	oneLighter->stats.food--;
3831	esrv_send_item (who, lighter);
3832	oneLighter = insert_ob_in_ob (oneLighter, who);
3833	esrv_send_item (who, oneLighter);
3834	}
3835	else
3836	lighter->stats.food--;
3837	}
3838	else if (lighter->last_eat)
3839	{
3840	/* no charges left in lighter */
3841	who->failmsg (format ("You attempt to light the %s with a used up %s.", &item->name, &lighter->name));
3842	return;
3843	}
3844
3845	/* Perhaps we should split what we are trying to light on fire?
3846	* I can't see many times when you would want to light multiple
3847	* objects at once.
3848	*/
3849
3850	if (who == item->in_player ())
3851	is_player_env = 1;
3852
3853	save_throw_object (item, AT_FIRE, who);
3854
3855	if (item->destroyed ())
3856	{
3857	who->statusmsg (format ("You light the %s with the %s.", &item->name, &lighter->name));
3858	/* Need to update the player so that the players glow radius
3859	* gets changed.
3860	*/
3861	if (is_player_env)
3862	who->update_stats ();
3863	}
3864	else
3865	who->failmsg (format ("You attempt to light the %s with the %s and fail.", &item->name, &lighter->name));
3866	}
3867	else
3868	who->failmsg ("You need to mark a lightable object.");
3869	}
3870		3903
3871	/**	3904	/**
3872	* op made some mistake with a scroll, this takes care of punishment.	3905	* op made some mistake with a scroll, this takes care of punishment.
3873	* scroll_failure()- hacked directly from spell_failure	3906	* scroll_failure()- hacked directly from spell_failure
3874	*/	3907	*/
…		…
3974	}	4007	}
3975		4008
3976	/* insert the randomitems from the change's treasurelist into	4009	/* insert the randomitems from the change's treasurelist into
3977	* the player ref: player.c	4010	* the player ref: player.c
3978	*/	4011	*/
3979	if (change->randomitems != NULL)	4012	if (change->randomitems)
3980	give_initial_items (pl, change->randomitems);	4013	give_initial_items (pl, change->randomitems);
3981		4014
3982	/* set up the face, for some races. */	4015	/* set up the face, for some races. */
3983		4016
3984	/* first, look for the force object banning	4017	/* first, look for the force object banning
3985	* changing the face. Certain races never change face with class.	4018	* changing the face. Certain races never change face with class.
3986	*/	4019	*/
3987	for (walk = pl->inv; walk != NULL; walk = walk->below)	4020	for (walk = pl->inv; walk; walk = walk->below)
3988	if (!strcmp (walk->name, "NOCLASSFACECHANGE"))	4021	if (walk->name == shstr_NOCLASSFACECHANGE)
3989	flag_change_face = 0;	4022	flag_change_face = 0;
3990		4023
3991	if (flag_change_face)	4024	if (flag_change_face)
3992	{	4025	{
3993	pl->animation_id = GET_ANIM_ID (change);
3994	pl->face = change->face;	4026	pl->face = change->face;
3995		4027	pl->animation_id = change->animation_id;
3996	if (QUERY_FLAG (change, FLAG_ANIMATE))	4028	pl->flag [FLAG_ANIMATE] = change->flag [FLAG_ANIMATE];
3997	SET_FLAG (pl, FLAG_ANIMATE);
3998	else
3999	CLEAR_FLAG (pl, FLAG_ANIMATE);
4000	}	4029	}
4001		4030
4002	/* check the special case of can't use weapons */	4031	/* check the special case of can't use weapons */
4003	/*if(QUERY_FLAG(change,FLAG_USE_WEAPON)) CLEAR_FLAG(pl,FLAG_USE_WEAPON); */	4032	/*if(QUERY_FLAG(change,FLAG_USE_WEAPON)) CLEAR_FLAG(pl,FLAG_USE_WEAPON); */
4004	if (!strcmp (change->name, "monk"))	4033	if (change->name == shstr_monk)
4005	CLEAR_FLAG (pl, FLAG_USE_WEAPON);	4034	CLEAR_FLAG (pl, FLAG_USE_WEAPON);
4006		4035
4007	break;	4036	break;
4008	}	4037	}
4009	}	4038	}
…		…
4046	pl->failmsg (format ("You can't use the %s with your %s!", query_name (transformer), query_name (marked)));	4075	pl->failmsg (format ("You can't use the %s with your %s!", query_name (transformer), query_name (marked)));
4047	return;	4076	return;
4048	}	4077	}
4049		4078
4050	/* check whether they are compatible or not */	4079	/* check whether they are compatible or not */
4051	find = strstr (marked->slaying, transformer->arch->archname);	4080	find = strstr (&marked->slaying, transformer->arch->archname);
4052	if (!find || (*(find + strlen (transformer->arch->archname)) != ':'))	4081	if (!find || (*(find + strlen (transformer->arch->archname)) != ':'))
4053	{	4082	{
4054	pl->failmsg (format ("You can't use the %s with your %s!", query_name (transformer), query_name (marked)));	4083	pl->failmsg (format ("You can't use the %s with your %s!", query_name (transformer), query_name (marked)));
4055	return;	4084	return;
4056	}	4085	}
…		…
4098		4127
4099	new_item->nrof = yield;	4128	new_item->nrof = yield;
4100		4129
4101	pl->statusmsg (format ("You %s the %s.", &transformer->slaying, query_base_name (marked, 0)));	4130	pl->statusmsg (format ("You %s the %s.", &transformer->slaying, query_base_name (marked, 0)));
4102		4131
4103	insert_ob_in_ob (new_item, pl);	4132	pl->insert (new_item);
4104	esrv_send_inventory (pl, pl);
4105	/* Eat up one item */	4133	/* Eat up one item */
4106	decrease_ob_nr (marked, 1);	4134	marked->decrease ();
4107		4135
4108	/* Eat one transformer if needed */	4136	/* Eat one transformer if needed */
4109	if (transformer->stats.food)	4137	if (transformer->stats.food)
4110	if (--transformer->stats.food == 0)	4138	if (--transformer->stats.food == 0)
4111	decrease_ob_nr (transformer, 1);	4139	transformer->decrease ();
4112	}	4140	}
4113		4141

Diff Legend

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