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.7 by root, Sun Aug 27 15:24:22 2006 UTC vs.
Revision 1.119 by root, Sat Apr 10 04:54:09 2010 UTC

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

Diff Legend

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