ViewVC Help

View File | Revision Log | Show Annotations | Download File

/cvs/deliantra/server/server/c_object.C

Comparing deliantra/server/server/c_object.C (file contents):
Revision 1.25 by root, Tue Dec 12 21:39:57 2006 UTC vs.
Revision 1.82 by elmex, Tue Oct 7 11:10:30 2008 UTC

1	/*	1	/*
2	CrossFire, A Multiplayer game for X-windows	2	* This file is part of Deliantra, the Roguelike Realtime MMORPG.
3		3	*
		4	* Copyright (©) 2005,2006,2007,2008 Marc Alexander Lehmann / Robin Redeker / the Deliantra team
4	Copyright (C) 2002 Mark Wedel & Crossfire Development Team	5	* Copyright (©) 2002,2007 Mark Wedel & Crossfire Development Team
5	Copyright (C) 1992 Frank Tore Johansen	6	* Copyright (©) 1992,2007 Frank Tore Johansen
6		7	*
7	This program is free software; you can redistribute it and/or modify	8	* Deliantra is free software: you can redistribute it and/or modify
8	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
9	the Free Software Foundation; either version 2 of the License, or	10	* the Free Software Foundation, either version 3 of the License, or
10	(at your option) any later version.	11	* (at your option) any later version.
11		12	*
12	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,
13	but WITHOUT ANY WARRANTY; without even the implied warranty of	14	* but WITHOUT ANY WARRANTY; without even the implied warranty of
14	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the	15	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15	GNU General Public License for more details.	16	* GNU General Public License for more details.
16		17	*
17	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
18	along with this program; if not, write to the Free Software	19	* along with this program. If not, see <http://www.gnu.org/licenses/>.
19	Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.	20	*
		21	* The authors can be reached via e-mail to <support@deliantra.net>
		22	*/
20		23
21	The author can be reached via e-mail to <crossfire@schmorp.de>	24	/*
22
23	Object (handling) commands	25	* Object (handling) commands
24	*/	26	*/
25		27
26	#include <global.h>	28	#include <global.h>
27	#include <loader.h>	29	#include <loader.h>
28	#include <skills.h>	30	#include <skills.h>
29	#ifndef __CEXTRACT__
30	# include <sproto.h>	31	#include <sproto.h>
31	#endif
32	#include <living.h>	32	#include <living.h>
33	#include <math.h>	33	#include <math.h>
34		34
35	/*	35	/*
36	* Object id parsing functions	36	* Object id parsing functions
…		…
56	* only unapply applied, or apply unapplied objects	56	* only unapply applied, or apply unapplied objects
57	**/	57	**/
58	static object *	58	static object *
59	find_best_apply_object_match (object *pl, const char *params, enum apply_flag aflag)	59	find_best_apply_object_match (object *pl, const char *params, enum apply_flag aflag)
60	{	60	{
61	object *tmp, *best = NULL;	61	object *best = 0;
62	int match_val = 0, tmpmatch;	62	int match_val = 0;
63		63
64	for (tmp = pl->inv; tmp; tmp = tmp->below)	64	for (object *tmp = pl->inv; tmp; tmp = tmp->below)
65	{	65	{
66	if (tmp->invisible)	66	if (tmp->invisible)
67	continue;	67	continue;
		68
68	if ((tmpmatch = item_matched_string (pl, tmp, params)) > match_val)	69	int tmpmatch = item_matched_string (pl, tmp, params);
		70
		71	if (tmpmatch > match_val)
69	{	72	{
70	if ((aflag == AP_APPLY) && (QUERY_FLAG (tmp, FLAG_APPLIED)))	73	if ((aflag == AP_APPLY) && (QUERY_FLAG (tmp, FLAG_APPLIED)))
71	continue;	74	continue;
		75
72	if ((aflag == AP_UNAPPLY) && (!QUERY_FLAG (tmp, FLAG_APPLIED)))	76	if ((aflag == AP_UNAPPLY) && (!QUERY_FLAG (tmp, FLAG_APPLIED)))
73	continue;	77	continue;
		78
74	match_val = tmpmatch;	79	match_val = tmpmatch;
75	best = tmp;	80	best = tmp;
76	}	81	}
77	}	82	}
		83
78	return best;	84	return best;
79	}	85	}
80		86
81	/**	87	/**
82	* Shortcut to find_best_apply_object_match(pl, params, AF_NULL);	88	* Shortcut to find_best_apply_object_match(pl, params, AF_NULL);
83	**/	89	**/
84	object *	90	object *
85	find_best_object_match (object *pl, const char *params)	91	find_best_object_match (object *pl, const char *params)
86	{	92	{
87	return find_best_apply_object_match (pl, params, AP_NULL);	93	return find_best_apply_object_match (pl, params, AP_TOGGLE);
		94	}
		95
		96	static bool
		97	can_split (object *pl, object *&op, sint32 nrof)
		98	{
		99	if (object *tmp = op->split (nrof ? nrof : op->number_of ()))
		100	{
		101	op = tmp;
		102	return true;
		103	}
		104	else
		105	{
		106	if (op->nrof > 1)
		107	new_draw_info_format (NDI_UNIQUE, 0, pl, "There are only %d %s.", op->nrof, &op->name_pl);
		108	else
		109	new_draw_info_format (NDI_UNIQUE, 0, pl, "There is only one %s.", &op->name);
		110
		111	return false;
		112	}
88	}	113	}
89		114
90	int	115	int
91	command_uskill (object *pl, char *params)	116	command_uskill (object *pl, char *params)
92	{	117	{
93	if (!params)	118	if (!params)
94	{	119	{
95	new_draw_info (NDI_UNIQUE, 0, pl, "Usage: use_skill <skill name>");	120	new_draw_info (NDI_UNIQUE, 0, pl, "Usage: use_skill <skill name>");
96	return 0;	121	return 0;
97	}	122	}
		123
98	return use_skill (pl, params);	124	return use_skill (pl, params);
99	}	125	}
100		126
101	int	127	int
102	command_rskill (object *pl, char *params)	128	command_rskill (object *pl, char *params)
…		…
106	if (!params)	132	if (!params)
107	{	133	{
108	new_draw_info (NDI_UNIQUE, 0, pl, "Usage: ready_skill <skill name>");	134	new_draw_info (NDI_UNIQUE, 0, pl, "Usage: ready_skill <skill name>");
109	return 0;	135	return 0;
110	}	136	}
		137
111	skill = find_skill_by_name (pl, params);	138	skill = find_skill_by_name (pl, params);
112		139
113	if (!skill)	140	if (!skill)
114	{	141	{
115	new_draw_info_format (NDI_UNIQUE, 0, pl, "You have no knowledge of the skill %s", params);	142	new_draw_info_format (NDI_UNIQUE, 0, pl, "You have no knowledge of the skill %s", params);
116	return 0;	143	return 0;
117	}	144	}
118	return change_skill (pl, skill, 0);
119	}
120		145
		146	pl->change_skill (0);
		147	apply_special (pl, skill, AP_APPLY);
		148	return 1;
		149	}
121		150
122	/* These functions (command_search, command_disarm) are really just wrappers for	151	/* These functions (command_search, command_disarm) are really just wrappers for
123	* things like 'use_skill ...'). In fact, they should really be obsoleted	152	* things like 'use_skill ...'). In fact, they should really be obsoleted
124	* and replaced with those.	153	* and replaced with those.
125	*/	154	*/
…		…
133	command_disarm (object *op, char *params)	162	command_disarm (object *op, char *params)
134	{	163	{
135	return use_skill (op, skill_names[SK_DISARM_TRAPS]);	164	return use_skill (op, skill_names[SK_DISARM_TRAPS]);
136	}	165	}
137		166
138
139	/* A little special because we do want to pass the full params along	167	/* A little special because we do want to pass the full params along
140	* as it includes the object to throw.	168	* as it includes the object to throw.
141	*/	169	*/
142	int	170	int
143	command_throw (object *op, char *params)	171	command_throw (object *op, char *params)
144	{	172	{
145	object *skop;
146
147	skop = find_skill_by_name (op, skill_names[SK_THROWING]);	173	if (object *skop = find_skill_by_name (op, skill_names[SK_THROWING]))
148	if (skop)
149	return do_skill (op, op, skop, op->facing, params);	174	return do_skill (op, op, skop, op->facing, params);
150	else	175	else
151	{
152	new_draw_info (NDI_UNIQUE, 0, op, "You have no knowledge of the skill throwing.");	176	new_draw_info (NDI_UNIQUE, 0, op, "You have no knowledge of the skill throwing.");
153	}	177
154	return 0;	178	return 0;
155	}	179	}
156
157		180
158	int	181	int
159	command_apply (object *op, char *params)	182	command_apply (object *op, char *params)
160	{	183	{
161	if (!params)	184	if (!params)
…		…
163	player_apply_below (op);	186	player_apply_below (op);
164	return 0;	187	return 0;
165	}	188	}
166	else	189	else
167	{	190	{
168	apply_flag aflag = (apply_flag) 0;	191	apply_flag aflag = (apply_flag)0;
169	object *inv;
170		192
171	while (*params == ' ')	193	while (*params == ' ')
172	params++;	194	params++;
		195
173	if (!strncmp (params, "-a ", 3))	196	if (!strncmp (params, "-a ", 3))
174	{	197	{
175	aflag = AP_APPLY;	198	aflag = AP_APPLY;
176	params += 3;	199	params += 3;
177	}	200	}
		201
178	if (!strncmp (params, "-u ", 3))	202	if (!strncmp (params, "-u ", 3))
179	{	203	{
180	aflag = AP_UNAPPLY;	204	aflag = AP_UNAPPLY;
181	params += 3;	205	params += 3;
182	}	206	}
		207
183	while (*params == ' ')	208	while (*params == ' ')
184	params++;	209	params++;
185		210
186	inv = find_best_apply_object_match (op, params, aflag);	211	if (object *inv = find_best_apply_object_match (op, params, aflag))
187	if (inv)
188	{
189	player_apply (op, inv, aflag, 0);	212	player_apply (op, inv, aflag, 0);
190	}
191	else	213	else
192	new_draw_info_format (NDI_UNIQUE, 0, op, "Could not find any match to the %s.", params);	214	new_draw_info_format (NDI_UNIQUE, 0, op, "Could not find any match to the %s.", params);
193	}	215	}
		216
