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

Diff Legend

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