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.92 by root, Sat May 12 18:23:51 2007 UTC vs.
Revision 1.182 by root, Thu Jan 1 11:41:17 2009 UTC

1	/*	1	/*
2	* CrossFire, A Multiplayer game	2	* This file is part of Deliantra, the Roguelike Realtime MMORPG.
3	*	3	*
4	* Copyright (C) 2005, 2006, 2007 Marc Lehmann & Crossfire+ Development Team	4	* Copyright (©) 2005,2006,2007,2008 Marc Alexander Lehmann / Robin Redeker / the Deliantra team
5	* Copyright (C) 2001 Mark Wedel & Crossfire Development Team	5	* Copyright (©) 2001,2007 Mark Wedel & Crossfire Development Team
6	* Copyright (C) 1992 Frank Tore Johansen	6	* Copyright (©) 1992,2007 Frank Tore Johansen
7	*	7	*
8	* This program is free software; you can redistribute it and/or modify	8	* Deliantra is free software: you can redistribute it and/or modify
9	* it under the terms of the GNU General Public License as published by	9	* it under the terms of the GNU General Public License as published by
10	* the Free Software Foundation; either version 2 of the License, or	10	* the Free Software Foundation, either version 3 of the License, or
11	* (at your option) any later version.	11	* (at your option) any later version.
12	*	12	*
13	* This program is distributed in the hope that it will be useful,	13	* This program is distributed in the hope that it will be useful,
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 GNU General Public License
19	* along with this program; if not, write to the Free Software	19	* along with this program. If not, see <http://www.gnu.org/licenses/>.
20	* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
21	*	20	*
22	* The authors can be reached via e-mail to <crossfire@schmorp.de>	21	* The authors can be reached via e-mail to <support@deliantra.net>
23	*/	22	*/
24		23
25	#include <cmath>	24	#include <cmath>
26		25
27	#include <global.h>	26	#include <global.h>
…		…
54	* subtype 5: arch or race	53	* subtype 5: arch or race
55	* subtype 7: all three	54	* subtype 7: all three
56	*/	55	*/
57	if (op->subtype)	56	if (op->subtype)
58	{	57	{
59	arch_flag = (op->subtype & 1);	58	arch_flag = op->subtype & 1;
60	name_flag = (op->subtype & 2);	59	name_flag = op->subtype & 2;
61	race_flag = (op->subtype & 4);	60	race_flag = op->subtype & 4;
62	}	61	}
63	else	62	else
64	{	63	{
65	arch_flag = 1;	64	arch_flag = 1;
66	name_flag = 1;	65	name_flag = 1;
…		…
69		68
70	/* If the director has race set, only affect objects with a arch,	69	/* If the director has race set, only affect objects with a arch,
71	* name or race that matches.	70	* name or race that matches.
72	*/	71	*/
73	if ((op->race) &&	72	if ((op->race) &&
74	((!(victim->arch && arch_flag && victim->arch->name) || op->race != victim->arch->name)) &&	73	((!(victim->arch && arch_flag && victim->arch->archname) || op->race != victim->arch->archname)) &&
75	((!(victim->name && name_flag) || op->race != victim->name)) &&	74	((!(victim->name && name_flag) || op->race != victim->name)) &&
76	((!(victim->race && race_flag) || op->race != victim->race)))	75	((!(victim->race && race_flag) || op->race != victim->race)))
77	return 1;	76	return 1;
78		77
79	/* If the director has slaying set, only affect objects where none	78	/* If the director has slaying set, only affect objects where none
80	* of arch, name, or race match.	79	* of arch, name, or race match.
81	*/	80	*/
82	if ((op->slaying) && (((victim->arch && arch_flag && victim->arch->name && op->slaying == victim->arch->name))) ||	81	if ((op->slaying) && (((victim->arch && arch_flag && victim->arch->archname && op->slaying == victim->arch->archname))) ||
83	((victim->name && name_flag && op->slaying == victim->name)) ||	82	((victim->name && name_flag && op->slaying == victim->name)) ||
84	((victim->race && race_flag && op->slaying == victim->race)))	83	((victim->race && race_flag && op->slaying == victim->race)))
85	return 1;	84	return 1;
86		85
87	return 0;	86	return 0;
…		…
93	* Return value: 1 if money was destroyed, 0 if not.	92	* Return value: 1 if money was destroyed, 0 if not.
94	*/	93	*/
95	static int	94	static int
96	apply_id_altar (object *money, object *altar, object *pl)	95	apply_id_altar (object *money, object *altar, object *pl)
97	{	96	{
98	object *id, *marked;	97	dynbuf_text buf;
99	int success = 0;
100		98
101	if (pl == NULL || pl->type != PLAYER)	99	if (!pl || pl->type != PLAYER)
102	return 0;	100	return 0;
103		101
104	/* Check for MONEY type is a special hack - it prevents 'nothing needs	102	/* Check for MONEY type is a special hack - it prevents 'nothing needs
105	* identifying' from being printed out more than it needs to be.	103	* identifying' from being printed out more than it needs to be.
106	*/	104	*/
107	if (!check_altar_sacrifice (altar, money) || money->type != MONEY)	105	if (!check_altar_sacrifice (altar, money) || money->type != MONEY)
108	return 0;	106	return 0;
109		107
110	marked = find_marked_object (pl);
111	/* if the player has a marked item, identify that if it needs to be	108	/* if the player has a marked item, identify that if it needs to be
112	* identified. IF it doesn't, then go through the player inventory.	109	* identified. If it doesn't, then go through the player inventory.
113	*/	110	*/
		111	if (object *marked = find_marked_object (pl))
114	if (marked && !QUERY_FLAG (marked, FLAG_IDENTIFIED) && need_identify (marked))	112	if (!QUERY_FLAG (marked, FLAG_IDENTIFIED) && need_identify (marked))
115	{	113	{
116	if (operate_altar (altar, &money))	114	if (operate_altar (altar, &money))
117	{	115	{
118	identify (marked);	116	identify (marked);
119	new_draw_info_format (NDI_UNIQUE, 0, pl, "You have %s.", long_desc (marked, pl));	117
		118	buf.printf ("You have %s.\r", long_desc (marked, pl));
120	if (marked->msg)	119	if (marked->msg)
121	{	120	buf << "The item has a story:\r" << marked->msg << "\n\n";
122	new_draw_info (NDI_UNIQUE, 0, pl, "The item has a story:");	121
123	new_draw_info (NDI_UNIQUE, 0, pl, marked->msg);	122	return !money;
124	}	123	}
125	return money == NULL;
126	}	124	}
127	}
128		125
129	for (id = pl->inv; id; id = id->below)	126	for (object *id = pl->inv; id; id = id->below)
130	{	127	{
131	if (!QUERY_FLAG (id, FLAG_IDENTIFIED) && !id->invisible && need_identify (id))	128	if (!QUERY_FLAG (id, FLAG_IDENTIFIED) && !id->invisible && need_identify (id))
132	{	129	{
133	if (operate_altar (altar, &money))	130	if (operate_altar (altar, &money))
134	{	131	{
135	identify (id);	132	identify (id);
136	new_draw_info_format (NDI_UNIQUE, 0, pl, "You have %s.", long_desc (id, pl));	133
		134	buf.printf ("You have %s.\r", long_desc (id, pl));
137	if (id->msg)	135	if (id->msg)
138	{	136	buf << "The item has a story:\r" << id->msg << "\n\n";
139	new_draw_info (NDI_UNIQUE, 0, pl, "The item has a story:");	137
140	new_draw_info (NDI_UNIQUE, 0, pl, id->msg);
141	}
142	success = 1;
143	/* If no more money, might as well quit now */	138	/* If no more money, might as well quit now */
144	if (money == NULL || !check_altar_sacrifice (altar, money))	139	if (!money || !check_altar_sacrifice (altar, money))
145	break;	140	break;
146	}	141	}
147	else	142	else
148	{	143	{
149	LOG (llevError, "check_id_altar: Couldn't do sacrifice when we should have been able to\n");	144	LOG (llevError, "check_id_altar: Couldn't do sacrifice when we should have been able to\n");
150	break;	145	break;
151	}	146	}
152	}	147	}
153	}	148	}
154	if (!success)	149
155	new_draw_info (NDI_UNIQUE, 0, pl, "You have nothing that needs identifying");	150	if (buf.empty ())
		151	pl->failmsg ("You have nothing that needs identifying");
		152	else
		153	pl->contr->infobox (MSG_CHANNEL ("identify"), buf);
		154
156	return money == NULL;	155	return !money;
157	}	156	}
158		157
159	/**	158	/**
160	* This checks whether the object has a "on_use_yield" field, and if so generated and drops	159	* This checks whether the object has a "on_use_yield" field, and if so generated and drops
161	* matching item.	160	* matching item.
162	**/	161	**/
163	static void	162	void
164	handle_apply_yield (object *tmp)	163	handle_apply_yield (object *tmp)
165	{	164	{
166	const char *yield;	165	if (shstr_tmp yield = tmp->kv (shstr_on_use_yield))
167		166	archetype::get (yield)->insert_at (tmp, tmp, INS_BELOW_ORIGINATOR);
168	yield = get_ob_key_value (tmp, "on_use_yield");
169	if (yield != NULL)
170	{
171	object *drop = get_archetype (yield);
172
173	if (tmp->env)
174	{
175	drop = insert_ob_in_ob (drop, tmp->env);
176	if (tmp->env->type == PLAYER)
177	esrv_send_item (tmp->env, drop);
178	}
179	else
180	{
181	drop->x = tmp->x;
182	drop->y = tmp->y;
183	insert_ob_in_map (drop, tmp->map, tmp, INS_BELOW_ORIGINATOR);
184	}
185	}
186	}	167	}
187		168
188	/**	169	/**
189	* Handles applying a potion.	170	* Handles applying a potion.
190	*/	171	*/
…		…
196		177
197	floor = GET_MAP_OB (op->map, op->x, op->y);	178	floor = GET_MAP_OB (op->map, op->x, op->y);
198		179
199	if (get_map_flags (op->map, NULL, op->x, op->y, NULL, NULL) & P_SAFE)	180	if (get_map_flags (op->map, NULL, op->x, op->y, NULL, NULL) & P_SAFE)
200	{	181	{
201	if (op->type == PLAYER)
202	new_draw_info (NDI_UNIQUE, 0, op, "Gods prevent you from using this here, it's sacred ground!");	182	op->failmsg ("Gods prevent you from using this here, it's sacred ground!");
		183
203	CLEAR_FLAG (tmp, FLAG_APPLIED);	184	CLEAR_FLAG (tmp, FLAG_APPLIED);
204	return 0;	185	return 0;
205	}	186	}
206		187
207	if (op->type == PLAYER)	188	if (op->type == PLAYER)
…		…
218		199
219	if (QUERY_FLAG (tmp, FLAG_CURSED) || QUERY_FLAG (tmp, FLAG_DAMNED))	200	if (QUERY_FLAG (tmp, FLAG_CURSED) || QUERY_FLAG (tmp, FLAG_DAMNED))
220	{	201	{
221	op->drain_stat ();	202	op->drain_stat ();
222	op->update_stats ();	203	op->update_stats ();
223	decrease_ob (tmp);	204	tmp->decrease ();
224	return 1;	205	return 1;
225	}	206	}
226		207
227	if (!(at = archetype::find (ARCH_DEPLETION)))	208	if (!(at = archetype::find (ARCH_DEPLETION)))
228	{	209	{
229	LOG (llevError, "Could not find archetype depletion\n");	210	LOG (llevError, "Could not find archetype depletion\n");
230	return 0;	211	return 0;
231	}	212	}
		213
232	depl = present_arch_in_ob (at, op);	214	depl = present_arch_in_ob (at, op);
233		215
234	if (depl)	216	if (depl)
235	{	217	{
236	for (i = 0; i < NUM_STATS; i++)	218	for (i = 0; i < NUM_STATS; i++)
237	if (depl->stats.stat (i))	219	if (depl->stats.stat (i))
238	new_draw_info (NDI_UNIQUE, 0, op, restore_msg[i]);	220	op->statusmsg (restore_msg[i]);
239		221
240	depl->destroy ();	222	depl->destroy ();
241	op->update_stats ();	223	op->update_stats ();
242	}	224	}
243	else	225	else
244	new_draw_info (NDI_UNIQUE, 0, op, "You potion had no effect.");	226	op->statusmsg ("Your potion had no effect.");
245		227
246	decrease_ob (tmp);	228	tmp->decrease ();
247	return 1;	229	return 1;
248	}	230	}
249		231
250	/* improvement potion - only for players */	232	/* improvement potion - only for players */
251	if (op->type == PLAYER && tmp->attacktype & AT_GODPOWER)	233	if (op->type == PLAYER && (tmp->attacktype & AT_GODPOWER))
252	{	234	{
253	for (i = 1; i < MIN (11, op->level); i++)	235	for (i = 1; i < MIN (11, op->level); i++)
254	{	236	{
255	if (QUERY_FLAG (tmp, FLAG_CURSED) || QUERY_FLAG (tmp, FLAG_DAMNED))	237	if (QUERY_FLAG (tmp, FLAG_CURSED) || QUERY_FLAG (tmp, FLAG_DAMNED))
256	{	238	{
257	if (op->contr->levhp[i] != 1)	239	if (op->contr->levhp[i] != 1)
258	{	240	{
259	op->contr->levhp[i] = 1;	241	op->contr->levhp[i] = 1;
260	break;	242	break;
261	}	243	}
		244
262	if (op->contr->levsp[i] != 1)	245	if (op->contr->levsp[i] != 1)
263	{	246	{
264	op->contr->levsp[i] = 1;	247	op->contr->levsp[i] = 1;
265	break;	248	break;
266	}	249	}
		250
267	if (op->contr->levgrace[i] != 1)	251	if (op->contr->levgrace[i] != 1)
268	{	252	{
269	op->contr->levgrace[i] = 1;	253	op->contr->levgrace[i] = 1;
270	break;	254	break;
271	}	255	}
…		…
275	if (op->contr->levhp[i] < 9)	259	if (op->contr->levhp[i] < 9)
276	{	260	{
277	op->contr->levhp[i] = 9;	261	op->contr->levhp[i] = 9;
278	break;	262	break;
279	}	263	}
		264
280	if (op->contr->levsp[i] < 6)	265	if (op->contr->levsp[i] < 6)
281	{	266	{
282	op->contr->levsp[i] = 6;	267	op->contr->levsp[i] = 6;
283	break;	268	break;
284	}	269	}
		270
285	if (op->contr->levgrace[i] < 3)	271	if (op->contr->levgrace[i] < 3)
286	{	272	{
287	op->contr->levgrace[i] = 3;	273	op->contr->levgrace[i] = 3;
288	break;	274	break;
289	}	275	}
…		…
297	if (!QUERY_FLAG (tmp, FLAG_CURSED) && !QUERY_FLAG (tmp, FLAG_DAMNED))	283	if (!QUERY_FLAG (tmp, FLAG_CURSED) && !QUERY_FLAG (tmp, FLAG_DAMNED))
298	{	284	{
299	if (got_one)	285	if (got_one)
300	{	286	{
301	op->update_stats ();	287	op->update_stats ();
302	new_draw_info (NDI_UNIQUE, 0, op, "The Gods smile upon you and remake you");	288	op->statusmsg ("The Gods smile upon you and remake you "
303	new_draw_info (NDI_UNIQUE, 0, op, "a little more in their image.");	289	"a little more in their image. "
304	new_draw_info (NDI_UNIQUE, 0, op, "You feel a little more perfect.");	290	"You feel a little more perfect.", NDI_GREEN);
305	}	291	}
306	else	292	else
307	new_draw_info (NDI_UNIQUE, 0, op, "The potion had no effect - you are already perfect");	293	op->statusmsg ("The potion had no effect - you are already perfect.");
308	}	294	}
309	else	295	else
310	{ /* cursed potion */	296	{ /* cursed potion */
311	if (got_one)	297	if (got_one)
312	{	298	{
313	op->update_stats ();	299	op->update_stats ();
314	new_draw_info (NDI_UNIQUE, 0, op, "The Gods are angry and punish you.");	300	op->failmsg ("The Gods are angry and punish you.");
315	}	301	}
316	else	302	else
317	new_draw_info (NDI_UNIQUE, 0, op, "You are fortunate that you are so pathetic.");	303	op->statusmsg ("You are fortunate that you are so pathetic.", NDI_DK_ORANGE);
318	}	304	}
319		305
320	decrease_ob (tmp);	306	tmp->decrease ();
321	return 1;	307	return 1;
322	}	308	}
323		309
324		310
325	/* A potion that casts a spell. Healing, restore spellpoint (power potion)	311	/* A potion that casts a spell. Healing, restore spellpoint (power potion)
…		…
331	{	317	{
332	if (QUERY_FLAG (tmp, FLAG_CURSED) || QUERY_FLAG (tmp, FLAG_DAMNED))	318	if (QUERY_FLAG (tmp, FLAG_CURSED) || QUERY_FLAG (tmp, FLAG_DAMNED))
333	{	319	{
334	object *fball;	320	object *fball;
335		321
336	new_draw_info (NDI_UNIQUE, 0, op, "Yech! Your lungs are on fire!");	322	op->failmsg ("Yech! Your lungs are on fire!");
		323
337	/* Explodes a fireball centered at player */	324	/* Explodes a fireball centered at player */
338	fball = get_archetype (EXPLODING_FIREBALL);	325	fball = get_archetype (EXPLODING_FIREBALL);
339	fball->dam_modifier = random_roll (1, op->level, op, PREFER_LOW) / 5 + 1;	326	fball->dam_modifier = random_roll (1, op->level, op, PREFER_LOW) / 5 + 1;
340	fball->stats.maxhp = random_roll (1, op->level, op, PREFER_LOW) / 10 + 2;	327	fball->stats.maxhp = random_roll (1, op->level, op, PREFER_LOW) / 10 + 2;
341	fball->x = op->x;	328	fball->x = op->x;
…		…
343	insert_ob_in_map (fball, op->map, NULL, 0);	330	insert_ob_in_map (fball, op->map, NULL, 0);
344	}	331	}
345	else	332	else
346	cast_spell (op, tmp, op->facing, tmp->inv, NULL);	333	cast_spell (op, tmp, op->facing, tmp->inv, NULL);
347		334
348	decrease_ob (tmp);	335	tmp->decrease ();
		336
349	/* if youre dead, no point in doing this... */	337	/* if youre dead, no point in doing this... */
350	if (!QUERY_FLAG (op, FLAG_REMOVED))	338	if (!QUERY_FLAG (op, FLAG_REMOVED))
351	op->update_stats ();	339	op->update_stats ();
		340
352	return 1;	341	return 1;
353	}	342	}
354		343
355	/* Deal with protection potions */	344	/* Deal with protection potions */
356	force = NULL;	345	force = NULL;
…		…
358	{	347	{
359	if (tmp->resist[i])	348	if (tmp->resist[i])
360	{	349	{
361	if (!force)	350	if (!force)
362	force = get_archetype (FORCE_NAME);	351	force = get_archetype (FORCE_NAME);
		352
363	memcpy (force->resist, tmp->resist, sizeof (tmp->resist));	353	memcpy (force->resist, tmp->resist, sizeof (tmp->resist));
364	force->type = POTION_EFFECT;	354	force->type = POTION_EFFECT;
365	break; /* Only need to find one protection since we copy entire batch */	355	break; /* Only need to find one protection since we copy entire batch */
366	}	356	}
367	}	357	}
		358