194	return 0;	217	return 0;
195	}	218	}
196		219
197	/*	220	/*
198	* Check if an item op can be put into a sack. If pl exists then tell	221	* Check if an item op can be put into a sack. If pl exists then tell
…		…
204	* not need to use split_ob and stuff.	227	* not need to use split_ob and stuff.
205	*/	228	*/
206	int	229	int
207	sack_can_hold (object *pl, object *sack, object *op, uint32 nrof)	230	sack_can_hold (object *pl, object *sack, object *op, uint32 nrof)
208	{	231	{
209
210	if (!QUERY_FLAG (sack, FLAG_APPLIED))	232	if (!QUERY_FLAG (sack, FLAG_APPLIED))
211	{	233	{
212	new_draw_info_format (NDI_UNIQUE, 0, pl, "The %s is not active.", query_name (sack));	234	new_draw_info_format (NDI_UNIQUE, 0, pl, "The %s is not active.", query_name (sack));
213	return 0;	235	return 0;
214	}	236	}
		237
215	if (sack == op)	238	if (sack == op)
216	{	239	{
217	new_draw_info_format (NDI_UNIQUE, 0, pl, "You can't put the %s into itself.", query_name (sack));	240	new_draw_info_format (NDI_UNIQUE, 0, pl, "You can't put the %s into itself.", query_name (sack));
218	return 0;	241	return 0;
219	}	242	}
		243
220	if (sack->race && (sack->race != op->race || op->type == CONTAINER || (sack->stats.food && sack->stats.food != op->type)))	244	if (sack->race && (sack->race != op->race || op->type == CONTAINER || (sack->stats.food && sack->stats.food != op->type)))
221	{	245	{
222	new_draw_info_format (NDI_UNIQUE, 0, pl, "You can put only %s into the %s.", &sack->race, query_name (sack));	246	new_draw_info_format (NDI_UNIQUE, 0, pl, "You can put only %s into the %s.", &sack->race, query_name (sack));
223	return 0;	247	return 0;
224	}	248	}
		249
225	if (op->type == SPECIAL_KEY && sack->slaying && op->slaying)	250	if (op->type == SPECIAL_KEY && sack->slaying && op->slaying)
226	{	251	{
227	new_draw_info_format (NDI_UNIQUE, 0, pl, "You can't put the key into %s.", query_name (sack));	252	new_draw_info_format (NDI_UNIQUE, 0, pl, "You can't put the key into %s.", query_name (sack));
228	return 0;	253	return 0;
229	}	254	}
		255
230	if (sack->weight_limit && (sint32) (sack->carrying + (nrof ? nrof : 1) *	256	if (sack->weight_limit && (sint32) (sack->carrying + (nrof ? nrof : 1) *
231	(op->weight + (op->type == CONTAINER ? (op->carrying * op->stats.Str) : 0))	257	(op->weight + (op->type == CONTAINER ? (op->carrying * op->stats.Str) : 0))
232	* (100 - sack->stats.Str) / 100) > sack->weight_limit)	258	* (100 - sack->stats.Str) / 100) > sack->weight_limit)
233	{	259	{
234	new_draw_info_format (NDI_UNIQUE, 0, pl, "That won't fit in the %s!", query_name (sack));	260	new_draw_info_format (NDI_UNIQUE, 0, pl, "That won't fit in the %s!", query_name (sack));
235	return 0;	261	return 0;
236	}	262	}
		263
237	/* All other checks pass, must be OK */	264	/* All other checks pass, must be OK */
238	return 1;	265	return 1;
239	}	266	}
240		267
241	/* Pick up commands follow */	268	/* Pick up commands follow */
…		…
246	* pick up (0 means all of them)	273	* pick up (0 means all of them)
247	*/	274	*/
248	static void	275	static void
249	pick_up_object (object *pl, object *op, object *tmp, int nrof)	276	pick_up_object (object *pl, object *op, object *tmp, int nrof)
250	{	277	{
251	/* buf needs to be big (more than 256 chars) because you can get
252	* very long item names.
253	*/
254	char buf[HUGE_BUF];
255	object *env = tmp->env;	278	object *env = tmp->env;
256	uint32 weight, effective_weight_limit;	279	uint32 weight, effective_weight_limit;
257	int tmp_nrof = tmp->nrof ? tmp->nrof : 1;	280	int tmp_nrof = tmp->number_of ();
258		281
259	/* IF the player is flying & trying to take the item out of a container	282	/* IF the player is flying & trying to take the item out of a container
260	* that is in his inventory, let him. tmp->env points to the container	283	* that is in his inventory, let him. tmp->env points to the container
261	* (sack, luggage, etc), tmp->env->env then points to the player (nested	284	* (sack, luggage, etc), tmp->env->env then points to the player (nested
262	* containers not allowed as of now)	285	* containers not allowed as of now)
263	*/	286	*/
264	if ((pl->move_type & MOVE_FLYING) && !QUERY_FLAG (pl, FLAG_WIZ) && is_player_inv (tmp) != pl)	287	if ((pl->move_type & MOVE_FLYING) && !QUERY_FLAG (pl, FLAG_WIZ) && tmp->in_player () != pl)
265	{	288	{
266	new_draw_info (NDI_UNIQUE, 0, pl, "You are levitating, you can't reach the ground!");	289	pl->failmsg ("You are levitating, you can't reach the ground! "
		290	"H<You have to stop levitating first, if you can, either by using your levitation skill, "
		291	"or waiting till the levitation effect wears off.>");
267	return;	292	return;
268	}	293	}
269		294
270	if (QUERY_FLAG (tmp, FLAG_NO_DROP))	295	if (QUERY_FLAG (tmp, FLAG_NO_DROP))
271	return;	296	return;
272		297
273	if (QUERY_FLAG (tmp, FLAG_WAS_WIZ) && !QUERY_FLAG (pl, FLAG_WAS_WIZ))
274	{
275	new_draw_info (NDI_UNIQUE, 0, pl, "The object disappears in a puff of smoke!");
276	new_draw_info (NDI_UNIQUE, 0, pl, "It must have been an illusion.");
277
278	if (pl->type == PLAYER)
279	esrv_del_item (pl->contr, tmp->count);
280
281	tmp->destroy ();
282	return;
283	}
284
285	if (nrof > tmp_nrof || nrof == 0)	298	if (nrof > tmp_nrof || nrof <= 0)
286	nrof = tmp_nrof;	299	nrof = tmp_nrof;
287		300
288	/* Figure out how much weight this object will add to the player */	301	/* Figure out how much weight this object will add to the player */
289	weight = tmp->weight * nrof;	302	weight = tmp->weight * nrof;
290	if (tmp->inv)	303	if (tmp->inv)
291	weight += tmp->carrying * (100 - tmp->stats.Str) / 100;	304	weight += tmp->carrying * (100 - tmp->stats.Str) / 100;
292		305
293	if (pl->stats.Str <= MAX_STAT)
294	effective_weight_limit = weight_limit[pl->stats.Str];	306	effective_weight_limit = weight_limit [min (MAX_STAT, pl->stats.Str)];
295	else
296	effective_weight_limit = weight_limit[MAX_STAT];
297		307
298	if ((pl->weight + pl->carrying + weight) > effective_weight_limit)	308	if ((pl->weight + pl->carrying + weight) > effective_weight_limit)
299	{	309	{
300	new_draw_info (0, 0, pl, "That item is too heavy for you to pick up.");	310	new_draw_info (0, 0, pl, "That item is too heavy for you to pick up.");
301	return;	311	return;
302	}	312	}
303		313
304	if (settings.real_wiz == FALSE && QUERY_FLAG (pl, FLAG_WAS_WIZ))	314	if (!can_split (pl, tmp, nrof))
305	SET_FLAG (tmp, FLAG_WAS_WIZ);
306
307	if (nrof != tmp_nrof)
308	{
309	object *tmp2 = tmp;
310
311	tmp = get_split_ob (tmp, nrof);
312	if (!tmp)
313	{
314	new_draw_info (NDI_UNIQUE, 0, pl, errmsg);
315	return;	315	return;
316	}
317		316
318	/* Tell a client what happened rest of objects */	317	if (QUERY_FLAG (tmp, FLAG_UNPAID))
319	if (pl->type == PLAYER)	318	{
320	{	319	tmp->flag.reset (FLAG_UNPAID);
321	if (tmp2->destroyed ())	320	new_draw_info_format (NDI_UNIQUE, 0, pl, "%s will cost you %s.", query_name (tmp), query_cost_string (tmp, pl, F_BUY | F_SHOP));
322	esrv_del_item (pl->contr, tmp2->count);	321	tmp->flag.set (FLAG_UNPAID);
323	else
324	esrv_send_item (pl, tmp2);
325	}
326	}	322	}
327	else	323	else
328	{	324	new_draw_info_format (NDI_UNIQUE, 0, pl, "You pick up the %s.", query_name (tmp));
329	/* If the object is in a container, send a delete to the client.
330	* - we are moving all the items from the container to elsewhere,
331	* so it needs to be deleted.
332	*/
333	if (!QUERY_FLAG (tmp, FLAG_REMOVED))
334	{
335	if (tmp->env && pl->type == PLAYER)
336	esrv_del_item (pl->contr, tmp->count);
337	tmp->remove (); /* Unlink it */
338	}
339	}
340	if (QUERY_FLAG (tmp, FLAG_UNPAID))
341	(void) sprintf (buf, "%s will cost you %s.", query_name (tmp), query_cost_string (tmp, pl, F_BUY | F_SHOP));
342	else
343	(void) sprintf (buf, "You pick up the %s.", query_name (tmp));
344	new_draw_info (NDI_UNIQUE, 0, pl, buf);
345		325
346	tmp = insert_ob_in_ob (tmp, op);	326	op->insert (tmp);
347
348	/* All the stuff below deals with client/server code, and is only
349	* usable by players
350	*/
351	if (pl->type != PLAYER)
352	return;
353
354	esrv_send_item (pl, tmp);
355	/* These are needed to update the weight for the container we
356	* are putting the object in.
357	*/
358	if (op != pl)
359	{
360	esrv_update_item (UPD_WEIGHT, pl, op);
361	esrv_send_item (pl, pl);
362	}
363
364	/* Update the container the object was in */
365	if (env && env != pl && env != op)
366	esrv_update_item (UPD_WEIGHT, pl, env);
367	}	327	}
368		328
369	/* modified slightly to allow monsters use this -b.t. 5-31-95 */	329	/* modified slightly to allow monsters use this -b.t. 5-31-95 */
370	void	330	void
371	pick_up (object *op, object *alt)	331	pick_up (object *op, object *alt)
…		…
381	if (!can_pick (op, alt))	341	if (!can_pick (op, alt))
382	{	342	{
383	new_draw_info_format (NDI_UNIQUE, 0, op, "You can't pick up the %s.", &alt->name);	343	new_draw_info_format (NDI_UNIQUE, 0, op, "You can't pick up the %s.", &alt->name);
384	goto leave;	344	goto leave;
385	}	345	}
		346
