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.158 by root, Wed May 7 19:19:09 2008 UTC vs.
Revision 1.201 by root, Mon Oct 12 14:00:58 2009 UTC

…		…
3	*	3	*
4	* Copyright (©) 2005,2006,2007,2008 Marc Alexander Lehmann / Robin Redeker / the Deliantra team	4	* Copyright (©) 2005,2006,2007,2008 Marc Alexander Lehmann / Robin Redeker / the Deliantra team
5	* Copyright (©) 2001,2007 Mark Wedel & Crossfire Development Team	5	* Copyright (©) 2001,2007 Mark Wedel & Crossfire Development Team
6	* Copyright (©) 1992,2007 Frank Tore Johansen	6	* Copyright (©) 1992,2007 Frank Tore Johansen
7	*	7	*
8	* Deliantra is free software: you can redistribute it and/or modify	8	* Deliantra is free software: you can redistribute it and/or modify it under
9	* it under the terms of the GNU General Public License as published by	9	* the terms of the Affero GNU General Public License as published by the
10	* the Free Software Foundation, either version 3 of the License, or	10	* Free Software Foundation, either version 3 of the License, or (at your
11	* (at your option) any later version.	11	* option) any later version.
12	*	12	*
13	* This program is distributed in the hope that it will be useful,	13	* This program is distributed in the hope that it will be useful,
14	* but WITHOUT ANY WARRANTY; without even the implied warranty of	14	* but WITHOUT ANY WARRANTY; without even the implied warranty of
15	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the	15	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16	* GNU General Public License for more details.	16	* GNU General Public License for more details.
17	*	17	*
18	* You should have received a copy of the GNU General Public License	18	* You should have received a copy of the Affero GNU General Public License
19	* along with this program. If not, see <http://www.gnu.org/licenses/>.	19	* and the GNU General Public License along with this program. If not, see
		20	* <http://www.gnu.org/licenses/>.