368	/* This is a protection potion */	359	/* This is a protection potion */
369	if (force)	360	if (force)
370	{	361	{
371	/* cursed items last longer */	362	/* cursed items last longer */
372	if (QUERY_FLAG (tmp, FLAG_CURSED) || QUERY_FLAG (tmp, FLAG_DAMNED))	363	if (QUERY_FLAG (tmp, FLAG_CURSED) || QUERY_FLAG (tmp, FLAG_DAMNED))
…		…
380	force->speed_left = -1;	371	force->speed_left = -1;
381	force = insert_ob_in_ob (force, op);	372	force = insert_ob_in_ob (force, op);
382	CLEAR_FLAG (tmp, FLAG_APPLIED);	373	CLEAR_FLAG (tmp, FLAG_APPLIED);
383	SET_FLAG (force, FLAG_APPLIED);	374	SET_FLAG (force, FLAG_APPLIED);
384	change_abil (op, force);	375	change_abil (op, force);
385	decrease_ob (tmp);	376	tmp->decrease ();
386	return 1;	377	return 1;
387	}	378	}
388		379
389	/* Only thing left are the stat potions */	380	/* Only thing left are the stat potions */
390	if (op->type == PLAYER)	381	if (op->type == PLAYER)
391	{ /* only for players */	382	{ /* only for players */
392	if ((QUERY_FLAG (tmp, FLAG_CURSED) || QUERY_FLAG (tmp, FLAG_DAMNED)) && tmp->value != 0)	383	if ((QUERY_FLAG (tmp, FLAG_CURSED) || QUERY_FLAG (tmp, FLAG_DAMNED)) && tmp->value != 0)
393	CLEAR_FLAG (tmp, FLAG_APPLIED);	384	CLEAR_FLAG (tmp, FLAG_APPLIED);
394	else	385	else
395	SET_FLAG (tmp, FLAG_APPLIED);	386	SET_FLAG (tmp, FLAG_APPLIED);
		387
396	if (!change_abil (op, tmp))	388	if (!change_abil (op, tmp))
397	new_draw_info (NDI_UNIQUE, 0, op, "Nothing happened.");	389	op->statusmsg ("Nothing happened.");
398	}	390	}
399		391
400	/* CLEAR_FLAG is so that if the character has other potions	392	/* CLEAR_FLAG is so that if the character has other potions
401	* that were grouped with the one consumed, his	393	* that were grouped with the one consumed, his
402	* stat will not be raised by them. fix_player just clears	394	* stat will not be raised by them. fix_player just clears
403	* up all the stats.	395	* up all the stats.
404	*/	396	*/
405	CLEAR_FLAG (tmp, FLAG_APPLIED);	397	CLEAR_FLAG (tmp, FLAG_APPLIED);
406	op->update_stats ();	398	op->update_stats ();
407	decrease_ob (tmp);	399	tmp->decrease ();
408	return 1;	400	return 1;
409	}	401	}
410		402
411	/****************************************************************************	403	/****************************************************************************
412	* Weapon improvement code follows	404	* Weapon improvement code follows
…		…
414		406
415	/**	407	/**
416	* This returns the sum of nrof of item (arch name).	408	* This returns the sum of nrof of item (arch name).
417	*/	409	*/
418	static int	410	static int
419	check_item (object *op, const char *item)	411	check_item (object *op, shstr_cmp item)
420	{	412	{
421	int count = 0;	413	int count = 0;
422		414
423		415	if (!item)
424	if (item == NULL)
425	return 0;	416	return 0;
426		417
427	op = op->below;	418	for (op = op->below; op; op = op->below)
428	while (op != NULL)	419	if (op->arch->archname == item)
429	{
430	if (strcmp (op->arch->name, item) == 0)
431	{
432	if (!QUERY_FLAG (op, FLAG_CURSED) && !QUERY_FLAG (op, FLAG_DAMNED)	420	if (!QUERY_FLAG (op, FLAG_CURSED) && !QUERY_FLAG (op, FLAG_DAMNED)
433	/* Loophole bug? -FD- */ && !QUERY_FLAG (op, FLAG_UNPAID))	421	&& /* Loophole bug? -FD- */ !QUERY_FLAG (op, FLAG_UNPAID))
434	{
435	if (op->nrof == 0) /* this is necessary for artifact sacrifices --FD-- */
436	count++;
437	else
438	count += op->nrof;	422	count += op->number_of ();
439	}
440	}
441
442	op = op->below;
443	}
444		423
445	return count;	424	return count;
446	}	425	}
447		426
448	/**	427	/**
…		…
450	* op is typically the player, which is only	429	* op is typically the player, which is only
451	* really used to determine what space to look at.	430	* really used to determine what space to look at.
452	* Modified to only eat 'nrof' of objects.	431	* Modified to only eat 'nrof' of objects.
453	*/	432	*/
454	static void	433	static void
455	eat_item (object *op, const char *item, uint32 nrof)	434	eat_item (object *op, shstr_cmp item, uint32 nrof)
456	{	435	{
457	object *prev;	436	object *prev;
458		437
459	prev = op;	438	prev = op;
460	op = op->below;	439	op = op->below;
461		440
462	while (op != NULL)	441	while (op)
463	{	442	{
464	if (strcmp (op->arch->name, item) == 0)	443	if (op->arch->archname == item)
465	{	444	{
466	if (op->nrof >= nrof)	445	if (op->nrof >= nrof)
467	{	446	{
468	decrease_ob_nr (op, nrof);	447	op->decrease (nrof);
469	return;	448	return;
470	}	449	}
471	else	450	else
472	{	451	{
473	decrease_ob_nr (op, op->nrof);	452	op->decrease (nrof);
474	nrof -= op->nrof;	453	nrof -= op->nrof;
475	}	454	}
		455
476	op = prev;	456	op = prev;
477	}	457	}
		458
478	prev = op;	459	prev = op;
479	op = op->below;	460	op = op->below;
480	}	461	}
481	}	462	}
482		463
…		…
488	* we return 1 (true) if the player can use the weapon.	469	* we return 1 (true) if the player can use the weapon.
489	*/	470	*/
490	static int	471	static int
491	check_weapon_power (const object *who, int improvs)	472	check_weapon_power (const object *who, int improvs)
492	{	473	{
493
494	/* Old code is below (commented out). Basically, since weapons are the only	474	/* Old code is below (commented out). Basically, since weapons are the only
495	* object players really have any control to improve, it's a bit harsh to	475	* object players really have any control to improve, it's a bit harsh to
496	* require high level in some combat skill, so we just use overall level.	476	* require high level in some combat skill, so we just use overall level.
497	*/	477	*/
498	#if 1	478	#if 1
…		…
539	static int	519	static int
540	check_sacrifice (object *op, const object *improver)	520	check_sacrifice (object *op, const object *improver)
541	{	521	{
542	int count = 0;	522	int count = 0;
543		523
544	if (improver->slaying != NULL)	524	if (improver->slaying)
545	{	525	{
546	count = check_item (op, improver->slaying);	526	count = check_item (op, improver->slaying);
547	if (count < 1)	527	if (count < 1)
548	{	528	{
549	char buf[200];
550
551	sprintf (buf, "The gods want more %ss", &improver->slaying);	529	op->failmsg (format ("The gods want more %ss", &improver->slaying));
552	new_draw_info (NDI_UNIQUE, 0, op, buf);
553	return 0;	530	return 0;
554	}	531	}
555	}	532	}
556	else	533	else
557	count = 1;	534	count = 1;
…		…
560	}	537	}
561		538
562	/**	539	/**
563	* Actually improves the weapon, and tells user.	540	* Actually improves the weapon, and tells user.
564	*/	541	*/
565	int	542	static int
566	improve_weapon_stat (object *op, object *improver, object *weapon, signed char *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)
567	{	544	{
568
569	new_draw_info (NDI_UNIQUE, 0, op, "Your sacrifice was accepted.");
570	*stat += sacrifice_count;	545	stat += sacrifice_count;
571	weapon->last_eat++;	546	weapon->last_eat++;
572	new_draw_info_format (NDI_UNIQUE, 0, op, "Weapon's bonus to %s improved by %d", statname, sacrifice_count);	547	improver->decrease ();
573	decrease_ob (improver);
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 ();
		551
		552	op->statusmsg (format (
		553	"Your sacrifice was accepted.\n"
		554	"Weapon's bonus to %s improved by %d.",
		555	statname, sacrifice_count
		556	));
		557
577	return 1;	558	return 1;
578	}	559	}
579		560
580	/* Types of improvements, hidden in the sp field. */	561	/* Types of improvements, hidden in the sp field. */
581	#define IMPROVE_PREPARE 1	562	#define IMPROVE_PREPARE 1
582	#define IMPROVE_DAMAGE 2	563	#define IMPROVE_DAMAGE 2
583	#define IMPROVE_WEIGHT 3	564	#define IMPROVE_WEIGHT 3
584	#define IMPROVE_ENCHANT 4	565	#define IMPROVE_ENCHANT 4
585	#define IMPROVE_STR 5	566	#define IMPROVE_STR 5
586	#define IMPROVE_DEX 6	567	#define IMPROVE_DEX 6
587	#define IMPROVE_CON 7	568	#define IMPROVE_CON 7
588	#define IMPROVE_WIS 8	569	#define IMPROVE_WIS 8
589	#define IMPROVE_CHA 9	570	#define IMPROVE_CHA 9
590	#define IMPROVE_INT 10	571	#define IMPROVE_INT 10
591	#define IMPROVE_POW 11	572	#define IMPROVE_POW 11
592
593		573
594	/**	574	/**
595	* This does the prepare weapon scroll.	575	* This does the prepare weapon scroll.
596	* Checks for sacrifice, and so on.	576	* Checks for sacrifice, and so on.
597	*/	577	*/
598
599	int	578	int
600	prepare_weapon (object *op, object *improver, object *weapon)	579	prepare_weapon (object *op, object *improver, object *weapon)
601	{	580	{
602	int sacrifice_count, i;	581	int sacrifice_count, i;
603	char buf[MAX_BUF];	582	char buf[MAX_BUF];
604		583
605	if (weapon->level != 0)	584	if (weapon->level != 0)
606	{	585	{
607	new_draw_info (NDI_UNIQUE, 0, op, "Weapon already prepared.");	586	op->failmsg ("Weapon is already prepared!");
608	return 0;	587	return 0;
609	}	588	}
		589
610	for (i = 0; i < NROFATTACKS; i++)	590	for (i = 0; i < NROFATTACKS; i++)
611	if (weapon->resist[i])	591	if (weapon->resist[i])
612	break;	592	break;
613		593
614	/* If we break out, i will be less than nrofattacks, preventing	594	/* If we break out, i will be less than nrofattacks, preventing
…		…
617	if (i < NROFATTACKS || weapon->stats.hp || /* regeneration */	597	if (i < NROFATTACKS || weapon->stats.hp || /* regeneration */
618	(weapon->stats.sp && weapon->type == WEAPON) || /* sp regeneration */	598	(weapon->stats.sp && weapon->type == WEAPON) || /* sp regeneration */
619	weapon->stats.exp || /* speed */	599	weapon->stats.exp || /* speed */
620	weapon->stats.ac) /* AC - only taifu's I think */	600	weapon->stats.ac) /* AC - only taifu's I think */
621	{	601	{
622	new_draw_info (NDI_UNIQUE, 0, op, "Cannot prepare magic weapons.");	602	op->failmsg ("You cannot prepare magic weapons. "
		603	"H<A weapon is considered magical if it changes regeneration, "
		604	"speed or ac, or has other protections.>");
623	return 0;	605	return 0;
624	}	606	}
		607
625	sacrifice_count = check_sacrifice (op, improver);	608	sacrifice_count = check_sacrifice (op, improver);
626	if (sacrifice_count <= 0)	609	if (sacrifice_count <= 0)
627	return 0;	610	return 0;
		611
628	weapon->level = isqrt (sacrifice_count);	612	weapon->level = isqrt (sacrifice_count);
629	new_draw_info (NDI_UNIQUE, 0, op, "Your sacrifice was accepted.");
630	eat_item (op, improver->slaying, sacrifice_count);	613	eat_item (op, improver->slaying, sacrifice_count);
631		614
632	new_draw_info_format (NDI_UNIQUE, 0, op, "Your *%s may be improved %d times.", &weapon->name, weapon->level);	615	op->statusmsg (format (
		616	"Your sacrifice was accepted."
		617	"Your *%s may be improved %d times.",
		618	&weapon->name, weapon->level
		619	));
633		620
634	sprintf (buf, "%s's %s", &op->name, &weapon->name);	621	sprintf (buf, "%s's %s", &op->name, &weapon->name);
635	weapon->name = weapon->name_pl = buf;	622	weapon->name = weapon->name_pl = buf;
636	weapon->nrof = 0; /* prevents preparing n weapons in the same	623	weapon->nrof = 0; /* prevents preparing n weapons in the same
637	slot at once! */	624	slot at once! */
638	decrease_ob (improver);	625	improver->decrease ();
639	weapon->last_eat = 0;	626	weapon->last_eat = 0;
640	return 1;	627	return 1;
641	}	628	}
642
643		629
644	/**	630	/**
645	* 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.
646	* This is the new improve weapon code.	632	* This is the new improve weapon code.
647	* 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.
…		…
656	improve_weapon (object *op, object *improver, object *weapon)	642	improve_weapon (object *op, object *improver, object *weapon)
657	{	643	{
658	int sacrifice_count, sacrifice_needed = 0;	644	int sacrifice_count, sacrifice_needed = 0;
659		645
660	if (improver->stats.sp == IMPROVE_PREPARE)	646	if (improver->stats.sp == IMPROVE_PREPARE)
661	{
662	return prepare_weapon (op, improver, weapon);	647	return prepare_weapon (op, improver, weapon);
663	}	648
664	if (weapon->level == 0)	649	if (weapon->level == 0)
665	{	650	{
666	new_draw_info (NDI_UNIQUE, 0, op, "This weapon has not been prepared.");	651	op->failmsg ("This weapon has not been prepared. H<You first ahve to prepare a weapon with a prepare weapon scroll.>");
667	return 0;	652	return 0;
668	}	653	}
		654
669	if (weapon->level == weapon->last_eat && weapon->item_power >= 100)	655	if (weapon->level == weapon->last_eat && weapon->item_power >= 100)
670	{	656	{
671	new_draw_info (NDI_UNIQUE, 0, op, "This weapon cannot be improved any more.");	657	op->failmsg ("This weapon cannot be improved any more.");
672	return 0;	658	return 0;
673	}	659	}
		660
674	if (QUERY_FLAG (weapon, FLAG_APPLIED) && !check_weapon_power (op, weapon->last_eat + 1))	661	if (QUERY_FLAG (weapon, FLAG_APPLIED) && !check_weapon_power (op, weapon->last_eat + 1))
675	{	662	{
676	new_draw_info (NDI_UNIQUE, 0, op, "Improving the weapon will make it too");	663	op->failmsg ("Improving the weapon will make it too "
677	new_draw_info (NDI_UNIQUE, 0, op, "powerful for you to use. Unready it if you");	664	"powerful for you to use. Unready it if you "
678	new_draw_info (NDI_UNIQUE, 0, op, "really want to improve it.");	665	"really want to improve it.");
679	return 0;	666	return 0;
680	}	667	}
		668
681	/* This just increases damage by 5 points, no matter what. No sacrifice	669	/* This just increases damage by 5 points, no matter what. No sacrifice
682	* is needed. Since stats.dam is now a 16 bit value and not 8 bit,	670	* is needed. Since stats.dam is now a 16 bit value and not 8 bit,
683	* don't put any maximum value on damage - the limit is how much the	671	* don't put any maximum value on damage - the limit is how much the
684	* weapon can be improved.	672	* weapon can be improved.
685	*/	673	*/
686	if (improver->stats.sp == IMPROVE_DAMAGE)	674	if (improver->stats.sp == IMPROVE_DAMAGE)
687	{	675	{
688	weapon->stats.dam += 5;	676	weapon->stats.dam += 5;
689	weapon->weight += 5000; /* 5 KG's */	677	weapon->weight += 5000; /* 5 KG's */
690	new_draw_info_format (NDI_UNIQUE, 0, op, "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));
691	weapon->last_eat++;	679	weapon->last_eat++;
692		680
693	weapon->item_power++;	681	weapon->item_power++;
694	decrease_ob (improver);	682	improver->decrease ();
695	return 1;	683	return 1;
696	}	684	}
		685
697	if (improver->stats.sp == IMPROVE_WEIGHT)	686	if (improver->stats.sp == IMPROVE_WEIGHT)
698	{	687	{
699	/* Reduce weight by 20% */	688	/* Reduce weight by 20% */
700	weapon->weight = (weapon->weight * 8) / 10;	689	weapon->weight = (weapon->weight * 8) / 10;
701	if (weapon->weight < 1)	690	if (weapon->weight < 1)
702	weapon->weight = 1;	691	weapon->weight = 1;
		692
703	new_draw_info_format (NDI_UNIQUE, 0, op, "Weapon weight reduced to %6.1f kg", (float) weapon->weight / 1000.0);	693	op->statusmsg (format ("Weapon weight reduced to %6.1fkg.", (float) weapon->weight / 1000.0));
704	weapon->last_eat++;	694	weapon->last_eat++;
705	weapon->item_power++;	695	weapon->item_power++;
706	decrease_ob (improver);	696	improver->decrease ();
707	return 1;	697	return 1;
708	}	698	}
		699
709	if (improver->stats.sp == IMPROVE_ENCHANT)	700	if (improver->stats.sp == IMPROVE_ENCHANT)
710	{	701	{
711	weapon->magic++;	702	weapon->magic++;
712	weapon->last_eat++;	703	weapon->last_eat++;
713	new_draw_info_format (NDI_UNIQUE, 0, op, "Weapon magic increased to %d", weapon->magic);	704	op->statusmsg (format ("Weapon magic increased to %d.", weapon->magic));
714	decrease_ob (improver);	705	improver->decrease ();
715	weapon->item_power++;	706	weapon->item_power++;
716	return 1;	707	return 1;
717	}	708	}
718		709
719	sacrifice_needed = weapon->stats.Str + weapon->stats.Int + weapon->stats.Dex +	710	sacrifice_needed = weapon->stats.Str + weapon->stats.Int + weapon->stats.Dex +
…		…
724	sacrifice_needed *= 2;	715	sacrifice_needed *= 2;
725		716
726	sacrifice_count = check_sacrifice (op, improver);	717	sacrifice_count = check_sacrifice (op, improver);
727	if (sacrifice_count < sacrifice_needed)	718	if (sacrifice_count < sacrifice_needed)
728	{	719	{
729	new_draw_info_format (NDI_UNIQUE, 0, op, "You need at least %d %s", sacrifice_needed, &improver->slaying);	720	op->failmsg (format ("You need at least %d %s.", sacrifice_needed, &improver->slaying));
730	return 0;	721	return 0;
731	}	722	}
		723
732	eat_item (op, improver->slaying, sacrifice_needed);	724	eat_item (op, improver->slaying, sacrifice_needed);
733	weapon->item_power++;	725	weapon->item_power++;
734		726
735	switch (improver->stats.sp)	727	switch (improver->stats.sp)
736	{	728	{
737	case IMPROVE_STR:
738	return improve_weapon_stat (op, improver, weapon, (signed char *) &(weapon->stats.Str), 1, "strength");	729	case IMPROVE_STR: return improve_weapon_stat (op, improver, weapon, weapon->stats.Str, 1, "strength");
739	case IMPROVE_DEX:
740	return improve_weapon_stat (op, improver, weapon, (signed char *) &(weapon->stats.Dex), 1, "dexterity");	730	case IMPROVE_DEX: return improve_weapon_stat (op, improver, weapon, weapon->stats.Dex, 1, "dexterity");
741	case IMPROVE_CON:
742	return improve_weapon_stat (op, improver, weapon, (signed char *) &(weapon->stats.Con), 1, "constitution");	731	case IMPROVE_CON: return improve_weapon_stat (op, improver, weapon, weapon->stats.Con, 1, "constitution");
743	case IMPROVE_WIS:
744	return improve_weapon_stat (op, improver, weapon, (signed char *) &(weapon->stats.Wis), 1, "wisdom");	732	case IMPROVE_WIS: return improve_weapon_stat (op, improver, weapon, weapon->stats.Wis, 1, "wisdom");
745	case IMPROVE_CHA:
746	return improve_weapon_stat (op, improver, weapon, (signed char *) &(weapon->stats.Cha), 1, "charisma");	733	case IMPROVE_CHA: return improve_weapon_stat (op, improver, weapon, weapon->stats.Cha, 1, "charisma");
747	case IMPROVE_INT:
748	return improve_weapon_stat (op, improver, weapon, (signed char *) &(weapon->stats.Int), 1, "intelligence");	734	case IMPROVE_INT: return improve_weapon_stat (op, improver, weapon, weapon->stats.Int, 1, "intelligence");
749	case IMPROVE_POW:
750	return improve_weapon_stat (op, improver, weapon, (signed char *) &(weapon->stats.Pow), 1, "power");	735	case IMPROVE_POW: return improve_weapon_stat (op, improver, weapon, weapon->stats.Pow, 1, "power");
751	default:	736	default:
752	new_draw_info (NDI_UNIQUE, 0, op, "Unknown improvement type.");	737	op->failmsg ("Unknown improvement type.");
753	}	738	}
		739
754	LOG (llevError, "improve_weapon: Got to end of function\n");	740	LOG (llevError, "improve_weapon: Got to end of function\n");
755	return 0;	741	return 0;
756	}	742	}
757		743
758	/**	744	/**
…		…
768	if (op->type != PLAYER)	754	if (op->type != PLAYER)
769	return 0;	755	return 0;
770		756
771	if (!QUERY_FLAG (op, FLAG_WIZCAST) && (get_map_flags (op->map, NULL, op->x, op->y, NULL, NULL) & P_NO_MAGIC))	757	if (!QUERY_FLAG (op, FLAG_WIZCAST) && (get_map_flags (op->map, NULL, op->x, op->y, NULL, NULL) & P_NO_MAGIC))
772	{	758	{
773	new_draw_info (NDI_UNIQUE, 0, op, "Something blocks the magic of the scroll.");	759	op->failmsg ("Something blocks the magic of the scroll!");
774	return 0;	760	return 0;
775	}	761	}
776		762
777	otmp = find_marked_object (op);	763	otmp = find_marked_object (op);
		764
778	if (!otmp)	765	if (!otmp)
779	{	766	{
780	new_draw_info (NDI_UNIQUE, 0, op, "You need to mark a weapon object.");	767	op->failmsg ("You need to mark a weapon object. H<Use the mark command or the mark option from the item popup menu.>");
781	return 0;	768	return 0;
782	}	769	}
783		770
784	if (otmp->type != WEAPON && otmp->type != BOW)	771	if (otmp->type != WEAPON && otmp->type != BOW)
785	{	772	{
786	new_draw_info (NDI_UNIQUE, 0, op, "Marked item is not a weapon or bow");	773	op->failmsg ("Marked item is not a weapon or bow!");
787	return 0;	774	return 0;
788	}	775	}
789		776
790	new_draw_info (NDI_UNIQUE, 0, op, "Applied weapon builder.");	777	op->statusmsg ("Applied weapon builder.");
		778
791	improve_weapon (op, tmp, otmp);	779	improve_weapon (op, tmp, otmp);
792	esrv_send_item (op, otmp);	780	esrv_send_item (op, otmp);
793	return 1;	781	return 1;
794	}	782	}
795		783
…		…
820	{	808	{
821	object *tmp;	809	object *tmp;
822		810
823	if (armour->magic >= settings.armor_max_enchant)	811	if (armour->magic >= settings.armor_max_enchant)
824	{	812	{
825	new_draw_info (NDI_UNIQUE, 0, op, "This armour can not be enchanted any further.");	813	op->failmsg ("This armour can not be enchanted any further!");
826	return 0;	814	return 0;
827	}	815	}
		816
828	/* Dealing with random artifact armor is a lot trickier (in terms of value, weight,	817	/* Dealing with random artifact armor is a lot trickier (in terms of value, weight,
829	* etc), so take the easy way out and don't worry about it.	818	* etc), so take the easy way out and don't worry about it.
830	* Note - maybe add scrolls which make the random artifact versions (eg, armour	819	* Note - maybe add scrolls which make the random artifact versions (eg, armour
831	* of gnarg and what not?)	820	* of gnarg and what not?)
832	*/	821	*/
833	if (armour->title)	822	if (armour->title)
834	{	823	{
835	new_draw_info (NDI_UNIQUE, 0, op, "This armour will not accept further enchantment.");	824	op->failmsg ("This armour will not accept further enchantment.");
836	return 0;	825	return 0;
837	}	826	}
838		827
839	/* Split objects if needed. Can't insert tmp until the	828	/* Split objects if needed. Can't insert tmp until the
840	* end of this function - otherwise it will just re-merge.	829	* end of this function - otherwise it will just re-merge.
841	*/	830	*/
842	if (armour->nrof > 1)	831	tmp = armour->nrof > 1 ? armour->split (armour->nrof - 1) : 0;
843	tmp = get_split_ob (armour, armour->nrof - 1);
844	else
845	tmp = NULL;
846		832
847	armour->magic++;	833	armour->magic++;
848		834
849	if (!settings.armor_speed_linear)	835	if (!settings.armor_speed_linear)
850	{	836	{
…		…
855	{	841	{
856	base = base - (base * settings.armor_speed_improvement) / 100;	842	base = base - (base * settings.armor_speed_improvement) / 100;
857	pow++;	843	pow++;
858	}	844	}
859		845
860	ARMOUR_SPEED (armour) = (ARMOUR_SPEED (&armour->arch->clone) * base) / 100;	846	ARMOUR_SPEED (armour) = (ARMOUR_SPEED (armour->arch) * base) / 100;
861	}	847	}
862	else	848	else
863	ARMOUR_SPEED (armour) = (ARMOUR_SPEED (&armour->arch->clone) * (100 + armour->magic * settings.armor_speed_improvement)) / 100;	849	ARMOUR_SPEED (armour) = (ARMOUR_SPEED (armour->arch) * (100 + armour->magic * settings.armor_speed_improvement)) / 100;
864		850
865	if (!settings.armor_weight_linear)	851	if (!settings.armor_weight_linear)
866	{	852	{
867	int base = 100;	853	int base = 100;
868	int pow = 0;	854	int pow = 0;
…		…
871	{	857	{
872	base = base - (base * settings.armor_weight_reduction) / 100;	858	base = base - (base * settings.armor_weight_reduction) / 100;
873	pow++;	859	pow++;
874	}	860	}
875		861
876	armour->weight = (armour->arch->clone.weight * base) / 100;	862	armour->weight = (armour->arch->weight * base) / 100;
877	}	863	}
878	else	864	else
879	armour->weight = (armour->arch->clone.weight * (100 - armour->magic * settings.armor_weight_reduction)) / 100;	865	armour->weight = (armour->arch->weight * (100 - armour->magic * settings.armor_weight_reduction)) / 100;
880		866
881	if (armour->weight <= 0)	867	if (armour->weight <= 0)
882	{	868	{
883	LOG (llevInfo, "Warning: enchanted armours can have negative weight\n.");	869	LOG (llevInfo, "Warning: enchanted armours can have negative weight\n.");
884	armour->weight = 1;	870	armour->weight = 1;
885	}	871	}
886		872
887	armour->item_power = get_power_from_ench (armour->arch->clone.item_power + armour->magic);	873	armour->item_power = get_power_from_ench (armour->arch->item_power + armour->magic);
888		874
889	if (op->type == PLAYER)	875	if (op->type == PLAYER)
890	{	876	{
891	esrv_send_item (op, armour);	877	esrv_send_item (op, armour);
		878
892	if (QUERY_FLAG (armour, FLAG_APPLIED))	879	if (QUERY_FLAG (armour, FLAG_APPLIED))
893	op->update_stats ();	880	op->update_stats ();
894	}	881	}
895	decrease_ob (improver);	882
		883	improver->decrease ();
		884