386	tmp = alt;	347	tmp = alt;
387	}	348	}
388	else	349	else
389	{	350	{
390	if (op->below == NULL || !can_pick (op, op->below))	351	if (op->below == NULL || !can_pick (op, op->below))
…		…
399	/* Try to catch it. */	360	/* Try to catch it. */
400	tmp_map = tmp->map;	361	tmp_map = tmp->map;
401	tmp = stop_item (tmp);	362	tmp = stop_item (tmp);
402	if (tmp == NULL)	363	if (tmp == NULL)
403	goto leave;	364	goto leave;
		365
404	need_fix_tmp = 1;	366	need_fix_tmp = 1;
405	if (!can_pick (op, tmp))	367	if (!can_pick (op, tmp))
406	goto leave;	368	goto leave;
407		369
408	if (op->type == PLAYER)	370	if (op->type == PLAYER)
…		…
413	}	375	}
414	else	376	else
415	count = tmp->nrof;	377	count = tmp->nrof;
416		378
417	/* container is open, so use it */	379	/* container is open, so use it */
		380	if (tmp->flag [FLAG_STARTEQUIP])
		381	alt = op;
418	if (op->container)	382	else if (op->container)
419	{	383	{
420	alt = op->container;	384	alt = op->container;
421	if (alt != tmp->env && !sack_can_hold (op, alt, tmp, count))	385	if (alt != tmp->env && !sack_can_hold (op, alt, tmp, count))
422	goto leave;	386	goto leave;
423	}	387	}
…		…
430		394
431	if (!alt)	395	if (!alt)
432	for (alt = op->inv; alt; alt = alt->below)	396	for (alt = op->inv; alt; alt = alt->below)
433	if (alt->type == CONTAINER && QUERY_FLAG (alt, FLAG_APPLIED) && sack_can_hold (NULL, alt, tmp, count))	397	if (alt->type == CONTAINER && QUERY_FLAG (alt, FLAG_APPLIED) && sack_can_hold (NULL, alt, tmp, count))
434	break; /* General container comes next */	398	break; /* General container comes next */
		399
435	if (!alt)	400	if (!alt)
436	alt = op; /* No free containers */	401	alt = op; /* No free containers */
437	}	402	}
438		403
439	if (tmp->env == alt)	404	if (tmp->env == alt)
…		…
441	/* here it could be possible to check rent,	406	/* here it could be possible to check rent,
442	* if someone wants to implement it	407	* if someone wants to implement it
443	*/	408	*/
444	alt = op;	409	alt = op;
445	}	410	}
		411
446	#ifdef PICKUP_DEBUG	412	#ifdef PICKUP_DEBUG
447	LOG (llevDebug, "Pick_up(): %s picks %s (%d) and inserts it %s.\n", op->name, tmp->name, op->contr->count, alt->name);	413	LOG (llevDebug, "Pick_up(): %s picks %s (%d) and inserts it %s.\n", op->name, tmp->name, op->contr->count, alt->name);
448	#endif	414	#endif
449		415
450	/* startequip items are not allowed to be put into containers: */	416	/* startequip items are not allowed to be put into containers: */
…		…
466		432
467	leave:	433	leave:
468	if (need_fix_tmp)	434	if (need_fix_tmp)
469	fix_stopped_item (tmp, tmp_map, op);	435	fix_stopped_item (tmp, tmp_map, op);
470	}	436	}
471
472		437
473	/* This takes (picks up) and item. op is the player	438	/* This takes (picks up) and item. op is the player
474	* who issued the command. params is a string to	439	* who issued the command. params is a string to
475	* match against the item name. Basically, always	440	* match against the item name. Basically, always
476	* returns zero, but that should be improved.	441	* returns zero, but that should be improved.
…		…
491		456
492	if (!tmp)	457	if (!tmp)
493	tmp = op->below;	458	tmp = op->below;
494	}	459	}
495		460
496	if (tmp == NULL)	461	if (!tmp)
497	{	462	{
498	new_draw_info (NDI_UNIQUE, 0, op, "Nothing to take!");	463	new_draw_info (NDI_UNIQUE, 0, op, "Nothing to take!");
499	return 0;	464	return 0;
500	}	465	}
501		466
502	/* Makes processing easier */	467	/* Makes processing easier */
503	if (params && *params == '\0')	468	if (params && *params == '\0')
504	params = NULL;	469	params = 0;
		470
		471	int cnt = MAX_ITEM_PER_DROP;