20	*	21	*
21	* The authors can be reached via e-mail to <support@deliantra.net>	22	* The authors can be reached via e-mail to <support@deliantra.net>
22	*/	23	*/
23		24
24	#include <cmath>	25	#include <cmath>
…		…
53	* subtype 5: arch or race	54	* subtype 5: arch or race
54	* subtype 7: all three	55	* subtype 7: all three
55	*/	56	*/
56	if (op->subtype)	57	if (op->subtype)
57	{	58	{
58	arch_flag = (op->subtype & 1);	59	arch_flag = op->subtype & 1;
59	name_flag = (op->subtype & 2);	60	name_flag = op->subtype & 2;
60	race_flag = (op->subtype & 4);	61	race_flag = op->subtype & 4;
61	}	62	}
62	else	63	else
63	{	64	{
64	arch_flag = 1;	65	arch_flag = 1;
65	name_flag = 1;	66	name_flag = 1;
…		…
92	* Return value: 1 if money was destroyed, 0 if not.	93	* Return value: 1 if money was destroyed, 0 if not.
93	*/	94	*/
94	static int	95	static int
95	apply_id_altar (object *money, object *altar, object *pl)	96	apply_id_altar (object *money, object *altar, object *pl)
96	{	97	{
97	dynbuf_text buf;	98	dynbuf_text &buf = msg_dynbuf; buf.clear ();
98		99
99	if (!pl || pl->type != PLAYER)	100	if (!pl || pl->type != PLAYER)
100	return 0;	101	return 0;
101		102
102	/* Check for MONEY type is a special hack - it prevents 'nothing needs	103	/* Check for MONEY type is a special hack - it prevents 'nothing needs
103	* identifying' from being printed out more than it needs to be.	104	* identifying' from being printed out more than it needs to be.
104	*/	105	*/
105	if (!check_altar_sacrifice (altar, money) || money->type != MONEY)	106	if (!check_altar_sacrifice (altar, money, pl) || money->type != MONEY)
106	return 0;	107	return 0;
107		108
108	/* if the player has a marked item, identify that if it needs to be	109	/* if the player has a marked item, identify that if it needs to be
109	* identified. If it doesn't, then go through the player inventory.	110	* identified. If it doesn't, then go through the player inventory.
110	*/	111	*/
111	if (object *marked = find_marked_object (pl))	112	if (object *marked = find_marked_object (pl))
112	if (!QUERY_FLAG (marked, FLAG_IDENTIFIED) && need_identify (marked))	113	if (!QUERY_FLAG (marked, FLAG_IDENTIFIED) && need_identify (marked))
113	{	114	{
114	if (operate_altar (altar, &money))	115	if (operate_altar (altar, &money, pl))
115	{	116	{
116	identify (marked);	117	identify (marked);
117		118
118	buf.printf ("You have %s.\n\n", long_desc (marked, pl));	119	buf.printf ("You have %s.\r", long_desc (marked, pl));
119	if (marked->msg)	120	if (marked->msg)
120	buf << "The item has a story:\n\n" << marked->msg << "\n\n";	121	buf << "The item has a story:\r" << marked->msg << "\n\n";
121		122
122	return !money;	123	return !money;
123	}	124	}
124	}	125	}
125		126
126	for (object *id = pl->inv; id; id = id->below)	127	for (object *id = pl->inv; id; id = id->below)
127	{	128	{
128	if (!QUERY_FLAG (id, FLAG_IDENTIFIED) && !id->invisible && need_identify (id))	129	if (!QUERY_FLAG (id, FLAG_IDENTIFIED) && !id->invisible && need_identify (id))
129	{	130	{
130	if (operate_altar (altar, &money))	131	if (operate_altar (altar, &money, pl))
131	{	132	{
132	identify (id);	133	identify (id);
133		134
134	buf.printf ("You have %s.\n\n", long_desc (id, pl));	135	buf.printf ("You have %s.\r", long_desc (id, pl));
135	if (id->msg)	136	if (id->msg)
136	buf << "The item has a story:\n\n" << id->msg << "\n\n";	137	buf << "The item has a story:\r" << id->msg << "\n\n";
137		138
138	/* If no more money, might as well quit now */	139	/* If no more money, might as well quit now */
139	if (!money || !check_altar_sacrifice (altar, money))	140	if (!money || !check_altar_sacrifice (altar, money))
140	break;	141	break;
141	}	142	}
…		…
160	* matching item.	161	* matching item.
161	**/	162	**/
162	void	163	void
163	handle_apply_yield (object *tmp)	164	handle_apply_yield (object *tmp)
164	{	165	{
165	if (shstr yield = tmp->kv (shstr_on_use_yield))	166	if (shstr_tmp yield = tmp->kv (shstr_on_use_yield))
166	archetype::get (yield)->insert_at (tmp, tmp, INS_BELOW_ORIGINATOR);	167	archetype::get (yield)->insert_at (tmp, tmp, INS_BELOW_ORIGINATOR);
167	}	168	}
168		169
169	/**	170	/**
170	* Handles applying a potion.	171	* Handles applying a potion.
…		…
315	*/	316	*/
316	if (tmp->inv)	317	if (tmp->inv)
317	{	318	{
318	if (QUERY_FLAG (tmp, FLAG_CURSED) || QUERY_FLAG (tmp, FLAG_DAMNED))	319	if (QUERY_FLAG (tmp, FLAG_CURSED) || QUERY_FLAG (tmp, FLAG_DAMNED))
319	{	320	{
320	object *fball;
321
322	op->failmsg ("Yech! Your lungs are on fire!");	321	op->failmsg ("Yech! Your lungs are on fire!");
323		322	create_exploding_ball_at (op, op->level);
324	/* Explodes a fireball centered at player */
325	fball = get_archetype (EXPLODING_FIREBALL);
326	fball->dam_modifier = random_roll (1, op->level, op, PREFER_LOW) / 5 + 1;
327	fball->stats.maxhp = random_roll (1, op->level, op, PREFER_LOW) / 10 + 2;
328	fball->x = op->x;
329	fball->y = op->y;
330	insert_ob_in_map (fball, op->map, NULL, 0);
331	}	323	}
332	else	324	else
333	cast_spell (op, tmp, op->facing, tmp->inv, NULL);	325	cast_spell (op, tmp, op->facing, tmp->inv, NULL);
334		326
335	tmp->decrease ();	327	tmp->decrease ();
…		…
378	}	370	}
379		371
380	/* Only thing left are the stat potions */	372	/* Only thing left are the stat potions */
381	if (op->type == PLAYER)	373	if (op->type == PLAYER)
382	{ /* only for players */	374	{ /* only for players */
383	if ((QUERY_FLAG (tmp, FLAG_CURSED) || QUERY_FLAG (tmp, FLAG_DAMNED)) && tmp->value != 0)	375	if ((QUERY_FLAG (tmp, FLAG_CURSED)
		376	|| QUERY_FLAG (tmp, FLAG_DAMNED))
		377	&& tmp->value != 0)
384	CLEAR_FLAG (tmp, FLAG_APPLIED);	378	CLEAR_FLAG (tmp, FLAG_APPLIED);
385	else	379	else
386	SET_FLAG (tmp, FLAG_APPLIED);	380	SET_FLAG (tmp, FLAG_APPLIED);
387		381
388	if (!change_abil (op, tmp))	382	if (!change_abil (op, tmp))
…		…
403	/****************************************************************************	397	/****************************************************************************
404	* Weapon improvement code follows	398	* Weapon improvement code follows
405	****************************************************************************/	399	****************************************************************************/
406		400
407	/**	401	/**
		402	* This function just checks whether who can handle equipping an item
		403	* with item_power.
		404	*/
		405
		406	bool
		407	check_item_power (object *who, int item_power)
		408	{
		409	if (who->type == PLAYER
		410	&& item_power
		411	&& item_power + who->contr->item_power > settings.item_power_factor * who->level)
		412	return false;
		413	else
		414	return true;
		415	}
		416
		417	/**
408	* This returns the sum of nrof of item (arch name).	418	* This returns the sum of nrof of item (arch name).
409	*/	419	*/
410	static int	420	static int
411	check_item (object *op, const char *item)	421	check_item (object *op, shstr_cmp item)
412	{	422	{
413	int count = 0;	423	int count = 0;
414		424
415	if (!item)	425	if (!item)
416	return 0;	426	return 0;
417		427
418	for (op = op->below; op; op = op->below)	428	for (op = op->below; op; op = op->below)
419	{
420	if (strcmp (op->arch->archname, item) == 0)	429	if (op->arch->archname == item)
421	{
422	if (!QUERY_FLAG (op, FLAG_CURSED) && !QUERY_FLAG (op, FLAG_DAMNED)	430	if (!QUERY_FLAG (op, FLAG_CURSED) && !QUERY_FLAG (op, FLAG_DAMNED)
423	/* Loophole bug? -FD- */ && !QUERY_FLAG (op, FLAG_UNPAID))	431	&& /* Loophole bug? -FD- */ !QUERY_FLAG (op, FLAG_UNPAID))
424	{
425	if (op->nrof == 0) /* this is necessary for artifact sacrifices --FD-- */
426	count++;
427	else
428	count += op->nrof;	432	count += op->number_of ();
429	}
430	}
431	}
432		433
433	return count;	434	return count;
434	}	435	}
435		436
436	/**	437	/**
…		…
438	* op is typically the player, which is only	439	* op is typically the player, which is only
439	* really used to determine what space to look at.	440	* really used to determine what space to look at.
440	* Modified to only eat 'nrof' of objects.	441	* Modified to only eat 'nrof' of objects.
441	*/	442	*/
442	static void	443	static void
443	eat_item (object *op, const char *item, uint32 nrof)	444	eat_item (object *op, shstr_cmp item, uint32 nrof)
444	{	445	{
445	object *prev;	446	object *prev;
446		447
447	prev = op;	448	prev = op;
448	op = op->below;	449	op = op->below;
449		450
450	while (op)	451	while (op)
451	{	452	{
452	if (strcmp (op->arch->archname, item) == 0)	453	if (op->arch->archname == item)
453	{	454	{
454	if (op->nrof >= nrof)	455	if (op->nrof >= nrof)
455	{	456	{
456	op->decrease (nrof);	457	op->decrease (nrof);
457	return;	458	return;
…		…
466	}	467	}
467		468
468	prev = op;	469	prev = op;
469	op = op->below;	470	op = op->below;
470	}	471	}
471	}
472
473	/**
474	* This checks to see of the player (who) is sufficient level to use a weapon
475	* with improvs improvements (typically last_eat). We take an int here
476	* instead of the object so that the improvement code can pass along the
477	* increased value to see if the object is usuable.
478	* we return 1 (true) if the player can use the weapon.
479	*/
480	static int
481	check_weapon_power (const object *who, int improvs)
482	{
483	/* Old code is below (commented out). Basically, since weapons are the only
484	* object players really have any control to improve, it's a bit harsh to
485	* require high level in some combat skill, so we just use overall level.
486	*/
487	#if 1
488	if (((who->level / 5) + 5) >= improvs)
489	return 1;
490	else
491	return 0;
492
493	#else
494	int level = 0;
495
496	/* The skill system hands out wc and dam bonuses to fighters
497	* more generously than the old system (see fix_player). Thus
498	* we need to curtail the power of player enchanted weapons.
499	* I changed this to 1 improvement per "fighter" level/5 -b.t.
500	* Note: Nothing should break by allowing this ratio to be different or
501	* using normal level - it is just a matter of play balance.
502	*/
503	if (who->type == PLAYER)
504	{
505	object *wc_obj = NULL;
506
507	for (wc_obj = who->inv; wc_obj; wc_obj = wc_obj->below)
508	if (wc_obj->type == SKILL && IS_COMBAT_SKILL (wc_obj->subtype) && wc_obj->level > level)
509	level = wc_obj->level;
510
511	if (!level)
512	{
513	LOG (llevError, "Error: Player: %s lacks wc experience object\n", who->name);
514	level = who->level;
515	}
516	}
517	else
518	level = who->level;
519
520	return (improvs <= ((level / 5) + 5));
521	#endif
522	}	472	}
523		473
524	/**	474	/**
525	* Returns how many items of type improver->slaying there are under op.	475	* Returns how many items of type improver->slaying there are under op.
526	* Will display a message if none found, and 1 if improver->slaying is NULL.	476	* Will display a message if none found, and 1 if improver->slaying is NULL.
…		…
608	weapon->stats.exp || /* speed */	558	weapon->stats.exp || /* speed */
609	weapon->stats.ac) /* AC - only taifu's I think */	559	weapon->stats.ac) /* AC - only taifu's I think */
610	{	560	{
611	op->failmsg ("You cannot prepare magic weapons. "	561	op->failmsg ("You cannot prepare magic weapons. "
612	"H<A weapon is considered magical if it changes regeneration, "	562	"H<A weapon is considered magical if it changes regeneration, "
613	"speed or ac.>");	563	"speed or ac, or has other protections.>");
614	return 0;	564	return 0;
615	}	565	}
616		566
617	sacrifice_count = check_sacrifice (op, improver);	567	sacrifice_count = check_sacrifice (op, improver);
618	if (sacrifice_count <= 0)	568	if (sacrifice_count <= 0)
…		…
655	if (improver->stats.sp == IMPROVE_PREPARE)	605	if (improver->stats.sp == IMPROVE_PREPARE)
656	return prepare_weapon (op, improver, weapon);	606	return prepare_weapon (op, improver, weapon);
657		607
658	if (weapon->level == 0)	608	if (weapon->level == 0)
659	{	609	{
660	op->failmsg ("This weapon has not been prepared. H<You first ahve to prepare a weapon with a prepare weapon scroll.>");	610	op->failmsg (
		611	"This weapon has not been prepared."
		612	" H<You first have to prepare a weapon with a prepare weapon scroll.>");
661	return 0;	613	return 0;
662	}	614	}
663		615
664	if (weapon->level == weapon->last_eat && weapon->item_power >= 100)	616	if (weapon->last_eat >= weapon->level // improvements used up
		617	|| weapon->item_power >= 100) // or item_power >= arbitrary limit of 100
665	{	618	{
666	op->failmsg ("This weapon cannot be improved any more.");	619	op->failmsg ("This weapon cannot be improved any more.");
667	return 0;	620	return 0;
668	}	621	}
669		622
670	if (QUERY_FLAG (weapon, FLAG_APPLIED) && !check_weapon_power (op, weapon->last_eat + 1))	623	if (QUERY_FLAG (weapon, FLAG_APPLIED)
		624	&& !check_item_power (op, weapon->item_power + 1))
671	{	625	{
672	op->failmsg ("Improving the weapon will make it too "	626	op->failmsg ("Improving the weapon will make it too "
673	"powerful for you to use. Unready it if you "	627	"powerful for you to use. Unready it if you "
674	"really want to improve it.");	628	"really want to improve it.");
675	return 0;	629	return 0;
…		…
703	weapon->last_eat++;	657	weapon->last_eat++;
704	weapon->item_power++;	658	weapon->item_power++;
705	improver->decrease ();	659	improver->decrease ();
706	return 1;	660	return 1;
707	}	661	}
		662
708	if (improver->stats.sp == IMPROVE_ENCHANT)	663	if (improver->stats.sp == IMPROVE_ENCHANT)
709	{	664	{
710	weapon->magic++;	665	weapon->magic++;
711	weapon->last_eat++;	666	weapon->last_eat++;
712	op->statusmsg (format ("Weapon magic increased to %d.", weapon->magic));	667	op->statusmsg (format ("Weapon magic increased to %d.", weapon->magic));
…		…
767	op->failmsg ("Something blocks the magic of the scroll!");	722	op->failmsg ("Something blocks the magic of the scroll!");
768	return 0;	723	return 0;
769	}	724	}
770		725
771	otmp = find_marked_object (op);	726	otmp = find_marked_object (op);
		727
772	if (!otmp)	728	if (!otmp)
773	{	729	{
774	op->failmsg ("You need to mark a weapon object. H<Use the mark command or the mark option from the item popup menu.>");	730	op->failmsg ("You need to mark a weapon object. H<Use the mark command or the mark option from the item popup menu.>");
775	return 0;	731	return 0;
776	}	732	}
…		…
902	* Takes one type of items and makes another.	858	* Takes one type of items and makes another.
903	* converter is the object that is doing the conversion.	859	* converter is the object that is doing the conversion.
904	* item is the object that triggered the converter - if it is not	860	* item is the object that triggered the converter - if it is not
905	* what the converter wants, this will not do anything.	861	* what the converter wants, this will not do anything.
906	*/	862	*/
907	static int	863	int
908	convert_item (object *item, object *converter)	864	convert_item (object *item, object *converter)
909	{	865	{
910	sint64 nr, price_in;	866	sint64 nr, price_in;
911		867
912	if (item->flag [FLAG_UNPAID])	868	if (item->flag [FLAG_UNPAID])
…		…
993	item->nrof = give;	949	item->nrof = give;
994		950
995	if (nr)	951	if (nr)
996	item->nrof *= nr;	952	item->nrof *= nr;
997		953
998	if (is_in_shop (converter))	954	if (converter->flag [FLAG_PRECIOUS])
999	SET_FLAG (item, FLAG_UNPAID);	955	SET_FLAG (item, FLAG_UNPAID);
		956
		957	if (is_in_shop (converter))
		958	{
		959	// converters on shop floors don't work anymore, bug lets check for it
		960	// and report in case someone still does it.
		961	LOG (llevDebug, "ITEMBUG: broken converter, converters on shop floor don't work: %s\n",
		962	converter->debug_desc ());
		963	SET_FLAG (item, FLAG_UNPAID);
		964	}
1000	else if (price_in < sint64 (item->nrof) * item->value)	965	else if (price_in < sint64 (item->nrof) * item->value)
1001	{	966	{
1002	LOG (llevDebug, "converter output price higher than input: %s at %s (%d, %d) in value %d, out value %d for %s\n",	967	LOG (llevDebug, "converter output price higher than input: %s at %s (%d, %d) in value %d, out value %d for %s\n",
1003	&converter->name, &converter->map->path, converter->x, converter->y, price_in, item->nrof * item->value, &item->name);	968	&converter->name, &converter->map->path, converter->x, converter->y, price_in, item->nrof * item->value, &item->name);
1004	/**	969	/**
1005	* elmex: we are going to let the game continue, as the mapcreator	970	* elmex: we are going to let the game continue, as the mapcreator
1006	* hopefully had something in mind when doing this.	971	* hopefully had something in mind when doing this.
1007	*/	972	*/
1008	}	973	}
1009		974
1010	SET_FLAG (item, FLAG_IDENTIFIED);	975	// elmex: only identify if we need to, for example so that generated money doesn't
		976	// get an 'identified' flag so easily.
		977	if (need_identify (item))
		978	identify (item);
		979
1011	insert_ob_in_map_at (item, converter->map, converter, 0, converter->x, converter->y);	980	insert_ob_in_map_at (item, converter->map, converter, 0, converter->x, converter->y);
1012	return 1;	981	return 1;
1013	}	982	}
1014		983
1015	/**	984	/**
…		…
1092	{	1061	{
1093	/* Only players can make sacrifices on spell casting altars. */	1062	/* Only players can make sacrifices on spell casting altars. */
1094	if (altar->inv && (!originator || originator->type != PLAYER))	1063	if (altar->inv && (!originator || originator->type != PLAYER))
1095	return 0;	1064	return 0;
1096		1065
1097	if (operate_altar (altar, &sacrifice))	1066	if (operate_altar (altar, &sacrifice, originator))
1098	{	1067	{
1099	/* Simple check. Unfortunately, it means you can't cast magic bullet	1068	/* Simple check. Unfortunately, it means you can't cast magic bullet
1100	* with an altar. We call it a Potion - altars are stationary - it	1069	* with an altar. We call it a Potion - altars are stationary - it
1101	* is up to map designers to use them properly.	1070	* is up to map designers to use them properly.
1102	*/	1071	*/
…		…
1111	/* push_button (altar);*/	1080	/* push_button (altar);*/
1112	}	1081	}
1113	else	1082	else
1114	{	1083	{
1115	altar->value = 1; /* works only once */	1084	altar->value = 1; /* works only once */
1116	push_button (altar);	1085	push_button (altar, originator);
1117	}	1086	}
1118		1087
1119	return !sacrifice;	1088	return !sacrifice;
1120	}	1089	}
1121	else	1090	else
…		…
1138		1107
1139	SET_FLAG (op, FLAG_NO_APPLY); /* prevent loops */	1108	SET_FLAG (op, FLAG_NO_APPLY); /* prevent loops */
1140		1109
1141	bool has_unpaid = false;	1110	bool has_unpaid = false;
1142		1111
1143	// quite inefficient to do this here twice, but the api doesn'T lend itself to	1112	// quite inefficient to do this here twice, but the api doesn't lend itself to
1144	// a quick and small change :(	1113	// a quick and small change :(
1145	for (object::depth_iterator item = op->begin (); item != op->end (); ++item)	1114	for (object::depth_iterator item = op->begin (); item != op->end (); ++item)
1146	if (item->flag [FLAG_UNPAID])	1115	if (item->flag [FLAG_UNPAID])
1147	{	1116	{
1148	has_unpaid = true;	1117	has_unpaid = true;
1149	break;	1118	break;
1150	}	1119	}
1151		1120
1152	if (op->type != PLAYER)	1121	if (!op->is_player ())
1153	{	1122	{
1154	/* Remove all the unpaid objects that may be carried here.	1123	/* Remove all the unpaid objects that may be carried here.
1155	* This could be pets or monsters that are somehow in	1124	* This could be pets or monsters that are somehow in
1156	* the shop.	1125	* the shop.
1157	*/	1126	*/
…		…
1161		1130
1162	if (QUERY_FLAG (tmp, FLAG_UNPAID))	1131	if (QUERY_FLAG (tmp, FLAG_UNPAID))
1163	{	1132	{
1164	int i = find_free_spot (tmp, op->map, op->x, op->y, 1, 9);	1133	int i = find_free_spot (tmp, op->map, op->x, op->y, 1, 9);
1165		1134
		1135	if (i >= 0)
1166	tmp->remove ();	1136	tmp->move (i);
1167
1168	if (i == -1)
1169	i = 0;
1170
1171	tmp->map = op->map;
1172	tmp->x = op->x + freearr_x[i];
1173	tmp->y = op->y + freearr_y[i];
1174	insert_ob_in_map (tmp, op->map, op, 0);
1175	}	1137	}
1176	}	1138	}
1177		1139
1178	/* Don't teleport things like spell effects */	1140	/* Don't teleport things like spell effects */
1179	if (QUERY_FLAG (op, FLAG_NO_PICK))	1141	if (QUERY_FLAG (op, FLAG_NO_PICK))
…		…
1190	if (i != -1)	1152	if (i != -1)
1191	rv = transfer_ob (op, op->x + freearr_x[i], op->y + freearr_y[i], 0, shop_mat);	1153	rv = transfer_ob (op, op->x + freearr_x[i], op->y + freearr_y[i], 0, shop_mat);
1192		1154
1193	return 0;	1155	return 0;
1194	}	1156	}
		1157
1195	/* Removed code that checked for multipart objects - it appears that	1158	/* Removed code that checked for multipart objects - it appears that
1196	* the teleport function should be able to handle this just fine.	1159	* the teleport function should be able to handle this just fine.
1197	*/	1160	*/
1198	rv = teleport (shop_mat, SHOP_MAT, op);	1161	rv = teleport (shop_mat, SHOP_MAT, op);
1199	}	1162	}
…		…
1254	* Handles applying a sign.	1217	* Handles applying a sign.
1255	*/	1218	*/
1256	static void	1219	static void
1257	apply_sign (object *op, object *sign, int autoapply)	1220	apply_sign (object *op, object *sign, int autoapply)
1258	{	1221	{
1259	readable_message_type *msgType;	1222	if (!op->is_player())
		1223	return;
		1224
		1225	if (sign->has_dialogue ())
		1226	{
		1227	op->statusmsg (format ("Maybe you should I<talk> to the %s instead?", &sign->name));
		1228	return;
		1229	}
1260		1230
1261	if (!sign->msg)	1231	if (!sign->msg)
1262	{	1232	{
1263	op->statusmsg ("Nothing is written on it.");	1233	op->contr->infobox (MSG_CHANNEL ("examine"),
		1234	format ("T<%s>\n\n Nothing %sis written on it.",
		1235	&sign->name,
		1236	sign->name == sign->arch->name ? "" : "else "));
1264	return;	1237	return;
1265	}	1238	}
1266		1239
1267	if (sign->stats.food)	1240	if (sign->stats.food)
1268	{	1241	{
1269	if (sign->last_eat >= sign->stats.food)	1242	if (sign->last_eat >= sign->stats.food)
1270	{	1243	{
1271	if (!sign->move_on)	1244	if (!sign->move_on)
1272	op->statusmsg ("You cannot read it anymore.");	1245	op->failmsg ("You cannot read it anymore.");
1273		1246
1274	return;	1247	return;
1275	}	1248	}
1276		1249
1277	if (!QUERY_FLAG (op, FLAG_WIZPASS))	1250	if (!QUERY_FLAG (op, FLAG_WIZPASS))
…		…
1295	if (sign->sound)	1268	if (sign->sound)
1296	ns->play_sound (sign->sound);	1269	ns->play_sound (sign->sound);
1297	else if (autoapply)	1270	else if (autoapply)
1298	ns->play_sound (sound_find ("msg_voice"));	1271	ns->play_sound (sound_find ("msg_voice"));
1299		1272
1300	if (ns->can_msg)
1301	op->contr->infobox (MSG_CHANNEL ("examine"), format ("T<%s>\n\n\n\n%s", &sign->name, &sign->msg));	1273	op->contr->infobox (MSG_CHANNEL ("examine"), format ("T<%s>\n\n%s", &sign->name, &sign->msg));
1302	else
1303	{
1304	msgType = get_readable_message_type (sign);
1305	const char *somemsg = format ("%u %s", autoapply ? 1 : 0, &sign->msg);
1306	draw_ext_info (NDI_UNIQUE | NDI_NAVY, 0, op, msgType->message_type, msgType->message_subtype, somemsg, &sign->msg);
1307	}
1308	}	1274	}
		1275	}
		1276
		1277	static void
		1278	move_apply_hole (object *trap, object *victim)
		1279	{
		1280	/* Hole not open? */
		1281	if (trap->stats.wc > 0)
		1282	return;
		1283
		1284	/* Is this a multipart monster and not the head? If so, return.
		1285	* Processing will happen if the head runs into the pit
		1286	*/
		1287	if (victim->head)
		1288	return;
		1289
		1290	// now find all possible locations and randomly pick one
		1291	int dir = find_free_spot (victim, trap->map, EXIT_X (trap), EXIT_Y (trap), 0,
		1292	trap->range >= 3 ? SIZEOFFREE3 + 1
		1293	: trap->range >= 2 ? SIZEOFFREE2 + 1
		1294	: trap->range >= 1 ? SIZEOFFREE1 + 1
		1295	: SIZEOFFREE0 + 1);
		1296
		1297	if (dir < 0)
		1298	return;
		1299
		1300	victim->play_sound (trap->sound ? trap->sound : sound_find ("fall_hole"));
		1301	victim->statusmsg ("You fall through the hole!", NDI_RED);
		1302
		1303	transfer_ob (victim,
		1304	EXIT_X (trap) + freearr_x[dir],
		1305	EXIT_Y (trap) + freearr_y[dir],
		1306	0, victim);
1309	}	1307	}
1310		1308
1311	/**	1309	/**
1312	* 'victim' moves onto 'trap'	1310	* 'victim' moves onto 'trap'
1313	* 'victim' leaves 'trap'	1311	* 'victim' leaves 'trap'
…		…
1344		1342
1345	recursion_depth++;	1343	recursion_depth++;
1346	if (trap->head)	1344	if (trap->head)
1347	trap = trap->head;	1345	trap = trap->head;
1348		1346
1349	if (INVOKE_OBJECT (MOVE_TRIGGER, trap, ARG_OBJECT (victim), ARG_OBJECT (originator)))	1347	if (!INVOKE_OBJECT (MOVE_TRIGGER, trap, ARG_OBJECT (victim), ARG_OBJECT (originator)))
1350	goto leave;
1351
1352	switch (trap->type)	1348	switch (trap->type)
1353	{	1349	{
1354	case PLAYERMOVER:	1350	case PLAYERMOVER:
1355	if (trap->attacktype && (trap->level || victim->type != PLAYER) && !should_director_abort (trap, victim))	1351	if (trap->attacktype && (trap->level || victim->type != PLAYER) && !should_director_abort (trap, victim))
		1352	{
		1353	if (!trap->stats.maxsp)
		1354	trap->stats.maxsp = 2;
		1355
		1356	/* Is this correct? From the docs, it doesn't look like it
		1357	* should be divided by trap->speed
		1358	*/
		1359	victim->speed_left = -FABS (trap->stats.maxsp * victim->speed / trap->speed);
		1360
		1361	/* Just put in some sanity check. I think there is a bug in the
		1362	* above with some objects have zero speed, and thus the player
		1363	* getting permanently paralyzed.
		1364	*/
		1365	if (victim->speed_left < -50.f)
		1366	victim->speed_left = -50.f;
		1367	/* LOG(llevDebug, "apply, playermove, player speed_left=%f\n", victim->speed_left); */
		1368	}
		1369	break;
		1370
		1371	case SPINNER:
		1372	if (victim->direction)
		1373	{
		1374	victim->direction = absdir (victim->direction - trap->stats.sp);
		1375	update_turn_face (victim);
		1376	}
		1377	break;
		1378
		1379	case DIRECTOR:
		1380	if (victim->direction && !should_director_abort (trap, victim))
		1381	{
		1382	victim->direction = trap->stats.sp;
		1383	update_turn_face (victim);
		1384	}
		1385	break;
		1386
		1387	case BUTTON:
		1388	case PEDESTAL:
		1389	update_button (trap, originator);
		1390	break;
		1391
		1392	case ALTAR:
		1393	/* sacrifice victim on trap */
		1394	apply_altar (trap, victim, originator);
		1395	break;
		1396
		1397	case THROWN_OBJ:
		1398	if (trap->inv == NULL)
		1399	break;
		1400	/* fallthrough */
		1401
		1402	case ARROW:
		1403	/* bad bug: monster throw a object, make a step forwards, step on object ,
		1404	* trigger this here and get hit by own missile - and will be own enemy.
		1405	* Victim then is his own enemy and will start to kill herself (this is
		1406	* removed) but we have not synced victim and his missile. To avoid senseless
		1407	* action, we avoid hits here
		1408	*/
		1409	if ((QUERY_FLAG (victim, FLAG_ALIVE) && trap->speed) && trap->owner != victim)
		1410	hit_with_arrow (trap, victim);
		1411	break;
		1412
		1413	case SPELL_EFFECT:
		1414	apply_spell_effect (trap, victim);
		1415	break;
		1416
		1417	case TRAPDOOR:
1356	{	1418	{
		1419	int max, sound_was_played;
		1420	object *ab, *ab_next;
		1421
1357	if (!trap->stats.maxsp)	1422	if (!trap->value)
1358	trap->stats.maxsp = 2;	1423	{
		1424	int tot;
1359		1425
1360	/* Is this correct? From the docs, it doesn't look like it	1426	for (ab = trap->above, tot = 0; ab; ab = ab->above)
1361	* should be divided by trap->speed	1427	if ((ab->move_type && trap->move_on) || ab->move_type == 0)
		1428	tot += ab->head_ ()->total_weight ();
		1429
		1430	if (!(trap->value = (tot > trap->weight) ? 1 : 0))
		1431	break;
		1432
		1433	SET_ANIMATION (trap, trap->value);
		1434	update_object (trap, UP_OBJ_FACE);
		1435	}
		1436
		1437	for (ab = trap->above, max = 100, sound_was_played = 0; --max && ab; ab = ab_next)
		1438	{
		1439	/* need to set this up, since if we do transfer the object,
		1440	* ab->above would be bogus
1362	*/	1441	*/
1363	victim->speed_left = -FABS (trap->stats.maxsp * victim->speed / trap->speed);	1442	ab_next = ab->above;
1364		1443
1365	/* Just put in some sanity check. I think there is a bug in the	1444	if ((ab->move_type && trap->move_on) || ab->move_type == 0)
1366	* above with some objects have zero speed, and thus the player	1445	{
1367	* getting permanently paralyzed.	1446	if (!sound_was_played)
		1447	{
		1448	trap->play_sound (trap->sound ? trap->sound : sound_find ("fall_hole"));
		1449	sound_was_played = 1;
		1450	}
		1451
		1452	ab->statusmsg ("You fall into a trapdoor!", NDI_RED);
		1453	transfer_ob (ab, EXIT_X (trap), EXIT_Y (trap), 0, ab);
		1454	}
1368	*/	1455	}
1369	if (victim->speed_left < -50.f)	1456	break;
1370	victim->speed_left = -50.f;
1371	/* LOG(llevDebug, "apply, playermove, player speed_left=%f\n", victim->speed_left); */
1372	}	1457	}
1373	goto leave;
1374		1458
1375	case SPINNER:	1459	case CONVERTER:
1376	if (victim->direction)	1460	if (convert_item (victim, trap) < 0)
1377	{
1378	victim->direction = absdir (victim->direction - trap->stats.sp);
1379	update_turn_face (victim);
1380	}
1381	goto leave;
1382
1383	case DIRECTOR:
1384	if (victim->direction && !should_director_abort (trap, victim))
1385	{
1386	victim->direction = trap->stats.sp;
1387	update_turn_face (victim);
1388	}
1389	goto leave;
1390
1391	case BUTTON:
1392	case PEDESTAL:
1393	update_button (trap);
1394	goto leave;
1395
1396	case ALTAR:
1397	/* sacrifice victim on trap */
1398	apply_altar (trap, victim, originator);
1399	goto leave;
1400
1401	case THROWN_OBJ:
1402	if (trap->inv == NULL)
1403	goto leave;
1404	/* fallthrough */
1405
1406	case ARROW:
1407	/* bad bug: monster throw a object, make a step forwards, step on object ,
1408	* trigger this here and get hit by own missile - and will be own enemy.
1409	* Victim then is his own enemy and will start to kill herself (this is
1410	* removed) but we have not synced victim and his missile. To avoid senseless
1411	* action, we avoid hits here
1412	*/
1413	if ((QUERY_FLAG (victim, FLAG_ALIVE) && trap->speed) && trap->owner != victim)
1414	hit_with_arrow (trap, victim);
1415	goto leave;
1416
1417	case SPELL_EFFECT:
1418	apply_spell_effect (trap, victim);
1419	goto leave;
1420
1421	case TRAPDOOR:
1422	{
1423	int max, sound_was_played;
1424	object *ab, *ab_next;
1425
1426	if (!trap->value)
1427	{	1461	{
1428	int tot;	1462	originator->failmsg (format ("The %s seems to be broken!", query_name (trap)));
1429		1463	archetype::get (shstr_burnout)->insert_at (trap, trap);
1430	for (ab = trap->above, tot = 0; ab; ab = ab->above)
1431	if ((ab->move_type && trap->move_on) || ab->move_type == 0)
1432	tot += ab->head_ ()->total_weight ();
1433
1434	if (!(trap->value = (tot > trap->weight) ? 1 : 0))
1435	goto leave;
1436
1437	SET_ANIMATION (trap, trap->value);
1438	update_object (trap, UP_OBJ_FACE);
1439	}	1464	}
1440		1465
1441	for (ab = trap->above, max = 100, sound_was_played = 0; --max && ab; ab = ab_next)	1466	break;
		1467
		1468	case TRIGGER_BUTTON:
		1469	case TRIGGER_PEDESTAL:
		1470	case TRIGGER_ALTAR:
		1471	check_trigger (trap, victim, originator);
		1472	break;
		1473
		1474	case DEEP_SWAMP:
		1475	walk_on_deep_swamp (trap, victim);
		1476	break;
		1477
		1478	case CHECK_INV:
		1479	check_inv (victim, trap);
		1480	break;
		1481
		1482	case HOLE:
		1483	move_apply_hole (trap, victim);
		1484	break;
		1485
		1486	case EXIT:
		1487	if (victim->type == PLAYER && EXIT_PATH (trap))
1442	{	1488	{
1443	/* need to set this up, since if we do transfer the object,	1489	/* Basically, don't show exits leading to random maps the
1444	* ab->above would be bogus	1490	* players output.
1445	*/	1491	*/
1446	ab_next = ab->above;	1492	if (trap->msg && !EXIT_PATH (trap).starts_with ("/!"))
		1493	victim->statusmsg (trap->msg, NDI_NAVY);
1447		1494
1448	if ((ab->move_type && trap->move_on) || ab->move_type == 0)	1495	trap->play_sound (trap->sound);
1449	{	1496	victim->enter_exit (trap);
1450	if (!sound_was_played)
1451	{
1452	trap->play_sound (trap->sound ? trap->sound : sound_find ("fall_hole"));
1453	sound_was_played = 1;
1454	}
1455
1456	ab->statusmsg ("You fall into a trapdoor!", NDI_RED);
1457	transfer_ob (ab, EXIT_X (trap), EXIT_Y (trap), 0, ab);
1458	}
1459	}	1497	}
1460	goto leave;	1498	break;
1461	}
1462		1499
1463	case CONVERTER:
1464	if (convert_item (victim, trap) < 0)
1465	{
1466	originator->failmsg (format ("The %s seems to be broken!", query_name (trap)));
1467	archetype::get (shstr_burnout)->insert_at (trap, trap);
1468	}
1469
1470	goto leave;
1471
1472	case TRIGGER_BUTTON:
1473	case TRIGGER_PEDESTAL:
1474	case TRIGGER_ALTAR:
1475	check_trigger (trap, victim);
1476	goto leave;
1477
1478	case DEEP_SWAMP:
1479	walk_on_deep_swamp (trap, victim);
1480	goto leave;
1481
1482	case CHECK_INV:
1483	check_inv (victim, trap);
1484	goto leave;
1485
1486	case HOLE:
1487	/* Hole not open? */
1488	if (trap->stats.wc > 0)
1489	goto leave;
1490
1491	/* Is this a multipart monster and not the head? If so, return.
1492	* Processing will happen if the head runs into the pit
1493	*/
1494	if (victim->head)
1495	goto leave;
1496
1497	victim->play_sound (trap->sound ? trap->sound : sound_find ("fall_hole"));
1498	victim->statusmsg ("You fall through the hole!", NDI_RED);
1499	transfer_ob (victim, EXIT_X (trap), EXIT_Y (trap), 1, victim);
1500	goto leave;
1501
1502	case EXIT:
1503	if (victim->type == PLAYER && EXIT_PATH (trap))
1504	{
1505	/* Basically, don't show exits leading to random maps the
1506	* players output.
1507	*/
1508	if (trap->msg && strncmp (EXIT_PATH (trap), "/!", 2))
1509	victim->statusmsg (trap->msg, NDI_NAVY);
1510
1511	trap->play_sound (trap->sound);
1512	victim->enter_exit (trap);
1513	}
1514	goto leave;
1515
1516	case ENCOUNTER:	1500	case ENCOUNTER:
1517	/* may be some leftovers on this */	1501	/* may be some leftovers on this */
1518	goto leave;	1502	break;
1519		1503
1520	case SHOP_MAT:	1504	case SHOP_MAT:
1521	apply_shop_mat (trap, victim);	1505	apply_shop_mat (trap, victim);
1522	goto leave;	1506	break;
1523		1507
1524	/* Drop a certain amount of gold, and have one item identified */	1508	/* Drop a certain amount of gold, and have one item identified */
1525	case IDENTIFY_ALTAR:	1509	case IDENTIFY_ALTAR:
1526	apply_id_altar (victim, trap, originator);	1510	apply_id_altar (victim, trap, originator);
1527	goto leave;	1511	break;
1528		1512
1529	case SIGN:	1513	case SIGN:
1530	if (victim->type != PLAYER && trap->stats.food > 0)	1514	if (victim->type != PLAYER && trap->stats.food > 0)
1531	goto leave; /* monsters musn't apply magic_mouths with counters */	1515	break; /* monsters musn't apply magic_mouths with counters */
1532		1516
1533	apply_sign (victim, trap, 1);	1517	apply_sign (victim, trap, 1);
1534	goto leave;	1518	break;
1535		1519
1536	case CONTAINER:	1520	case CONTAINER:
1537	apply_container (victim, trap);	1521	apply_container (victim, trap);
1538	goto leave;	1522	break;
1539		1523
1540	case RUNE:	1524	case RUNE:
1541	case TRAP:	1525	case TRAP:
1542	if (trap->level && QUERY_FLAG (victim, FLAG_ALIVE))	1526	if (trap->level && QUERY_FLAG (victim, FLAG_ALIVE))
1543	spring_trap (trap, victim);	1527	spring_trap (trap, victim);
1544	goto leave;	1528	break;
1545		1529
1546	default:	1530	default:
1547	LOG (llevDebug, "name %s, arch %s, type %d with fly/walk on/off not "	1531	LOG (llevDebug, "name %s, arch %s, type %d with fly/walk on/off not "
1548	"handled in move_apply()\n", &trap->name, &trap->arch->archname, trap->type);	1532	"handled in move_apply()\n", &trap->name, &trap->arch->archname, trap->type);
1549	goto leave;	1533	break;
1550	}	1534	}
1551		1535
1552	leave:
1553	recursion_depth--;	1536	recursion_depth--;
1554	}	1537	}
1555		1538
1556	/**	1539	/**
1557	* Handles reading a regular (ie not containing a spell) book.	1540	* Handles reading a regular (ie not containing a spell) book.
…		…
1596		1579
1597	readable_message_type *msgType = get_readable_message_type (tmp);	1580	readable_message_type *msgType = get_readable_message_type (tmp);
1598		1581
1599	if (player *pl = op->contr)	1582	if (player *pl = op->contr)
1600	if (client *ns = pl->ns)	1583	if (client *ns = pl->ns)
1601	if (ns->can_msg)
1602	pl->infobox (MSG_CHANNEL ("book"), format ("T<%s>\n\n\n\n%s", (char *)long_desc (tmp, op), &tmp->msg));	1584	pl->infobox (MSG_CHANNEL ("book"), format ("T<%s>\n\n%s", (char *)long_desc (tmp, op), &tmp->msg));
1603	else
1604	draw_ext_info_format (NDI_UNIQUE | NDI_NAVY, 0, op,
1605	msgType->message_type, msgType->message_subtype,
1606	"You open the %s and start reading.\n%s", (char *)"%s\n%s",
1607	long_desc (tmp, op), &tmp->msg);
1608		1585
1609	/* gain xp from reading */	1586	/* gain xp from reading */
1610	if (!QUERY_FLAG (tmp, FLAG_NO_SKILL_IDENT))	1587	if (!QUERY_FLAG (tmp, FLAG_NO_SKILL_IDENT))
1611	{ /* only if not read before */	1588	{ /* only if not read before */
1612	int exp_gain = calc_skill_exp (op, tmp, skill_ob);	1589	int exp_gain = calc_skill_exp (op, tmp, skill_ob);
…		…
1766	LOG (llevError, "apply_spellbook: Book %s has no spell in it!\n", &tmp->name);	1743	LOG (llevError, "apply_spellbook: Book %s has no spell in it!\n", &tmp->name);
1767	op->failmsg ("The spellbook symbols make no sense. This is a bug, please report!");	1744	op->failmsg ("The spellbook symbols make no sense. This is a bug, please report!");
1768	return;	1745	return;
1769	}	1746	}
1770		1747
1771	if (skop->level < int (sqrtf (spell->level) * 1.5f))	1748	int learn_level = sqrtf (spell->level) * 1.5f;
		1749	if (skop->level < learn_level)