896	if (tmp)	885	if (tmp)
897	{	886	op->insert (tmp);
898	insert_ob_in_ob (tmp, op);	887
899	esrv_send_item (op, tmp);
900	}
901	return 1;	888	return 1;
902	}	889	}
903
904		890
905	/*	891	/*
906	* convert_item() returns 1 if anything was converted, 0 if the item was not	892	* convert_item() returns 1 if anything was converted, 0 if the item was not
907	* what the converter wants, -1 if the converter is broken.	893	* what the converter wants, -1 if the converter is broken.
908	*/	894	*
909	#define CONV_FROM(xyz) xyz->slaying
910	#define CONV_TO(xyz) xyz->other_arch
911	#define CONV_NR(xyz) xyz->stats.sp
912	#define CONV_NEED(xyz) xyz->stats.food
913
914	/* Takes one items and makes another.	895	* Takes one type of items and makes another.
915	* converter is the object that is doing the conversion.	896	* converter is the object that is doing the conversion.
916	* item is the object that triggered the converter - if it is not	897	* item is the object that triggered the converter - if it is not
917	* what the converter wants, this will not do anything.	898	* what the converter wants, this will not do anything.
918	*/	899	*/
919	int	900	static int
920	convert_item (object *item, object *converter)	901	convert_item (object *item, object *converter)
921	{	902	{
922	int nr = 0;
923	uint32 price_in;	903	sint64 nr, price_in;
		904
		905	if (item->flag [FLAG_UNPAID])
		906	return 0;
		907
		908	shstr conv_from = converter->slaying;
		909	archetype *conv_to = converter->other_arch;
		910	sint64 need = converter->stats.food;
		911	sint64 give = converter->stats.sp;
924		912
925	/* We make some assumptions - we assume if it takes money as it type,	913	/* We make some assumptions - we assume if it takes money as it type,
926	* it wants some amount. We don't make change (ie, if something costs	914	* it wants some amount. We don't make change (ie, if something costs
927	* 3 gp and player drops a platinum, tough luck)	915	* 3 gp and player drops a platinum, tough luck)
928	*/	916	*/
929	if (!strcmp (CONV_FROM (converter), "money"))	917	if (conv_from == shstr_money)
930	{	918	{
931	int cost;
932
933	if (item->type != MONEY)	919	if (item->type != MONEY)
934	return 0;	920	return 0;
935		921
936	nr = (item->nrof * item->value) / CONV_NEED (converter);	922	nr = sint64 (item->nrof) * item->value / need;
937	if (!nr)	923	if (!nr)
938	return 0;	924	return 0;
939	cost = nr * CONV_NEED (converter) / item->value;	925
940	/* take into account rounding errors */	926	converter->play_sound (sound_find ("shop_buy"));
941	if (nr * CONV_NEED (converter) % item->value)	927
942	cost++;	928	sint64 cost = (nr * need + item->value - 1) / item->value;
943	decrease_ob_nr (item, cost);	929
		930	item->decrease (cost);
944		931
945	price_in = cost * item->value;	932	price_in = cost * item->value;
946	}	933	}
947	else	934	else
948	{	935	{
949	if (item->type == PLAYER || CONV_FROM (converter) != item->arch->name ||	936	if (item->type == PLAYER
950	(CONV_NEED (converter) && CONV_NEED (converter) > (uint16) item->nrof))	937	|| conv_from != item->arch->archname
		938	|| (need && need > (uint16) item->nrof))
951	return 0;	939	return 0;
952		940
953	if (CONV_NEED (converter))	941	converter->play_sound (sound_find ("convert_item"));
		942
		943	if (need)
954	{	944	{
955	nr = item->nrof / CONV_NEED (converter);	945	nr = sint64 (item->nrof) / need;
956	decrease_ob_nr (item, nr * CONV_NEED (converter));	946	item->decrease (nr * need);
957	price_in = nr * CONV_NEED (converter) * item->value;	947	price_in = nr * need * item->value;
958	}	948	}
959	else	949	else
960	{	950	{
961	price_in = item->value;	951	price_in = item->value;
962	item->destroy ();	952	item->destroy ();
963	}	953	}
964	}	954	}
965		955
966	if (converter->inv != NULL)	956	if (converter->inv)
967	{	957	{
968	object *ob;	958	object *ob;
969	int i;	959	int i;
970	object *ob_to_copy;	960	object *ob_to_copy;
971		961
972	/* select random object from inventory to copy */	962	/* select random object from inventory to copy */
973	ob_to_copy = converter->inv;	963	ob_to_copy = converter->inv;
974	for (ob = converter->inv->below, i = 1; ob != NULL; ob = ob->below, i++)	964	for (ob = converter->inv->below, i = 1; ob; ob = ob->below, i++)
975	{
976	if (rndm (0, i) == 0)	965	if (rndm (0, i) == 0)
977	{
978	ob_to_copy = ob;	966	ob_to_copy = ob;
979	}	967
980	}	968	item = ob_to_copy->deep_clone ();
981	item = object_create_clone (ob_to_copy);
982	CLEAR_FLAG (item, FLAG_IS_A_TEMPLATE);	969	CLEAR_FLAG (item, FLAG_IS_A_TEMPLATE);
983	unflag_inv (item, FLAG_IS_A_TEMPLATE);	970	unflag_inv (item, FLAG_IS_A_TEMPLATE);
984	}	971	}
985	else	972	else
986	{	973	{
987	if (converter->other_arch == NULL)	974	if (!conv_to)
988	{	975	{
989	LOG (llevError, "move_creator: Converter doesn't have other arch set: %s (%s, %d, %d)\n",	976	LOG (llevError, "move_creator: Converter doesn't have other arch set: %s (%s, %d, %d)\n",
990	&converter->name, &converter->map->path, converter->x, converter->y);	977	&converter->name, &converter->map->path, converter->x, converter->y);
991	return -1;	978	return -1;
992	}	979	}
993		980
994	item = object_create_arch (converter->other_arch);	981	item = object_create_arch (conv_to);
995	fix_generated_item (item, converter, 0, 0, GT_MINIMAL);	982	fix_generated_item (item, converter, 0, 0, GT_MINIMAL);
996	}	983	}
997		984
998	if (CONV_NR (converter))	985	if (give)
999	item->nrof = CONV_NR (converter);	986	item->nrof = give;
		987
1000	if (nr)	988	if (nr)
1001	item->nrof *= nr;	989	item->nrof *= nr;
1002	if (is_in_shop (converter))	990
		991	if (converter->flag [FLAG_PRECIOUS])
1003	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	}
1004	else if (price_in < item->nrof * item->value)	1002	else if (price_in < sint64 (item->nrof) * item->value)
1005	{	1003	{
1006	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",
1007	&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);
1008
1009	/**	1006	/**
1010	* 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
1011	* propably had something in mind when doing this	1008	* hopefully had something in mind when doing this.
1012	*/	1009	*/
1013	}	1010	}
		1011
		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
1014	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);
1015	return 1;	1018	return 1;
1016	}	1019	}
1017		1020
1018	/**	1021	/**
…		…
1035		1038
1036	op->contr->last_used = 0;	1039	op->contr->last_used = 0;
1037		1040
1038	if (sack->env && sack->env != op)	1041	if (sack->env && sack->env != op)
1039	{	1042	{
1040	new_draw_info (NDI_UNIQUE, 0, op, "You must put it onto the floor or into your inventory first.");	1043	op->failmsg ("You must put it onto the floor or into your inventory first.");
1041	return 1;	1044	return 1;
1042	}	1045	}
1043		1046
1044	// already applied == open on ground, or open in inv, or active in inv	1047	// already applied == open on ground, or open in inv, or active in inv
1045	if (sack->flag [FLAG_APPLIED])	1048	if (sack->flag [FLAG_APPLIED])
…		…
1051	return 1;	1054	return 1;
1052	}	1055	}
1053	else if (!sack->env)	1056	else if (!sack->env)
1054	{	1057	{
1055	// active, but not ours: some other player has opened it	1058	// active, but not ours: some other player has opened it
1056	new_draw_info_format (NDI_UNIQUE, 0, op, "%s is already occupied.", query_name (sack));	1059	op->failmsg (format ("Somebody else is using the %s already.", query_name (sack)));
1057	return 1;	1060	return 1;
1058	}	1061	}
1059		1062
1060	// fall through to opening it (active in inv)	1063	// fall through to opening it (active in inv)
1061	}	1064	}
…		…
1063	{	1066	{
1064	// it is in our env, so activate it, do not open yet	1067	// it is in our env, so activate it, do not open yet
1065	op->close_container ();	1068	op->close_container ();
1066	sack->flag [FLAG_APPLIED] = 1;	1069	sack->flag [FLAG_APPLIED] = 1;
1067	esrv_update_item (UPD_FLAGS, op, sack);	1070	esrv_update_item (UPD_FLAGS, op, sack);
1068	new_draw_info_format (NDI_UNIQUE, 0, op, "You ready %s.", query_name (sack));	1071	op->statusmsg (format ("You ready %s.", query_name (sack)));
1069	return 1;	1072	return 1;
1070	}	1073	}
1071		1074
1072	// it's locked?	1075	// it's locked?
1073	if (sack->slaying)	1076	if (sack->slaying)
1074	{	1077	{
1075	if (object *tmp = find_key (op, op, sack))	1078	if (object *tmp = find_key (op, op, sack))
1076	new_draw_info_format (NDI_UNIQUE, 0, op, "You unlock %s with %s.", query_name (sack), query_name (tmp));	1079	op->statusmsg (format ("You unlock %s with %s.", query_name (sack), query_name (tmp)));
1077	else	1080	else
1078	{	1081	{
1079	new_draw_info_format (NDI_UNIQUE, 0, op, "You don't have the key to unlock %s.", query_name (sack));	1082	op->statusmsg (format ("You don't have the key to unlock %s.", query_name (sack)));
1080	return 1;	1083	return 1;
1081	}	1084	}
1082	}	1085	}
1083		1086
1084	op->open_container (sack);	1087	op->open_container (sack);
…		…
1103	* with an altar. We call it a Potion - altars are stationary - it	1106	* with an altar. We call it a Potion - altars are stationary - it
1104	* is up to map designers to use them properly.	1107	* is up to map designers to use them properly.
1105	*/	1108	*/
1106	if (altar->inv && altar->inv->type == SPELL)	1109	if (altar->inv && altar->inv->type == SPELL)
1107	{	1110	{
1108	new_draw_info_format (NDI_BLACK, 0, originator, "The altar casts %s.", &altar->inv->name);	1111	originator->statusmsg (format ("The altar casts %s.", &altar->inv->name));
1109	cast_spell (originator, altar, 0, altar->inv, NULL);	1112	cast_spell (originator, altar, 0, altar->inv, NULL);
1110	/* If it is connected, push the button. Fixes some problems with	1113	/* If it is connected, push the button. Fixes some problems with
1111	* old maps.	1114	* old maps.
1112	*/	1115	*/
1113		1116
1114	/* push_button (altar);*/	1117	/* push_button (altar);*/
1115	}	1118	}
…		…
1139	double opinion;	1142	double opinion;
1140	object *tmp, *next;	1143	object *tmp, *next;
1141		1144
1142	SET_FLAG (op, FLAG_NO_APPLY); /* prevent loops */	1145	SET_FLAG (op, FLAG_NO_APPLY); /* prevent loops */
1143		1146
1144	if (op->type != PLAYER)	1147	bool has_unpaid = false;
		1148
		1149	// quite inefficient to do this here twice, but the api doesn'T lend itself to
		1150	// a quick and small change :(
		1151	for (object::depth_iterator item = op->begin (); item != op->end (); ++item)
		1152	if (item->flag [FLAG_UNPAID])
		1153	{
		1154	has_unpaid = true;
		1155	break;
		1156	}
		1157
		1158	if (!op->is_player ())
1145	{	1159	{
1146	/* Remove all the unpaid objects that may be carried here.	1160	/* Remove all the unpaid objects that may be carried here.
1147	* This could be pets or monsters that are somehow in	1161	* This could be pets or monsters that are somehow in
1148	* the shop.	1162	* the shop.
1149	*/	1163	*/
…		…
1153		1167
1154	if (QUERY_FLAG (tmp, FLAG_UNPAID))	1168	if (QUERY_FLAG (tmp, FLAG_UNPAID))
1155	{	1169	{
1156	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);
1157		1171
		1172	if (i >= 0)
1158	tmp->remove ();	1173	tmp->move (i);
1159
1160	if (i == -1)
1161	i = 0;
1162
1163	tmp->map = op->map;
1164	tmp->x = op->x + freearr_x[i];
1165	tmp->y = op->y + freearr_y[i];
1166	insert_ob_in_map (tmp, op->map, op, 0);
1167	}	1174	}
1168	}	1175	}
1169		1176
1170	/* Don't teleport things like spell effects */	1177	/* Don't teleport things like spell effects */
1171	if (QUERY_FLAG (op, FLAG_NO_PICK))	1178	if (QUERY_FLAG (op, FLAG_NO_PICK))
…		…
1174	/* unpaid objects, or non living objects, can't transfer by	1181	/* unpaid objects, or non living objects, can't transfer by
1175	* shop mats. Instead, put it on a nearby space.	1182	* shop mats. Instead, put it on a nearby space.
1176	*/	1183	*/
1177	if (QUERY_FLAG (op, FLAG_UNPAID) || !QUERY_FLAG (op, FLAG_ALIVE))	1184	if (QUERY_FLAG (op, FLAG_UNPAID) || !QUERY_FLAG (op, FLAG_ALIVE))
1178	{	1185	{
1179
1180	/* Somebody dropped an unpaid item, just move to an adjacent place. */	1186	/* Somebody dropped an unpaid item, just move to an adjacent place. */
1181	int i = find_free_spot (op, op->map, op->x, op->y, 1, 9);	1187	int i = find_free_spot (op, op->map, op->x, op->y, 1, 9);
1182		1188
1183	if (i != -1)	1189	if (i != -1)
1184	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);
1185		1191
1186	return 0;	1192	return 0;
1187	}	1193	}
		1194
1188	/* Removed code that checked for multipart objects - it appears that	1195	/* Removed code that checked for multipart objects - it appears that
1189	* the teleport function should be able to handle this just fine.	1196	* the teleport function should be able to handle this just fine.
1190	*/	1197	*/
1191	rv = teleport (shop_mat, SHOP_MAT, op);	1198	rv = teleport (shop_mat, SHOP_MAT, op);
1192	}	1199	}
1193	else if (can_pay (op) && get_payment (op))	1200	else if (can_pay (op) && get_payment (op))
1194	{	1201	{
1195	/* this is only used for players */	1202	/* this is only used for players */
1196	rv = teleport (shop_mat, SHOP_MAT, op);	1203	rv = teleport (shop_mat, SHOP_MAT, op);
1197		1204
		1205	if (has_unpaid)
		1206	op->contr->play_sound (sound_find ("shop_buy"));
		1207	else if (is_in_shop (op))
		1208	op->contr->play_sound (sound_find ("shop_enter"));
		1209	else
		1210	op->contr->play_sound (sound_find ("shop_leave"));
		1211
1198	if (shop_mat->msg)	1212	if (shop_mat->msg)
1199	new_draw_info (NDI_UNIQUE, 0, op, shop_mat->msg);	1213	op->statusmsg (shop_mat->msg);
1200	/* This check below is a bit simplistic - generally it should be correct,	1214	/* This check below is a bit simplistic - generally it should be correct,
1201	* but there is never a guarantee that the bottom space on the map is	1215	* but there is never a guarantee that the bottom space on the map is
1202	* actually the shop floor.	1216	* actually the shop floor.
1203	*/	1217	*/
1204	else if (!rv && !is_in_shop (op))	1218	else if (!rv && !is_in_shop (op))
1205	{	1219	{
1206	opinion = shopkeeper_approval (op->map, op);	1220	opinion = shopkeeper_approval (op->map, op);
1207		1221
1208	if (opinion > 0.9)	1222	op->statusmsg (
1209	new_draw_info (NDI_UNIQUE, 0, op, "The shopkeeper gives you a friendly wave.");	1223	opinion >= 0.90 ? "The shopkeeper gives you a friendly wave."
1210	else if (opinion > 0.75)	1224	: opinion >= 0.75 ? "The shopkeeper waves to you."
1211	new_draw_info (NDI_UNIQUE, 0, op, "The shopkeeper waves to you.");	1225	: opinion >= 0.50 ? "The shopkeeper ignores you."
1212	else if (opinion > 0.5)	1226	: "The shopkeeper glares at you with contempt."
1213	new_draw_info (NDI_UNIQUE, 0, op, "The shopkeeper ignores you.");
1214	else	1227	);
1215	new_draw_info (NDI_UNIQUE, 0, op, "The shopkeeper glares at you with contempt.");
1216	}	1228	}
1217	}	1229	}
1218	else	1230	else
1219	{	1231	{
1220	/* if we get here, a player tried to leave a shop but was not able	1232	/* if we get here, a player tried to leave a shop but was not able
1221	* to afford the items he has. We try to move the player so that	1233	* to afford the items he has. We try to move the player so that
1222	* they are not on the mat anymore	1234	* they are not on the mat anymore
1223	*/	1235	*/
1224	int i = find_free_spot (op, op->map, op->x, op->y, 1, 9);	1236	int i = find_free_spot (op, op->map, op->x, op->y, 1, 9);
1225		1237
1226	if (i == -1)	1238	if (i == -1)
1227	{
1228	LOG (llevError, "Internal shop-mat problem.\n");	1239	LOG (llevError, "Internal shop-mat problem.\n");
1229	}
1230	else	1240	else
1231	{	1241	{
1232	op->remove ();	1242	op->remove ();
1233	op->x += freearr_x[i];	1243	op->x += freearr_x[i];
1234	op->y += freearr_y[i];	1244	op->y += freearr_y[i];
…		…
1244	* Handles applying a sign.	1254	* Handles applying a sign.
1245	*/	1255	*/
1246	static void	1256	static void
1247	apply_sign (object *op, object *sign, int autoapply)	1257	apply_sign (object *op, object *sign, int autoapply)
1248	{	1258	{
1249	readable_message_type *msgType;	1259	if (!op->is_player())
1250	char newbuf[HUGE_BUF];	1260	return;
1251		1261
1252	if (sign->msg == NULL)	1262	if (sign->has_dialogue ())
1253	{	1263	{
1254	new_draw_info (NDI_UNIQUE, 0, op, "Nothing is written on it.");	1264	op->statusmsg (format ("Maybe you should I<talk> to the %s instead?", &sign->name));
1255	return;	1265	return;
1256	}	1266	}
1257		1267
		1268	if (!sign->msg)
		1269	{
		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 "));
		1274	return;
		1275	}
		1276
1258	if (sign->stats.food)	1277	if (sign->stats.food)
1259	{	1278	{
1260	if (sign->last_eat >= sign->stats.food)	1279	if (sign->last_eat >= sign->stats.food)
1261	{	1280	{
1262	if (!sign->move_on)	1281	if (!sign->move_on)
1263	new_draw_info (NDI_UNIQUE, 0, op, "You cannot read it anymore.");	1282	op->failmsg ("You cannot read it anymore.");
		1283
1264	return;	1284	return;
1265	}	1285	}
1266		1286
1267	if (!QUERY_FLAG (op, FLAG_WIZPASS))	1287	if (!QUERY_FLAG (op, FLAG_WIZPASS))
1268	sign->last_eat++;	1288	sign->last_eat++;
…		…
1273	* move_on is zero, it needs to be manually applied (doesn't talk	1293	* move_on is zero, it needs to be manually applied (doesn't talk
1274	* to us).	1294	* to us).
1275	*/	1295	*/
1276	if (QUERY_FLAG (op, FLAG_BLIND) && !QUERY_FLAG (op, FLAG_WIZ) && !sign->move_on)	1296	if (QUERY_FLAG (op, FLAG_BLIND) && !QUERY_FLAG (op, FLAG_WIZ) && !sign->move_on)
1277	{	1297	{
1278	new_draw_info (NDI_UNIQUE, 0, op, "You are unable to read while blind.");	1298	op->failmsg ("You are unable to read while blind!");
1279	return;	1299	return;
1280	}	1300	}
1281	msgType = get_readable_message_type (sign);	1301
1282	snprintf (newbuf, sizeof (newbuf), "%hhu %s", autoapply ? 1 : 0, &sign->msg);	1302	if (op->contr)
1283	draw_ext_info (NDI_UNIQUE | NDI_NAVY, 0, op, msgType->message_type, msgType->message_subtype, newbuf, &sign->msg);	1303	if (client *ns = op->contr->ns)
		1304	{
		1305	if (sign->sound)
		1306	ns->play_sound (sign->sound);
		1307	else if (autoapply)
		1308	ns->play_sound (sound_find ("msg_voice"));
		1309
		1310	op->contr->infobox (MSG_CHANNEL ("examine"), format ("T<%s>\n\n%s", &sign->name, &sign->msg));
		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);
1284	}	1344	}
1285		1345
1286	/**	1346	/**
1287	* 'victim' moves onto 'trap'	1347	* 'victim' moves onto 'trap'
1288	* 'victim' leaves 'trap'	1348	* 'victim' leaves 'trap'
…		…
1311	* proper. This code was causing needless crashes.	1371	* proper. This code was causing needless crashes.
1312	*/	1372	*/
1313	if (recursion_depth >= 500)	1373	if (recursion_depth >= 500)
1314	{	1374	{
1315	LOG (llevDebug, "WARNING: move_apply(): aborting recursion "	1375	LOG (llevDebug, "WARNING: move_apply(): aborting recursion "
1316	"[trap arch %s, name %s; victim arch %s, name %s]\n", &trap->arch->name, &trap->name, &victim->arch->name, &victim->name);	1376	"[trap arch %s, name %s; victim arch %s, name %s]\n", &trap->arch->archname, &trap->name, &victim->arch->archname, &victim->name);
1317	return;	1377	return;
1318	}	1378	}
		1379
1319	recursion_depth++;	1380	recursion_depth++;
1320	if (trap->head)	1381	if (trap->head)
1321	trap = trap->head;	1382	trap = trap->head;
1322		1383
1323	if (INVOKE_OBJECT (MOVE_TRIGGER, trap, ARG_OBJECT (victim), ARG_OBJECT (originator)))	1384	if (INVOKE_OBJECT (MOVE_TRIGGER, trap, ARG_OBJECT (victim), ARG_OBJECT (originator)))
…		…
1338		1399
1339	/* Just put in some sanity check. I think there is a bug in the	1400	/* Just put in some sanity check. I think there is a bug in the
1340	* above with some objects have zero speed, and thus the player	1401	* above with some objects have zero speed, and thus the player
1341	* getting permanently paralyzed.	1402	* getting permanently paralyzed.
1342	*/	1403	*/
1343	if (victim->speed_left < -50.0)	1404	if (victim->speed_left < -50.f)
1344	victim->speed_left = -50.0;	1405	victim->speed_left = -50.f;
1345	/* LOG(llevDebug, "apply, playermove, player speed_left=%f\n", victim->speed_left); */	1406	/* LOG(llevDebug, "apply, playermove, player speed_left=%f\n", victim->speed_left); */
1346	}	1407	}
1347	goto leave;	1408	goto leave;
1348		1409
1349	case SPINNER:	1410	case SPINNER:
…		…
1399		1460
1400	if (!trap->value)	1461	if (!trap->value)
1401	{	1462	{
1402	int tot;	1463	int tot;
1403		1464
1404	for (ab = trap->above, tot = 0; ab != NULL; ab = ab->above)	1465	for (ab = trap->above, tot = 0; ab; ab = ab->above)
1405	if ((ab->move_type && trap->move_on) || ab->move_type == 0)	1466	if ((ab->move_type && trap->move_on) || ab->move_type == 0)
1406	tot += (ab->nrof ? ab->nrof : 1) * ab->weight + ab->carrying;	1467	tot += ab->head_ ()->total_weight ();
1407		1468
1408	if (!(trap->value = (tot > trap->weight) ? 1 : 0))	1469	if (!(trap->value = (tot > trap->weight) ? 1 : 0))
1409	goto leave;	1470	goto leave;
1410		1471
1411	SET_ANIMATION (trap, trap->value);	1472	SET_ANIMATION (trap, trap->value);
…		…
1421		1482
1422	if ((ab->move_type && trap->move_on) || ab->move_type == 0)	1483	if ((ab->move_type && trap->move_on) || ab->move_type == 0)
1423	{	1484	{
1424	if (!sound_was_played)	1485	if (!sound_was_played)
1425	{	1486	{
1426	play_sound_map (trap->map, trap->x, trap->y, SOUND_FALL_HOLE);	1487	trap->play_sound (trap->sound ? trap->sound : sound_find ("fall_hole"));
1427	sound_was_played = 1;	1488	sound_was_played = 1;
1428	}	1489	}
1429	new_draw_info (NDI_UNIQUE, 0, ab, "You fall into a trapdoor!");	1490
		1491	ab->statusmsg ("You fall into a trapdoor!", NDI_RED);
1430	transfer_ob (ab, (int) EXIT_X (trap), (int) EXIT_Y (trap), 0, ab);	1492	transfer_ob (ab, EXIT_X (trap), EXIT_Y (trap), 0, ab);
1431	}	1493	}
1432	}	1494	}
1433	goto leave;	1495	goto leave;
1434	}	1496	}
1435		1497
1436
1437	case CONVERTER:	1498	case CONVERTER:
1438	if (convert_item (victim, trap) < 0)	1499	if (convert_item (victim, trap) < 0)
1439	{	1500	{
1440	new_draw_info_format (NDI_UNIQUE, 0, originator, "The %s seems to be broken!", query_name (trap));	1501	originator->failmsg (format ("The %s seems to be broken!", query_name (trap)));
1441	get_archetype ("burnout")->insert_at (trap, trap);	1502	archetype::get (shstr_burnout)->insert_at (trap, trap);
1442	}	1503	}
1443		1504
1444	goto leave;	1505	goto leave;
1445		1506
1446	case TRIGGER_BUTTON:	1507	case TRIGGER_BUTTON:
…		…
1456	case CHECK_INV:	1517	case CHECK_INV:
1457	check_inv (victim, trap);	1518	check_inv (victim, trap);
1458	goto leave;	1519	goto leave;
1459		1520
1460	case HOLE:	1521	case HOLE:
1461	/* Hole not open? */	1522	move_apply_hole (trap, victim);
1462	if (trap->stats.wc > 0)
1463	goto leave;
1464
1465	/* Is this a multipart monster and not the head? If so, return.
1466	* Processing will happen if the head runs into the pit
1467	*/
1468	if (victim->head)
1469	goto leave;
1470
1471	play_sound_map (victim->map, victim->x, victim->y, SOUND_FALL_HOLE);
1472	new_draw_info (NDI_UNIQUE, 0, victim, "You fall through the hole!\n");
1473	transfer_ob (victim, EXIT_X (trap), EXIT_Y (trap), 1, victim);
1474	goto leave;	1523	goto leave;
1475		1524
1476	case EXIT:	1525	case EXIT:
1477	if (victim->type == PLAYER && EXIT_PATH (trap))	1526	if (victim->type == PLAYER && EXIT_PATH (trap))
1478	{	1527	{
1479	/* Basically, don't show exits leading to random maps the	1528	/* Basically, don't show exits leading to random maps the
1480	* players output.	1529	* players output.
1481	*/	1530	*/
1482	if (trap->msg && strncmp (EXIT_PATH (trap), "/!", 2))	1531	if (trap->msg && !EXIT_PATH (trap).starts_with ("/!"))
1483	new_draw_info (NDI_NAVY, 0, victim, trap->msg);	1532	victim->statusmsg (trap->msg, NDI_NAVY);
1484		1533
		1534	trap->play_sound (trap->sound);
1485	victim->enter_exit (trap);	1535	victim->enter_exit (trap);
1486	}	1536	}
1487	goto leave;	1537	goto leave;
1488		1538
1489	case ENCOUNTER:	1539	case ENCOUNTER:
…		…
1511	goto leave;	1561	goto leave;
1512		1562
1513	case RUNE:	1563	case RUNE:
1514	case TRAP:	1564	case TRAP:
1515	if (trap->level && QUERY_FLAG (victim, FLAG_ALIVE))	1565	if (trap->level && QUERY_FLAG (victim, FLAG_ALIVE))
1516	{
1517	spring_trap (trap, victim);	1566	spring_trap (trap, victim);
1518	}
1519	goto leave;	1567	goto leave;
1520		1568
1521	default:	1569	default:
1522	LOG (llevDebug, "name %s, arch %s, type %d with fly/walk on/off not "	1570	LOG (llevDebug, "name %s, arch %s, type %d with fly/walk on/off not "
1523	"handled in move_apply()\n", &trap->name, &trap->arch->name, trap->type);	1571	"handled in move_apply()\n", &trap->name, &trap->arch->archname, trap->type);
1524	goto leave;	1572	goto leave;
1525	}	1573	}
1526		1574
1527	leave:	1575	leave:
1528	recursion_depth--;	1576	recursion_depth--;
…		…
1537	int lev_diff;	1585	int lev_diff;
1538	object *skill_ob;	1586	object *skill_ob;
1539		1587
1540	if (QUERY_FLAG (op, FLAG_BLIND) && !QUERY_FLAG (op, FLAG_WIZ))	1588	if (QUERY_FLAG (op, FLAG_BLIND) && !QUERY_FLAG (op, FLAG_WIZ))
1541	{	1589	{
1542	new_draw_info (NDI_UNIQUE, 0, op, "You are unable to read while blind.");	1590	op->failmsg ("You are unable to read while blind!");
1543	return;	1591	return;
1544	}	1592	}
		1593
