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.14 by root, Sun Sep 10 15:59:57 2006 UTC vs.
Revision 1.134 by root, Sat Nov 17 23:40:03 2018 UTC

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

Diff Legend

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