1772	{	1750	{
1773	op->failmsg (format ("You are unable to decipher the strange symbols. H<Your %s level is too low.>", &tmp->skill));	1751	op->failmsg (format ("You are unable to decipher the strange symbols. H<Your %s level is too low, it must be at least %d.>",
		1752	&tmp->skill, learn_level));
1774	return;	1753	return;
1775	}	1754	}
1776		1755
1777	op->statusmsg (format ("The spellbook contains the %s level spell %s.", get_levelnumber (spell->level), &spell->name));	1756	op->statusmsg (format ("The spellbook contains the %s level spell %s.", get_levelnumber (spell->level), &spell->name));
1778		1757
…		…
1935	if (op->destroyed () || tmp->destroyed ())	1914	if (op->destroyed () || tmp->destroyed ())
1936	break;	1915	break;
1937	}	1916	}
1938		1917
1939	if (!tmp->destroyed () && !tmp->inv)	1918	if (!tmp->destroyed () && !tmp->inv)
1940	tmp->decrease ();	1919	tmp->decrease (true);
1941	}	1920	}
1942		1921
1943	/**	1922	/**
1944	* op eats food.	1923	* op eats food.
1945	* If player, takes care of messages and dragon special food.	1924	* If player, takes care of messages and dragon special food.
…		…
2140	op->statusmsg (buf);	2119	op->statusmsg (buf);
2141		2120
2142	/* now choose a winner if we have any */	2121	/* now choose a winner if we have any */
2143	i = -1;	2122	i = -1;
2144	if (winners > 0)	2123	if (winners > 0)
2145	i = atnr_winner[RANDOM () % winners];	2124	i = atnr_winner [rndm (winners)];
2146		2125
2147	if (i >= 0 && i < NROFATTACKS && skin->resist[i] < 95)	2126	if (i >= 0 && i < NROFATTACKS && skin->resist[i] < 95)
2148	{	2127	{
2149	/* resistance increased! */	2128	/* resistance increased! */
2150	skin->resist[i]++;	2129	skin->resist[i]++;
…		…
2325		2304
2326	return 0;	2305	return 0;
2327	}	2306	}
2328		2307
2329	/**	2308	/**
		2309	* This function will try to apply a lighter and in case no lighter
		2310	* is specified it will try to find a lighter in the players inventory,
		2311	* and inform him about this requirement.
		2312	*
		2313	* who - the player
		2314	* op - the item we want to light
		2315	* lighter - the lighter or 0 if a lighter has yet to be found
		2316	*/
		2317	static object *
		2318	auto_apply_lighter (object *who, object *op, object *lighter)
		2319	{
		2320	if (lighter == 0)
		2321	{
		2322	for (object *tmp = who->inv; tmp; tmp = tmp->below)
		2323	{
		2324	if (tmp->type == LIGHTER)
		2325	{
		2326	lighter = tmp;
		2327	break;
		2328	}
		2329	}
		2330
		2331	if (!lighter)
		2332	{
		2333	who->failmsg (format (
		2334	"You can't light up the %s with your bare hands! "
		2335	"H<You need a lighter in your inventory, for example a flint and steel.>",
		2336	&op->name));
		2337	return 0;
		2338	}
		2339	}
		2340
		2341	// last_eat == 0 means the lighter is not being used up!
		2342	if (lighter->last_eat && lighter->stats.food)
		2343	{
		2344	/* lighter gets used up */
		2345	lighter = lighter->split ();
		2346	lighter->stats.food--;
		2347	who->insert (lighter);
		2348	}
		2349	else if (lighter->last_eat)
		2350	{
		2351	/* no charges left in lighter */
		2352	who->failmsg (format (
		2353	"You attempt to light the %s with a used up %s.",
		2354	&op->name, &lighter->name));
		2355	return 0;
		2356	}
		2357
		2358	return lighter;
		2359	}
		2360
		2361	/**
		2362	* Designed primarily to light torches/lanterns/etc.
		2363	* Also burns up burnable material too. First object in the inventory is
		2364	* the selected object to "burn". -b.t.
		2365	*/
		2366	void
		2367	apply_lighter (object *who, object *lighter)
		2368	{
		2369	object *item;
		2370	int is_player_env = 0;
		2371
		2372	item = find_marked_object (who);
		2373	if (item)
		2374	{
		2375	if (!auto_apply_lighter (who, item, lighter))
		2376	return;
		2377
		2378	/* Perhaps we should split what we are trying to light on fire?
		2379	* I can't see many times when you would want to light multiple
		2380	* objects at once.
		2381	*/
		2382
		2383	save_throw_object (item, AT_FIRE, who);
		2384
		2385	if (item->destroyed ()
		2386	|| ((item->type == LAMP || item->type == TORCH)
		2387	&& item->glow_radius > 0))
		2388	who->statusmsg (format (
		2389	"You light the %s with the %s.",
		2390	&item->name, &lighter->name));
		2391	else
		2392	who->failmsg (format (
		2393	"You attempt to light the %s with the %s and fail.",
		2394	&item->name, &lighter->name));
		2395	}
		2396	else
		2397	who->failmsg ("You need to mark a lightable object.");
		2398	}
		2399
		2400	/**
		2401	* This function generates a cursed effect for cursed lamps and torches.
		2402	*/
		2403	void player_apply_lamp_cursed_effect (object *who, object *op)
		2404	{
		2405	if (op->level)
		2406	{
		2407	who->failmsg (format (
		2408	"The %s was cursed, it explodes in a big fireball!",
		2409	&op->name));
		2410	create_exploding_ball_at (who, op->level);
		2411	}
		2412	else
		2413	{
		2414	who->failmsg (format (
		2415	"The %s was cursed, it crumbles to dust, at least it didn't explode.!",
		2416	&op->name));
		2417	}
		2418
		2419	op->destroy ();
		2420	}
		2421
		2422	/**
		2423	* Apply for players and lamps
		2424	*
		2425	* who - the player
		2426	* op - the lamp
		2427	*/
		2428	void player_apply_lamp (object *who, object *op)
		2429	{
		2430	bool switch_on = op->glow_radius ? false : true;
		2431
		2432	if (switch_on)
		2433	{
		2434	object *lighter = 0;
		2435
		2436	if (op->flag [FLAG_IS_LIGHTABLE]
		2437	&& !(lighter = auto_apply_lighter (who, op, 0)))
		2438	return;
		2439
		2440	if (op->stats.food < 1)
		2441	{
		2442	if (op->type == LAMP)
		2443	who->failmsg (format (
		2444	"The %s is out of fuel! "
		2445	"H<Lamps and similar items need fuel. They cannot be refilled.>",
		2446	&op->name));
		2447	else
		2448	who->failmsg (format (
		2449	"The %s is burnt out! "
		2450	"H<Torches and similar items burn out and become worthless.>",
		2451	&op->name));
		2452	return;
		2453	}
		2454
		2455	if (op->flag [FLAG_CURSED])
		2456	{
		2457	player_apply_lamp_cursed_effect (who, op);
		2458	return;
		2459	}
		2460
		2461	if (lighter)
		2462	who->statusmsg (format (
		2463	"You light up the %s with the %s.", &op->name, &lighter->name));
		2464	else
		2465	who->statusmsg (format ("You light up the %s.", &op->name));
		2466	}
		2467	else
		2468	{
		2469	if (op->flag [FLAG_CURSED])
		2470	{
		2471	player_apply_lamp_cursed_effect (who, op);
		2472	return;
		2473	}
		2474
		2475	if (op->type == TORCH)
		2476	{
		2477	if (!op->flag [FLAG_IS_LIGHTABLE])
		2478	{
		2479	who->statusmsg (format (
		2480	"You put out the %s. "
		2481	"H<The %s can't be used anymore, as it can't be lighted up again.>",
		2482	&op->name, &op->name));
		2483	}
		2484	else
		2485	who->statusmsg (format (
		2486	"You put out the %s."
		2487	"H<Torches wear out if you put them out.>",
		2488	&op->name));
		2489	}
		2490	else
		2491	who->statusmsg (format ("You turn off the %s.", &op->name));
		2492	}
		2493
		2494	apply_lamp (op, switch_on);
		2495	}
		2496
		2497	void get_animation_from_arch (object *op, arch_ptr a)
		2498	{
		2499	op->animation_id = a->animation_id;
		2500	op->flag [FLAG_IS_TURNABLE] = a->flag [FLAG_IS_TURNABLE];
		2501	op->flag [FLAG_ANIMATE] = a->flag [FLAG_ANIMATE];
		2502	op->anim_speed = a->anim_speed;
		2503	op->last_anim = 0;
		2504	op->state = 0;
		2505	op->face = a->face;
		2506
		2507	if (NUM_ANIMATIONS(op) > 1)
		2508	{
		2509	SET_ANIMATION(op, 0);
		2510	animate_object (op, op->direction);
		2511	}
		2512	else
		2513	update_object (op, UP_OBJ_FACE);
		2514	}
		2515
		2516	/**
		2517	* Apply for LAMPs and TORCHes.
		2518	*
		2519	* op - the lamp
		2520	* switch_on - a flag which says whether the lamp should be switched on or off
		2521	*/
		2522	void apply_lamp (object *op, bool switch_on)
		2523	{
		2524	op->set_glow_radius (switch_on ? op->range : 0);
		2525	op->set_speed (switch_on ? op->arch->speed : 0);
		2526
		2527	// torches wear out if you put them out
		2528	if (op->type == TORCH && !switch_on)
		2529	{
		2530	if (op->flag [FLAG_IS_LIGHTABLE])
		2531	{
		2532	op->stats.food -= (double) op->arch->stats.food / 15;
		2533	if (op->stats.food < 0)
		2534	op->stats.food = 0;
		2535	}
		2536	else
		2537	op->stats.food = 0;
		2538	}
		2539
		2540	// lamps and torched get worthless when used up
		2541	if (op->stats.food <= 0)
		2542	op->value = 0;
		2543
		2544	// FIXME: This is a hack to make the more sane torches and lamps
		2545	// still animated ;-/
		2546	if (op->other_arch)
		2547	get_animation_from_arch (op, switch_on ? op->other_arch : op->arch);
		2548
		2549	if (object *pl = op->visible_to ())
		2550	esrv_update_item (UPD_ANIM | UPD_FACE | UPD_NAME, pl, op);
		2551	}
		2552
		2553	/**
2330	* Main apply handler.	2554	* Main apply handler.
2331	*	2555	*
2332	* Checks for unpaid items before applying.	2556	* Checks for unpaid items before applying.
2333	*	2557	*
2334	* Return value:	2558	* Return value:
2335	* 0: player or monster can't apply objects of that type	2559	* 0: player or monster can't apply objects of that type
2336	* 1: has been applied, or there was an error applying the object	2560	* 1: has been applied, or there was an error applying the object
2337	* 2: objects of that type can't be applied if not in inventory	2561	* 2: objects of that type can't be applied if not in inventory
2338	*	2562	*
2339	* op is the object that is causing object to be applied, tmp is the object	2563	* who is the object that is causing object to be applied, op is the object
2340	* being applied.	2564	* being applied.
2341	*	2565	*
2342	* aflag is special (always apply/unapply) flags. Nothing is done with	2566	* aflag is special (always apply/unapply) flags. Nothing is done with
2343	* them in this function - they are passed to apply_special	2567	* them in this function - they are passed to apply_special
2344	*/	2568	*/
2345	int	2569	int
2346	manual_apply (object *op, object *tmp, int aflag)	2570	manual_apply (object *who, object *op, int aflag)
2347	{	2571	{
2348	tmp = tmp->head_ ();	2572	op = op->head_ ();
2349		2573
2350	if (QUERY_FLAG (tmp, FLAG_UNPAID) && !QUERY_FLAG (tmp, FLAG_APPLIED))	2574	if (QUERY_FLAG (op, FLAG_UNPAID) && !QUERY_FLAG (op, FLAG_APPLIED))
2351	{	2575	{
2352	if (op->type == PLAYER)	2576	if (who->type == PLAYER)
2353	{	2577	{
		2578	examine (who, op);
2354	op->failmsg ("You should pay for it first! H<You cannot use items marked as unpaid.>");	2579	//who->failmsg ("You should pay for it first! H<You cannot use items marked as unpaid.>");//TODO remove
2355	return 1;	2580	return 1;
2356	}	2581	}
2357	else	2582	else
2358	return 0; /* monsters just skip unpaid items */	2583	return 0; /* monsters just skip unpaid items */
2359	}	2584	}
2360		2585
2361	if (INVOKE_OBJECT (APPLY, tmp, ARG_OBJECT (op)))	2586	if (INVOKE_OBJECT (APPLY, op, ARG_OBJECT (who)))
2362	return RESULT_INT (0);	2587	return RESULT_INT (0);
2363		2588
2364	switch (tmp->type)	2589	switch (op->type)
2365	{	2590	{
2366	case CF_HANDLE:	2591	case CF_HANDLE:
2367	op->play_sound (sound_find ("turn_handle"));	2592	who->play_sound (sound_find ("turn_handle"));
2368	op->statusmsg ("You turn the handle.");	2593	who->statusmsg ("You turn the handle.");
2369	tmp->value = tmp->value ? 0 : 1;	2594	op->value = op->value ? 0 : 1;
2370	SET_ANIMATION (tmp, tmp->value);	2595	SET_ANIMATION (op, op->value);
2371	update_object (tmp, UP_OBJ_FACE);	2596	update_object (op, UP_OBJ_FACE);
2372	push_button (tmp);	2597	push_button (op, who);
2373	return 1;	2598	return 1;
2374		2599
2375	case TRIGGER:	2600	case TRIGGER:
2376	if (check_trigger (tmp, op))	2601	if (check_trigger (op, who, who))
2377	{	2602	{
2378	op->statusmsg ("You turn the handle.");	2603	who->statusmsg ("You turn the handle.");
2379	op->play_sound (sound_find ("turn_handle"));	2604	who->play_sound (sound_find ("turn_handle"));
2380	}	2605	}
2381	else	2606	else
2382	op->failmsg ("The handle doesn't move.");	2607	who->failmsg ("The handle doesn't move.");
2383		2608
2384	return 1;	2609	return 1;
2385		2610
2386	case EXIT:	2611	case EXIT:
2387	if (op->type != PLAYER)	2612	if (who->type != PLAYER)
2388	return 0;	2613	return 0;
2389		2614
2390	if (!EXIT_PATH (tmp) || !is_legal_2ways_exit (op, tmp))	2615	if (!EXIT_PATH (op) || !is_legal_2ways_exit (who, op))
2391	op->failmsg (format ("The %s is closed.", query_name (tmp)));	2616	who->failmsg (format ("The %s is closed. H<And will stay closed, until somebody fires up the map editor and adds it.>", query_name (op)));
2392	else	2617	else
2393	{	2618	{
2394	/* Don't display messages for random maps. */	2619	/* Don't display messages for random maps. */
2395	if (tmp->msg && strncmp (EXIT_PATH (tmp), "/!", 2))	2620	if (op->msg && !EXIT_PATH (op).starts_with ("/!"))
2396	op->statusmsg (tmp->msg, NDI_NAVY);	2621	who->statusmsg (op->msg, NDI_NAVY);
2397		2622
2398	op->enter_exit (tmp);	2623	who->enter_exit (op);
2399	}	2624	}
2400		2625
2401	return 1;	2626	return 1;
2402		2627
2403	case INSCRIBABLE:	2628	case INSCRIBABLE:
2404	op->statusmsg (tmp->msg);	2629	who->statusmsg (op->msg);
2405	// maybe show a spell menu to chose from or something like that	2630	// maybe show a spell menu to chose from or something like that
2406	return 1;	2631	return 1;
2407		2632
2408	case SIGN:	2633	case SIGN:
2409	apply_sign (op, tmp, 0);	2634	apply_sign (who, op, 0);
2410	return 1;	2635	return 1;
2411		2636
2412	case BOOK:	2637	case BOOK:
2413	if (op->type == PLAYER)	2638	if (who->type == PLAYER)
2414	{	2639	{
2415	apply_book (op, tmp);	2640	apply_book (who, op);
2416	return 1;	2641	return 1;
2417	}	2642	}
2418	else	2643	else
2419	return 0;	2644	return 0;
2420		2645
2421	case SKILLSCROLL:	2646	case SKILLSCROLL:
2422	if (op->type == PLAYER)	2647	if (who->type == PLAYER)
2423	{	2648	{
2424	apply_skillscroll (op, tmp);	2649	apply_skillscroll (who, op);
2425	return 1;	2650	return 1;
2426	}	2651	}
2427	else	2652	else
2428	return 0;	2653	return 0;
2429		2654
2430	case SPELLBOOK:	2655	case SPELLBOOK:
2431	if (op->type == PLAYER)	2656	if (who->type == PLAYER)
2432	{	2657	{
2433	apply_spellbook (op, tmp);	2658	apply_spellbook (who, op);
2434	return 1;	2659	return 1;
2435	}	2660	}
2436	else	2661	else
2437	return 0;	2662	return 0;
2438		2663
2439	case SCROLL:	2664	case SCROLL:
2440	apply_scroll (op, tmp, 0);	2665	apply_scroll (who, op, 0);
2441	return 1;	2666	return 1;
2442		2667
2443	case POTION:	2668	case POTION:
2444	apply_potion (op, tmp);	2669	apply_potion (who, op);
2445	return 1;	2670	return 1;
2446		2671
2447	/* Eneq(@csd.uu.se): Handle apply on containers. */	2672	/* Eneq(@csd.uu.se): Handle apply on containers. */
2448	//TODO: remove, as it is unsed?	2673	//TODO: remove, as it is unsed?
2449	case CLOSE_CON:	2674	case CLOSE_CON:
2450	apply_container (op, tmp->env);	2675	apply_container (who, op->env);
2451	return 1;	2676	return 1;
2452		2677
2453	case CONTAINER:	2678	case CONTAINER:
2454	apply_container (op, tmp);	2679	apply_container (who, op);
2455	return 1;	2680	return 1;
2456		2681
2457	case TREASURE:	2682	case TREASURE:
2458	if (op->type == PLAYER)	2683	if (who->type == PLAYER)
2459	{	2684	{
2460	apply_treasure (op, tmp);	2685	apply_treasure (who, op);
2461	return 1;	2686	return 1;
2462	}	2687	}
2463	else	2688	else
2464	return 0;	2689	return 0;
		2690
		2691	case LAMP:
		2692	case TORCH:
		2693	player_apply_lamp (who, op);
		2694	return 1;
2465		2695
2466	case WEAPON:	2696	case WEAPON:
2467	case ARMOUR:	2697	case ARMOUR:
2468	case BOOTS:	2698	case BOOTS:
2469	case GLOVES:	2699	case GLOVES:
…		…
2477	case WAND:	2707	case WAND:
2478	case ROD:	2708	case ROD:
2479	case HORN:	2709	case HORN:
2480	case SKILL:	2710	case SKILL:
2481	case BOW:	2711	case BOW:
2482	case LAMP:
2483	case BUILDER:	2712	case BUILDER:
2484	case SKILL_TOOL:	2713	case SKILL_TOOL:
2485	if (tmp->env != op)	2714	if (op->env != who)
2486	return 2; /* not in inventory */	2715	return 2; /* not in inventory */
2487		2716
2488	apply_special (op, tmp, aflag);	2717	apply_special (who, op, aflag);
2489	return 1;	2718	return 1;
2490		2719
2491	case DRINK:	2720	case DRINK:
2492	case FOOD:	2721	case FOOD:
2493	case FLESH:	2722	case FLESH:
2494	apply_food (op, tmp);	2723	apply_food (who, op);
2495	return 1;	2724	return 1;
2496		2725
2497	case POISON:	2726	case POISON:
2498	apply_poison (op, tmp);	2727	apply_poison (who, op);
2499	return 1;	2728	return 1;
2500		2729
2501	case SAVEBED:	2730	case SAVEBED:
2502	return 1;	2731	return 1;
2503		2732
2504	case ARMOUR_IMPROVER:	2733	case ARMOUR_IMPROVER:
2505	if (op->type == PLAYER)	2734	if (who->type == PLAYER)
2506	{	2735	{
2507	apply_armour_improver (op, tmp);	2736	apply_armour_improver (who, op);
2508	return 1;	2737	return 1;
2509	}	2738	}
2510	else	2739	else
2511	return 0;	2740	return 0;
2512		2741
2513	case WEAPON_IMPROVER:	2742	case WEAPON_IMPROVER:
2514	check_improve_weapon (op, tmp);	2743	check_improve_weapon (who, op);
2515	return 1;	2744	return 1;
2516		2745
2517	case CLOCK:	2746	case CLOCK:
2518	if (op->type == PLAYER)	2747	if (who->type == PLAYER)
2519	{	2748	{
2520	char buf[MAX_BUF];	2749	char buf[MAX_BUF];
2521	timeofday_t tod;	2750	timeofday_t tod;
2522		2751
2523	get_tod (&tod);	2752	get_tod (&tod);
2524	op->play_sound (sound_find ("sound_clock"));	2753	who->play_sound (sound_find ("sound_clock"));
2525	op->statusmsg (format (	2754	who->statusmsg (format (
2526	"It is %d minute%s past %d o'clock %s",	2755	"It is %d minute%s past %d o'clock %s",
2527	tod.minute + 1, ((tod.minute + 1 < 2) ? "" : "s"),	2756	tod.minute + 1, ((tod.minute + 1 < 2) ? "" : "s"),
2528	((tod.hour % 14 == 0) ? 14 : ((tod.hour) % 14)), ((tod.hour >= 14) ? "pm" : "am")	2757	((tod.hour % 14 == 0) ? 14 : ((tod.hour) % 14)), ((tod.hour >= 14) ? "pm" : "am")
2529	));	2758	));
2530	return 1;	2759	return 1;
2531	}	2760	}
2532	else	2761	else
2533	return 0;	2762	return 0;
2534		2763
2535	case MENU:	2764	case MENU:
2536	if (op->type == PLAYER)	2765	if (who->type == PLAYER)
2537	{	2766	{
2538	shop_listing (tmp, op);	2767	shop_listing (op, who);
2539	return 1;	2768	return 1;
2540	}	2769	}
2541	else	2770	else
2542	return 0;	2771	return 0;
2543		2772
2544	case POWER_CRYSTAL:	2773	case POWER_CRYSTAL:
2545	apply_power_crystal (op, tmp); /* see egoitem.c */	2774	apply_power_crystal (who, op); /* see egoitem.c */
2546	return 1;	2775	return 1;
2547		2776
2548	case LIGHTER: /* for lighting torches/lanterns/etc */	2777	case LIGHTER: /* for lighting torches/lanterns/etc */
2549	if (op->type == PLAYER)	2778	if (who->type == PLAYER)
2550	{	2779	{
2551	apply_lighter (op, tmp);	2780	apply_lighter (who, op);
2552	return 1;	2781	return 1;
2553	}	2782	}
2554	else	2783	else
2555	return 0;	2784	return 0;
2556		2785
2557	case ITEM_TRANSFORMER:	2786	case ITEM_TRANSFORMER:
2558	apply_item_transformer (op, tmp);	2787	apply_item_transformer (who, op);
2559	return 1;	2788	return 1;
2560		2789
2561	default:	2790	default:
2562	return 0;	2791	return 0;
2563	}	2792	}
…		…
2630	* person moving on it, also activate. Added code to make it	2859	* person moving on it, also activate. Added code to make it
2631	* so that at least one of players movement types be that which	2860	* so that at least one of players movement types be that which
2632	* the item needs.	2861	* the item needs.
2633	*/	2862	*/
2634	if (!tmp->invisible || (tmp->move_on & pl->move_type))	2863	if (!tmp->invisible || (tmp->move_on & pl->move_type))
2635	{
2636	if (player_apply (pl, tmp, 0, 1) == 1)	2864	if (player_apply (pl, tmp, 0, 1) == 1)
2637	return;	2865	return;
2638	}	2866
2639	if (floors >= 2)	2867	if (floors >= 2)
2640	return; /* process at most two floor objects */	2868	return; /* process at most two floor objects */
2641	}	2869	}
2642	}	2870	}
2643		2871
…		…
2687	break;	2915	break;
2688		2916
2689	case SKILL:	2917	case SKILL:
2690	if (who->contr)	2918	if (who->contr)
2691	{	2919	{
		2920	if (IS_COMBAT_SKILL (op->subtype))
		2921	who->change_weapon (who->contr->combat_ob = 0);
		2922	else if (IS_RANGED_SKILL (op->subtype))
		2923	who->change_weapon (who->contr->ranged_ob = 0);
		2924
2692	if (!op->invisible)	2925	if (op->invisible)
		2926	who->statusmsg (format ("You can no longer use the skill: %s.", &op->skill));
		2927	else
2693	who->statusmsg (format ("You stop using the %s.", query_name (op)));	2928	who->statusmsg (format ("You stop using the %s.", query_name (op)));
2694	else
2695	who->statusmsg (format ("You can no longer use the skill: %s.", &op->skill));
2696	}	2929	}
2697		2930
2698	change_abil (who, op);	2931	change_abil (who, op);
2699	CLEAR_FLAG (who, FLAG_READY_SKILL);	2932	CLEAR_FLAG (who, FLAG_READY_SKILL);
2700	break;	2933	break;
…		…
2710	case BRACERS:	2943	case BRACERS:
2711	case CLOAK:	2944	case CLOAK:
2712	who->statusmsg (format ("You unwear %s.", query_name (op)));	2945	who->statusmsg (format ("You unwear %s.", query_name (op)));
2713	change_abil (who, op);	2946	change_abil (who, op);
2714	break;	2947	break;
2715
2716	case LAMP:
2717	{
2718	who->statusmsg (format ("You turn off your %s.", &op->name));
2719
2720	object *tmp2 = arch_to_object (op->other_arch);
2721	tmp2->x = op->x;
2722	tmp2->y = op->y;
2723	tmp2->map = op->map;
2724	tmp2->below = op->below;
2725	tmp2->above = op->above;
2726	tmp2->stats.food = op->stats.food;
2727	CLEAR_FLAG (tmp2, FLAG_APPLIED);
2728
2729	if (QUERY_FLAG (op, FLAG_INV_LOCKED))
2730	SET_FLAG (tmp2, FLAG_INV_LOCKED);
2731
2732	op->destroy ();
2733	who->insert (tmp2);
2734	who->update_stats ();
2735
2736	if (who->contr)
2737	{
2738	if (QUERY_FLAG (op, FLAG_CURSED) || QUERY_FLAG (op, FLAG_DAMNED))
2739	{
2740	who->failmsg ("Oops, it feels deadly cold!");
2741	SET_FLAG (tmp2, FLAG_KNOWN_CURSED);
2742	}
2743	}
2744	}
2745
2746	return 1; /* otherwise, an attempt to drop causes problems */
2747		2948
2748	case BOW:	2949	case BOW:
2749	case WAND:	2950	case WAND:
2750	case ROD:	2951	case ROD:
2751	case HORN:	2952	case HORN:
…		…
3091	return 1;	3292	return 1;
3092	}	3293	}
3093		3294
3094	return unapply_special (who, op, aflags);	3295	return unapply_special (who, op, aflags);
3095	}	3296	}
3096
3097	if (basic_flag == AP_UNAPPLY)	3297	else if (basic_flag == AP_UNAPPLY)
3098	return 0;	3298	return 0;
3099		3299
3100	// if the item is combat/ranged, wield the relevant slot first	3300	// if the item is combat/ranged, wield the relevant slot first
3101	// to resolve conflicts.	3301	// to resolve conflicts.
3102	if (player *pl = who->contr)	3302	if (player *pl = who->contr)
…		…
3160	* skill so that the dam and wc get updated	3360	* skill so that the dam and wc get updated
3161	*/	3361	*/
3162	who->change_skill (skop);	3362	who->change_skill (skop);
3163	}	3363	}
3164		3364
3165	if (who->type == PLAYER	3365	if (!check_item_power (who, op->item_power))
3166	&& op->item_power
3167	&& op->item_power + who->contr->item_power > settings.item_power_factor * who->level)
3168	{	3366	{
3169	who->failmsg ("Equipping that combined with other items would consume your soul!" LACK_ITEM_POWER);	3367	who->failmsg ("Equipping that combined with other items would consume your soul!" LACK_ITEM_POWER);
3170	return 1;	3368	return 1;
3171	}	3369	}
3172		3370
…		…
3180	return RESULT_INT (0);	3378	return RESULT_INT (0);
3181		3379
3182	switch (op->type)	3380	switch (op->type)
3183	{	3381	{
3184	case WEAPON:	3382	case WEAPON:
3185	if (!check_weapon_power (who, op->last_eat))
3186	{
3187	op->failmsg ("This weapon is too powerful for you to use. It would consume your soul!" LACK_ITEM_POWER);
3188
3189	if (tmp)
3190	insert_ob_in_ob (tmp, who);
3191
3192	return 1;
3193	}
3194
3195	//TODO: this obviously fails for players using a shorter prefix	3383	//TODO: this obviously fails for players using a shorter prefix
3196	// i.e. "R" can use Ragnarok's sword.	3384	// i.e. "R" can use Ragnarok's sword.
3197	if (op->level && (strncmp (op->name, who->name, strlen (who->name))))	3385	if (op->level && !op->name.starts_with (who->name))
3198	{	3386	{
3199	/* if the weapon does not have the name as the character, can't use it. */	3387	/* if the weapon does not have the name as the character, can't use it. */
3200	/* (Ragnarok's sword attempted to be used by Foo: won't work) */	3388	/* (Ragnarok's sword attempted to be used by Foo: won't work) */
3201	who->failmsg ("The weapon does not recognize you as its owner. H<Its name indicates that it belongs to somebody else.>");	3389	who->failmsg ("The weapon does not recognize you as its owner. H<Its name indicates that it belongs to somebody else.>");
3202		3390
…		…
3236	case AMULET:	3424	case AMULET:
3237	SET_FLAG (op, FLAG_APPLIED);	3425	SET_FLAG (op, FLAG_APPLIED);
3238	who->statusmsg (format ("You wear %s.", query_name (op)));	3426	who->statusmsg (format ("You wear %s.", query_name (op)));
3239	change_abil (who, op);	3427	change_abil (who, op);
3240	break;	3428	break;
3241
3242	case LAMP:
3243	if (op->stats.food < 1)
3244	{
3245	who->failmsg (format (
3246	"Your %s is out of fuel! "
3247	"H<Lamps and similar items need fuel. They cannot be refilled.>",
3248	&op->name
3249	));
3250	return 1;
3251	}
3252
3253	who->statusmsg (format ("You turn on your %s.", &op->name));
3254
3255	tmp2 = arch_to_object (op->other_arch);
3256	tmp2->stats.food = op->stats.food;
3257	SET_FLAG (tmp2, FLAG_APPLIED);
3258
3259	if (QUERY_FLAG (op, FLAG_INV_LOCKED))
3260	SET_FLAG (tmp2, FLAG_INV_LOCKED);
3261
3262	who->insert (tmp2);
3263
3264	/* Remove the old lantern */
3265	op->destroy ();
3266
3267	/* insert the portion that was split off */
3268	if (tmp)
3269	who->insert (tmp);
3270
3271	who->update_stats ();
3272
3273	if (QUERY_FLAG (op, FLAG_CURSED) || QUERY_FLAG (op, FLAG_DAMNED))
3274	if (who->type == PLAYER)
3275	{
3276	who->failmsg ("Oops, it feels deadly cold! H<Maybe it wasn't such a bright idea to apply this cursed/damned item.>");
3277	SET_FLAG (tmp2, FLAG_KNOWN_CURSED);
3278	}
3279
3280	return 0;
3281		3429
3282	case SKILL_TOOL:	3430	case SKILL_TOOL:
3283	// applying a skill tool also readies the skill	3431	// applying a skill tool also readies the skill
3284	SET_FLAG (op, FLAG_APPLIED);	3432	SET_FLAG (op, FLAG_APPLIED);
3285		3433
…		…
3365	}	3513	}
3366		3514
3367	break;	3515	break;
3368		3516
3369	case BOW:	3517	case BOW:
3370	if (!check_weapon_power (who, op->last_eat))	3518	if (op->level && !op->name.starts_with (who->name))
3371	{
3372	who->failmsg ("That weapon is too powerful for you to use. It would consume your soul!" LACK_ITEM_POWER);
3373
3374	if (tmp)
3375	insert_ob_in_ob (tmp, who);
3376
3377	return 1;
3378	}
3379
3380	if (op->level && (strncmp (op->name, who->name, strlen (who->name))))
3381	{	3519	{
3382	who->failmsg ("The weapon does not recognize you as its owner. "	3520	who->failmsg ("The weapon does not recognize you as its owner. "
3383	"H<Its name indicates that it belongs to somebody else.>");	3521	"H<Its name indicates that it belongs to somebody else.>");
3384	if (tmp)	3522	if (tmp)
3385	insert_ob_in_ob (tmp, who);	3523	insert_ob_in_ob (tmp, who);
…		…
3459	if (QUERY_FLAG (op, FLAG_CURSED) || QUERY_FLAG (op, FLAG_DAMNED))	3597	if (QUERY_FLAG (op, FLAG_CURSED) || QUERY_FLAG (op, FLAG_DAMNED))
3460	if (who->type == PLAYER)	3598	if (who->type == PLAYER)
3461	{	3599	{
3462	who->failmsg (	3600	who->failmsg (
3463	"Oops, it feels deadly cold! "	3601	"Oops, it feels deadly cold! "
3464	"H<Maybe it wasn't such a bright idea to apply this cursed/damned item.>"	3602	"H<Maybe it wasn't such a bright idea to apply this cursed or damned item.>"
3465	);	3603	);
3466	SET_FLAG (op, FLAG_KNOWN_CURSED);	3604	SET_FLAG (op, FLAG_KNOWN_CURSED);
3467	}	3605	}
3468		3606
3469	if (object *pl = op->visible_to ())	3607	if (object *pl = op->visible_to ())
…		…
3489	int	3627	int
3490	auto_apply (object *op)	3628	auto_apply (object *op)
3491	{	3629	{
3492	object *tmp = NULL, *tmp2;	3630	object *tmp = NULL, *tmp2;
3493	int i;	3631	int i;
		3632
		3633	CLEAR_FLAG (op, FLAG_AUTO_APPLY);
3494		3634
3495	switch (op->type)	3635	switch (op->type)
3496	{	3636	{
3497	case SHOP_FLOOR:	3637	case SHOP_FLOOR:
3498	if (!op->has_random_items ())	3638	if (!op->has_random_items ())
…		…
3500		3640
3501	do	3641	do
3502	{	3642	{
3503	i = 10; /* let's give it 10 tries */	3643	i = 10; /* let's give it 10 tries */
3504	while ((tmp = generate_treasure (op->randomitems,	3644	while ((tmp = generate_treasure (op->randomitems,
3505	op->stats.exp ? (int) op->stats.exp : MAX (op->map->difficulty, 5))) == NULL && --i);	3645	op->stats.exp
		3646	? (int) op->stats.exp
		3647	: max (op->map->difficulty, 5)))
		3648	== NULL && --i);
		3649
3506	if (tmp == NULL)	3650	if (tmp == NULL)
3507	return 0;	3651	return 0;
		3652
3508	if (QUERY_FLAG (tmp, FLAG_CURSED) || QUERY_FLAG (tmp, FLAG_DAMNED))	3653	if (QUERY_FLAG (tmp, FLAG_CURSED) || QUERY_FLAG (tmp, FLAG_DAMNED))
3509	{	3654	{
3510	tmp->destroy ();	3655	tmp->destroy ();
3511	tmp = NULL;	3656	tmp = NULL;
3512	}	3657	}
…		…
3515		3660
3516	tmp->x = op->x;	3661	tmp->x = op->x;
3517	tmp->y = op->y;	3662	tmp->y = op->y;
3518	SET_FLAG (tmp, FLAG_UNPAID);	3663	SET_FLAG (tmp, FLAG_UNPAID);
3519	insert_ob_in_map (tmp, op->map, NULL, 0);	3664	insert_ob_in_map (tmp, op->map, NULL, 0);
3520	CLEAR_FLAG (op, FLAG_AUTO_APPLY);
3521	identify (tmp);	3665	identify (tmp);
3522	break;	3666	break;
3523		3667
3524	case TREASURE:	3668	case TREASURE:
3525	if (QUERY_FLAG (op, FLAG_IS_A_TEMPLATE))	3669	if (QUERY_FLAG (op, FLAG_IS_A_TEMPLATE))
…		…
3532	/* If we generated an object and put it in this object inventory,	3676	/* If we generated an object and put it in this object inventory,
3533	* move it to the parent object as the current object is about	3677	* move it to the parent object as the current object is about
3534	* to disappear. An example of this item is the random_* stuff	3678	* to disappear. An example of this item is the random_* stuff
3535	* that is put inside other objects.	3679	* that is put inside other objects.
3536	*/	3680	*/
3537	for (tmp = op->inv; tmp; tmp = tmp2)
3538	{
3539	tmp2 = tmp->below;
3540	tmp->remove ();
3541
3542	if (op->env)	3681	if (op->env)
3543	insert_ob_in_ob (tmp, op->env);	3682	while (op->inv)
3544	else	3683	op->env->insert (op->inv);
3545	tmp->destroy ();
3546	}
3547		3684
3548	op->destroy ();	3685	op->destroy ();
3549	break;	3686	break;
3550	}	3687	}
3551	return tmp ? 1 : 0;	3688
		3689	return !!tmp;
3552	}	3690	}
3553		3691
3554	/**	3692	/**
3555	* fix_auto_apply goes through the entire map every time a map	3693	* fix_auto_apply goes through the entire map every time a map
3556	* is loaded or swapped in and performs special actions for	3694	* is loaded or swapped in and performs special actions for
…		…
3570		3708
3571	if (tmp->inv)	3709	if (tmp->inv)
3572	{	3710	{
3573	object *invtmp, *invnext;	3711	object *invtmp, *invnext;
3574		3712
3575	for (invtmp = tmp->inv; invtmp != NULL; invtmp = invnext)	3713	for (invtmp = tmp->inv; invtmp; invtmp = invnext)
3576	{	3714	{
3577	invnext = invtmp->below;	3715	invnext = invtmp->below;
3578		3716
3579	if (QUERY_FLAG (invtmp, FLAG_AUTO_APPLY))	3717	if (QUERY_FLAG (invtmp, FLAG_AUTO_APPLY))
3580	auto_apply (invtmp);	3718	auto_apply (invtmp);
3581	else if (invtmp->type == TREASURE && invtmp->has_random_items ())	3719	else if (invtmp->type == TREASURE && invtmp->has_random_items ())
3582	{	3720	{
3583	while ((invtmp->stats.hp--) > 0)	3721	while (invtmp->stats.hp-- > 0)
3584	create_treasure (invtmp->randomitems, invtmp, 0, difficulty, 0);	3722	create_treasure (invtmp->randomitems, invtmp, 0, difficulty, 0);
3585		3723
3586	invtmp->randomitems = NULL;	3724	invtmp->randomitems = NULL;
3587	}	3725	}
3588	else if (invtmp && invtmp->arch	3726	else if (invtmp && invtmp->arch
…		…
3649	}	3787	}
3650		3788
3651	for (mapspace *ms = spaces + size (); ms-- > spaces; )	3789	for (mapspace *ms = spaces + size (); ms-- > spaces; )
3652	for (object *tmp = ms->bot; tmp; tmp = tmp->above)	3790	for (object *tmp = ms->bot; tmp; tmp = tmp->above)
3653	if (tmp->above && (tmp->type == TRIGGER_BUTTON || tmp->type == TRIGGER_PEDESTAL))	3791	if (tmp->above && (tmp->type == TRIGGER_BUTTON || tmp->type == TRIGGER_PEDESTAL))
3654	check_trigger (tmp, tmp->above);	3792	check_trigger (tmp, tmp->above, tmp->above);
3655	}	3793	}
3656		3794
3657	/**	3795	/**
3658	* Handles player eating food that temporarily changes status (resistances, stats).	3796	* Handles player eating food that temporarily changes status (resistances, stats).
3659	* This used to call cast_change_attr(), but	3797	* This used to call cast_change_attr(), but
…		…
3664	eat_special_food (object *who, object *food)	3802	eat_special_food (object *who, object *food)
3665	{	3803	{
3666	object *force;	3804	object *force;
3667	int i, did_one = 0;	3805	int i, did_one = 0;
3668		3806
3669	force = get_archetype (FORCE_NAME);	3807	char buf[64];
		3808	snprintf (buf, sizeof(buf), "sp_food_%s", &food->title);
		3809	shstr key (buf);
3670		3810
3671	for (i = 0; i < NUM_STATS; i++)
3672	if (sint8 k = food->stats.stat (i))
3673	{
3674	force->stats.stat (i) = k;
3675	did_one = 1;
3676	}
3677
3678	/* check if we can protect the eater */
3679	for (i = 0; i < NROFATTACKS; i++)
3680	{
3681	if (food->resist[i] > 0)
3682	{
3683	force->resist[i] = food->resist[i] / 2;
3684	did_one = 1;
3685	}
3686	}
3687
3688	if (did_one)
3689	{
3690	force->set_speed (0.1);
3691	/* bigger morsel of food = longer effect time */	3811	/* bigger morsel of food = longer effect time */
3692	force->duration = food->stats.food / 5;	3812	int duration = TIME2TICK (food->stats.food);
3693	SET_FLAG (force, FLAG_APPLIED);	3813
3694	change_abil (who, force);	3814	if (force = who->force_find (key))
3695	insert_ob_in_ob (force, who);	3815	{
		3816	if (duration > abs (force->speed_left / force->speed))
		3817	{
		3818	new_draw_info_format (NDI_UNIQUE, 0, who, "More magical force spreads through you. H<The effect will last for about %.10g more seconds.>", TICK2TIME (duration));
		3819	force->force_set_timer (duration);
		3820	}
		3821	else
		3822	new_draw_info (NDI_UNIQUE, 0, who, "It had no additional effect.");
		3823
		3824	return;
3696	}	3825	}
3697	else	3826	else
		3827	{
		3828	force = who->force_add (key, duration);
		3829	force->name = key;
		3830
		3831	/* check if the food affects a stat */
		3832	for (i = 0; i < NUM_STATS; i++)
		3833	if (sint8 k = food->stats.stat (i))
		3834	{
		3835	force->stats.stat (i) = k;
		3836	did_one = 1;
		3837	}
		3838
		3839	/* check if we can protect the eater */
		3840	for (i = 0; i < NROFATTACKS; i++)
		3841	{
		3842	if (food->resist[i] > 0)
		3843	{
		3844	force->resist[i] = food->resist[i];
		3845	did_one = 1;
		3846	}
		3847	}
		3848
		3849	if (did_one)
		3850	{
		3851	new_draw_info_format (NDI_UNIQUE, 0, who, "You are suffused with magical force. H<The effect will last for about %.10g seconds.>", TICK2TIME (duration));
		3852
		3853	/* make the force take effect and report effects to user */
		3854	change_abil (who, force);
		3855	}
		3856	else
3698	force->destroy ();	3857	force->destroy ();
		3858	}
3699		3859
3700	/* check for hp, sp change */	3860	/* check for hp, sp change */
3701	if (food->stats.hp != 0)	3861	if (food->stats.hp != 0)
3702	{	3862	{
3703	if (QUERY_FLAG (food, FLAG_CURSED))	3863	if (QUERY_FLAG (food, FLAG_CURSED))
…		…
3735	}	3895	}
3736		3896
3737	who->update_stats ();	3897	who->update_stats ();
3738	}	3898	}
3739		3899
3740	/**
3741	* Designed primarily to light torches/lanterns/etc.
3742	* Also burns up burnable material too. First object in the inventory is
3743	* the selected object to "burn". -b.t.
3744	*/
3745	void
3746	apply_lighter (object *who, object *lighter)
3747	{
3748	object *item;
3749	int is_player_env = 0;
3750
3751	item = find_marked_object (who);
3752	if (item)
3753	{
3754	if (lighter->last_eat && lighter->stats.food)
3755	{ /* lighter gets used up */
3756	object *oneLighter = lighter->split ();
3757	oneLighter->stats.food--;
3758	who->insert (oneLighter);
3759	}
3760	else if (lighter->last_eat)
3761	{
3762	/* no charges left in lighter */
3763	who->failmsg (format ("You attempt to light the %s with a used up %s.", &item->name, &lighter->name));
3764	return;
3765	}
3766
3767	/* Perhaps we should split what we are trying to light on fire?
3768	* I can't see many times when you would want to light multiple
3769	* objects at once.
3770	*/
3771
3772	if (who == item->in_player ())
3773	is_player_env = 1;
3774
3775	save_throw_object (item, AT_FIRE, who);
3776
3777	if (item->destroyed ())
3778	{
3779	who->statusmsg (format ("You light the %s with the %s.", &item->name, &lighter->name));
3780	/* Need to update the player so that the players glow radius
3781	* gets changed.
3782	*/
3783	if (is_player_env)
3784	who->update_stats ();
3785	}
3786	else
3787	who->failmsg (format ("You attempt to light the %s with the %s and fail.", &item->name, &lighter->name));
3788	}
3789	else
3790	who->failmsg ("You need to mark a lightable object.");
3791	}
3792		3900
3793	/**	3901	/**
3794	* op made some mistake with a scroll, this takes care of punishment.	3902	* op made some mistake with a scroll, this takes care of punishment.
3795	* scroll_failure()- hacked directly from spell_failure	3903	* scroll_failure()- hacked directly from spell_failure
3796	*/	3904	*/
…		…
3896	}	4004	}
3897		4005
3898	/* insert the randomitems from the change's treasurelist into	4006	/* insert the randomitems from the change's treasurelist into
3899	* the player ref: player.c	4007	* the player ref: player.c
3900	*/	4008	*/
3901	if (change->randomitems != NULL)	4009	if (change->randomitems)
3902	give_initial_items (pl, change->randomitems);	4010	give_initial_items (pl, change->randomitems);
3903		4011
3904	/* set up the face, for some races. */	4012	/* set up the face, for some races. */
3905		4013
3906	/* first, look for the force object banning	4014	/* first, look for the force object banning
3907	* changing the face. Certain races never change face with class.	4015	* changing the face. Certain races never change face with class.
3908	*/	4016	*/
3909	for (walk = pl->inv; walk != NULL; walk = walk->below)	4017	for (walk = pl->inv; walk; walk = walk->below)
3910	if (!strcmp (walk->name, "NOCLASSFACECHANGE"))	4018	if (walk->name == shstr_NOCLASSFACECHANGE)
3911	flag_change_face = 0;	4019	flag_change_face = 0;
3912		4020
3913	if (flag_change_face)	4021	if (flag_change_face)
3914	{	4022	{
3915	pl->face = change->face;	4023	pl->face = change->face;
…		…
3917	pl->flag [FLAG_ANIMATE] = change->flag [FLAG_ANIMATE];	4025	pl->flag [FLAG_ANIMATE] = change->flag [FLAG_ANIMATE];
3918	}	4026	}
3919		4027
3920	/* check the special case of can't use weapons */	4028	/* check the special case of can't use weapons */
3921	/*if(QUERY_FLAG(change,FLAG_USE_WEAPON)) CLEAR_FLAG(pl,FLAG_USE_WEAPON); */	4029	/*if(QUERY_FLAG(change,FLAG_USE_WEAPON)) CLEAR_FLAG(pl,FLAG_USE_WEAPON); */
3922	if (!strcmp (change->name, "monk"))	4030	if (change->name == shstr_monk)
3923	CLEAR_FLAG (pl, FLAG_USE_WEAPON);	4031	CLEAR_FLAG (pl, FLAG_USE_WEAPON);
3924		4032
3925	break;	4033	break;
3926	}	4034	}
3927	}	4035	}
…		…
3964	pl->failmsg (format ("You can't use the %s with your %s!", query_name (transformer), query_name (marked)));	4072	pl->failmsg (format ("You can't use the %s with your %s!", query_name (transformer), query_name (marked)));
3965	return;	4073	return;
3966	}	4074	}
3967		4075
3968	/* check whether they are compatible or not */	4076	/* check whether they are compatible or not */
3969	find = strstr (marked->slaying, transformer->arch->archname);	4077	find = strstr (&marked->slaying, transformer->arch->archname);
3970	if (!find || (*(find + strlen (transformer->arch->archname)) != ':'))	4078	if (!find || (*(find + strlen (transformer->arch->archname)) != ':'))
3971	{	4079	{
3972	pl->failmsg (format ("You can't use the %s with your %s!", query_name (transformer), query_name (marked)));	4080	pl->failmsg (format ("You can't use the %s with your %s!", query_name (transformer), query_name (marked)));
3973	return;	4081	return;
3974	}	4082	}

Diff Legend

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