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

Diff Legend

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