505		472
506	while (tmp)	473	while (tmp)
507	{	474	{
508	next = tmp->below;	475	next = tmp->below;
509		476
510	if (tmp->invisible)	477	if (tmp->invisible)
511	{	478	{
512	tmp = next;	479	tmp = next;
513	continue;	480	continue;
514	}	481	}
		482
515	/* This following two if and else if could be merged into line	483	/* This following two if and else if could be merged into line
516	* but that probably will make it more difficult to read, and	484	* but that probably will make it more difficult to read, and
517	* not make it any more efficient	485	* not make it any more efficient
518	*/	486	*/
519	if (params && item_matched_string (op, tmp, params))	487	if (params && item_matched_string (op, tmp, params))
520	{	488	{
		489	if (--cnt < 0) break;
521	pick_up (op, tmp);	490	pick_up (op, tmp);
522	}	491	}
523	else if (can_pick (op, tmp) && !params)	492	else if (can_pick (op, tmp) && !params)
524	{	493	{
		494	if (--cnt < 0) break;
525	pick_up (op, tmp);	495	pick_up (op, tmp);
526	break;	496	break;
527	}	497	}
		498
528	tmp = next;	499	tmp = next;
529	/* Might as well just skip over the player immediately -	500	}
530	* we know it can't be picked up	501
531	*/	502	if (cnt < 0)
532	if (tmp == op)
533	tmp = tmp->below;
534	}	503	{
		504	op->failmsg ("Couldn't pick up so many items at once.");
		505	return 0;
		506	}
		507
535	if (!params && !tmp)	508	if (!params && !tmp)
536	{	509	{
537	for (tmp = op->below; tmp != NULL; tmp = tmp->next)	510	for (tmp = op->below; tmp; tmp = tmp->below)
538	if (!tmp->invisible)	511	if (!tmp->invisible)
539	{	512	{
540	char buf[MAX_BUF];
541
542	sprintf (buf, "You can't pick up a %s.", &tmp->name);	513	new_draw_info_format (NDI_UNIQUE, 0, op, "You can't pick up a %s.", &tmp->name);
543	new_draw_info (NDI_UNIQUE, 0, op, buf);
544	break;	514	break;
545	}	515	}
		516
546	if (!tmp)	517	if (!tmp)
547	new_draw_info (NDI_UNIQUE, 0, op, "There is nothing to pick up.");	518	new_draw_info (NDI_UNIQUE, 0, op, "There is nothing to pick up.");
548	}	519	}
		520
549	return 0;	521	return 0;
550	}	522	}
551
552		523
553	/*	524	/*
554	* This function was part of drop, now is own function.	525	* This function was part of drop, now is own function.
555	* Player 'op' tries to put object 'tmp' into sack 'sack',	526	* Player 'op' tries to put object 'tmp' into sack 'sack',
556	* if nrof is non zero, then nrof objects is tried to put into sack.	527	* if nrof is non zero, then nrof objects is tried to put into sack.
…		…
572	return;	543	return;
573	}	544	}
574		545
575	if (tmp->type == CONTAINER && tmp->inv)	546	if (tmp->type == CONTAINER && tmp->inv)
576	{	547	{
577
578	/* Eneq(@csd.uu.se): If the object to be dropped is a container	548	/* Eneq(@csd.uu.se): If the object to be dropped is a container
579	* we instead move the contents of that container into the active	549	* we instead move the contents of that container into the active
580	* container, this is only done if the object has something in it.	550	* container, this is only done if the object has something in it.
581	*/	551	*/
582	sack2 = tmp;	552	sack2 = tmp;
…		…
585	for (tmp2 = tmp->inv; tmp2; tmp2 = tmp)	555	for (tmp2 = tmp->inv; tmp2; tmp2 = tmp)
586	{	556	{
587	tmp = tmp2->below;	557	tmp = tmp2->below;
588		558
589	if ((sack->type == CONTAINER && sack_can_hold (op, op->container, tmp2, tmp2->nrof)))	559	if ((sack->type == CONTAINER && sack_can_hold (op, op->container, tmp2, tmp2->nrof)))
590	{
591	put_object_in_sack (op, sack, tmp2, 0);	560	put_object_in_sack (op, sack, tmp2, 0);
592	}
593	else	561	else
594	{	562	{
595	sprintf (buf, "Your %s fills up.", query_name (sack));	563	sprintf (buf, "Your %s fills up.", query_name (sack));
596	new_draw_info (NDI_UNIQUE, 0, op, buf);	564	new_draw_info (NDI_UNIQUE, 0, op, buf);
597	break;	565	break;
598	}	566	}
599	}	567	}
600		568
601	esrv_update_item (UPD_WEIGHT, op, sack2);
602	return;	569	return;
603	}	570	}
604		571
605	/* Don't worry about this for containers - our caller should have	572	/* Don't worry about this for containers - our caller should have
606	* already checked this.	573	* already checked this.
…		…
611	if (QUERY_FLAG (tmp, FLAG_APPLIED))	578	if (QUERY_FLAG (tmp, FLAG_APPLIED))
612	if (apply_special (op, tmp, AP_UNAPPLY | AP_NO_MERGE))	579	if (apply_special (op, tmp, AP_UNAPPLY | AP_NO_MERGE))
613	return;	580	return;
614		581
615	/* we want to put some portion of the item into the container */	582	/* we want to put some portion of the item into the container */
616	if (nrof && tmp->nrof != nrof)	583	if (!can_split (op, tmp, nrof))
617	{
618	object *tmp2 = tmp;
619
620	tmp = get_split_ob (tmp, nrof);
621
622	if (!tmp)
623	{
624	new_draw_info (NDI_UNIQUE, 0, op, errmsg);
625	return;	584	return;
626	}
627	/* Tell a client what happened other objects */
628	if (tmp2->destroyed ())
629	esrv_del_item (op->contr, tmp2->count);
630	else /* this can proably be replaced with an update */
631	esrv_send_item (op, tmp2);
632	}
633	else
634	tmp->remove ();
635		585
636	new_draw_info_format (NDI_UNIQUE, 0, op, "You put the %s in %s.", query_name (tmp), query_name (sack));	586	new_draw_info_format (NDI_UNIQUE, 0, op, "You put the %s in %s.", query_name (tmp), query_name (sack));
637	tmp2 = insert_ob_in_ob (tmp, sack);	587	sack->insert (tmp);
638	fix_player (op); /* This is overkill, fix_player() is called somewhere */
639	/* in object.c */
640
641	/* If an object merged (and thus, different object), we need to
642	* delete the original.
643	*/
644	if (tmp2 != tmp)
645	esrv_del_item (op->contr, tmp->count);
646
647	esrv_send_item (op, tmp2);
648
649	/* update the sacks weight */
650	esrv_update_item (UPD_WEIGHT, op, sack);
651	}	588	}
652		589
653	/*	590	/*
654	* This function was part of drop, now is own function.	591	* This function was part of drop, now is own function.
655	* Player 'op' tries to drop object 'tmp', if tmp is non zero, then	592	* Player 'op' tries to drop object 'tmp', if tmp is non zero, then
…		…
657	* This is used when dropping objects onto the floor.	594	* This is used when dropping objects onto the floor.
658	*/	595	*/
659	void	596	void
660	drop_object (object *op, object *tmp, uint32 nrof)	597	drop_object (object *op, object *tmp, uint32 nrof)
661	{	598	{
662	char buf[MAX_BUF];
663	object *floor;
664
665	if (QUERY_FLAG (tmp, FLAG_NO_DROP))	599	if (QUERY_FLAG (tmp, FLAG_NO_DROP))
666	return;	600	return;
667		601
668	if (QUERY_FLAG (tmp, FLAG_APPLIED))	602	if (QUERY_FLAG (tmp, FLAG_APPLIED))
669	if (apply_special (op, tmp, AP_UNAPPLY | AP_NO_MERGE))	603	if (apply_special (op, tmp, AP_UNAPPLY | AP_NO_MERGE))
670	return; /* can't unapply it */	604	return; /* can't unapply it */
671		605
		606	//fprintf (stderr, "ui, on space is %ld\n", op->ms ().volume ());//D
		607
672	/* We are only dropping some of the items. We split the current object	608	/* We are only dropping some of the items. We split the current object
673	* off	609	* off
674	*/	610	*/
675	if (nrof && tmp->nrof != nrof)	611	if (!can_split (op, tmp, nrof))
676	{
677	object *tmp2 = tmp;
678
679	tmp = get_split_ob (tmp, nrof);
680	if (!tmp)
681	{
682	new_draw_info (NDI_UNIQUE, 0, op, errmsg);
683	return;
684	}
685	/* Tell a client what happened rest of objects. tmp2 is now the
686	* original object
687	*/
688	if (op->type == PLAYER)
689	{
690	if (tmp2->destroyed ())
691	esrv_del_item (op->contr, tmp2->count);
692	else
693	esrv_send_item (op, tmp2);
694	}
695	}
696	else
697	tmp->remove ();
698
699	if (INVOKE_OBJECT (DROP, tmp, ARG_OBJECT (op)))
700	return;	612	return;
701		613
		614	drop_object (op, tmp);
		615
		616	if (!tmp->destroyed () && !tmp->is_inserted ())
		617	{
		618	// if nothing happened with the object we give it back
		619	op->insert (tmp);
		620	}
		621	}
		622
		623	/* In contrast to drop_object (op, tmp, nrof) above this function takes the
		624	* already split off object, and feeds it to the event handlers and does
		625	* other magic with it.
		626	*
		627	* <droppper> is the object that dropped this object and <obj> is the
		628	* object that was dropped.
		629	*
		630	* Make sure to check what happened with <obj> after this function returns!
		631	* Otherwise you may leak this object.
		632	*/
		633
		634	void
		635	drop_object (object *dropper, object *obj)
		636	{
		637	if (INVOKE_OBJECT (DROP, obj, ARG_OBJECT (dropper)))
		638	return;
		639
		640	if (obj->destroyed () || obj->is_inserted ())
		641	return;
		642
702	if (QUERY_FLAG (tmp, FLAG_STARTEQUIP))	643	if (QUERY_FLAG (obj, FLAG_STARTEQUIP))
703	{	644	{
704	sprintf (buf, "You drop the %s.", query_name (tmp));	645	dropper->statusmsg (format ("You drop the %s.", query_name (obj)));
705	new_draw_info (NDI_UNIQUE, 0, op, buf);	646	dropper->statusmsg ("The god who lent it to you retrieves it.");
706	new_draw_info (NDI_UNIQUE, 0, op, "The gods who lent it to you retrieves it.");	647
707	if (op->type == PLAYER)
708	esrv_del_item (op->contr, tmp->count);
709	tmp->destroy ();	648	obj->destroy ();
710	fix_player (op);	649	dropper->update_stats ();
711	return;	650	return;
712	}	651	}
713		652
714	/* If SAVE_INTERVAL is commented out, we never want to save	653	for (object *floor = GET_MAP_OB (dropper->map, dropper->x, dropper->y);
715	* the player here.	654	floor;
716	*/	655	floor = floor->above)
717	#ifdef SAVE_INTERVAL	656	if (INVOKE_OBJECT (DROP_ON, floor, ARG_OBJECT (obj), ARG_OBJECT (dropper)))
718	/* I'm not sure why there is a value check - since the save	657	return;
719	* is done every SAVE_INTERVAL seconds, why care the value	658
720	* of what he is dropping?	659	if (obj->destroyed () || obj->is_inserted ())
		660	return;
		661
		662	if (is_in_shop (dropper) && !QUERY_FLAG (obj, FLAG_UNPAID) && obj->type != MONEY)
		663	if (!sell_item (obj, dropper))
		664	return;
		665
		666	/* If nothing special happened with this object, the default action is to
		667	* insert it below the dropper:
721	*/	668	*/
722	if (op->type == PLAYER && !QUERY_FLAG (tmp, FLAG_UNPAID) &&
723	(tmp->nrof ? tmp->value * tmp->nrof : tmp->value > 2000) && (op->contr->last_save_time + SAVE_INTERVAL) <= time (NULL))
724	{
725	save_player (op, 1);
726	op->contr->last_save_time = time (NULL);
727	}
728	#endif /* SAVE_INTERVAL */
729		669
730	if (op->type == PLAYER)	670	obj->x = dropper->x;
731	esrv_del_item (op->contr, tmp->count);	671	obj->y = dropper->y;
732		672
733	/* Call this before we update the various windows/players. At least
734	* that we, we know the weight is correct.
735	*/
736	fix_player (op); /* This is overkill, fix_player() is called somewhere */
737	/* in object.c */
738
739	if (op->type == PLAYER)
740	{
741	op->contr->socket.update_look = 1;
742	/* Need to update the weight for the player */
743	esrv_send_item (op, op);
744	}
745
746	for (floor = get_map_ob (op->map, op->x, op->y); floor; floor = floor->above)
747	if (INVOKE_OBJECT (DROP_ON, floor, ARG_OBJECT (tmp), ARG_OBJECT (op)))
748	return;
749
750	if (is_in_shop (op) && !QUERY_FLAG (tmp, FLAG_UNPAID) && tmp->type != MONEY)
751	sell_item (tmp, op);
752
753	tmp->x = op->x;
754	tmp->y = op->y;
755
756	insert_ob_in_map (tmp, op->map, op, INS_BELOW_ORIGINATOR);	673	insert_ob_in_map (obj, dropper->map, dropper, INS_BELOW_ORIGINATOR);
757	}	674	}
758		675
759	void	676	void
760	drop (object *op, object *tmp)	677	drop (object *op, object *tmp)
761	{	678	{
…		…
770	if (tmp->env && tmp->env->type != PLAYER)	687	if (tmp->env && tmp->env->type != PLAYER)
771	{	688	{
772	/* Just toss the object - probably shouldn't be hanging	689	/* Just toss the object - probably shouldn't be hanging
773	* around anyways	690	* around anyways
774	*/	691	*/
775	tmp->remove ();
776	tmp->destroy ();	692	tmp->destroy ();
777	return;	693	return;
778	}	694	}
779	else	695	else
780	{	696	{
781	while (tmp != NULL && tmp->invisible)	697	while (tmp && tmp->invisible)
782	tmp = tmp->below;	698	tmp = tmp->below;
783	}	699	}
784	}	700	}
785		701
786	if (tmp == NULL)	702	if (tmp == NULL)
787	{	703	{
788	new_draw_info (NDI_UNIQUE, 0, op, "You don't have anything to drop.");	704	new_draw_info (NDI_UNIQUE, 0, op, "You don't have anything to drop.");
789	return;	705	return;
790	}	706	}
		707