1545	if (tmp->msg == NULL)	1594	if (!tmp->msg)
1546	{	1595	{
1547	new_draw_info_format (NDI_UNIQUE, 0, op, "You open the %s and find it empty.", &tmp->name);	1596	op->failmsg (format ("You open the %s and find it empty.", &tmp->name));
1548	return;	1597	return;
1549	}	1598	}
1550		1599
1551	/* need a literacy skill to read stuff! */	1600	/* need a literacy skill to read stuff! */
1552	skill_ob = find_skill_by_name (op, tmp->skill);	1601	skill_ob = find_skill_by_name (op, tmp->skill);
1553	if (!skill_ob)	1602	if (!skill_ob)
1554	{	1603	{
1555	new_draw_info (NDI_UNIQUE, 0, op, "You are unable to decipher the strange symbols.");	1604	op->failmsg (format ("You are unable to decipher the strange symbols. H<You lack the %s skill to read this.>", &tmp->skill));
1556	return;	1605	return;
1557	}	1606	}
		1607
1558	lev_diff = tmp->level - (skill_ob->level + 5);	1608	lev_diff = tmp->level - (skill_ob->level + 5);
1559	if (!QUERY_FLAG (op, FLAG_WIZ) && lev_diff > 0)	1609	if (!QUERY_FLAG (op, FLAG_WIZ) && lev_diff > 0)
1560	{	1610	{
1561	if (lev_diff < 2)	1611	op->failmsg (lev_diff < 2 ? "This book is just barely beyond your comprehension."
1562	new_draw_info (NDI_UNIQUE, 0, op, "This book is just barely beyond your comprehension.");	1612	: lev_diff < 3 ? "This book is slightly beyond your comprehension."
1563	else if (lev_diff < 3)	1613	: lev_diff < 5 ? "This book is beyond your comprehension."
1564	new_draw_info (NDI_UNIQUE, 0, op, "This book is slightly beyond your comprehension.");	1614	: lev_diff < 8 ? "This book is quite a bit beyond your comprehension."
1565	else if (lev_diff < 5)	1615	: lev_diff < 15 ? "This book is way beyond your comprehension."
1566	new_draw_info (NDI_UNIQUE, 0, op, "This book is beyond your comprehension.");	1616	: "This book is totally beyond your comprehension.");
1567	else if (lev_diff < 8)
1568	new_draw_info (NDI_UNIQUE, 0, op, "This book is quite a bit beyond your comprehension.");
1569	else if (lev_diff < 15)
1570	new_draw_info (NDI_UNIQUE, 0, op, "This book is way beyond your comprehension.");
1571	else
1572	new_draw_info (NDI_UNIQUE, 0, op, "This book is totally beyond your comprehension.");
1573	return;	1617	return;
1574	}	1618	}
1575		1619
1576	readable_message_type *msgType = get_readable_message_type (tmp);	1620	readable_message_type *msgType = get_readable_message_type (tmp);
1577		1621
1578	draw_ext_info_format (NDI_UNIQUE | NDI_NAVY, 0, op,	1622	if (player *pl = op->contr)
1579	msgType->message_type, msgType->message_subtype,	1623	if (client *ns = pl->ns)
1580	"You open the %s and start reading.\n%s", (char *)"%s\n%s",	1624	pl->infobox (MSG_CHANNEL ("book"), format ("T<%s>\n\n%s", (char *)long_desc (tmp, op), &tmp->msg));
1581	long_desc (tmp, op), &tmp->msg);
1582		1625
1583	/* gain xp from reading */	1626	/* gain xp from reading */
1584	if (!QUERY_FLAG (tmp, FLAG_NO_SKILL_IDENT))	1627	if (!QUERY_FLAG (tmp, FLAG_NO_SKILL_IDENT))
1585	{ /* only if not read before */	1628	{ /* only if not read before */
1586	int exp_gain = calc_skill_exp (op, tmp, skill_ob);	1629	int exp_gain = calc_skill_exp (op, tmp, skill_ob);
…		…
1588	if (!QUERY_FLAG (tmp, FLAG_IDENTIFIED))	1631	if (!QUERY_FLAG (tmp, FLAG_IDENTIFIED))
1589	{	1632	{
1590	/*exp_gain *= 2; because they just identified it too */	1633	/*exp_gain *= 2; because they just identified it too */
1591	SET_FLAG (tmp, FLAG_IDENTIFIED);	1634	SET_FLAG (tmp, FLAG_IDENTIFIED);
1592		1635
1593	/* If in a container, update how it looks */	1636	if (object *pl = tmp->visible_to ())
1594	if (tmp->env)
1595	esrv_update_item (UPD_FLAGS | UPD_NAME, op, tmp);	1637	esrv_update_item (UPD_FLAGS | UPD_NAME, pl, tmp);
1596	else
1597	op->contr->ns->floorbox_update ();
1598	}	1638	}
1599		1639
1600	change_exp (op, exp_gain, skill_ob->skill, 0);	1640	change_exp (op, exp_gain, skill_ob->skill, 0);
1601	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 */
1602	}	1642	}
…		…
1607	* op is the person learning the skill, tmp is the skill scroll object	1647	* op is the person learning the skill, tmp is the skill scroll object
1608	*/	1648	*/
1609	static void	1649	static void
1610	apply_skillscroll (object *op, object *tmp)	1650	apply_skillscroll (object *op, object *tmp)
1611	{	1651	{
1612	switch ((int) learn_skill (op, tmp))	1652	switch (learn_skill (op, tmp))
1613	{	1653	{
1614	case 0:	1654	case 0:
1615	new_draw_info (NDI_UNIQUE, 0, op, "You already possess the knowledge ");	1655	op->play_sound (sound_find ("generic_fail"));
1616	new_draw_info_format (NDI_UNIQUE, 0, op, "held within the %s.\n", query_name (tmp));	1656	op->failmsg (format ("You already possess the knowledge held within the %s.", query_name (tmp)));
1617	return;	1657	break;
1618		1658
1619	case 1:	1659	case 1:
1620	new_draw_info_format (NDI_UNIQUE, 0, op, "You succeed in learning %s", &tmp->skill);
1621	decrease_ob (tmp);	1660	tmp->decrease ();
		1661	op->play_sound (sound_find ("skill_learn"));
		1662	op->statusmsg (format ("You succeed in learning %s", &tmp->skill));
1622	return;	1663	break;
1623		1664
1624	default:	1665	default:
		1666	tmp->decrease ();
		1667	op->play_sound (sound_find ("generic_fail"));
1625	new_draw_info_format (NDI_UNIQUE, 0, op, "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)));
1626	decrease_ob (tmp);
1627	return;	1669	break;
1628	}	1670	}
1629	}	1671	}
1630		1672
1631	/**	1673	/**
1632	* Actually makes op learn spell.	1674	* Actually makes op learn spell.
…		…
1652	return;	1694	return;
1653	}	1695	}
1654	return;	1696	return;
1655	}	1697	}
1656		1698
1657	play_sound_player_only (op->contr, SOUND_LEARN_SPELL, 0, 0);	1699	op->contr->play_sound (sound_find ("learn_spell"));
		1700
1658	tmp = spell->clone ();	1701	tmp = spell->clone ();
1659	insert_ob_in_ob (tmp, op);	1702	insert_ob_in_ob (tmp, op);
1660		1703
1661	if (special_prayer)	1704	if (special_prayer)
1662	SET_FLAG (tmp, FLAG_STARTEQUIP);	1705	SET_FLAG (tmp, FLAG_STARTEQUIP);
…		…
1681	{	1724	{
1682	LOG (llevError, "BUG: do_forget_spell(): spell not known\n");	1725	LOG (llevError, "BUG: do_forget_spell(): spell not known\n");
1683	return;	1726	return;
1684	}	1727	}
1685		1728
1686	new_draw_info_format (NDI_UNIQUE | NDI_NAVY, 0, op, "You lose knowledge of %s.", spell);	1729	op->failmsg (format ("You lose knowledge of %s.", spell));
1687	player_unready_range_ob (op->contr, spob);	1730	player_unready_range_ob (op->contr, spob);
1688	esrv_remove_spell (op->contr, spob);	1731	esrv_remove_spell (op->contr, spob);
1689	spob->destroy ();	1732	spob->destroy ();
1690	}	1733	}
1691		1734
…		…
1699	{	1742	{
1700	object *skop, *spell, *spell_skill;	1743	object *skop, *spell, *spell_skill;
1701		1744
1702	if (QUERY_FLAG (op, FLAG_BLIND) && !QUERY_FLAG (op, FLAG_WIZ))	1745	if (QUERY_FLAG (op, FLAG_BLIND) && !QUERY_FLAG (op, FLAG_WIZ))
1703	{	1746	{
1704	new_draw_info (NDI_UNIQUE, 0, op, "You are unable to read while blind.");	1747	op->failmsg ("You are unable to read while blind.");
1705	return;	1748	return;
1706	}	1749	}
1707		1750
1708	/* artifact_spellbooks have 'slaying' field point to a spell name,	1751	/* artifact_spellbooks have 'slaying' field point to a spell name,
1709	* instead of having their spell stored in stats.sp. These are	1752	* instead of having their spell stored in stats.sp. These are
1710	* legacy spellbooks	1753	* legacy spellbooks
1711	*/	1754	*/
1712
1713	if (tmp->slaying != NULL)	1755	if (tmp->slaying)
1714	{	1756	{
1715	spell = arch_to_object (find_archetype_by_object_name (tmp->slaying));	1757	spell = arch_to_object (find_archetype_by_object_name (tmp->slaying));
1716	if (!spell)	1758	if (!spell)
1717	{	1759	{
1718	new_draw_info_format (NDI_UNIQUE, 0, op, "The book's formula for %s is incomplete", &tmp->slaying);	1760	op->failmsg (format ("The book's formula for %s is incomplete.", &tmp->slaying));
1719	return;	1761	return;
1720	}	1762	}
1721	else	1763	else
1722	insert_ob_in_ob (spell, tmp);	1764	insert_ob_in_ob (spell, tmp);
		1765
1723	tmp->slaying = NULL;	1766	tmp->slaying = 0;
1724	}	1767	}
1725		1768
1726	skop = find_skill_by_name (op, tmp->skill);	1769	skop = find_skill_by_name (op, tmp->skill);
1727		1770
1728	/* need a literacy skill to learn spells. Also, having a literacy level	1771	/* need a literacy skill to learn spells. Also, having a literacy level
1729	* lower than the spell will make learning the spell more difficult */	1772	* lower than the spell will make learning the spell more difficult */
1730	if (!skop)	1773	if (!skop)
1731	{	1774	{
1732	new_draw_info (NDI_UNIQUE, 0, op, "You can't read! Your attempt fails.");	1775	op->failmsg (format ("You can't read! Your attempt fails. H<You lack the %s skill.>", &tmp->skill));
1733	return;	1776	return;
1734	}	1777	}
1735		1778
1736	spell = tmp->inv;	1779	spell = tmp->inv;
1737		1780
1738	if (!spell)	1781	if (!spell)
1739	{	1782	{
1740	LOG (llevError, "apply_spellbook: Book %s has no spell in it!\n", &tmp->name);	1783	LOG (llevError, "apply_spellbook: Book %s has no spell in it!\n", &tmp->name);
1741	new_draw_info (NDI_UNIQUE, 0, op, "The spellbook symbols make no sense.");	1784	op->failmsg ("The spellbook symbols make no sense. This is a bug, please report!");
1742	return;	1785	return;
1743	}	1786	}
1744		1787
1745	if (skop->level < int (sqrtf (spell->level) * 1.5f))	1788	if (skop->level < int (sqrtf (spell->level) * 1.5f))
1746	{	1789	{
1747	new_draw_info (NDI_UNIQUE, 0, op, "You are unable to decipher the strange symbols. [Your literacy level is too low]");	1790	op->failmsg (format ("You are unable to decipher the strange symbols. H<Your %s level is too low.>", &tmp->skill));
1748	return;	1791	return;
1749	}	1792	}
1750		1793
1751	new_draw_info_format (NDI_UNIQUE, 0, op, "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));
1752		1795
1753	if (!QUERY_FLAG (tmp, FLAG_IDENTIFIED))	1796	if (!QUERY_FLAG (tmp, FLAG_IDENTIFIED))
1754	{
1755	identify (tmp);	1797	identify (tmp);
1756
1757	if (tmp->env)
1758	esrv_update_item (UPD_FLAGS | UPD_NAME, op, tmp);
1759	else
1760	op->contr->ns->floorbox_update ();
1761	}
1762		1798
1763	/* 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
1764	* 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
1765	* 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
1766	* they would have a special prayer mark.	1802	* they would have a special prayer mark.
1767	*/	1803	*/
1768	if (check_spell_known (op, spell->name))	1804	if (check_spell_known (op, spell->name))
1769	{	1805	{
1770	new_draw_info (NDI_UNIQUE, 0, op, "You already know that spell.\n");	1806	op->statusmsg ("You already know that spell. H<It makes no sense to learn spells twice, and would only waste the spellbook.>\n");
1771	return;	1807	return;
1772	}	1808	}
1773		1809
1774	if (spell->skill)	1810	if (spell->skill)
1775	{	1811	{
1776	spell_skill = find_skill_by_name (op, spell->skill);	1812	spell_skill = find_skill_by_name (op, spell->skill);
1777		1813
1778	if (!spell_skill)	1814	if (!spell_skill)
1779	{	1815	{
1780	new_draw_info_format (NDI_UNIQUE, 0, op, "You lack the skill %s to use this spell.", &spell->skill);	1816	op->failmsg (format ("You lack the skill %s to use this spell.", &spell->skill));
1781	return;	1817	return;
1782	}	1818	}
1783		1819
1784	if (spell_skill->level < spell->level)	1820	if (spell_skill->level < spell->level)
1785	{	1821	{
1786	new_draw_info_format (NDI_UNIQUE, 0, op, "You need to be level %d in %s to learn this spell.", spell->level, &spell->skill);	1822	op->failmsg (format ("You need to be level %d in %s to learn this spell.", spell->level, &spell->skill));
1787	return;	1823	return;
1788	}	1824	}
1789	}	1825	}
1790		1826
1791	/* Logic as follows	1827	/* Logic as follows
…		…
1800	* Overall, chances are the same but a player will find having a high	1836	* Overall, chances are the same but a player will find having a high
1801	* literacy rate very useful! -b.t.	1837	* literacy rate very useful! -b.t.
1802	*/	1838	*/
1803	if (QUERY_FLAG (op, FLAG_CONFUSED))	1839	if (QUERY_FLAG (op, FLAG_CONFUSED))
1804	{	1840	{
1805	new_draw_info (NDI_UNIQUE, 0, op, "In your confused state you flub the wording of the text!");	1841	op->failmsg ("In your confused state you flub the wording of the text!");
1806	scroll_failure (op, 0 - random_roll (0, spell->level, op, PREFER_LOW), MAX (spell->stats.sp, spell->stats.grace));	1842	scroll_failure (op, 0 - random_roll (0, spell->level, op, PREFER_LOW), MAX (spell->stats.sp, spell->stats.grace));
1807	}	1843	}
1808	else if (QUERY_FLAG (tmp, FLAG_STARTEQUIP) ||	1844	else if (QUERY_FLAG (tmp, FLAG_STARTEQUIP) ||
1809	(random_roll (0, 100, op, PREFER_LOW) - (5 * skop->level)) < learn_spell[spell->stats.grace ? op->stats.Wis : op->stats.Int])	1845	(random_roll (0, 100, op, PREFER_LOW) - (5 * skop->level)) < learn_spell[spell->stats.grace ? op->stats.Wis : op->stats.Int])
1810	{	1846	{
1811		1847	op->statusmsg ("You succeed in learning the spell!", NDI_GREEN);
1812	new_draw_info (NDI_UNIQUE, 0, op, "You succeed in learning the spell!");
1813	do_learn_spell (op, spell, 0);	1848	do_learn_spell (op, spell, 0);
1814		1849
1815	/* xp gain to literacy for spell learning */	1850	/* xp gain to literacy for spell learning */
1816	if (!QUERY_FLAG (tmp, FLAG_STARTEQUIP))	1851	if (!QUERY_FLAG (tmp, FLAG_STARTEQUIP))
1817	change_exp (op, calc_skill_exp (op, tmp, skop), skop->skill, 0);	1852	change_exp (op, calc_skill_exp (op, tmp, skop), skop->skill, 0);
1818	}	1853	}
1819	else	1854	else
1820	{	1855	{
1821	play_sound_player_only (op->contr, SOUND_FUMBLE_SPELL, 0, 0);	1856	op->contr->play_sound (sound_find ("fumble_spell"));
1822	new_draw_info (NDI_UNIQUE, 0, op, "You fail to learn the 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");
1823	}	1858	}
1824		1859
1825	decrease_ob (tmp);	1860	tmp->decrease ();
1826	}	1861	}
1827		1862
1828	/**	1863	/**
1829	* Handles applying a spell scroll.	1864	* Handles applying a spell scroll.
1830	*/	1865	*/
…		…
1833	{	1868	{
1834	object *skop;	1869	object *skop;
1835		1870
1836	if (QUERY_FLAG (op, FLAG_BLIND) && !QUERY_FLAG (op, FLAG_WIZ))	1871	if (QUERY_FLAG (op, FLAG_BLIND) && !QUERY_FLAG (op, FLAG_WIZ))
1837	{	1872	{
1838	new_draw_info (NDI_UNIQUE, 0, op, "You are unable to read while blind.");	1873	op->failmsg ("You are unable to read while blind.");
1839	return;	1874	return;
1840	}	1875	}
1841		1876
1842	if (!tmp->inv || tmp->inv->type != SPELL)	1877	if (!tmp->inv || tmp->inv->type != SPELL)
1843	{	1878	{
1844	new_draw_info (NDI_UNIQUE, 0, op, "The scroll just doesn't make sense!");	1879	op->failmsg ("The scroll just doesn't make sense! H<...and never will make sense.>");
1845	return;	1880	return;
1846	}	1881	}
1847		1882
1848	if (op->type == PLAYER)	1883	if (op->type == PLAYER)
1849	{	1884	{
…		…
1855	*/	1890	*/
1856	skop = find_skill_by_name (op, skill_names[SK_LITERACY]);	1891	skop = find_skill_by_name (op, skill_names[SK_LITERACY]);
1857		1892
1858	if (!skop)	1893	if (!skop)
1859	{	1894	{
1860	new_draw_info (NDI_UNIQUE, 0, op, "You are unable to decipher the strange symbols.");	1895	op->failmsg (format ("You are unable to decipher the strange symbols. H<You lack the %s skill.>", &skill_names[SK_LITERACY]));
1861	return;	1896	return;
1862	}	1897	}
1863		1898
1864	if ((exp_gain = calc_skill_exp (op, tmp, skop)))	1899	if ((exp_gain = calc_skill_exp (op, tmp, skop)))
1865	change_exp (op, exp_gain, skop->skill, 0);	1900	change_exp (op, exp_gain, skop->skill, 0);
1866	}	1901	}
1867		1902
1868	if (!QUERY_FLAG (tmp, FLAG_IDENTIFIED))	1903	if (!QUERY_FLAG (tmp, FLAG_IDENTIFIED))
1869	identify (tmp);	1904	identify (tmp);
1870		1905
1871	new_draw_info_format (NDI_BLACK, 0, op, "The scroll of %s turns to dust.", &tmp->inv->name);	1906	op->statusmsg (format ("The scroll of %s turns to dust.", &tmp->inv->name));
1872
1873		1907
1874	cast_spell (op, tmp, dir, tmp->inv, NULL);	1908	cast_spell (op, tmp, dir, tmp->inv, NULL);
1875	decrease_ob (tmp);	1909	tmp->decrease ();
1876	}	1910	}
1877		1911
1878	/**	1912	/**
1879	* Applies a treasure object - by default, chest. op	1913	* Applies a treasure object - by default, chest. op
1880	* is the person doing the applying, tmp is the treasure	1914	* is the person doing the applying, tmp is the treasure
1881	* chest.	1915	* chest.
1882	*/	1916	*/
1883	static void	1917	static void
1884	apply_treasure (object *op, object *tmp)	1918	apply_treasure (object *op, object *tmp)
1885	{	1919	{
1886	object *treas;
1887
1888
1889	/* Nice side effect of new treasure creation method is that the treasure	1920	/* Nice side effect of this treasure creation method is that the treasure
1890	* for the chest is done when the chest is created, and put into the chest	1921	* for the chest is done when the chest is created, and put into the chest
1891	* inventory. So that when the chest burns up, the items still exist. Also	1922	* inventory. So that when the chest burns up, the items still exist. Also
1892	* prevents people fromt moving chests to more difficult maps to get better	1923	* prevents people from moving chests to more difficult maps to get better
1893	* treasure	1924	* treasure
1894	*/	1925	*/
1895
1896	treas = tmp->inv;	1926	object *treas = tmp->inv;
1897	if (treas == NULL)	1927
		1928	if (!treas)
1898	{	1929	{
1899	new_draw_info (NDI_UNIQUE, 0, op, "The chest was empty.");	1930	op->statusmsg ("The chest was empty.");
1900	decrease_ob (tmp);	1931	tmp->decrease ();
1901	return;	1932	return;
1902	}	1933	}
		1934
1903	while (tmp->inv)	1935	while (tmp->inv)
1904	{	1936	{
1905	treas = tmp->inv;	1937	treas = tmp->inv;
1906
1907	treas->remove ();	1938	treas->remove ();
1908	new_draw_info_format (NDI_UNIQUE, 0, op, "You find %s in the chest.", query_name (treas));
1909		1939
1910	treas->x = op->x;	1940	treas->x = op->x;
1911	treas->y = op->y;	1941	treas->y = op->y;
1912	treas = insert_ob_in_map (treas, op->map, op, INS_BELOW_ORIGINATOR);	1942	treas = insert_ob_in_map (treas, op->map, op, INS_BELOW_ORIGINATOR);
1913		1943
1914	if (treas && (treas->type == RUNE || treas->type == TRAP) && treas->level && QUERY_FLAG (op, FLAG_ALIVE))	1944	if (treas && (treas->type == RUNE || treas->type == TRAP) && treas->level && QUERY_FLAG (op, FLAG_ALIVE))
1915	spring_trap (treas, op);	1945	spring_trap (treas, op);
1916		1946
1917	/* If either player or container was destroyed, no need to do	1947	/* If either player or container was destroyed, no need to do
1918	* further processing. I think this should be enclused with	1948	* further processing. I think this should be enclused with
1919	* spring trap above, as I don't think there is otherwise	1949	* spring trap above, as I don't think there is otherwise
1920	* any way for the treasure chest or player to get killed	1950	* any way for the treasure chest or player to get killed.
1921	*/	1951	*/
1922	if (op->destroyed () || tmp->destroyed ())	1952	if (op->destroyed () || tmp->destroyed ())
1923	break;	1953	break;
1924	}	1954	}
1925		1955
1926	if (!tmp->destroyed () && tmp->inv == NULL)	1956	if (!tmp->destroyed () && !tmp->inv)
1927	decrease_ob (tmp);	1957	tmp->decrease (true);
1928
1929	}	1958	}
1930		1959
1931	/**	1960	/**
1932	* op eats food.	1961	* op eats food.
1933	* If player, takes care of messages and dragon special food.	1962	* If player, takes care of messages and dragon special food.
…		…
1948	{	1977	{
1949	/* usual case - no dragon meal: */	1978	/* usual case - no dragon meal: */
1950	if (op->stats.food + tmp->stats.food > 999)	1979	if (op->stats.food + tmp->stats.food > 999)
1951	{	1980	{
1952	if (tmp->type == FOOD || tmp->type == FLESH)	1981	if (tmp->type == FOOD || tmp->type == FLESH)
1953	new_draw_info (NDI_UNIQUE, 0, op, "You feel full, but what a waste of food!");	1982	op->failmsg ("You feel full, but what a waste of food!");
1954	else	1983	else
1955	new_draw_info (NDI_UNIQUE, 0, op, "Most of the drink goes down your face not your throat!");	1984	op->statusmsg ("Most of the drink goes down your face not your throat!");
1956	}	1985	}
		1986
		1987	tmp->play_sound (
		1988	tmp->sound
		1989	? tmp->sound
		1990	: tmp->type == DRINK
		1991	? sound_find ("eat_drink")
		1992	: sound_find ("eat_food")
		1993	);