791	if (QUERY_FLAG (tmp, FLAG_INV_LOCKED))	708	if (QUERY_FLAG (tmp, FLAG_INV_LOCKED))
792	{	709	{
793	new_draw_info (NDI_UNIQUE, 0, op, "This item is locked");	710	new_draw_info (NDI_UNIQUE, 0, op, "This item is locked");
794	return;	711	return;
795	}	712	}
		713
796	if (QUERY_FLAG (tmp, FLAG_NO_DROP))	714	if (QUERY_FLAG (tmp, FLAG_NO_DROP))
797	{	715	{
798	#if 0	716	#if 0
799	/* Eneq(@csd.uu.se): Objects with NO_DROP defined can't be dropped. */	717	/* Eneq(@csd.uu.se): Objects with NO_DROP defined can't be dropped. */
800	new_draw_info (NDI_UNIQUE, 0, op, "This item can't be dropped.");	718	new_draw_info (NDI_UNIQUE, 0, op, "This item can't be dropped.");
801	#endif	719	#endif
802	return;	720	return;
803	}	721	}
804		722
805	if (op->type == PLAYER)	723	if (op->type == PLAYER && op->contr->last_used == tmp)
806	{	724	op->contr->last_used = tmp->below ? tmp->below
807	if (op->contr->last_used == tmp && op->contr->last_used_id == tmp->count)	725	: tmp->above ? tmp->above
808	{	726	: 0;
809	object *n = NULL;
810
811	if (tmp->below != NULL)
812	n = tmp->below;
813	else if (tmp->above != NULL)
814	n = tmp->above;
815	op->contr->last_used = n;
816	if (n != NULL)
817	op->contr->last_used_id = n->count;
818	else
819	op->contr->last_used_id = 0;
820	}
821	};
822		727
823	if (op->container)	728	if (op->container)
824	{	729	{
825	if (op->type == PLAYER)	730	if (op->type == PLAYER)
826	{
827	put_object_in_sack (op, op->container, tmp, op->contr->count);	731	put_object_in_sack (op, op->container, tmp, op->contr->count);
828	}
829	else	732	else
830	{
831	put_object_in_sack (op, op->container, tmp, 0);	733	put_object_in_sack (op, op->container, tmp, 0);
832	};
833	}	734	}
834	else	735	else
835	{	736	{
836	if (op->type == PLAYER)	737	if (op->type == PLAYER)
837	{
838	drop_object (op, tmp, op->contr->count);	738	drop_object (op, tmp, op->contr->count);
839	}
840	else	739	else
841	{
842	drop_object (op, tmp, 0);	740	drop_object (op, tmp, 0);
843	};
844	}	741	}
		742
845	if (op->type == PLAYER)	743	if (op->type == PLAYER)
846	op->contr->count = 0;	744	op->contr->count = 0;
847	}	745	}
848
849
850		746
851	/* Command will drop all items that have not been locked */	747	/* Command will drop all items that have not been locked */
852	int	748	int
853	command_dropall (object *op, char *params)	749	command_dropall (object *op, char *params)
854	{	750	{
855		751
856	object *curinv, *nextinv;
857
858	if (op->inv == NULL)	752	if (op->inv == NULL)
859	{	753	{
860	new_draw_info (NDI_UNIQUE, 0, op, "Nothing to drop!");	754	new_draw_info (NDI_UNIQUE, 0, op, "Nothing to drop!");
861	return 0;	755	return 0;
862	}	756	}
863		757
864	curinv = op->inv;	758	object *curinv = op->inv;
		759	object *nextinv;
865		760
866	/*	761	/*
867	This is the default. Drops everything not locked or considered	762	This is the default. Drops everything not locked or considered
868	not something that should be dropped.	763	not something that should be dropped.
869	*/	764	*/
…		…
871	Care must be taken that the next item pointer is not to money as	766	Care must be taken that the next item pointer is not to money as
872	the drop() routine will do unknown things to it when dropping	767	the drop() routine will do unknown things to it when dropping
873	in a shop. --Tero.Pelander@utu.fi	768	in a shop. --Tero.Pelander@utu.fi
874	*/	769	*/
875		770
876	if (params == NULL)	771	int cnt = MAX_ITEM_PER_DROP;
		772
		773	if (!params)
877	{	774	{
878	while (curinv != NULL)	775	while (curinv)
879	{	776	{
880	nextinv = curinv->below;	777	nextinv = curinv->below;
		778
881	while (nextinv && nextinv->type == MONEY)	779	while (nextinv && nextinv->type == MONEY)
882	nextinv = nextinv->below;	780	nextinv = nextinv->below;
		781
883	if (!QUERY_FLAG (curinv, FLAG_INV_LOCKED) && curinv->type != MONEY &&	782	if (!QUERY_FLAG (curinv, FLAG_INV_LOCKED) && curinv->type != MONEY &&
884	curinv->type != FOOD && curinv->type != KEY &&	783	curinv->type != FOOD && curinv->type != KEY &&
885	curinv->type != SPECIAL_KEY && curinv->type != GEM &&	784	curinv->type != SPECIAL_KEY && curinv->type != GEM &&
886	!curinv->invisible && (curinv->type != CONTAINER || op->container != curinv))	785	!curinv->invisible && (curinv->type != CONTAINER || op->container != curinv))
887	{	786	{
888	drop (op, curinv);	787	drop (op, curinv);
		788	if (--cnt <= 0) break;
889	}	789	}
		790
890	curinv = nextinv;	791	curinv = nextinv;
891	}	792	}
892	}	793	}
893
894	else if (strcmp (params, "weapons") == 0)	794	else if (strcmp (params, "weapons") == 0)
895	{	795	{
896	while (curinv != NULL)	796	while (curinv)
897	{	797	{
898	nextinv = curinv->below;	798	nextinv = curinv->below;
		799
899	while (nextinv && nextinv->type == MONEY)	800	while (nextinv && nextinv->type == MONEY)
900	nextinv = nextinv->below;	801	nextinv = nextinv->below;
		802
901	if (!QUERY_FLAG (curinv, FLAG_INV_LOCKED) && ((curinv->type == WEAPON) || (curinv->type == BOW) || (curinv->type == ARROW)))	803	if (!QUERY_FLAG (curinv, FLAG_INV_LOCKED) && ((curinv->type == WEAPON) || (curinv->type == BOW) || (curinv->type == ARROW)))
902	{	804	{
903	drop (op, curinv);	805	drop (op, curinv);
		806	if (--cnt <= 0) break;
904	}	807	}
		808
905	curinv = nextinv;	809	curinv = nextinv;
906	}	810	}
907	}	811	}
908
909	else if (strcmp (params, "armor") == 0 || strcmp (params, "armour") == 0)	812	else if (strcmp (params, "armor") == 0 || strcmp (params, "armour") == 0)
910	{	813	{
911	while (curinv != NULL)	814	while (curinv)
912	{	815	{
913	nextinv = curinv->below;	816	nextinv = curinv->below;
		817
914	while (nextinv && nextinv->type == MONEY)	818	while (nextinv && nextinv->type == MONEY)
915	nextinv = nextinv->below;	819	nextinv = nextinv->below;
		820
916	if (!QUERY_FLAG (curinv, FLAG_INV_LOCKED) && ((curinv->type == ARMOUR) || curinv->type == SHIELD || curinv->type == HELMET))	821	if (!QUERY_FLAG (curinv, FLAG_INV_LOCKED) && ((curinv->type == ARMOUR) || curinv->type == SHIELD || curinv->type == HELMET))
917	{	822	{
918	drop (op, curinv);	823	drop (op, curinv);
		824	if (--cnt <= 0) break;
919	}	825	}
		826
920	curinv = nextinv;	827	curinv = nextinv;
921	}	828	}
922	}	829	}
923
924	else if (strcmp (params, "misc") == 0)	830	else if (strcmp (params, "misc") == 0)
925	{	831	{
926	while (curinv != NULL)	832	while (curinv)
927	{	833	{
928	nextinv = curinv->below;	834	nextinv = curinv->below;
		835
929	while (nextinv && nextinv->type == MONEY)	836	while (nextinv && nextinv->type == MONEY)
930	nextinv = nextinv->below;	837	nextinv = nextinv->below;
		838
931	if (!QUERY_FLAG (curinv, FLAG_INV_LOCKED) && !QUERY_FLAG (curinv, FLAG_APPLIED))	839	if (!QUERY_FLAG (curinv, FLAG_INV_LOCKED) && !QUERY_FLAG (curinv, FLAG_APPLIED))
932	{	840	{
933	switch (curinv->type)	841	switch (curinv->type)
934	{	842	{
935	case HORN:	843	case HORN:
…		…
953	break;	861	break;
954	default:	862	default:
955	curinv = nextinv;	863	curinv = nextinv;
956	break;	864	break;
957	}	865	}
		866
		867	if (--cnt <= 0) break;
958	}	868	}
		869
959	curinv = nextinv;	870	curinv = nextinv;
960	}	871	}
961	}	872	}
962	op->contr->socket.update_look = 1;	873
		874	if (cnt <= 0)
		875	op->failmsg ("Only dropped some items, can't drop that many items at once.");
963		876
964	/* draw_look(op);*/	877	/* draw_look(op);*/
965	return 0;	878	return 0;
		879	}
		880
		881
		882	/* This function tries to drop all objects in the <objs> vector.
		883	* <dropper> is the object that wants to drop them.
		884	* <cnt> can be a 0 pointer or a pointer to the maximum number of
		885	* drop operations to perform.
		886	*
		887	* Returns true if at least one item was dropped.
		888	*/
		889	bool
		890	drop_vector (object *dropper, vector<object *> &objs, int *cnt)
		891	{
		892	vector<object *>::iterator i;
		893
		894	bool did_one = false;
		895
		896	for (i = objs.begin (); i != objs.end (); i++)
		897	{
		898	drop (dropper, *i);
		899	if (cnt && --*cnt <= 0) break;
		900	did_one = true;
		901	}
		902
		903	return did_one;
966	}	904	}
967		905
968	/* Object op wants to drop object(s) params. params can be a	906	/* Object op wants to drop object(s) params. params can be a
969	* comma seperated list.	907	* comma seperated list.
970	*/	908	*/
971
972	int	909	int
973	command_drop (object *op, char *params)	910	command_drop (object *op, char *params)
974	{	911	{
975	object *tmp, *next;	912	object *tmp, *next;
976	int did_one = 0;	913	int did_one = 0;
…		…
980	new_draw_info (NDI_UNIQUE, 0, op, "Drop what?");	917	new_draw_info (NDI_UNIQUE, 0, op, "Drop what?");
981	return 0;	918	return 0;
982	}	919	}
983	else	920	else
984	{	921	{
		922	vector<object *> matched_objs;
		923
985	for (tmp = op->inv; tmp; tmp = next)	924	for (tmp = op->inv; tmp; tmp = next)
986	{	925	{
987	next = tmp->below;	926	next = tmp->below;
988	if (QUERY_FLAG (tmp, FLAG_NO_DROP) || tmp->invisible)	927	if (QUERY_FLAG (tmp, FLAG_NO_DROP) || tmp->invisible)
989	continue;	928	continue;
		929
990	if (item_matched_string (op, tmp, params))	930	if (item_matched_string (op, tmp, params))
991	{	931	matched_objs.push_back (tmp);
992	drop (op, tmp);
993	did_one = 1;
994	}	932	}
995	}	933
996	if (!did_one)	934	int cnt = MAX_ITEM_PER_DROP;
		935
		936	if (!drop_vector (op, matched_objs, &cnt))
997	new_draw_info (NDI_UNIQUE, 0, op, "Nothing to drop.");	937	new_draw_info (NDI_UNIQUE, 0, op, "Nothing to drop.");
998	}	938
999	if (op->type == PLAYER)	939	if (cnt <= 0)
1000	{	940	op->failmsg ("Only dropped some items, can't drop that many items at once.");
1001	op->contr->count = 0;
1002	op->contr->socket.update_look = 1;
1003	};	941	}
1004		942
1005	/* draw_look(op);*/
1006	return 0;	943	return 0;
1007	}	944	}
1008		945
1009	int	946	int
1010	command_examine (object *op, char *params)	947	command_examine (object *op, char *params)
1011	{	948	{
1012	if (!params)	949	if (!params)
1013	{	950	{
1014	object *tmp = op->below;	951	object *tmp = op->below;
1015		952
1016	while (tmp && !LOOK_OBJ (tmp))	953	while (tmp && !tmp->client_visible ())
1017	tmp = tmp->below;	954	tmp = tmp->below;
		955
1018	if (tmp)	956	if (tmp)
1019	examine (op, tmp);	957	examine (op, tmp);
1020	}	958	}
1021	else	959	else
1022	{	960	{
1023	object *tmp = find_best_object_match (op, params);	961	object *tmp = find_best_object_match (op, params);
1024		962
1025	if (tmp)	963	if (tmp)
1026	examine (op, tmp);	964	examine (op, tmp);
1027	else	965	else
1028	new_draw_info_format (NDI_UNIQUE, 0, op, "Could not find an object that matches %s", params);	966	op->contr->infobox (MSG_CHANNEL ("examine"), format ("Could not find an object that matches %s", params));
1029	}	967	}
		968
1030	return 0;	969	return 0;
1031	}	970	}
1032		971
1033	/* op should be a player.	972	/* op should be a player.
1034	* we return the object the player has marked with the 'mark' command	973	* we return the object the player has marked with the 'mark' command
…		…
1073	}	1012	}
1074		1013
1075	return 0;	1014	return 0;
1076	}	1015	}
1077		1016
1078		1017	std::string
1079	/* op should be a player, params is any params.	1018	object::describe_monster (object *who)
1080	* If no params given, we print out the currently marked object.
1081	* otherwise, try to find a matching object - try best match first.
1082	*/
1083	int
1084	command_mark (object *op, char *params)
1085	{	1019	{
1086	if (!op->contr)	1020	dynbuf_text buf (512, 512);
1087	return 1;
1088		1021
1089	if (!params)	1022	object *mon = head ? head : this;
1090	{
1091	object *mark = find_marked_object (op);
1092		1023
1093	if (!mark)	1024	if (QUERY_FLAG (mon, FLAG_UNDEAD))
1094	new_draw_info (NDI_UNIQUE, 0, op, "You have no marked object.");	1025	buf << "It is an undead force.\r";
1095	else	1026
1096	new_draw_info_format (NDI_UNIQUE, 0, op, "%s is marked.", query_name (mark));	1027	if (mon->level > who->level)
1097	}	1028	buf << "It is likely more powerful than you.\r";
		1029	else if (mon->level < who->level)
		1030	buf << "It is likely less powerful than you.\r";
1098	else	1031	else
1099	{	1032	buf << "It is probably as powerful as you.\r";
1100	object *mark1 = find_best_object_match (op, params);
1101		1033
1102	if (!mark1)
1103	{
1104	new_draw_info_format (NDI_UNIQUE, 0, op, "Could not find an object that matches %s", params);
1105	return 1;
1106	}
1107	else
1108	{
1109	op->contr->mark = mark1;
1110	new_draw_info_format (NDI_UNIQUE, 0, op, "Marked item %s", query_name (mark1));
1111	return 0;
1112	}
1113	}
1114
1115	return 0; /*shouldnt get here */
1116	}
1117
1118
1119	/* op is the player
1120	* tmp is the monster being examined.
1121	*/
1122	void
1123	examine_monster (object *op, object *tmp)
1124	{
1125	object *mon = tmp->head ? tmp->head : tmp;
1126
1127	if (QUERY_FLAG (mon, FLAG_UNDEAD))
1128	new_draw_info (NDI_UNIQUE, 0, op, "It is an undead force.");
1129	if (mon->level > op->level)
1130	new_draw_info (NDI_UNIQUE, 0, op, "It is likely more powerful than you.");
1131	else if (mon->level < op->level)
1132	new_draw_info (NDI_UNIQUE, 0, op, "It is likely less powerful than you.");
1133	else
1134	new_draw_info (NDI_UNIQUE, 0, op, "It is probably as powerful as you.");
1135	if (mon->attacktype & AT_ACID)	1034	if (mon->attacktype & AT_ACID)
1136	new_draw_info (NDI_UNIQUE, 0, op, "You seem to smell an acrid odor.");	1035	buf << "You seem to smell an acrid odor.\r";
1137		1036
1138	/* Anyone know why this used to use the clone value instead of the	1037	/* Anyone know why this used to use the clone value instead of the
1139	* maxhp field? This seems that it should give more accurate results.	1038	* maxhp field? This seems that it should give more accurate results.
1140	*/	1039	*/
1141	switch ((mon->stats.hp + 1) * 4 / (mon->stats.maxhp + 1))	1040	switch ((mon->stats.hp + 1) * 4 / (mon->stats.maxhp + 1))
1142	{ /* From 1-4 */	1041	{ /* From 1-4 */
1143	case 1:	1042	case 1:
1144	new_draw_info (NDI_UNIQUE, 0, op, "It is in a bad shape.");	1043	buf << "It is in a bad shape.\r";
1145	break;	1044	break;
1146	case 2:	1045	case 2:
1147	new_draw_info (NDI_UNIQUE, 0, op, "It is hurt.");	1046	buf << "It is hurt.\r";
1148	break;	1047	break;
1149	case 3:	1048	case 3:
1150	new_draw_info (NDI_UNIQUE, 0, op, "It is somewhat hurt.");	1049	buf << "It is somewhat hurt.\r";
1151	break;	1050	break;
1152	case 4:	1051	case 4:
1153	new_draw_info (NDI_UNIQUE, 0, op, "It is in excellent shape.");	1052	buf << "It is in excellent shape.\r";
1154	break;	1053	break;
1155	}	1054	}
		1055
1156	if (present_in_ob (POISONING, mon) != NULL)	1056	if (present_in_ob (POISONING, mon))
1157	new_draw_info (NDI_UNIQUE, 0, op, "It looks very ill.");	1057	buf << "It looks very ill.\r";
1158	}
1159		1058
		1059	buf << '\n';
		1060
		1061	return buf;
		1062	}