1957		1994
1958	if (!QUERY_FLAG (tmp, FLAG_CURSED))	1995	if (!QUERY_FLAG (tmp, FLAG_CURSED))
1959	{	1996	{
1960	char buf[MAX_BUF];	1997	const char *buf;
1961		1998
1962	if (!is_dragon_pl (op))	1999	if (!is_dragon_pl (op))
1963	{	2000	{
1964	/* eating message for normal players */	2001	/* eating message for normal players */
1965	if (tmp->type == DRINK)	2002	if (tmp->type == DRINK)
1966	sprintf (buf, "Ahhh...that %s tasted good.", &tmp->name);	2003	buf = format ("Ahhh...that %s tasted good.", &tmp->name);
1967	else	2004	else
1968	sprintf (buf, "The %s tasted %s", &tmp->name, tmp->type == FLESH ? "terrible!" : "good.");	2005	buf = format ("The %s tasted %s", &tmp->name, tmp->type == FLESH ? "terrible!" : "good.");
1969	}	2006	}
1970	else	2007	else
1971	{
1972	/* eating message for dragon players */	2008	/* eating message for dragon players */
1973	sprintf (buf, "The %s tasted terrible!", &tmp->name);	2009	buf = format ("The %s tasted terrible!", &tmp->name);
1974	}
1975		2010
1976	new_draw_info (NDI_UNIQUE, 0, op, buf);	2011	op->statusmsg (buf);
		2012
1977	capacity_remaining = 999 - op->stats.food;	2013	capacity_remaining = 999 - op->stats.food;
1978	op->stats.food += tmp->stats.food;	2014	op->stats.food += tmp->stats.food;
1979	if (capacity_remaining < tmp->stats.food)	2015	if (capacity_remaining < tmp->stats.food)
1980	op->stats.hp += capacity_remaining / 50;	2016	op->stats.hp += capacity_remaining / 50;
1981	else	2017	else
1982	op->stats.hp += tmp->stats.food / 50;	2018	op->stats.hp += tmp->stats.food / 50;
		2019
1983	if (op->stats.hp > op->stats.maxhp)	2020	if (op->stats.hp > op->stats.maxhp)
1984	op->stats.hp = op->stats.maxhp;	2021	op->stats.hp = op->stats.maxhp;
1985	if (op->stats.food > 999)	2022	if (op->stats.food > 999)
1986	op->stats.food = 999;	2023	op->stats.food = 999;
1987	}	2024	}
…		…
1989	/* special food hack -b.t. */	2026	/* special food hack -b.t. */
1990	if (tmp->title || QUERY_FLAG (tmp, FLAG_CURSED))	2027	if (tmp->title || QUERY_FLAG (tmp, FLAG_CURSED))
1991	eat_special_food (op, tmp);	2028	eat_special_food (op, tmp);
1992	}	2029	}
1993	}	2030	}
		2031
1994	handle_apply_yield (tmp);	2032	handle_apply_yield (tmp);
1995	decrease_ob (tmp);	2033	tmp->decrease ();
1996	}	2034	}
1997		2035
1998	/**	2036	/**
1999	* A dragon is eating some flesh. If the flesh contains resistances,	2037	* A dragon is eating some flesh. If the flesh contains resistances,
2000	* 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.
…		…
2010	{	2048	{
2011	object *skin = NULL; /* pointer to dragon skin force */	2049	object *skin = NULL; /* pointer to dragon skin force */
2012	object *abil = NULL; /* pointer to dragon ability force */	2050	object *abil = NULL; /* pointer to dragon ability force */
2013	object *tmp = NULL; /* tmp. object */	2051	object *tmp = NULL; /* tmp. object */
2014		2052
2015	char buf[MAX_BUF]; /* tmp. string buffer */
2016	double chance; /* improvement-chance of one resistance type */	2053	double chance; /* improvement-chance of one resistance type */
2017	double totalchance = 1; /* total chance of gaining one resistance */	2054	double totalchance = 1; /* total chance of gaining one resistance */
2018	double bonus = 0; /* level bonus (improvement is easier at lowlevel) */	2055	double bonus = 0; /* level bonus (improvement is easier at lowlevel) */
2019	double mbonus = 0; /* monster bonus */	2056	double mbonus = 0; /* monster bonus */
2020	int atnr_winner[NROFATTACKS]; /* winning candidates for resistance improvement */	2057	int atnr_winner[NROFATTACKS]; /* winning candidates for resistance improvement */
…		…
2025	if (meal->type != FLESH || !is_dragon_pl (op))	2062	if (meal->type != FLESH || !is_dragon_pl (op))
2026	return 0;	2063	return 0;
2027		2064
2028	/* now grab the 'dragon_skin'- and 'dragon_ability'-forces	2065	/* now grab the 'dragon_skin'- and 'dragon_ability'-forces
2029	from the player's inventory */	2066	from the player's inventory */
2030	shstr_cmp dragon_ability_force ("dragon_ability_force");
2031	shstr_cmp dragon_skin_force ("dragon_skin_force");
2032
2033	for (tmp = op->inv; tmp; tmp = tmp->below)	2067	for (tmp = op->inv; tmp; tmp = tmp->below)
2034	if (tmp->type == FORCE)	2068	if (tmp->type == FORCE)
2035	if (tmp->arch->name == dragon_skin_force)	2069	if (tmp->arch->archname == shstr_dragon_skin_force)
2036	skin = tmp;	2070	skin = tmp;
2037	else if (tmp->arch->name == dragon_ability_force)	2071	else if (tmp->arch->archname == shstr_dragon_ability_force)
2038	abil = tmp;	2072	abil = tmp;
2039		2073
2040	/* if either skin or ability are missing, this is an old player	2074	/* if either skin or ability are missing, this is an old player
2041	which is not to be considered a dragon -> bail out */	2075	which is not to be considered a dragon -> bail out */
2042	if (skin == NULL || abil == NULL)	2076	if (skin == NULL || abil == NULL)
…		…
2045	/* now start by filling stomache and health, according to food-value */	2079	/* now start by filling stomache and health, according to food-value */
2046	if ((999 - op->stats.food) < meal->stats.food)	2080	if ((999 - op->stats.food) < meal->stats.food)
2047	op->stats.hp += (999 - op->stats.food) / 50;	2081	op->stats.hp += (999 - op->stats.food) / 50;
2048	else	2082	else
2049	op->stats.hp += meal->stats.food / 50;	2083	op->stats.hp += meal->stats.food / 50;
		2084
2050	if (op->stats.hp > op->stats.maxhp)	2085	if (op->stats.hp > op->stats.maxhp)
2051	op->stats.hp = op->stats.maxhp;	2086	op->stats.hp = op->stats.maxhp;
2052		2087
2053	op->stats.food = MIN (999, op->stats.food + meal->stats.food);	2088	op->stats.food = MIN (999, op->stats.food + meal->stats.food);
2054		2089
…		…
2099	}	2134	}
2100	}	2135	}
2101		2136
2102	/* inverse totalchance as until now we have the failure-chance */	2137	/* inverse totalchance as until now we have the failure-chance */
2103	totalchance = 100 - totalchance * 100;	2138	totalchance = 100 - totalchance * 100;
		2139
2104	/* print message according to totalchance */	2140	/* print message according to totalchance */
		2141	const char *buf;
2105	if (totalchance > 50.)	2142	if (totalchance > 50.)
2106	sprintf (buf, "Hmm! The %s tasted delicious!", &meal->name);	2143	buf = format ("Hmm! The %s tasted delicious!", &meal->name);
2107	else if (totalchance > 10.)	2144	else if (totalchance > 10.)
2108	sprintf (buf, "The %s tasted very good.", &meal->name);	2145	buf = format ("The %s tasted very good.", &meal->name);
2109	else if (totalchance > 1.)	2146	else if (totalchance > 1.)
2110	sprintf (buf, "The %s tasted good.", &meal->name);	2147	buf = format ("The %s tasted good.", &meal->name);
2111	else if (totalchance > 0.1)	2148	else if (totalchance > 0.1)
2112	sprintf (buf, "The %s tasted bland.", &meal->name);	2149	buf = format ("The %s tasted bland.", &meal->name);
2113	else if (totalchance >= 0.01)	2150	else if (totalchance >= 0.01)
2114	sprintf (buf, "The %s had a boring taste.", &meal->name);	2151	buf = format ("The %s had a boring taste.", &meal->name);
2115	else if (meal->last_eat > 0 && atnr_is_dragon_enabled (meal->last_eat))	2152	else if (meal->last_eat > 0 && atnr_is_dragon_enabled (meal->last_eat))
2116	sprintf (buf, "The %s tasted strange.", &meal->name);	2153	buf = format ("The %s tasted strange.", &meal->name);
2117	else	2154	else
2118	sprintf (buf, "The %s had no taste.", &meal->name);	2155	buf = format ("The %s had no taste.", &meal->name);
2119	new_draw_info (NDI_UNIQUE, 0, op, buf);	2156
		2157	op->statusmsg (buf);
2120		2158
2121	/* now choose a winner if we have any */	2159	/* now choose a winner if we have any */
2122	i = -1;	2160	i = -1;
2123	if (winners > 0)	2161	if (winners > 0)
2124	i = atnr_winner[RANDOM () % winners];	2162	i = atnr_winner [rndm (winners)];
2125		2163
2126	if (i >= 0 && i < NROFATTACKS && skin->resist[i] < 95)	2164	if (i >= 0 && i < NROFATTACKS && skin->resist[i] < 95)
2127	{	2165	{
2128	/* resistance increased! */	2166	/* resistance increased! */
2129	skin->resist[i]++;	2167	skin->resist[i]++;
2130	op->update_stats ();	2168	op->update_stats ();
2131		2169
2132	sprintf (buf, "Your skin is now more resistant to %s!", change_resist_msg[i]);	2170	op->statusmsg (format ("Your skin is now more resistant to %s!", change_resist_msg[i]));
2133	new_draw_info (NDI_UNIQUE | NDI_RED, 0, op, buf);
2134	}	2171	}
2135		2172
2136	/* if this flesh contains a new ability focus, we mark it	2173	/* if this flesh contains a new ability focus, we mark it
2137	into the ability_force and it will take effect on next level */	2174	into the ability_force and it will take effect on next level */
2138	if (meal->last_eat > 0 && atnr_is_dragon_enabled (meal->last_eat) && meal->last_eat != abil->last_eat)	2175	if (meal->last_eat > 0 && atnr_is_dragon_enabled (meal->last_eat) && meal->last_eat != abil->last_eat)
2139	{	2176	{
2140	abil->last_eat = meal->last_eat; /* write: last_eat <new attnr focus> */	2177	abil->last_eat = meal->last_eat; /* write: last_eat <new attnr focus> */
2141		2178
2142	if (meal->last_eat != abil->stats.exp)	2179	if (meal->last_eat != abil->stats.exp)
		2180	op->statusmsg (format (
		2181	"Your metabolism prepares to focus on %s!\n"
		2182	"The change will happen at level %d.",
		2183	change_resist_msg[meal->last_eat],
		2184	abil->level + 1
2143	{	2185	));
2144	sprintf (buf, "Your metabolism prepares to focus on %s!", change_resist_msg[meal->last_eat]);
2145	new_draw_info (NDI_UNIQUE, 0, op, buf);
2146	sprintf (buf, "The change will happen at level %d", abil->level + 1);
2147	new_draw_info (NDI_UNIQUE, 0, op, buf);
2148	}
2149	else	2186	else
2150	{	2187	{
2151	sprintf (buf, "Your metabolism will continue to focus on %s.", change_resist_msg[meal->last_eat]);	2188	op->statusmsg (format ("Your metabolism will continue to focus on %s.", change_resist_msg[meal->last_eat]));
2152	new_draw_info (NDI_UNIQUE, 0, op, buf);
2153	abil->last_eat = 0;	2189	abil->last_eat = 0;
2154	}	2190	}
2155	}	2191	}
		2192
2156	return 1;	2193	return 1;
2157	}	2194	}
2158		2195
2159	/**	2196	/**
2160	* Handles applying an improve armor scroll.	2197	* Handles applying an improve armor scroll.
…		…
2163	static void	2200	static void
2164	apply_armour_improver (object *op, object *tmp)	2201	apply_armour_improver (object *op, object *tmp)
2165	{	2202	{
2166	object *armor;	2203	object *armor;
2167		2204
2168	if (!QUERY_FLAG (op, FLAG_WIZCAST) && (get_map_flags (op->map, NULL, op->x, op->y, NULL, NULL) & P_NO_MAGIC))	2205	if (!QUERY_FLAG (op, FLAG_WIZCAST) && (get_map_flags (op->map, 0, op->x, op->y, 0, 0) & P_NO_MAGIC))
2169	{	2206	{
2170	new_draw_info (NDI_UNIQUE, 0, op, "Something blocks the magic of the scroll.");	2207	op->failmsg ("Something blocks the magic of the scroll. H<This area prevents magic effects.>");
2171	return;	2208	return;
2172	}	2209	}
2173		2210
2174	armor = find_marked_object (op);	2211	armor = find_marked_object (op);
2175		2212
2176	if (!armor)	2213	if (!armor)
2177	{	2214	{
2178	new_draw_info (NDI_UNIQUE, 0, op, "You need to mark an armor object.");	2215	op->failmsg ("You need to mark an armor object. Use the right mouse button popup or the mark command to do this.");
2179	return;	2216	return;
2180	}	2217	}
2181		2218
2182	if (armor->type != ARMOUR	2219	if (armor->type != ARMOUR
2183	&& armor->type != CLOAK	2220	&& armor->type != CLOAK
2184	&& armor->type != BOOTS && armor->type != GLOVES && armor->type != BRACERS && armor->type != SHIELD && armor->type != HELMET)	2221	&& armor->type != BOOTS && armor->type != GLOVES && armor->type != BRACERS && armor->type != SHIELD && armor->type != HELMET)
2185	{	2222	{
2186	new_draw_info (NDI_UNIQUE, 0, op, "Your marked item is not armour!\n");	2223	op->failmsg ("Your marked item is not armour!\n");
2187	return;	2224	return;
2188	}	2225	}
2189		2226
2190	new_draw_info (NDI_UNIQUE, 0, op, "Applying armour enchantment.");	2227	op->statusmsg ("Applying armour enchantment.");
2191	improve_armour (op, tmp, armor);	2228	improve_armour (op, tmp, armor);
2192	}	2229	}
2193		2230
2194	extern void	2231	void
2195	apply_poison (object *op, object *tmp)	2232	apply_poison (object *op, object *tmp)
2196	{	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
2197	if (op->type == PLAYER)	2239	if (op->type == PLAYER)
2198	{	2240	{
2199	play_sound_player_only (op->contr, SOUND_DRINK_POISON, 0, 0);	2241	op->contr->play_sound (sound_find ("drink_poison"));
2200	new_draw_info (NDI_UNIQUE, 0, op, "Yech! That tasted poisonous!");	2242	op->failmsg ("Yech! That tasted poisonous!");
2201	strcpy (op->contr->killer, "poisonous booze");	2243	op->contr->killer = poison;
2202	}	2244	}
		2245
2203	if (tmp->stats.hp > 0)	2246	if (poison->stats.hp > 0)
2204	{	2247	{
2205	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);
2206	hit_player (op, tmp->stats.hp, tmp, AT_POISON, 1);	2249	hit_player (op, poison->stats.hp, tmp, AT_POISON, 1);
2207	}	2250	}
		2251
2208	op->stats.food -= op->stats.food / 4;	2252	op->stats.food -= op->stats.food / 4;
2209	handle_apply_yield (tmp);	2253	poison->destroy ();
2210	decrease_ob (tmp);
2211	}	2254	}
2212		2255
2213	/**	2256	/**
2214	* 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.
2215	* A valid 2 way exit means:	2258	* A valid 2 way exit means:
…		…
2230		2273
2231	#if 0 //TODO	2274	#if 0 //TODO
2232	if (!has_been_loaded (EXIT_PATH (exit)) && exit->race)	2275	if (!has_been_loaded (EXIT_PATH (exit)) && exit->race)
2233	return 0; /* This is a reset town portal */	2276	return 0; /* This is a reset town portal */
2234	#endif	2277	#endif
		2278
		2279	LOG (llevError | logBacktrace, "sync map load due to %s\n", exit->debug_desc ());