1160		1063
1161	/* tmp is the object being described, pl is who is examing it. */	1064	/* tmp is the object being described, pl is who is examing it. */
1162	char *	1065	const char *
1163	long_desc (object *tmp, object *pl)	1066	long_desc (object *tmp, object *pl)
1164	{	1067	{
1165	static char buf[VERY_BIG_BUF];	1068	static std::string s;
1166	char *cp;
1167		1069
1168	if (tmp == NULL)	1070	return (s = tmp->long_desc (pl)).c_str ();
1169	return "";	1071	}
1170		1072
1171	buf[0] = '\0';	1073	std::string
		1074	object::long_desc (object *who)
		1075	{
		1076	std::string buf (query_name (this));
		1077
1172	switch (tmp->type)	1078	switch (type)
1173	{	1079	{
1174	case RING:	1080	case RING:
1175	case SKILL:	1081	case SKILL:
1176	case WEAPON:	1082	case WEAPON:
1177	case ARMOUR:	1083	case ARMOUR:
…		…
1188	case FOOD:	1094	case FOOD:
1189	case DRINK:	1095	case DRINK:
1190	case FLESH:	1096	case FLESH:
1191	case SKILL_TOOL:	1097	case SKILL_TOOL:
1192	case POWER_CRYSTAL:	1098	case POWER_CRYSTAL:
1193	if (*(cp = describe_item (tmp, pl)) != '\0')	1099	{
		1100	const char *cp = ::describe_item (this, who);
		1101
		1102	if (*cp)
		1103	{
		1104	buf.append (" ");
		1105	buf.append (cp);
		1106	}
		1107	}
		1108	}
		1109
		1110	return buf;
		1111	}
		1112
		1113	/* op is the player
		1114	* tmp is the monster being examined.
		1115	*/
		1116	void
		1117	examine_monster (object *op, object *tmp)
		1118	{
		1119	new_draw_info (NDI_UNIQUE, 0, op, tmp->describe_monster (op).c_str ());
		1120	}
		1121
		1122	std::string
		1123	object::describe (object *who)
		1124	{
		1125	dynbuf_text buf (1024, 1024);
		1126
		1127	buf.printf ("That is: %s.\r", long_desc (who).c_str ());
		1128
		1129	if (custom_name)
		1130	buf.printf ("You call it %s.\r", &custom_name);
		1131
		1132	switch (type)
		1133	{
		1134	case SPELLBOOK:
		1135	if (flag [FLAG_IDENTIFIED] && inv)
		1136	buf.printf ("%s is a %s %s spell.\r", &inv->name, get_levelnumber (inv->level), &inv->skill);
		1137	break;
		1138
		1139	case BOOK:
		1140	if (msg)
		1141	buf << "Something is written in it.\r";
		1142	break;
		1143
		1144	case CONTAINER:
		1145	if (race)
1194	{	1146	{
		1147	if (weight_limit && stats.Str < 100)
		1148	buf.printf ("It can hold only %s and its weight limit is %.1f kg.\r",
		1149	&race, weight_limit / (10.0 * (100 - stats.Str)));
1195	int len;	1150	else
1196		1151	buf.printf ("It can hold only %s.\r", &race);
1197	assign (buf, query_name (tmp));
1198	len = strlen (buf);
1199	if (len < VERY_BIG_BUF - 5)
1200	{
1201	/* Since we know the length, we save a few cpu cycles by using
1202	* it instead of calling strcat */
1203	strcpy (buf + len, " ");
1204	len++;
1205	assign (buf + len, cp, VERY_BIG_BUF - len - 1);
1206	}
1207	}	1152	}
1208	}
1209
1210	if (buf[0] == '\0')
1211	assign (buf, query_name (tmp));
1212
1213	return buf;
1214	}
1215
1216	void
1217	examine (object *op, object *tmp)
1218	{
1219	char buf[VERY_BIG_BUF];
1220	int i;
1221
1222	if (tmp == NULL || tmp->type == CLOSE_CON)
1223	return;
1224
1225	strcpy (buf, "That is ");
1226	strncat (buf, long_desc (tmp, op), VERY_BIG_BUF - strlen (buf) - 1);
1227	buf[VERY_BIG_BUF - 1] = 0;
1228
1229	new_draw_info (NDI_UNIQUE, 0, op, buf);
1230	buf[0] = '\0';
1231
1232	if (tmp->custom_name)
1233	{
1234	strcpy (buf, "You call it ");
1235	strncat (buf, tmp->custom_name, VERY_BIG_BUF - strlen (buf) - 1);
1236	buf[VERY_BIG_BUF - 1] = 0;
1237	new_draw_info (NDI_UNIQUE, 0, op, buf);
1238	buf[0] = '\0';
1239	}
1240
1241	switch (tmp->type)
1242	{
1243	case SPELLBOOK:
1244	if (QUERY_FLAG (tmp, FLAG_IDENTIFIED) && tmp->inv)
1245	{
1246	sprintf (buf, "%s is a %s level %s spell", &tmp->inv->name, get_levelnumber (tmp->inv->level), &tmp->inv->skill);
1247	}
1248	break;
1249
1250	case BOOK:
1251	if (tmp->msg != NULL)
1252	strcpy (buf, "Something is written in it.");
1253	break;
1254
1255	case CONTAINER:
1256	if (tmp->race != NULL)
1257	{
1258	if (tmp->weight_limit && tmp->stats.Str < 100)
1259	sprintf (buf, "It can hold only %s and its weight limit is %.1f kg.",
1260	&tmp->race, tmp->weight_limit / (10.0 * (100 - tmp->stats.Str)));
1261	else
1262	sprintf (buf, "It can hold only %s.", &tmp->race);
1263	}
1264	else if (tmp->weight_limit && tmp->stats.Str < 100)	1153	else if (weight_limit && stats.Str < 100)
1265	sprintf (buf, "Its weight limit is %.1f kg.", tmp->weight_limit / (10.0 * (100 - tmp->stats.Str)));	1154	buf.printf ("Its weight limit is %.1f kg.\r", weight_limit / (10.0 * (100 - stats.Str)));
1266	break;	1155	break;
1267		1156
1268	case WAND:	1157	case WAND:
1269	if (QUERY_FLAG (tmp, FLAG_IDENTIFIED))	1158	if (flag [FLAG_IDENTIFIED])
1270	sprintf (buf, "It has %d charges left.", tmp->stats.food);	1159	buf.printf ("It has %d charges left.\r", stats.food);
1271	break;	1160	break;
1272	}
1273
1274	if (buf[0] != '\0')
1275	new_draw_info (NDI_UNIQUE, 0, op, buf);
1276
1277	if (tmp->materialname != NULL && !tmp->msg)
1278	{	1161	}
		1162
		1163	if (materialname && !msg)
1279	sprintf (buf, "It is made of: %s.", &tmp->materialname);	1164	buf.printf ("It is made of: %s.\r", &materialname);
1280	new_draw_info (NDI_UNIQUE, 0, op, buf);	1165
1281	}	1166	if (who)
1282	/* Where to wear this item */	1167	/* Where to wear this item */
1283	for (i = 0; i < NUM_BODY_LOCATIONS; i++)	1168	for (int i = 0; i < NUM_BODY_LOCATIONS; i++)
1284	{	1169	if (slot[i].info)
1285	if (tmp->body_info[i] < -1)	1170	{
		1171	buf << (who->slot[i].info ? body_locations[i].use_name : body_locations[i].nonuse_name);
		1172
		1173	if (slot[i].info < -1 && who->slot[i].info)
		1174	buf.printf ("(%d)", -slot[i].info);
		1175
		1176	buf << ".\r";
1286	{	1177	}
1287	if (op->body_info[i])	1178
1288	new_draw_info_format (NDI_UNIQUE, 0, op, "It goes %s (%d)", body_locations[i].use_name, -tmp->body_info[i]);	1179	if (weight)
		1180	buf.printf ("%s %3.3f kg.\r", nrof > 1 ? "They weigh" : "It weighs", weight * (nrof ? nrof : 1) / 1000.0);
		1181
		1182	if (value && !flag [FLAG_STARTEQUIP] && !flag [FLAG_NO_PICK] && who)
		1183	{
		1184	buf.printf ("You reckon %s worth %s.\r", nrof > 1 ? "they are" : "it is", query_cost_string (this, who, F_TRUE | F_APPROX));
		1185
		1186	if (is_in_shop (who))
		1187	{
		1188	if (flag [FLAG_UNPAID])
		1189	buf.printf ("%s would cost you %s.\r", nrof > 1 ? "They" : "It", query_cost_string (this, who, F_BUY | F_SHOP));
1289	else	1190	else
1290	new_draw_info_format (NDI_UNIQUE, 0, op, "It goes %s", body_locations[i].nonuse_name);
1291	}
1292	else if (tmp->body_info[i])
1293	{
1294	if (op->body_info[i])
1295	new_draw_info_format (NDI_UNIQUE, 0, op, "It goes %s", body_locations[i].use_name);
1296	else
1297	new_draw_info_format (NDI_UNIQUE, 0, op, "It goes %s", body_locations[i].nonuse_name);
1298	}
1299	}
1300
1301	if (tmp->weight)
1302	{
1303	sprintf (buf, tmp->nrof > 1 ? "They weigh %3.3f kg." : "It weighs %3.3f kg.", tmp->weight * (tmp->nrof ? tmp->nrof : 1) / 1000.0);
1304	new_draw_info (NDI_UNIQUE, 0, op, buf);
1305	}
1306
1307	if (tmp->value && !QUERY_FLAG (tmp, FLAG_STARTEQUIP) && !QUERY_FLAG (tmp, FLAG_NO_PICK))
1308	{
1309	sprintf (buf, "You reckon %s worth %s.", tmp->nrof > 1 ? "they are" : "it is", query_cost_string (tmp, op, F_TRUE | F_APPROX));
1310	new_draw_info (NDI_UNIQUE, 0, op, buf);
1311	if (is_in_shop (op))
1312	{
1313	if (QUERY_FLAG (tmp, FLAG_UNPAID))
1314	sprintf (buf, "%s would cost you %s.", tmp->nrof > 1 ? "They" : "It", query_cost_string (tmp, op, F_BUY | F_SHOP));
1315	else
1316	sprintf (buf, "You are offered %s for %s.", query_cost_string (tmp, op, F_SELL + F_SHOP), tmp->nrof > 1 ? "them" : "it");	1191	buf.printf ("You are offered %s for %s.\r", query_cost_string (this, who, F_SELL + F_SHOP), nrof > 1 ? "them" : "it");
1317	new_draw_info (NDI_UNIQUE, 0, op, buf);
1318	}	1192	}
1319	}	1193	}
1320		1194
1321	if (QUERY_FLAG (tmp, FLAG_MONSTER))	1195	if (flag [FLAG_MONSTER])
1322	examine_monster (op, tmp);	1196	buf << describe_monster (who);
1323		1197
1324	/* Is this item buildable? */	1198	/* Is this item buildable? */
1325	if (QUERY_FLAG (tmp, FLAG_IS_BUILDABLE))	1199	if (flag [FLAG_IS_BUILDABLE])
1326	new_draw_info (NDI_UNIQUE, 0, op, "This is a buildable item.");	1200	buf << "This is a buildable item.\r";
1327		1201
1328	/* Does the object have a message? Don't show message for all object	1202	/* Does the object have a message? Don't show message for all object
1329	* types - especially if the first entry is a match	1203	* types - especially if the first entry is a match
1330	*/	1204	*/
1331	if (tmp->msg && tmp->type != EXIT && tmp->type != BOOK && tmp->type != CORPSE && !tmp->move_on && strncasecmp (tmp->msg, "@match", 7))	1205	if (msg && type != EXIT && type != BOOK && type != CORPSE && !move_on && !has_dialogue ())
1332	{	1206	{
1333
1334	/* This is just a hack so when identifying the items, we print	1207	/* This is just a hack so when identifying the items, we print
1335	* out the extra message	1208	* out the extra message
1336	*/	1209	*/
1337	if (need_identify (tmp) && QUERY_FLAG (tmp, FLAG_IDENTIFIED))	1210	if (need_identify (this) && flag [FLAG_IDENTIFIED])
1338	new_draw_info (NDI_UNIQUE, 0, op, "The object has a story:");	1211	buf << "The object has a story:\r";
1339		1212
1340	new_draw_info (NDI_UNIQUE, 0, op, tmp->msg);	1213	buf << msg << '\n';
1341	}
1342	new_draw_info (NDI_UNIQUE, 0, op, " "); /* Blank line */
1343	}
1344
1345	/*
1346	* inventory prints object's inventory. If inv==NULL then print player's
1347	* inventory.
1348	* [ Only items which are applied are showed. Tero.Haatanen@lut.fi ]
1349	*/
1350	void
1351	inventory (object *op, object *inv)
1352	{
1353	object *tmp;
1354	char *in;
1355	int items = 0, length;
1356
1357	if (inv == NULL && op == NULL)
1358	{	1214	}
1359	new_draw_info (NDI_UNIQUE, 0, op, "Inventory of what object?");
1360	return;
1361	}
1362	tmp = inv ? inv->inv : op->inv;
1363		1215
1364	while (tmp)	1216	buf << '\n';
1365	{	1217
1366	if ((!tmp->invisible &&	1218	return std::string (buf.linearise (), buf.size ());
1367	(inv == NULL || inv->type == CONTAINER || QUERY_FLAG (tmp, FLAG_APPLIED))) || (!op || QUERY_FLAG (op, FLAG_WIZ)))
1368	items++;
1369	tmp = tmp->below;
1370	}
1371	if (inv == NULL)
1372	{ /* player's inventory */
1373	if (items == 0)
1374	{
1375	new_draw_info (NDI_UNIQUE, 0, op, "You carry nothing.");
1376	return;
1377	}
1378	else
1379	{
1380	length = 28;
1381	in = "";
1382	if (op)
1383	clear_win_info (op);
1384	new_draw_info (NDI_UNIQUE, 0, op, "Inventory:");
1385	}
1386	}
1387	else
1388	{
1389	if (items == 0)
1390	return;
1391	else
1392	{
1393	length = 28;
1394	in = " ";
1395	}
1396	}
1397	for (tmp = inv ? inv->inv : op->inv; tmp; tmp = tmp->below)
1398	{
1399	if ((!op || !QUERY_FLAG (op, FLAG_WIZ)) && (tmp->invisible || (inv && inv->type != CONTAINER && !QUERY_FLAG (tmp, FLAG_APPLIED))))
1400	continue;
1401	if ((!op || QUERY_FLAG (op, FLAG_WIZ)))
1402	new_draw_info_format (NDI_UNIQUE, 0, op, "%s- %-*.*s (%5d) %-8s", in, length, length,
1403	query_name (tmp), tmp->count, query_weight (tmp));
1404	else
1405	new_draw_info_format (NDI_UNIQUE, 0, op, "%s- %-*.*s %-8s", in, length + 8, length + 8, query_name (tmp), query_weight (tmp));
1406	}
1407	if (!inv && op)
1408	{
1409	new_draw_info_format (NDI_UNIQUE, 0, op, "%-*s %-8s", 41, "Total weight :", query_weight (op));
1410	}
1411	}	1219	}
1412		1220
1413	static void	1221	static void
1414	display_new_pickup (object *op)	1222	display_new_pickup (object *op)
1415	{	1223	{
…		…
1576	new_draw_info (NDI_UNIQUE, 0, op, "Example: search magic+1");	1384	new_draw_info (NDI_UNIQUE, 0, op, "Example: search magic+1");
1577	new_draw_info (NDI_UNIQUE, 0, op, "Would automatically pick up all");	1385	new_draw_info (NDI_UNIQUE, 0, op, "Would automatically pick up all");
1578	new_draw_info (NDI_UNIQUE, 0, op, "items containing the word 'magic+1'.");	1386	new_draw_info (NDI_UNIQUE, 0, op, "items containing the word 'magic+1'.");
1579	return 1;	1387	return 1;
1580	}	1388	}
		1389