2235		2280
2236	maptile *exitmap = maptile::find_sync (EXIT_PATH (exit), exit->map);	2281	maptile *exitmap = maptile::find_sync (EXIT_PATH (exit), exit->map);
2237		2282
2238	if (exitmap)	2283	if (exitmap)
2239	{	2284	{
…		…
2315	* them in this function - they are passed to apply_special	2360	* them in this function - they are passed to apply_special
2316	*/	2361	*/
2317	int	2362	int
2318	manual_apply (object *op, object *tmp, int aflag)	2363	manual_apply (object *op, object *tmp, int aflag)
2319	{	2364	{
2320	if (tmp->head)
2321	tmp = tmp->head;	2365	tmp = tmp->head_ ();
2322		2366
2323	if (QUERY_FLAG (tmp, FLAG_UNPAID) && !QUERY_FLAG (tmp, FLAG_APPLIED))	2367	if (QUERY_FLAG (tmp, FLAG_UNPAID) && !QUERY_FLAG (tmp, FLAG_APPLIED))
2324	{	2368	{
2325	if (op->type == PLAYER)	2369	if (op->type == PLAYER)
2326	{	2370	{
2327	new_draw_info (NDI_UNIQUE, 0, op, "You should pay for it first.");	2371	op->failmsg ("You should pay for it first! H<You cannot use items marked as unpaid.>");
2328	return 1;	2372	return 1;
2329	}	2373	}
2330	else	2374	else
2331	return 0; /* monsters just skip unpaid items */	2375	return 0; /* monsters just skip unpaid items */
2332	}	2376	}
…		…
2335	return RESULT_INT (0);	2379	return RESULT_INT (0);
2336		2380
2337	switch (tmp->type)	2381	switch (tmp->type)
2338	{	2382	{
2339	case CF_HANDLE:	2383	case CF_HANDLE:
2340	new_draw_info (NDI_UNIQUE, 0, op, "You turn the handle.");	2384	op->play_sound (sound_find ("turn_handle"));
2341	play_sound_map (op->map, op->x, op->y, SOUND_TURN_HANDLE);	2385	op->statusmsg ("You turn the handle.");
2342	tmp->value = tmp->value ? 0 : 1;	2386	tmp->value = tmp->value ? 0 : 1;
2343	SET_ANIMATION (tmp, tmp->value);	2387	SET_ANIMATION (tmp, tmp->value);
2344	update_object (tmp, UP_OBJ_FACE);	2388	update_object (tmp, UP_OBJ_FACE);
2345	push_button (tmp);	2389	push_button (tmp);
2346	return 1;	2390	return 1;
2347		2391
2348	case TRIGGER:	2392	case TRIGGER:
2349	if (check_trigger (tmp, op))	2393	if (check_trigger (tmp, op))
2350	{	2394	{
2351	new_draw_info (NDI_UNIQUE, 0, op, "You turn the handle.");	2395	op->statusmsg ("You turn the handle.");
2352	play_sound_map (tmp->map, tmp->x, tmp->y, SOUND_TURN_HANDLE);	2396	op->play_sound (sound_find ("turn_handle"));
2353	}	2397	}
2354	else	2398	else
2355	new_draw_info (NDI_UNIQUE, 0, op, "The handle doesn't move.");	2399	op->failmsg ("The handle doesn't move.");
2356		2400
2357	return 1;	2401	return 1;
2358		2402
2359	case EXIT:	2403	case EXIT:
2360	if (op->type != PLAYER)	2404	if (op->type != PLAYER)
2361	return 0;	2405	return 0;
2362		2406
2363	if (!EXIT_PATH (tmp) || !is_legal_2ways_exit (op, tmp))	2407	if (!EXIT_PATH (tmp) || !is_legal_2ways_exit (op, tmp))
2364	new_draw_info_format (NDI_UNIQUE, 0, op, "The %s is closed.", query_name (tmp));	2408	op->failmsg (format ("The %s is closed.", query_name (tmp)));
2365	else	2409	else
2366	{	2410	{
2367	/* Don't display messages for random maps. */	2411	/* Don't display messages for random maps. */
2368	if (tmp->msg && strncmp (EXIT_PATH (tmp), "/!", 2))	2412	if (tmp->msg && !EXIT_PATH (tmp).starts_with ("/!"))
2369	new_draw_info (NDI_NAVY, 0, op, tmp->msg);	2413	op->statusmsg (tmp->msg, NDI_NAVY);
2370		2414
2371	op->enter_exit (tmp);	2415	op->enter_exit (tmp);
2372	}	2416	}
2373		2417
		2418	return 1;
		2419
		2420	case INSCRIBABLE:
		2421	op->statusmsg (tmp->msg);
		2422	// maybe show a spell menu to chose from or something like that
2374	return 1;	2423	return 1;
2375		2424
2376	case SIGN:	2425	case SIGN:
2377	apply_sign (op, tmp, 0);	2426	apply_sign (op, tmp, 0);
2378	return 1;	2427	return 1;
…		…
2487	{	2536	{
2488	char buf[MAX_BUF];	2537	char buf[MAX_BUF];
2489	timeofday_t tod;	2538	timeofday_t tod;
2490		2539
2491	get_tod (&tod);	2540	get_tod (&tod);
		2541	op->play_sound (sound_find ("sound_clock"));
		2542	op->statusmsg (format (
2492	sprintf (buf, "It is %d minute%s past %d o'clock %s",	2543	"It is %d minute%s past %d o'clock %s",
2493	tod.minute + 1, ((tod.minute + 1 < 2) ? "" : "s"),	2544	tod.minute + 1, ((tod.minute + 1 < 2) ? "" : "s"),
2494	((tod.hour % 14 == 0) ? 14 : ((tod.hour) % 14)), ((tod.hour >= 14) ? "pm" : "am"));	2545	((tod.hour % 14 == 0) ? 14 : ((tod.hour) % 14)), ((tod.hour >= 14) ? "pm" : "am")
2495	play_sound_player_only (op->contr, SOUND_CLOCK, 0, 0);	2546	));
2496	new_draw_info (NDI_UNIQUE, 0, op, buf);
2497	return 1;	2547	return 1;
2498	}	2548	}
2499	else	2549	else
2500	return 0;	2550	return 0;
2501		2551
…		…
2528	default:	2578	default:
2529	return 0;	2579	return 0;
2530	}	2580	}
2531	}	2581	}
2532		2582
2533
2534	/* quiet suppresses the "don't know how to apply" and "you must get it first"	2583	/* quiet suppresses the "don't know how to apply" and "you must get it first"
2535	* messages as needed by player_apply_below(). But there can still be	2584	* messages as needed by player_apply_below(). But there can still be
2536	* "but you are floating high above the ground" messages.	2585	* "but you are floating high above the ground" messages.
2537	*	2586	*
2538	* Same return value as apply() function.	2587	* Same return value as apply() function.
2539	*/	2588	*/
2540	int	2589	int
2541	player_apply (object *pl, object *op, int aflag, int quiet)	2590	player_apply (object *pl, object *op, int aflag, int quiet)
2542	{	2591	{
2543	int tmp;
2544
2545	if (op->env == NULL && (pl->move_type & MOVE_FLYING))	2592	if (!op->env && (pl->move_type & MOVE_FLYING))
2546	{	2593	{
2547	/* player is flying and applying object not in inventory */	2594	/* player is flying and applying object not in inventory */
2548	if (!QUERY_FLAG (pl, FLAG_WIZ) && !(op->move_type & MOVE_FLYING))	2595	if (!QUERY_FLAG (pl, FLAG_WIZ) && !(op->move_type & MOVE_FLYING))
2549	{	2596	{
2550	new_draw_info (NDI_UNIQUE, 0, pl, "But you are floating high " "above the ground!");	2597	pl->failmsg ("But you are floating high above the ground! "
		2598	"H<You have to stop levitating first, if you can, either by using your levitation skill, "
		2599	"or waiting till the levitation effect wears off.>");
2551	return 0;	2600	return 0;
2552	}	2601	}
2553	}	2602	}
2554		2603
2555	/* Check for PLAYER to avoid a DM to disappear in a puff of smoke if
2556	* applied.
2557	*/
2558	if (op->type != PLAYER && QUERY_FLAG (op, FLAG_WAS_WIZ) && !QUERY_FLAG (pl, FLAG_WAS_WIZ))
2559	{
2560	play_sound_map (pl->map, pl->x, pl->y, SOUND_OB_EVAPORATE);
2561	new_draw_info (NDI_UNIQUE, 0, pl, "The object disappears in a puff " "of smoke!");
2562	new_draw_info (NDI_UNIQUE, 0, pl, "It must have been an illusion.");
2563	op->destroy ();
2564	return 1;
2565	}
2566
2567	pl->contr->last_used = op;	2604	pl->contr->last_used = op;
2568		2605
2569	tmp = manual_apply (pl, op, aflag);	2606	int tmp = manual_apply (pl, op, aflag);
		2607
2570	if (!quiet)	2608	if (!quiet)
2571	{	2609	{
2572	if (tmp == 0)	2610	if (tmp == 0)
2573	new_draw_info_format (NDI_UNIQUE, 0, pl, "I don't know how to apply the %s.", query_name (op));	2611	pl->statusmsg (format ("I don't know how to apply the %s.", query_name (op)));
2574	else if (tmp == 2)	2612	else if (tmp == 2)
2575	new_draw_info_format (NDI_UNIQUE, 0, pl, "You must get it first!\n");	2613	pl->failmsg ("You must get it first!\n");
2576	}	2614	}
		2615
2577	return tmp;	2616	return tmp;
2578	}	2617	}
2579		2618
2580	/**	2619	/**
2581	* player_apply_below attempts to apply the object 'below' the player.	2620	* player_apply_below attempts to apply the object 'below' the player.
…		…
2608	* person moving on it, also activate. Added code to make it	2647	* person moving on it, also activate. Added code to make it
2609	* so that at least one of players movement types be that which	2648	* so that at least one of players movement types be that which
2610	* the item needs.	2649	* the item needs.
2611	*/	2650	*/
2612	if (!tmp->invisible || (tmp->move_on & pl->move_type))	2651	if (!tmp->invisible || (tmp->move_on & pl->move_type))
2613	{
2614	if (player_apply (pl, tmp, 0, 1) == 1)	2652	if (player_apply (pl, tmp, 0, 1) == 1)
2615	return;	2653	return;
2616	}	2654
2617	if (floors >= 2)	2655	if (floors >= 2)
2618	return; /* process at most two floor objects */	2656	return; /* process at most two floor objects */
2619	}	2657	}
2620	}	2658	}
2621		2659
…		…
2630	{	2668	{
2631	if (INVOKE_OBJECT (BE_UNREADY, op, ARG_OBJECT (who), ARG_INT (aflags))	2669	if (INVOKE_OBJECT (BE_UNREADY, op, ARG_OBJECT (who), ARG_INT (aflags))
2632	|| INVOKE_OBJECT (UNREADY, who, ARG_OBJECT (op), ARG_INT (aflags)))	2670	|| INVOKE_OBJECT (UNREADY, who, ARG_OBJECT (op), ARG_INT (aflags)))
2633	return RESULT_INT (0);	2671	return RESULT_INT (0);
2634		2672
2635	object *tmp2;
2636
2637	CLEAR_FLAG (op, FLAG_APPLIED);	2673	CLEAR_FLAG (op, FLAG_APPLIED);
2638		2674
2639	switch (op->type)	2675	switch (op->type)
2640	{	2676	{
		2677	case SKILL_TOOL:
		2678	// unapplying a skill tool should also unapply the skill it governs
		2679	// but this is hard, as it shouldn't do so when the skill can
		2680	// be used for other reasons
		2681	for (object *tmp = who->inv; tmp; tmp = tmp->below)
		2682	if (tmp->skill == op->skill
		2683	&& tmp->type == SKILL
		2684	&& tmp->flag [FLAG_APPLIED]
		2685	&& !tmp->flag [FLAG_CAN_USE_SKILL])
		2686	unapply_special (who, tmp, 0);
		2687
		2688	change_abil (who, op);
		2689	break;
		2690
2641	case WEAPON:	2691	case WEAPON:
2642	new_draw_info_format (NDI_UNIQUE, 0, who, "You unwield %s.", query_name (op));	2692	if (player *pl = who->contr)
		2693	if (op == pl->combat_ob)
		2694	{
		2695	pl->combat_ob = 0;
		2696	who->change_weapon (pl->ranged_ob);
		2697	}
		2698
		2699	who->statusmsg (format ("You unwield %s.", query_name (op)));
2643		2700
2644	change_abil (who, op);	2701	change_abil (who, op);
2645	CLEAR_FLAG (who, FLAG_READY_WEAPON);	2702	CLEAR_FLAG (who, FLAG_READY_WEAPON);
		2703	break;
2646		2704
		2705	case SKILL:
2647	if (who->contr)	2706	if (who->contr)
2648	{	2707	{
2649	if (who->contr->combat_ob == op)	2708	if (IS_COMBAT_SKILL (op->subtype))
2650	who->contr->combat_ob = 0;	2709	who->change_weapon (who->contr->combat_ob = 0);
		2710	else if (IS_RANGED_SKILL (op->subtype))
		2711	who->change_weapon (who->contr->ranged_ob = 0);
2651		2712
2652	if (who->current_weapon == op)	2713	if (op->invisible)
2653	who->current_weapon = 0;	2714	who->statusmsg (format ("You can no longer use the skill: %s.", &op->skill));
		2715	else
		2716	who->statusmsg (format ("You stop using the %s.", query_name (op)));
2654	}	2717	}
2655		2718
2656	clear_skill (who);
2657	break;
2658
2659	case SKILL: /* allows objects to impart skills */
2660	case SKILL_TOOL:
2661	if (op != who->chosen_skill)
2662	LOG (llevError, "BUG: apply_special(): applied skill is not a chosen skill\n");
2663
2664	if (who->contr)
2665	{
2666	if (!op->invisible)
2667	new_draw_info_format (NDI_UNIQUE, 0, who, "You stop using the %s.", query_name (op));
2668	else
2669	new_draw_info_format (NDI_UNIQUE, 0, who, "You can no longer use the skill: %s.", &op->skill);
2670	}
2671
2672	change_abil (who, op);	2719	change_abil (who, op);
2673	who->chosen_skill = 0;
2674	CLEAR_FLAG (who, FLAG_READY_SKILL);	2720	CLEAR_FLAG (who, FLAG_READY_SKILL);
2675	break;	2721	break;
2676		2722
2677	case ARMOUR:	2723	case ARMOUR:
2678	case HELMET:	2724	case HELMET:
…		…
2682	case GLOVES:	2728	case GLOVES:
2683	case AMULET:	2729	case AMULET:
2684	case GIRDLE:	2730	case GIRDLE:
2685	case BRACERS:	2731	case BRACERS:
2686	case CLOAK:	2732	case CLOAK:
2687	new_draw_info_format (NDI_UNIQUE, 0, who, "You unwear %s.", query_name (op));	2733	who->statusmsg (format ("You unwear %s.", query_name (op)));
2688	change_abil (who, op);	2734	change_abil (who, op);
2689	break;	2735	break;
2690		2736
2691	case LAMP:	2737	case LAMP:
2692	new_draw_info_format (NDI_UNIQUE, 0, who, "You turn off your %s.", &op->name);	2738	{
		2739	who->statusmsg (format ("You turn off your %s.", &op->name));
		2740
2693	tmp2 = arch_to_object (op->other_arch);	2741	object *tmp2 = arch_to_object (op->other_arch);
2694	tmp2->x = op->x;	2742	tmp2->x = op->x;
2695	tmp2->y = op->y;	2743	tmp2->y = op->y;
2696	tmp2->map = op->map;	2744	tmp2->map = op->map;
2697	tmp2->below = op->below;	2745	tmp2->below = op->below;
2698	tmp2->above = op->above;	2746	tmp2->above = op->above;
2699	tmp2->stats.food = op->stats.food;	2747	tmp2->stats.food = op->stats.food;
2700	CLEAR_FLAG (tmp2, FLAG_APPLIED);	2748	CLEAR_FLAG (tmp2, FLAG_APPLIED);
2701		2749
2702	if (QUERY_FLAG (op, FLAG_INV_LOCKED))	2750	if (QUERY_FLAG (op, FLAG_INV_LOCKED))
2703	SET_FLAG (tmp2, FLAG_INV_LOCKED);	2751	SET_FLAG (tmp2, FLAG_INV_LOCKED);
2704		2752
2705	if (who->contr)
2706	esrv_del_item (who->contr, op->count);
2707
2708	op->destroy ();	2753	op->destroy ();
2709	insert_ob_in_ob (tmp2, who);	2754	who->insert (tmp2);
2710	who->update_stats ();	2755	who->update_stats ();
2711		2756
		2757	if (who->contr)
2712	if (QUERY_FLAG (op, FLAG_CURSED) || QUERY_FLAG (op, FLAG_DAMNED))	2758	if (QUERY_FLAG (op, FLAG_CURSED) || QUERY_FLAG (op, FLAG_DAMNED))
2713	{
2714	if (who->contr)
2715	{	2759	{
2716	new_draw_info (NDI_UNIQUE, 0, who, "Oops, it feels deadly cold!");	2760	who->failmsg ("Oops, it feels deadly cold!");
2717	SET_FLAG (tmp2, FLAG_KNOWN_CURSED);	2761	SET_FLAG (tmp2, FLAG_KNOWN_CURSED);
2718	}	2762	}
2719	}	2763	}
2720
2721	if (who->contr)
2722	esrv_send_item (who, tmp2);
2723		2764
2724	return 1; /* otherwise, an attempt to drop causes problems */	2765	return 1; /* otherwise, an attempt to drop causes problems */
2725		2766
2726	case BOW:	2767	case BOW:
2727	case WAND:	2768	case WAND:
2728	case ROD:	2769	case ROD:
2729	case HORN:	2770	case HORN:
2730	clear_skill (who);
2731
2732	if (who->contr)	2771	if (player *pl = who->contr)
2733	{	2772	{
2734	new_draw_info_format (NDI_UNIQUE, 0, who, "You unready %s.", query_name (op));	2773	if (op == pl->ranged_ob)
2735		2774	{
2736	if (who->contr->ranged_ob == op)
2737	who->contr->ranged_ob = 0;	2775	pl->ranged_ob = 0;
		2776	who->change_weapon (pl->combat_ob);
		2777	}
2738		2778
2739	if (who->current_weapon == op)	2779	who->statusmsg (format ("You unready %s.", query_name (op)));
2740	who->current_weapon = 0;
2741	}	2780	}
2742	else	2781	else
2743	{	2782	{
		2783	who->change_skill (0);
		2784
2744	if (op->type == BOW)	2785	if (op->type == BOW)
2745	CLEAR_FLAG (who, FLAG_READY_BOW);	2786	CLEAR_FLAG (who, FLAG_READY_BOW);
2746	else	2787	else
2747	CLEAR_FLAG (who, FLAG_READY_RANGE);	2788	CLEAR_FLAG (who, FLAG_READY_RANGE);
2748	}	2789	}
2749		2790
2750	break;	2791	break;
2751		2792
2752	case BUILDER:	2793	case BUILDER:
2753	if (who->contr)	2794	if (who->contr)
2754	{	2795	who->statusmsg (format ("You unready %s.", query_name (op)));
2755	new_draw_info_format (NDI_UNIQUE, 0, who, "You unready %s.", query_name (op));
2756
2757	if (who->contr->ranged_ob == op)
2758	who->contr->ranged_ob = 0;
2759	}
2760	break;	2796	break;
2761		2797
2762	default:	2798	default:
2763	new_draw_info_format (NDI_UNIQUE, 0, who, "You unapply %s.", query_name (op));	2799	who->statusmsg (format ("You unapply %s.", query_name (op)));
2764	break;	2800	break;
2765	}	2801	}
2766		2802
		2803	if (aflags & AP_NO_MERGE || !merge_ob (op, 0))
		2804	if (object *pl = op->visible_to ())
		2805	esrv_send_item (pl, op);
		2806
2767	who->update_stats ();	2807	who->update_stats ();
2768
2769	if (!(aflags & AP_NO_MERGE))
2770	{
2771	object *tmp = merge_ob (op, 0);
2772
2773	if (who->contr)
2774	{
2775	if (tmp)
2776	{ /* it was merged */
2777	esrv_del_item (who->contr, op->count);
2778	op = tmp;
2779	}
2780
2781	esrv_send_item (who, op);
2782	}
2783	}
2784		2808
2785	return 0;	2809	return 0;
2786	}	2810	}
2787		2811
2788	/**	2812	/**
2789	* Returns the object that is using location 'loc'.	2813	* Returns the object that is using location 'loc'.
2790	* Note that 'start' is the first object to start examing - we	2814	* Note that 'start' is the first object to start examing - we
2791	* then go through the below of this. In this way, you can do	2815	* then go through the below of this. In this way, you can do
2792	* something like:	2816	* something like:
2793	* tmp = get_item_from_body_location(who->inv, 1);	2817	* tmp = get_next_item_from_body_location(who->inv, 1);
2794	* if (tmp) tmp1 = get_item_from_body_location(tmp->below, 1);	2818	* if (tmp) tmp1 = get_next_item_from_body_location(tmp->below, 1);
2795	* to find the second object that may use this location, etc.	2819	* to find the second object that may use this location, etc.
2796	* Returns NULL if no match is found.	2820	* Returns NULL if no match is found.
2797	* loc is the index into the array we are looking for a match.	2821	* loc is the index into the array we are looking for a match.
2798	* don't return invisible objects unless they are skill objects	2822	* don't return invisible objects unless they are skill objects
2799	* invisible other objects that use	2823	* invisible other objects that use
2800	* up body locations can be used as restrictions.	2824	* up body locations can be used as restrictions.
2801	*/	2825	*/
2802	static object *	2826	static object *
2803	get_item_from_body_location (int loc, object *start)	2827	get_next_item_from_body_location (int loc, object *start)
2804	{	2828	{
2805	if (start)
2806	for (object *tmp = start; tmp; tmp = tmp->below)	2829	for (object *tmp = start; tmp; tmp = tmp->below)
2807	if (QUERY_FLAG (tmp, FLAG_APPLIED) && tmp->slot[loc].info && (!tmp->invisible || tmp->type == SKILL))	2830	if (tmp->flag [FLAG_APPLIED]
		2831	&& tmp->slot[loc].info
		2832	&& (!tmp->invisible || tmp->type == SKILL))
2808	return tmp;	2833	return tmp;
2809		2834
2810	return 0;	2835	return 0;
2811	}	2836	}
2812		2837
2813	/**	2838	/**
…		…
2819	* Returns 0 on success, returns 1 if there is some problem.	2844	* Returns 0 on success, returns 1 if there is some problem.
2820	* if aflags is AP_PRINT, we instead print out waht to unapply	2845	* if aflags is AP_PRINT, we instead print out waht to unapply
2821	* instead of doing it. This is a lot less code than having	2846	* instead of doing it. This is a lot less code than having
2822	* another function that does just that.	2847	* another function that does just that.
2823	*/	2848	*/
		2849
		2850	#define CANNOT_REMOVE_CURSED \
		2851	"H<You cannot remove cursed or damned items, you first have to remove the curse. " \
		2852	"Praying over an altar, scrolls of remove curse/damnation, " \
		2853	"priests or even other players might help.>"
		2854