1581	op->contr->search_str[0] = '\0';	1390	op->contr->search_str[0] = '\0';
1582	new_draw_info (NDI_UNIQUE, 0, op, "Search mode turned off.");	1391	new_draw_info (NDI_UNIQUE, 0, op, "Search mode turned off.");
1583	fix_player (op);	1392	op->update_stats ();
1584	return 1;	1393	return 1;
1585	}	1394	}
		1395
1586	if ((int) strlen (params) >= MAX_BUF)	1396	if ((int) strlen (params) >= MAX_BUF)
1587	{	1397	{
1588	new_draw_info (NDI_UNIQUE, 0, op, "Search string too long.");	1398	new_draw_info (NDI_UNIQUE, 0, op, "Search string too long.");
1589	return 1;	1399	return 1;
1590	}	1400	}
		1401
1591	strcpy (op->contr->search_str, params);	1402	strcpy (op->contr->search_str, params);
1592	sprintf (buf, "Searching for '%s'.", op->contr->search_str);	1403	sprintf (buf, "Searching for '%s'.", op->contr->search_str);
1593	new_draw_info (NDI_UNIQUE, 0, op, buf);	1404	new_draw_info (NDI_UNIQUE, 0, op, buf);
1594	fix_player (op);	1405	op->update_stats ();
1595	return 1;	1406	return 1;
1596	}	1407	}
1597		1408

Diff Legend

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