2824	int	2855	int
2825	unapply_for_ob (object *who, object *op, int aflags)	2856	unapply_for_ob (object *who, object *op, int aflags)
2826	{	2857	{
2827	if (op->is_range ())	2858	if (op->is_range ())
2828	for (object *tmp = who->inv; tmp; tmp = tmp->below)	2859	for (object *tmp = who->inv; tmp; tmp = tmp->below)
2829	if (QUERY_FLAG (tmp, FLAG_APPLIED) && tmp->is_range ())	2860	if (QUERY_FLAG (tmp, FLAG_APPLIED) && tmp->is_range ())
2830	if ((aflags & AP_IGNORE_CURSE) || (aflags & AP_PRINT) || (!QUERY_FLAG (tmp, FLAG_CURSED) && !QUERY_FLAG (tmp, FLAG_DAMNED)))	2861	if ((aflags & AP_IGNORE_CURSE) || (aflags & AP_PRINT) || (!QUERY_FLAG (tmp, FLAG_CURSED) && !QUERY_FLAG (tmp, FLAG_DAMNED)))
2831	{	2862	{
2832	if (aflags & AP_PRINT)	2863	if (aflags & AP_PRINT)
2833	new_draw_info (NDI_UNIQUE, 0, who, query_name (tmp));	2864	who->failmsg (query_name (tmp));
2834	else	2865	else
2835	unapply_special (who, tmp, aflags);	2866	unapply_special (who, tmp, aflags);
2836	}	2867	}
2837	else	2868	else
2838	{	2869	{
2839	/* In this case, we want to try and remove a cursed item.	2870	/* In this case, we want to try and remove a cursed item.
2840	* While we know it won't work, we want unapply_special to	2871	* While we know it won't work, we want unapply_special to
2841	* at least generate the message.	2872	* at least generate the message.
2842	*/	2873	*/
2843	new_draw_info_format (NDI_UNIQUE, 0, who, "No matter how hard you try, you just can't remove the %s.", query_name (tmp));	2874	who->failmsg (format ("No matter how hard you try, you just can't remove the %s." CANNOT_REMOVE_CURSED, query_name (tmp)));
2844	return 1;	2875	return 1;
2845	}	2876	}
2846		2877
2847	for (int i = 0; i < NUM_BODY_LOCATIONS; i++)	2878	for (int i = 0; i < NUM_BODY_LOCATIONS; i++)
2848	{	2879	{
…		…
2854	/* We do a while loop - may need to remove several items in order	2885	/* We do a while loop - may need to remove several items in order
2855	* to free up enough slots.	2886	* to free up enough slots.
2856	*/	2887	*/
2857	while ((who->slot[i].used + op->slot[i].info) < 0)	2888	while ((who->slot[i].used + op->slot[i].info) < 0)
2858	{	2889	{
2859	object *tmp = get_item_from_body_location (i, last);	2890	object *tmp = get_next_item_from_body_location (i, last);
2860		2891
2861	if (!tmp)	2892	if (!tmp)
2862	{	2893	{
2863	#if 0	2894	#if 0
2864	/* Not a bug - we'll get this if the player has cursed items	2895	/* Not a bug - we'll get this if the player has cursed items
…		…
2871		2902
2872	/* If we are just printing, we don't care about cursed status */	2903	/* If we are just printing, we don't care about cursed status */
2873	if ((aflags & AP_IGNORE_CURSE) || (aflags & AP_PRINT) || (!(QUERY_FLAG (tmp, FLAG_CURSED) || QUERY_FLAG (tmp, FLAG_DAMNED))))	2904	if ((aflags & AP_IGNORE_CURSE) || (aflags & AP_PRINT) || (!(QUERY_FLAG (tmp, FLAG_CURSED) || QUERY_FLAG (tmp, FLAG_DAMNED))))
2874	{	2905	{
2875	if (aflags & AP_PRINT)	2906	if (aflags & AP_PRINT)
2876	new_draw_info (NDI_UNIQUE, 0, who, query_name (tmp));	2907	who->failmsg (query_name (tmp));
2877	else	2908	else
2878	unapply_special (who, tmp, aflags);	2909	unapply_special (who, tmp, aflags);
2879	}	2910	}
2880	else	2911	else
2881	{	2912	{
2882	/* Cursed item that we can't unequip - tell the player.	2913	/* Cursed item that we can't unequip - tell the player.
2883	* Note this could be annoying if this is just one of a few,	2914	* Note this could be annoying if this is just one of a few,
2884	* so it may not be critical (eg, putting on a ring and you have	2915	* so it may not be critical (eg, putting on a ring and you have
2885	* one cursed ring.)	2916	* one cursed ring.)
2886	*/	2917	*/
2887	new_draw_info_format (NDI_UNIQUE, 0, who, "The %s just won't come off", query_name (tmp));	2918	who->failmsg (format ("The %s just won't come off." CANNOT_REMOVE_CURSED, query_name (tmp)));
2888	}	2919	}
2889		2920
2890	last = tmp->below;	2921	last = tmp->below;
2891	}	2922	}
2892	/* if we got here, this slot is freed up - otherwise, if it wasn't freed up, the	2923	/* if we got here, this slot is freed up - otherwise, if it wasn't freed up, the
…		…
2902	* Checks to see if 'who' can apply object 'op'.	2933	* Checks to see if 'who' can apply object 'op'.
2903	* Returns 0 if apply can be done without anything special.	2934	* Returns 0 if apply can be done without anything special.
2904	* Otherwise returns a bitmask - potentially several of these may be	2935	* Otherwise returns a bitmask - potentially several of these may be
2905	* set, but largely depends on circumstance - in the future, processing	2936	* set, but largely depends on circumstance - in the future, processing
2906	* may be pruned once we know some status (eg, once CAN_APPLY_NEVER	2937	* may be pruned once we know some status (eg, once CAN_APPLY_NEVER
2907	* is set, do we really are what the other flags may be?)	2938	* is set, do we really care what the other flags may be?)
2908	*	2939	*
2909	* See include/define.h for detailed description of the meaning of	2940	* See include/define.h for detailed description of the meaning of
2910	* these return values.	2941	* these return values.
2911	*/	2942	*/
2912	int	2943	int
…		…
2921	for (int i = 0; i < NUM_BODY_LOCATIONS; i++)	2952	for (int i = 0; i < NUM_BODY_LOCATIONS; i++)
2922	{	2953	{
2923	if (op->slot[i].info)	2954	if (op->slot[i].info)
2924	{	2955	{
2925	/* Item uses more slots than we have */	2956	/* Item uses more slots than we have */
2926	if (abs (op->slot[i].info) > who->slot[i].info)	2957	if (who->slot[i].info + op->slot [i].info < 0)
2927	{	2958	{
2928	/* Could return now for efficiency - rest of info below isn't	2959	/* Could return now for efficiency - rest of info below isn't
2929	* really needed.	2960	* really needed.
2930	*/	2961	*/
2931	retval |= CAN_APPLY_NEVER;	2962	retval |= CAN_APPLY_NEVER;
2932	}	2963	}
2933	else if ((who->slot[i].used + op->slot[i].info) < 0)	2964	else if (who->slot[i].used + op->slot[i].info < 0)
2934	{	2965	{
2935	/* in this case, equipping this would use more free spots than	2966	/* in this case, equipping this would use more free spots than
2936	* we have.	2967	* we have.
2937	*/	2968	*/
2938		2969
…		…
2949	{	2980	{
2950	retval |= CAN_APPLY_UNAPPLY;	2981	retval |= CAN_APPLY_UNAPPLY;
2951	continue;	2982	continue;
2952	}	2983	}
2953		2984
2954	object *tmp1 = get_item_from_body_location (i, who->inv);	2985	object *tmp1 = get_next_item_from_body_location (i, who->inv);
2955	if (!tmp1)	2986	if (!tmp1)
2956	{	2987	{
2957	#if 0	2988	#if 0
2958	/* This is sort of an error, but happens a lot when old players	2989	/* This is sort of an error, but happens a lot when old players
2959	* join in with more stuff equipped than they are now allowed.	2990	* join in with more stuff equipped than they are now allowed.
…		…
2967	/* need to unapply something. However, if this something	2998	/* need to unapply something. However, if this something
2968	* is different than we had found before, it means they need	2999	* is different than we had found before, it means they need
2969	* to apply multiple objects	3000	* to apply multiple objects
2970	*/	3001	*/
2971	retval |= CAN_APPLY_UNAPPLY;	3002	retval |= CAN_APPLY_UNAPPLY;
		3003
2972	if (!tmp)	3004	if (!tmp)
2973	tmp = tmp1;	3005	tmp = tmp1;
2974	else if (tmp != tmp1)	3006	else if (tmp != tmp1)
2975	retval |= CAN_APPLY_UNAPPLY_MULT;	3007	retval |= CAN_APPLY_UNAPPLY_MULT;
2976		3008
…		…
3038	* AP_UNAPPLY=always unapply).	3070	* AP_UNAPPLY=always unapply).
3039	*	3071	*
3040	* Optional flags:	3072	* Optional flags:
3041	* AP_NO_MERGE: don't merge an unapplied object with other objects	3073	* AP_NO_MERGE: don't merge an unapplied object with other objects
3042	* AP_IGNORE_CURSE: unapply cursed items	3074	* AP_IGNORE_CURSE: unapply cursed items
		3075	* AP_NO_READY: do not ready skills when applying skill tools
3043	*	3076	*
3044	* Usage example: apply_special (who, op, AP_UNAPPLY | AP_IGNORE_CURSE)	3077	* Usage example: apply_special (who, op, AP_UNAPPLY | AP_IGNORE_CURSE)
3045	*	3078	*
3046	* apply_special() doesn't check for unpaid items.	3079	* apply_special() doesn't check for unpaid items.
3047	*/	3080	*/
		3081
		3082	#define LACK_ITEM_POWER \
		3083	" H<You lack enough unused item power to use this weapon, see the skills command.>"
		3084
3048	int	3085	int
3049	apply_special (object *who, object *op, int aflags)	3086	apply_special (object *who, object *op, int aflags)
3050	{	3087	{
3051	int basic_flag = aflags & AP_BASIC_FLAGS;	3088	int basic_flag = aflags & AP_BASIC_FLAGS;
3052	object *tmp, *tmp2, *skop = NULL;	3089	object *tmp, *tmp2, *skop = NULL;
…		…
3067	if (basic_flag == AP_APPLY)	3104	if (basic_flag == AP_APPLY)
3068	return 0;	3105	return 0;
3069		3106
3070	if (!(aflags & AP_IGNORE_CURSE) && (QUERY_FLAG (op, FLAG_CURSED) || QUERY_FLAG (op, FLAG_DAMNED)))	3107	if (!(aflags & AP_IGNORE_CURSE) && (QUERY_FLAG (op, FLAG_CURSED) || QUERY_FLAG (op, FLAG_DAMNED)))
3071	{	3108	{
3072	new_draw_info_format (NDI_UNIQUE, 0, who, "No matter how hard you try, you just can't remove %s.", query_name (op));	3109	who->failmsg (format ("No matter how hard you try, you just can't remove %s." CANNOT_REMOVE_CURSED, query_name (op)));
3073	return 1;	3110	return 1;
3074	}	3111	}
3075		3112
3076	return unapply_special (who, op, aflags);	3113	return unapply_special (who, op, aflags);
3077	}	3114	}
3078
3079	if (basic_flag == AP_UNAPPLY)	3115	else if (basic_flag == AP_UNAPPLY)
3080	return 0;	3116	return 0;
3081		3117
3082	// if the item is combat/ranged, wield the relevant slot first	3118	// if the item is combat/ranged, wield the relevant slot first
3083	// to resolve conflicts.	3119	// to resolve conflicts.
3084	if (player *pl = who->contr)	3120	if (player *pl = who->contr)
3085	switch (op->type)	3121	switch (op->slottype ())
3086	{	3122	{
3087	case WEAPON:
3088	who->change_weapon (pl->combat_ob);	3123	case slot_combat: who->change_weapon (pl->combat_ob); break;
3089	break;
3090
3091	case BOW:
3092	case ROD:
3093	case WAND:
3094	case HORN:
3095	case SKILL_TOOL:
3096	who->change_weapon (pl->ranged_ob);	3124	case slot_ranged: who->change_weapon (pl->ranged_ob); break;
3097	break;
3098
3099	case SKILL:
3100	if (IS_COMBAT_SKILL (op->subtype))
3101	who->change_weapon (pl->combat_ob);
3102	else if (IS_RANGED_SKILL (op->subtype))
3103	who->change_weapon (pl->ranged_ob);
3104	break;
3105	}	3125	}
		3126
		3127	splay (op);
3106		3128
3107	/* Can't just apply this object. Lets see what not and what to do */	3129	/* Can't just apply this object. Lets see what not and what to do */
3108	if (int i = can_apply_object (who, op))	3130	if (int i = can_apply_object (who, op))
3109	{	3131	{
3110	if (i & CAN_APPLY_NEVER)	3132	if (i & CAN_APPLY_NEVER)
3111	{	3133	{
3112	new_draw_info_format (NDI_UNIQUE, 0, who, "You don't have the body to use a %s\n", query_name (op));	3134	who->failmsg (format ("You don't have the body to use a %s. H<You can never apply this item.>", query_name (op)));
3113	return 1;	3135	return 1;
3114	}	3136	}
3115	else if (i & CAN_APPLY_RESTRICTION)	3137	else if (i & CAN_APPLY_RESTRICTION)
3116	{	3138	{
3117	new_draw_info_format (NDI_UNIQUE, 0, who, "You have a prohibition against using a %s\n", query_name (op));	3139	who->failmsg (format (
		3140	"You have a prohibition against using a %s. "
		3141	"H<Your belief, profession or class prevents you from applying this item.>",
		3142	query_name (op)
		3143	));
3118	return 1;	3144	return 1;
3119	}	3145	}
3120		3146
3121	if (who->type != PLAYER)	3147	if (who->type != PLAYER)
3122	{	3148	{
…		…
3126	}	3152	}
3127	else	3153	else
3128	{	3154	{
3129	if (who->contr->unapply == unapply_never || (i & CAN_APPLY_UNAPPLY_CHOICE && who->contr->unapply == unapply_nochoice))	3155	if (who->contr->unapply == unapply_never || (i & CAN_APPLY_UNAPPLY_CHOICE && who->contr->unapply == unapply_nochoice))
3130	{	3156	{
3131	new_draw_info (NDI_UNIQUE, 0, who, "You need to unapply some of the following item(s) or change your applymode:");	3157	who->failmsg ("You need to unapply some of the following item(s) or change your applymode:");
3132	unapply_for_ob (who, op, AP_PRINT);	3158	unapply_for_ob (who, op, AP_PRINT);
3133	return 1;	3159	return 1;
3134	}	3160	}
3135	else if (who->contr->unapply == unapply_always || !(i & CAN_APPLY_UNAPPLY_CHOICE))	3161	else if (who->contr->unapply == unapply_always || !(i & CAN_APPLY_UNAPPLY_CHOICE))
3136	if (unapply_for_ob (who, op, aflags))	3162	if (unapply_for_ob (who, op, aflags))
…		…
3142	{	3168	{
3143	skop = find_skill_by_name (who, op->skill);	3169	skop = find_skill_by_name (who, op->skill);
3144		3170
3145	if (!skop)	3171	if (!skop)
3146	{	3172	{
3147	new_draw_info_format (NDI_UNIQUE, 0, who, "You need the %s skill to use this item!", &op->skill);	3173	who->failmsg (format ("You need the %s skill to use this item!", &op->skill));
3148	return 1;	3174	return 1;
3149	}	3175	}
3150	else	3176	else
3151	/* While experience will be credited properly, we want to change the	3177	/* While experience will be credited properly, we want to change the
3152	* skill so that the dam and wc get updated	3178	* skill so that the dam and wc get updated
3153	*/	3179	*/
3154	change_skill (who, skop, 0);	3180	who->change_skill (skop);
3155	}	3181	}
3156		3182
3157	if (who->type == PLAYER	3183	if (who->type == PLAYER
3158	&& op->item_power	3184	&& op->item_power
3159	&& op->item_power + who->contr->item_power > settings.item_power_factor * who->level)	3185	&& op->item_power + who->contr->item_power > settings.item_power_factor * who->level)
3160	{	3186	{
3161	new_draw_info (NDI_UNIQUE, 0, who,
3162	"Equipping that combined with other items would consume your soul! "	3187	who->failmsg ("Equipping that combined with other items would consume your soul!" LACK_ITEM_POWER);
3163	"[use the skills command to check your available item power]");
3164	return 1;	3188	return 1;
3165	}	3189	}
3166		3190
3167	/* Ok. We are now at the state where we can apply the new object.	3191	/* Ok. We are now at the state where we can apply the new object.
3168	* Note that we don't have the checks for can_use_...	3192	* Note that we don't have the checks for can_use_...
3169	* below - that is already taken care of by can_apply_object.	3193	* below - that is already taken care of by can_apply_object.
3170	*/	3194	*/
3171	if (op->nrof > 1)	3195	tmp = op->nrof > 1 ? op->split (op->nrof - 1) : 0;
3172	tmp = get_split_ob (op, op->nrof - 1);
3173	else
3174	tmp = 0;
3175		3196
3176	if (INVOKE_OBJECT (BE_READY, op, ARG_OBJECT (who)) || INVOKE_OBJECT (READY, who, ARG_OBJECT (op)))	3197	if (INVOKE_OBJECT (BE_READY, op, ARG_OBJECT (who)) || INVOKE_OBJECT (READY, who, ARG_OBJECT (op)))
3177	return RESULT_INT (0);	3198	return RESULT_INT (0);
3178		3199
3179	switch (op->type)	3200	switch (op->type)
3180	{	3201	{
3181	case WEAPON:	3202	case WEAPON:
3182	if (!check_weapon_power (who, op->last_eat))	3203	if (!check_weapon_power (who, op->last_eat))
3183	{	3204	{
3184	new_draw_info (NDI_UNIQUE, 0, who, "This weapon is too powerful for you to use.\n"	3205	op->failmsg ("This weapon is too powerful for you to use. It would consume your soul!" LACK_ITEM_POWER);
3185	"It would consume your soul!.");
3186		3206
3187	if (tmp)	3207	if (tmp)
3188	insert_ob_in_ob (tmp, who);	3208	insert_ob_in_ob (tmp, who);
3189		3209
3190	return 1;	3210	return 1;
3191	}	3211	}
3192		3212
3193	//TODO: this obviously fails for players using a shorter prefix	3213	//TODO: this obviously fails for players using a shorter prefix
3194	// i.e. "R" can use Ragnarok's sword.	3214	// i.e. "R" can use Ragnarok's sword.
3195	if (op->level && (strncmp (op->name, who->name, strlen (who->name))))	3215	if (op->level && !op->name.starts_with (who->name))
3196	{	3216	{
3197	/* if the weapon does not have the name as the character, can't use it. */	3217	/* if the weapon does not have the name as the character, can't use it. */
3198	/* (Ragnarok's sword attempted to be used by Foo: won't work) */	3218	/* (Ragnarok's sword attempted to be used by Foo: won't work) */
3199	new_draw_info (NDI_UNIQUE, 0, who, "The weapon does not recognize you as its owner.");	3219	who->failmsg ("The weapon does not recognize you as its owner. H<Its name indicates that it belongs to somebody else.>");
3200		3220
3201	if (tmp)	3221	if (tmp)
3202	insert_ob_in_ob (tmp, who);	3222	insert_ob_in_ob (tmp, who);
3203		3223
3204	return 1;	3224	return 1;
3205	}	3225	}
3206		3226
3207	if (!skop)	3227	if (!skop)
3208	{	3228	{
3209	new_draw_info_format (NDI_UNIQUE, 0, who, "The %s is broken, please report this to the dungeon master!", query_name (op));//TODO	3229	who->failmsg (format ("The %s is broken, please report this to the dungeon master!", query_name (op)));//TODO
3210	return 1;	3230	return 1;
3211	}	3231	}
3212		3232
3213	SET_FLAG (op, FLAG_APPLIED);	3233	SET_FLAG (op, FLAG_APPLIED);
3214	change_skill (who, skop, 1);	3234	who->change_skill (skop);
3215		3235
3216	if (who->contr)	3236	if (who->contr)
3217	who->change_weapon (who->contr->combat_ob = op);	3237	who->change_weapon (who->contr->combat_ob = op);
3218		3238
3219	if (!QUERY_FLAG (who, FLAG_READY_WEAPON))	3239	who->statusmsg (format ("You wield %s.", query_name (op)));
		3240
3220	SET_FLAG (who, FLAG_READY_WEAPON);	3241	SET_FLAG (who, FLAG_READY_WEAPON);
3221
3222	new_draw_info_format (NDI_UNIQUE, 0, who, "You wield %s.", query_name (op));
3223
3224	change_abil (who, op);	3242	change_abil (who, op);
3225	break;	3243	break;
3226		3244
3227	case ARMOUR:	3245	case ARMOUR:
3228	case HELMET:	3246	case HELMET:
…		…
3233	case BRACERS:	3251	case BRACERS:
3234	case CLOAK:	3252	case CLOAK:
3235	case RING:	3253	case RING:
3236	case AMULET:	3254	case AMULET:
3237	SET_FLAG (op, FLAG_APPLIED);	3255	SET_FLAG (op, FLAG_APPLIED);
3238	new_draw_info_format (NDI_UNIQUE, 0, who, "You wear %s.", query_name (op));	3256	who->statusmsg (format ("You wear %s.", query_name (op)));
3239	change_abil (who, op);	3257	change_abil (who, op);
3240	break;	3258	break;
3241		3259
3242	case LAMP:	3260	case LAMP:
3243	if (op->stats.food < 1)	3261	if (op->stats.food < 1)
3244	{	3262	{
3245	new_draw_info_format (NDI_UNIQUE, 0, who, "Your %s is out of fuel!", &op->name);	3263	who->failmsg (format (
		3264	"Your %s is out of fuel! "
		3265	"H<Lamps and similar items need fuel. They cannot be refilled.>",
		3266	&op->name
		3267	));
3246	return 1;	3268	return 1;
3247	}	3269	}
3248		3270
3249	new_draw_info_format (NDI_UNIQUE, 0, who, "You turn on your %s.", &op->name);	3271	who->statusmsg (format ("You turn on your %s.", &op->name));
		3272
3250	tmp2 = arch_to_object (op->other_arch);	3273	tmp2 = arch_to_object (op->other_arch);
3251	tmp2->stats.food = op->stats.food;	3274	tmp2->stats.food = op->stats.food;
3252	SET_FLAG (tmp2, FLAG_APPLIED);	3275	SET_FLAG (tmp2, FLAG_APPLIED);
3253		3276
3254	if (QUERY_FLAG (op, FLAG_INV_LOCKED))	3277	if (QUERY_FLAG (op, FLAG_INV_LOCKED))
3255	SET_FLAG (tmp2, FLAG_INV_LOCKED);	3278	SET_FLAG (tmp2, FLAG_INV_LOCKED);
3256		3279
3257	insert_ob_in_ob (tmp2, who);	3280	who->insert (tmp2);
3258		3281
3259	/* Remove the old lantern */	3282	/* Remove the old lantern */
3260	if (who->type == PLAYER)
3261	esrv_del_item (who->contr, op->count);
3262
3263	op->destroy ();	3283	op->destroy ();
3264		3284
3265	/* insert the portion that was split off */	3285	/* insert the portion that was split off */
3266	if (tmp)	3286	if (tmp)
3267	{	3287	who->insert (tmp);
3268	insert_ob_in_ob (tmp, who);
3269	if (who->type == PLAYER)
3270	esrv_send_item (who, tmp);
3271	}
3272		3288
3273	who->update_stats ();	3289	who->update_stats ();
3274		3290
3275	if (QUERY_FLAG (op, FLAG_CURSED) || QUERY_FLAG (op, FLAG_DAMNED))	3291	if (QUERY_FLAG (op, FLAG_CURSED) || QUERY_FLAG (op, FLAG_DAMNED))
3276	if (who->type == PLAYER)	3292	if (who->type == PLAYER)
3277	{	3293	{
3278	new_draw_info (NDI_UNIQUE, 0, who, "Oops, it feels deadly cold!");	3294	who->failmsg ("Oops, it feels deadly cold! H<Maybe it wasn't such a bright (hrhrhr) idea to apply this cursed or damned item.>");
3279	SET_FLAG (tmp2, FLAG_KNOWN_CURSED);	3295	SET_FLAG (tmp2, FLAG_KNOWN_CURSED);
3280	}	3296	}
3281		3297
3282	if (who->type == PLAYER)
3283	esrv_send_item (who, tmp2);
3284
3285	return 0;	3298	return 0;
3286		3299
3287	/* this part is needed for skill-tools */	3300	case SKILL_TOOL:
		3301	// applying a skill tool also readies the skill
		3302	SET_FLAG (op, FLAG_APPLIED);
		3303
		3304	if (!(aflags & AP_NO_READY))
		3305	{
		3306	skop = find_skill_by_name (who, op->skill);
		3307	if (!skop->flag [FLAG_APPLIED])
		3308	apply_special (who, skop, AP_APPLY);
		3309	}
		3310	break;
		3311
3288	case SKILL:	3312	case SKILL:
3289	case SKILL_TOOL:
3290	if (who->chosen_skill)
3291	{
3292	LOG (llevError, "BUG: apply_special(): can't apply two skills\n");
3293	return 1;
3294	}
3295
3296	if (player *pl = who->contr)	3313	if (player *pl = who->contr)
3297	{	3314	{
3298	if (IS_COMBAT_SKILL (op->subtype))	3315	if (IS_COMBAT_SKILL (op->subtype))
3299	{	3316	{
3300	if (skill_flags [op->subtype] & SF_NEED_WEAPON)	3317	if (skill_flags [op->subtype] & SF_NEED_WEAPON)
3301	{	3318	{
3302	for (object *item = who->inv; item; item = item->below)	3319	for (object *item = who->inv; item; item = item->below)
3303	if (item->type == WEAPON && item->flag [FLAG_APPLIED])	3320	if (item->type == WEAPON && item->flag [FLAG_APPLIED])
3304	{	3321	{
		3322	if (item->skill == op->skill)
		3323	{
3305	who->change_weapon (pl->combat_ob = item);	3324	who->change_weapon (pl->combat_ob = item);
3306	goto found_weapon;	3325	goto found_weapon;
		3326	}
3307	}	3327	}
3308		3328
		3329	who->failmsg (format (
3309	new_draw_info (NDI_UNIQUE, 0, who, "You need to apply a melee weapon before readying this skill");	3330	"You need to apply a '%s' melee weapon before readying this skill. "
		3331	"H<Some skills need an item, in this case a melee weapon, to function.>",
		3332	&op->skill
		3333	));
3310	return 1;	3334	return 1;
3311		3335
3312	found_weapon:;	3336	found_weapon:;
3313	}	3337	}
3314	else	3338	else
…		…
3319	if (skill_flags [op->subtype] & SF_NEED_BOW)	3343	if (skill_flags [op->subtype] & SF_NEED_BOW)
3320	{	3344	{
3321	for (object *item = who->inv; item; item = item->below)	3345	for (object *item = who->inv; item; item = item->below)
3322	if (item->type == BOW && item->flag [FLAG_APPLIED])	3346	if (item->type == BOW && item->flag [FLAG_APPLIED])
3323	{	3347	{
		3348	//TODO: bows should/must all have skill missile weapon right now
3324	who->change_weapon (pl->ranged_ob = item);	3349	who->change_weapon (pl->ranged_ob = item);
3325	goto found_bow;	3350	goto found_bow;
3326	}	3351	}
3327		3352
		3353	who->failmsg (
3328	new_draw_info (NDI_UNIQUE, 0, who, "You need to apply a missile weapon before readying this skill");	3354	"You need to apply a missile weapon before readying this skill. "
		3355	"H<Some skills need an item, in this case a missile weapon, to function.>"
		3356	);
3329	return 1;	3357	return 1;
3330		3358
3331	found_bow:;	3359	found_bow:;
3332	}
3333	else if (skill_flags [op->subtype] & SF_NEED_ITEM)
3334	{
3335	for (object *item = who->inv; item; item = item->below)
3336	if (item->flag [FLAG_APPLIED]
3337	&& (item->type == WAND || item->type == ROD || item->type == HORN))
3338	{
3339	who->change_weapon (pl->ranged_ob = item);
3340	goto found_item;
3341	}
3342
3343	new_draw_info (NDI_UNIQUE, 0, who, "You need to apply a magic item before readying this skill");
3344	return 1;
3345
3346	found_item:;
3347	}	3360	}
3348	else	3361	else
3349	who->change_weapon (pl->ranged_ob = op);	3362	who->change_weapon (pl->ranged_ob = op);
3350	}	3363	}
3351		3364
3352	if (!op->invisible)	3365	if (!op->invisible)
3353	{	3366	{
3354	new_draw_info_format (NDI_UNIQUE, 0, who, "You ready %s.", query_name (op));	3367	who->statusmsg (format (
3355	new_draw_info_format (NDI_UNIQUE, 0, who, "You can now use the skill: %s.", &op->skill);	3368	"You ready %s."
		3369	"You can now use the skill: %s.",
		3370	query_name (op),
		3371	&op->skill
		3372	));
3356	}	3373	}
3357	else	3374	else
3358	new_draw_info_format (NDI_UNIQUE, 0, who, "Readied skill: %s.", op->skill ? &op->skill : &op->name);	3375	who->statusmsg (format ("Readied skill: %s.", op->skill ? &op->skill : &op->name));
3359	}	3376	}
3360		3377	else
		3378	{
3361	SET_FLAG (op, FLAG_APPLIED);	3379	SET_FLAG (op, FLAG_APPLIED);
3362	change_abil (who, op);	3380	change_abil (who, op);
3363	who->chosen_skill = op;	3381	who->chosen_skill = op;
3364	SET_FLAG (who, FLAG_READY_SKILL);	3382	SET_FLAG (who, FLAG_READY_SKILL);
		3383	}
		3384
3365	break;	3385	break;
3366		3386
3367	case BOW:	3387	case BOW:
3368	if (!check_weapon_power (who, op->last_eat))	3388	if (!check_weapon_power (who, op->last_eat))
3369	{	3389	{
3370	new_draw_info (NDI_UNIQUE, 0, who, "That weapon is too powerful for you to use.");	3390	who->failmsg ("That weapon is too powerful for you to use. It would consume your soul!" LACK_ITEM_POWER);
3371	new_draw_info (NDI_UNIQUE, 0, who, "It would consume your soul!.");
3372		3391
3373	if (tmp)	3392	if (tmp)
3374	insert_ob_in_ob (tmp, who);	3393	insert_ob_in_ob (tmp, who);
3375		3394
3376	return 1;	3395	return 1;
3377	}	3396	}
3378		3397
3379	if (op->level && (strncmp (op->name, who->name, strlen (who->name))))	3398	if (op->level && !op->name.starts_with (who->name))
3380	{	3399	{
3381	new_draw_info (NDI_UNIQUE, 0, who, "The weapon does not recognize you as its owner.");	3400	who->failmsg ("The weapon does not recognize you as its owner. "
		3401	"H<Its name indicates that it belongs to somebody else.>");
3382	if (tmp)	3402	if (tmp)
3383	insert_ob_in_ob (tmp, who);	3403	insert_ob_in_ob (tmp, who);
3384		3404
3385	return 1;	3405	return 1;
3386	}	3406	}
…		…
3391	case HORN:	3411	case HORN:
3392	/* check for skill, alter player status */	3412	/* check for skill, alter player status */
3393		3413
3394	if (!skop)	3414	if (!skop)
3395	{	3415	{
3396	new_draw_info_format (NDI_UNIQUE, 0, who, "The %s is broken, please report this to the dungeon master!", query_name (op));//TODO	3416	who->failmsg (format ("The %s is broken, please report this to the dungeon master!", query_name (op)));//TODO
3397	return 1;	3417	return 1;
3398	}	3418	}
3399		3419
3400	SET_FLAG (op, FLAG_APPLIED);	3420	SET_FLAG (op, FLAG_APPLIED);
3401	change_skill (who, skop, 0);	3421	who->change_skill (skop);
3402		3422
3403	if (who->contr)	3423	if (who->contr)
3404	{	3424	{
3405	who->contr->ranged_ob = op;	3425	who->contr->ranged_ob = op;
3406		3426
3407	new_draw_info_format (NDI_UNIQUE, 0, who, "You ready %s.", query_name (op));	3427	who->statusmsg (format ("You ready %s.", query_name (op)));
3408		3428
3409	if (op->type == BOW)	3429	if (op->type == BOW)
3410	{	3430	{
3411	who->current_weapon = op;	3431	who->current_weapon = op;
3412	change_abil (who, op);	3432	change_abil (who, op);
3413	new_draw_info_format (NDI_UNIQUE, 0, who,
3414	"You will now fire %s with %s.", op->race ? &op->race : "nothing", query_name (op));	3433	who->statusmsg (format ("You will now fire %s with %s.", op->race ? &op->race : "nothing", query_name (op)));
3415	}	3434	}
3416	}	3435	}
3417	else	3436	else
3418	{	3437	{
3419	if (op->type == BOW)	3438	if (op->type == BOW)
…		…
3425	break;	3444	break;
3426		3445
3427	case BUILDER:	3446	case BUILDER:
3428	if (who->type == PLAYER)	3447	if (who->type == PLAYER)
3429	{	3448	{
		3449	//TODO: wtf does this do? shouldn't this be managed automatically (slots?)
3430	if (who->contr->ranged_ob && who->contr->ranged_ob->type == BUILDER)	3450	if (who->contr->ranged_ob && who->contr->ranged_ob->type == BUILDER)
3431	unapply_special (who, who->contr->ranged_ob, 0);	3451	unapply_special (who, who->contr->ranged_ob, 0);
3432		3452
3433	new_draw_info_format (NDI_UNIQUE, 0, who, "You ready your %s.", query_name (op));	3453	who->statusmsg (format ("You ready your %s.", query_name (op)));
3434		3454
3435	who->contr->ranged_ob = op;	3455	who->contr->ranged_ob = op;
3436	}	3456	}
3437	break;	3457	break;
3438		3458
3439	default:	3459	default:
3440	new_draw_info_format (NDI_UNIQUE, 0, who, "You apply %s.", query_name (op));	3460	who->statusmsg (format ("You apply %s.", query_name (op)));
3441	} /* end of switch op->type */	3461	}
3442		3462
3443	SET_FLAG (op, FLAG_APPLIED);	3463	SET_FLAG (op, FLAG_APPLIED);
3444		3464
3445	if (tmp)	3465	if (tmp)
3446	tmp = insert_ob_in_ob (tmp, who);	3466	who->insert (tmp);
3447		3467
3448	who->update_stats ();	3468	who->update_stats ();
3449		3469
3450	/* We exclude spell casting objects. The fire code will set the	3470	/* We exclude spell casting objects. The fire code will set the
3451	* been applied flag when they are used - until that point,	3471	* been applied flag when they are used - until that point,
…		…
3453	*/	3473	*/
3454	if (who->type == PLAYER && op->type != WAND && op->type != HORN && op->type != ROD)	3474	if (who->type == PLAYER && op->type != WAND && op->type != HORN && op->type != ROD)
3455	SET_FLAG (op, FLAG_BEEN_APPLIED);	3475	SET_FLAG (op, FLAG_BEEN_APPLIED);
3456		3476
3457	if (QUERY_FLAG (op, FLAG_CURSED) || QUERY_FLAG (op, FLAG_DAMNED))	3477	if (QUERY_FLAG (op, FLAG_CURSED) || QUERY_FLAG (op, FLAG_DAMNED))
3458	{
3459	if (who->type == PLAYER)	3478	if (who->type == PLAYER)
3460	{	3479	{
3461	new_draw_info (NDI_UNIQUE, 0, who, "Oops, it feels deadly cold!");	3480	who->failmsg (
		3481	"Oops, it feels deadly cold! "
		3482	"H<Maybe it wasn't such a bright idea to apply this cursed or damned item.>"
		3483	);
3462	SET_FLAG (op, FLAG_KNOWN_CURSED);	3484	SET_FLAG (op, FLAG_KNOWN_CURSED);
3463	}	3485	}
3464	}
3465		3486
3466	if (who->type == PLAYER)	3487	if (object *pl = op->visible_to ())
3467	{
3468	/* if multiple objects were applied, update both slots */
3469	if (tmp)
3470	esrv_send_item (who, tmp);
3471
3472	esrv_send_item (who, op);	3488	esrv_send_item (pl, op);
3473	}
3474		3489
3475	return 0;	3490	return 0;
3476	}	3491	}
3477		3492
3478	int	3493	int
3479	monster_apply_special (object *who, object *op, int aflags)	3494	monster_apply_special (object *who, object *op, int aflags)
3480	{	3495	{
3481	if (QUERY_FLAG (op, FLAG_UNPAID) && !QUERY_FLAG (op, FLAG_APPLIED))	3496	if (QUERY_FLAG (op, FLAG_UNPAID) && !QUERY_FLAG (op, FLAG_APPLIED))
3482	return 1;	3497	return 1;
		3498
3483	return apply_special (who, op, aflags);	3499	return apply_special (who, op, aflags);
3484	}	3500	}
3485		3501
3486	/**	3502	/**
3487	* Map was just loaded, handle op's initialisation.	3503	* Map was just loaded, handle op's initialisation.
…		…
3491	int	3507	int
3492	auto_apply (object *op)	3508	auto_apply (object *op)
3493	{	3509	{
3494	object *tmp = NULL, *tmp2;	3510	object *tmp = NULL, *tmp2;
3495	int i;	3511	int i;
		3512
		3513	CLEAR_FLAG (op, FLAG_AUTO_APPLY);
3496		3514
3497	switch (op->type)	3515	switch (op->type)
3498	{	3516	{
3499	case SHOP_FLOOR:	3517	case SHOP_FLOOR:
3500	if (!op->has_random_items ())	3518	if (!op->has_random_items ())
…		…
3502		3520
3503	do	3521	do
3504	{	3522	{
3505	i = 10; /* let's give it 10 tries */	3523	i = 10; /* let's give it 10 tries */
3506	while ((tmp = generate_treasure (op->randomitems,	3524	while ((tmp = generate_treasure (op->randomitems,
3507	op->stats.exp ? (int) op->stats.exp : MAX (op->map->difficulty, 5))) == NULL && --i);	3525	op->stats.exp
		3526	? (int) op->stats.exp
		3527	: max (op->map->difficulty, 5)))
		3528	== NULL && --i);
		3529
3508	if (tmp == NULL)	3530	if (tmp == NULL)
3509	return 0;	3531	return 0;
		3532
3510	if (QUERY_FLAG (tmp, FLAG_CURSED) || QUERY_FLAG (tmp, FLAG_DAMNED))	3533	if (QUERY_FLAG (tmp, FLAG_CURSED) || QUERY_FLAG (tmp, FLAG_DAMNED))
3511	{	3534	{
3512	tmp->destroy ();	3535	tmp->destroy ();
3513	tmp = NULL;	3536	tmp = NULL;
3514	}	3537	}
…		…
3517		3540
3518	tmp->x = op->x;	3541	tmp->x = op->x;
3519	tmp->y = op->y;	3542	tmp->y = op->y;
3520	SET_FLAG (tmp, FLAG_UNPAID);	3543	SET_FLAG (tmp, FLAG_UNPAID);
3521	insert_ob_in_map (tmp, op->map, NULL, 0);	3544	insert_ob_in_map (tmp, op->map, NULL, 0);
3522	CLEAR_FLAG (op, FLAG_AUTO_APPLY);
3523	identify (tmp);	3545	identify (tmp);
3524	break;	3546	break;
3525		3547
3526	case TREASURE:	3548	case TREASURE:
3527	if (QUERY_FLAG (op, FLAG_IS_A_TEMPLATE))	3549	if (QUERY_FLAG (op, FLAG_IS_A_TEMPLATE))
…		…
3534	/* If we generated an object and put it in this object inventory,	3556	/* If we generated an object and put it in this object inventory,
3535	* move it to the parent object as the current object is about	3557	* move it to the parent object as the current object is about
3536	* to disappear. An example of this item is the random_* stuff	3558	* to disappear. An example of this item is the random_* stuff
3537	* that is put inside other objects.	3559	* that is put inside other objects.
3538	*/	3560	*/
3539	for (tmp = op->inv; tmp; tmp = tmp2)
3540	{
3541	tmp2 = tmp->below;
3542	tmp->remove ();
3543
3544	if (op->env)	3561	if (op->env)
3545	insert_ob_in_ob (tmp, op->env);	3562	while (op->inv)
3546	else	3563	op->env->insert (op->inv);
3547	tmp->destroy ();
3548	}
3549		3564
3550	op->destroy ();	3565	op->destroy ();
3551	break;	3566	break;
3552	}	3567	}
3553	return tmp ? 1 : 0;	3568
		3569	return !!tmp;
3554	}	3570	}
3555		3571
3556	/**	3572	/**
3557	* fix_auto_apply goes through the entire map every time a map	3573	* fix_auto_apply goes through the entire map every time a map
3558	* is loaded or swapped in and performs special actions for	3574	* is loaded or swapped in and performs special actions for
…		…
3572		3588
3573	if (tmp->inv)	3589	if (tmp->inv)
3574	{	3590	{
3575	object *invtmp, *invnext;	3591	object *invtmp, *invnext;
3576		3592
3577	for (invtmp = tmp->inv; invtmp != NULL; invtmp = invnext)	3593	for (invtmp = tmp->inv; invtmp; invtmp = invnext)
3578	{	3594	{
3579	invnext = invtmp->below;	3595	invnext = invtmp->below;
3580		3596
3581	if (QUERY_FLAG (invtmp, FLAG_AUTO_APPLY))	3597	if (QUERY_FLAG (invtmp, FLAG_AUTO_APPLY))
3582	auto_apply (invtmp);	3598	auto_apply (invtmp);
3583	else if (invtmp->type == TREASURE && invtmp->has_random_items ())	3599	else if (invtmp->type == TREASURE && invtmp->has_random_items ())
3584	{	3600	{
3585	while ((invtmp->stats.hp--) > 0)	3601	while (invtmp->stats.hp-- > 0)
3586	create_treasure (invtmp->randomitems, invtmp, 0, difficulty, 0);	3602	create_treasure (invtmp->randomitems, invtmp, 0, difficulty, 0);
3587		3603
3588	invtmp->randomitems = NULL;	3604	invtmp->randomitems = NULL;
3589	}	3605	}
3590	else if (invtmp && invtmp->arch	3606	else if (invtmp && invtmp->arch
…		…
3702	/* check for hp, sp change */	3718	/* check for hp, sp change */
3703	if (food->stats.hp != 0)	3719	if (food->stats.hp != 0)
3704	{	3720	{
3705	if (QUERY_FLAG (food, FLAG_CURSED))	3721	if (QUERY_FLAG (food, FLAG_CURSED))
3706	{	3722	{
3707	assign (who->contr->killer, food->name);	3723	who->contr->killer = food;
3708	hit_player (who, food->stats.hp, food, AT_POISON, 1);	3724	hit_player (who, food->stats.hp, food, AT_POISON, 1);
3709	new_draw_info (NDI_UNIQUE, 0, who, "Eck!...that was poisonous!");	3725	who->failmsg ("Eck!...that was poisonous!");
3710	}	3726	}
3711	else	3727	else
3712	{	3728	{
3713	if (food->stats.hp > 0)	3729	if (food->stats.hp > 0)
3714	new_draw_info (NDI_UNIQUE, 0, who, "You begin to feel better.");	3730	who->statusmsg ("You begin to feel better.");
3715	else	3731	else
3716	new_draw_info (NDI_UNIQUE, 0, who, "Eck!...that was poisonous!");	3732	who->failmsg ("Eck!...that was poisonous!");
		3733
3717	who->stats.hp += food->stats.hp;	3734	who->stats.hp += food->stats.hp;
3718	}	3735	}
3719	}	3736	}
		3737
3720	if (food->stats.sp != 0)	3738	if (food->stats.sp != 0)
3721	{	3739	{
3722	if (QUERY_FLAG (food, FLAG_CURSED))	3740	if (QUERY_FLAG (food, FLAG_CURSED))
3723	{	3741	{
3724	new_draw_info (NDI_UNIQUE, 0, who, "You are drained of mana!");	3742	who->failmsg ("You are drained of mana!");
3725	who->stats.sp -= food->stats.sp;	3743	who->stats.sp -= food->stats.sp;
3726	if (who->stats.sp < 0)	3744	if (who->stats.sp < 0)
3727	who->stats.sp = 0;	3745	who->stats.sp = 0;
3728	}	3746	}
3729	else	3747	else
3730	{	3748	{
3731	new_draw_info (NDI_UNIQUE, 0, who, "You feel a rush of magical energy!");	3749	who->statusmsg ("You feel a rush of magical energy!");
3732	who->stats.sp += food->stats.sp;	3750	who->stats.sp += food->stats.sp;
3733	/* place limit on max sp from food? */	3751	/* place limit on max sp from food? */
3734	}	3752	}
3735	}	3753	}
		3754
3736	who->update_stats ();	3755	who->update_stats ();
3737	}	3756	}
3738		3757
3739	/**	3758	/**
3740	* Designed primarily to light torches/lanterns/etc.	3759	* Designed primarily to light torches/lanterns/etc.
…		…
3750	item = find_marked_object (who);	3769	item = find_marked_object (who);
3751	if (item)	3770	if (item)
3752	{	3771	{
3753	if (lighter->last_eat && lighter->stats.food)	3772	if (lighter->last_eat && lighter->stats.food)
3754	{ /* lighter gets used up */	3773	{ /* lighter gets used up */
3755	/* Split multiple lighters if they're being used up. Otherwise *
3756	* one charge from each would be used up. --DAMN */
3757	if (lighter->nrof > 1)
3758	{
3759	object *oneLighter = lighter->clone ();	3774	object *oneLighter = lighter->split ();
3760
3761	lighter->nrof -= 1;
3762	oneLighter->nrof = 1;
3763	oneLighter->stats.food--;	3775	oneLighter->stats.food--;
3764	esrv_send_item (who, lighter);	3776	who->insert (oneLighter);
3765	oneLighter = insert_ob_in_ob (oneLighter, who);
3766	esrv_send_item (who, oneLighter);
3767	}
3768	else
3769	lighter->stats.food--;
3770	}	3777	}
3771	else if (lighter->last_eat)	3778	else if (lighter->last_eat)
		3779	{
3772	{ /* no charges left in lighter */	3780	/* no charges left in lighter */
3773	new_draw_info_format (NDI_UNIQUE, 0, who, "You attempt to light the %s with a used up %s.", &item->name, &lighter->name);	3781	who->failmsg (format ("You attempt to light the %s with a used up %s.", &item->name, &lighter->name));
3774	return;	3782	return;
3775	}	3783	}
3776		3784
3777	/* Perhaps we should split what we are trying to light on fire?	3785	/* Perhaps we should split what we are trying to light on fire?
3778	* I can't see many times when you would want to light multiple	3786	* I can't see many times when you would want to light multiple
…		…
3784		3792
3785	save_throw_object (item, AT_FIRE, who);	3793	save_throw_object (item, AT_FIRE, who);
3786		3794
3787	if (item->destroyed ())	3795	if (item->destroyed ())
3788	{	3796	{
3789	new_draw_info_format (NDI_UNIQUE, 0, who, "You light the %s with the %s.", &item->name, &lighter->name);	3797	who->statusmsg (format ("You light the %s with the %s.", &item->name, &lighter->name));
3790	/* Need to update the player so that the players glow radius	3798	/* Need to update the player so that the players glow radius
3791	* gets changed.	3799	* gets changed.
3792	*/	3800	*/
3793	if (is_player_env)	3801	if (is_player_env)
3794	who->update_stats ();	3802	who->update_stats ();
3795	}	3803	}
3796	else	3804	else
3797	new_draw_info_format (NDI_UNIQUE, 0, who, "You attempt to light the %s with the %s and fail.", &item->name, &lighter->name);	3805	who->failmsg (format ("You attempt to light the %s with the %s and fail.", &item->name, &lighter->name));
3798	}	3806	}
3799	else /* nothing to light */	3807	else
3800	new_draw_info (NDI_UNIQUE, 0, who, "You need to mark a lightable object.");	3808	who->failmsg ("You need to mark a lightable object.");
3801
3802	}	3809	}
3803		3810
3804	/**	3811	/**
3805	* op made some mistake with a scroll, this takes care of punishment.	3812	* op made some mistake with a scroll, this takes care of punishment.
3806	* scroll_failure()- hacked directly from spell_failure	3813	* scroll_failure()- hacked directly from spell_failure
…		…
3813		3820
3814	if (failure <= -1 && failure > -15)	3821	if (failure <= -1 && failure > -15)
3815	{ /* wonder */	3822	{ /* wonder */
3816	object *tmp;	3823	object *tmp;
3817		3824
3818	new_draw_info (NDI_UNIQUE, 0, op, "Your spell warps!.");	3825	op->failmsg ("Your spell warps!");
3819	tmp = get_archetype (SPELL_WONDER);	3826	tmp = get_archetype (SPELL_WONDER);
3820	cast_wonder (op, op, 0, tmp);	3827	cast_wonder (op, op, 0, tmp);
3821	tmp->destroy ();	3828	tmp->destroy ();
3822	}	3829	}
3823	else if (failure <= -15 && failure > -35)	3830	else if (failure <= -15 && failure > -35)
3824	{ /* drain mana */	3831	{ /* drain mana */
3825	new_draw_info (NDI_UNIQUE, 0, op, "Your mana is drained!.");	3832	op->failmsg ("Your mana is drained!");
3826	op->stats.sp -= random_roll (0, power - 1, op, PREFER_LOW);	3833	op->stats.sp -= random_roll (0, power - 1, op, PREFER_LOW);
3827	if (op->stats.sp < 0)	3834	if (op->stats.sp < 0)
3828	op->stats.sp = 0;	3835	op->stats.sp = 0;
3829	}	3836	}
3830	else if (settings.spell_failure_effects == TRUE)	3837	else if (settings.spell_failure_effects == TRUE)
3831	{	3838	{
3832	if (failure <= -35 && failure > -60)	3839	if (failure <= -35 && failure > -60)
3833	{ /* confusion */	3840	{ /* confusion */
3834	new_draw_info (NDI_UNIQUE, 0, op, "The magic recoils on you!");	3841	op->failmsg ("The magic recoils on you!");
3835	confuse_player (op, op, power);	3842	confuse_player (op, op, power);
3836	}	3843	}
3837	else if (failure <= -60 && failure > -70)	3844	else if (failure <= -60 && failure > -70)
3838	{ /* paralysis */	3845	{ /* paralysis */
3839	new_draw_info (NDI_UNIQUE, 0, op, "The magic recoils and paralyzes " "you!");	3846	op->failmsg ("The magic recoils and paralyzes you!");
3840	paralyze_player (op, op, power);	3847	paralyze_player (op, op, power);
3841	}	3848	}
3842	else if (failure <= -70 && failure > -80)	3849	else if (failure <= -70 && failure > -80)
3843	{ /* blind */	3850	{ /* blind */
3844	new_draw_info (NDI_UNIQUE, 0, op, "The magic recoils on you!");	3851	op->failmsg ("The magic recoils on you!");
3845	blind_player (op, op, power);	3852	blind_player (op, op, power);
3846	}	3853	}
3847	else if (failure <= -80)	3854	else if (failure <= -80)
3848	{ /* blast the immediate area */	3855	{ /* blast the immediate area */
3849	object *tmp = get_archetype (LOOSE_MANA);	3856	object *tmp = get_archetype (LOOSE_MANA);
3850	cast_magic_storm (op, tmp, power);	3857	cast_magic_storm (op, tmp, power);
3851	new_draw_info (NDI_UNIQUE, 0, op, "You unleash uncontrolled mana!");	3858	op->failmsg ("You unleash uncontrolled mana!");
3852	tmp->destroy ();	3859	tmp->destroy ();
3853	}	3860	}
3854	}	3861	}
3855	}	3862	}
3856		3863
…		…
3876	*/	3883	*/
3877	int i, j;	3884	int i, j;
3878		3885
3879	for (i = 0; i < NUM_STATS; i++)	3886	for (i = 0; i < NUM_STATS; i++)
3880	{	3887	{
3881	int race_bonus = pl->arch->clone.stats.stat (i);	3888	int race_bonus = pl->arch->stats.stat (i);
3882	sint8 stat = stats->stat (i) + ns->stat (i);	3889	sint8 stat = stats->stat (i) + ns->stat (i);
3883		3890
3884	if (stat > 20 + race_bonus)	3891	if (stat > 20 + race_bonus)
3885	{	3892	{
3886	excess_stat++;	3893	excess_stat++;
…		…
3896		3903
3897	if (i == CHA)	3904	if (i == CHA)
3898	continue; /* exclude cha from this */	3905	continue; /* exclude cha from this */
3899		3906
3900	int stat = stats->stat (i);	3907	int stat = stats->stat (i);
3901	int race_bonus = pl->arch->clone.stats.stat (i);	3908	int race_bonus = pl->arch->stats.stat (i);
3902	if (stat < 20 + race_bonus)	3909	if (stat < 20 + race_bonus)
3903	{	3910	{
3904	change_attr_value (stats, i, 1);	3911	change_attr_value (stats, i, 1);
3905	excess_stat--;	3912	excess_stat--;
3906	}	3913	}
3907	}	3914	}
3908		3915
3909	/* insert the randomitems from the change's treasurelist into	3916	/* insert the randomitems from the change's treasurelist into
3910	* the player ref: player.c	3917	* the player ref: player.c
3911	*/	3918	*/
3912	if (change->randomitems != NULL)	3919	if (change->randomitems)
3913	give_initial_items (pl, change->randomitems);	3920	give_initial_items (pl, change->randomitems);
3914		3921
3915	/* set up the face, for some races. */	3922	/* set up the face, for some races. */
3916		3923
3917	/* first, look for the force object banning	3924	/* first, look for the force object banning
3918	* changing the face. Certain races never change face with class.	3925	* changing the face. Certain races never change face with class.
3919	*/	3926	*/
3920	for (walk = pl->inv; walk != NULL; walk = walk->below)	3927	for (walk = pl->inv; walk; walk = walk->below)
3921	if (!strcmp (walk->name, "NOCLASSFACECHANGE"))	3928	if (walk->name == shstr_NOCLASSFACECHANGE)
3922	flag_change_face = 0;	3929	flag_change_face = 0;
3923		3930
3924	if (flag_change_face)	3931	if (flag_change_face)
3925	{	3932	{
3926	pl->animation_id = GET_ANIM_ID (change);
3927	pl->face = change->face;	3933	pl->face = change->face;
3928		3934	pl->animation_id = change->animation_id;
3929	if (QUERY_FLAG (change, FLAG_ANIMATE))	3935	pl->flag [FLAG_ANIMATE] = change->flag [FLAG_ANIMATE];
3930	SET_FLAG (pl, FLAG_ANIMATE);
3931	else
3932	CLEAR_FLAG (pl, FLAG_ANIMATE);
3933	}	3936	}
3934		3937
3935	/* check the special case of can't use weapons */	3938	/* check the special case of can't use weapons */
3936	/*if(QUERY_FLAG(change,FLAG_USE_WEAPON)) CLEAR_FLAG(pl,FLAG_USE_WEAPON); */	3939	/*if(QUERY_FLAG(change,FLAG_USE_WEAPON)) CLEAR_FLAG(pl,FLAG_USE_WEAPON); */
3937	if (!strcmp (change->name, "monk"))	3940	if (change->name == shstr_monk)
3938	CLEAR_FLAG (pl, FLAG_USE_WEAPON);	3941	CLEAR_FLAG (pl, FLAG_USE_WEAPON);
3939		3942
3940	break;	3943	break;
3941	}	3944	}
3942	}	3945	}
…		…
3963	char got[MAX_BUF];	3966	char got[MAX_BUF];
3964	int len;	3967	int len;
3965		3968
3966	if (!pl || !transformer)	3969	if (!pl || !transformer)
3967	return;	3970	return;
		3971
3968	marked = find_marked_object (pl);	3972	marked = find_marked_object (pl);
		3973
3969	if (!marked)	3974	if (!marked)
3970	{	3975	{
3971	new_draw_info_format (NDI_UNIQUE, 0, pl, "Use the %s with what item?", query_name (transformer));	3976	pl->failmsg (format ("Use the %s with what item?", query_name (transformer)));
3972	return;	3977	return;
3973	}	3978	}
		3979
3974	if (!marked->slaying)	3980	if (!marked->slaying)
3975	{	3981	{
3976	new_draw_info_format (NDI_UNIQUE, 0, pl, "You can't use the %s with your %s!", query_name (transformer), query_name (marked));	3982	pl->failmsg (format ("You can't use the %s with your %s!", query_name (transformer), query_name (marked)));
3977	return;	3983	return;
3978	}	3984	}
		3985
3979	/* check whether they are compatible or not */	3986	/* check whether they are compatible or not */
3980	find = strstr (marked->slaying, transformer->arch->name);	3987	find = strstr (&marked->slaying, transformer->arch->archname);
3981	if (!find || (*(find + strlen (transformer->arch->name)) != ':'))	3988	if (!find || (*(find + strlen (transformer->arch->archname)) != ':'))
3982	{	3989	{
3983	new_draw_info_format (NDI_UNIQUE, 0, pl, "You can't use the %s with your %s!", query_name (transformer), query_name (marked));	3990	pl->failmsg (format ("You can't use the %s with your %s!", query_name (transformer), query_name (marked)));
3984	return;	3991	return;
3985	}	3992	}
		3993
3986	find += strlen (transformer->arch->name) + 1;	3994	find += strlen (transformer->arch->archname) + 1;
3987	/* Item can be used, now find how many and what it yields */	3995	/* Item can be used, now find how many and what it yields */
3988	if (isdigit (*(find)))	3996	if (isdigit (*(find)))
3989	{	3997	{
3990	yield = atoi (find);	3998	yield = atoi (find);
3991	if (yield < 1)	3999	if (yield < 1)
…		…
3997	else	4005	else
3998	yield = 1;	4006	yield = 1;
3999		4007
4000	while (isdigit (*find))	4008	while (isdigit (*find))
4001	find++;	4009	find++;
		4010
4002	while (*find == ' ')	4011	while (*find == ' ')
4003	find++;	4012	find++;
		4013
4004	memset (got, 0, MAX_BUF);	4014	memset (got, 0, MAX_BUF);
		4015
4005	if ((separator = strchr (find, ';')) != NULL)	4016	if ((separator = strchr (find, ';')) != NULL)
4006	{
4007	len = separator - find;	4017	len = separator - find;
4008	}
4009	else	4018	else
4010	{
4011	len = strlen (find);	4019	len = strlen (find);
4012	}	4020
4013	if (len > MAX_BUF - 1)	4021	if (len > MAX_BUF - 1)
4014	len = MAX_BUF - 1;	4022	len = MAX_BUF - 1;
		4023
4015	strcpy (got, find);	4024	strcpy (got, find);
4016	got[len] = '\0';	4025	got[len] = '\0';
4017		4026
4018	/* Now create new item, remove used ones when required. */	4027	/* Now create new item, remove used ones when required. */
4019	new_item = get_archetype (got);	4028	new_item = get_archetype (got);
4020	if (!new_item)	4029	if (!new_item)
4021	{	4030	{
4022	new_draw_info_format (NDI_UNIQUE, 0, pl, "This %s is strange, better to not use it.", query_base_name (marked, 0));	4031	pl->failmsg (format ("This %s is strange, better to not use it.", query_base_name (marked, 0)));
4023	return;	4032	return;
4024	}	4033	}
4025		4034
4026	new_item->nrof = yield;	4035	new_item->nrof = yield;
		4036
4027	new_draw_info_format (NDI_UNIQUE, 0, pl, "You %s the %s.", &transformer->slaying, query_base_name (marked, 0));	4037	pl->statusmsg (format ("You %s the %s.", &transformer->slaying, query_base_name (marked, 0)));
4028	insert_ob_in_ob (new_item, pl);	4038
4029	esrv_send_inventory (pl, pl);	4039	pl->insert (new_item);
4030	/* Eat up one item */	4040	/* Eat up one item */
4031	decrease_ob_nr (marked, 1);	4041	marked->decrease ();
		4042
4032	/* Eat one transformer if needed */	4043	/* Eat one transformer if needed */
4033	if (transformer->stats.food)	4044	if (transformer->stats.food)
4034	if (--transformer->stats.food == 0)	4045	if (--transformer->stats.food == 0)
4035	decrease_ob_nr (transformer, 1);	4046	transformer->decrease ();
4036	}	4047	}
		4048

Diff Legend

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