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.80 by elmex, Sun Oct 5 12:40:21 2008 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 (©) 2005,2006,2007,2008 Marc Alexander Lehmann / Robin Redeker / the Deliantra team
		5	* Copyright (©) 2002,2007 Mark Wedel & Crossfire Development Team
		6	* Copyright (©) 1992,2007 Frank Tore Johansen
		7	*
		8	* Deliantra is free software: you can redistribute it and/or modify
		9	* it under the terms of the GNU General Public License as published by
		10	* the Free Software Foundation, either version 3 of the License, or
		11	* (at your 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 GNU General Public License
		19	* along with this program. If not, see <http://www.gnu.org/licenses/>.
		20	*
		21	* The authors can be reached via e-mail to <support@deliantra.net>
5	*/	22	*/
6		23
7	/*	24	/*
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	25	* Object (handling) commands
30	*/	26	*/
31		27
32	#include <global.h>	28	#include <global.h>
33	#include <loader.h>	29	#include <loader.h>
34	#include <skills.h>	30	#include <skills.h>
35	#ifndef __CEXTRACT__
36	# include <sproto.h>	31	#include <sproto.h>
37	#endif
38	#include <living.h>	32	#include <living.h>
39	#include <math.h>	33	#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) && (QUERY_FLAG (tmp, FLAG_APPLIED)))
80	continue;	74	continue;
		75
81	if ((aflag == AP_UNAPPLY) && (!QUERY_FLAG (tmp, FLAG_APPLIED)))	76	if ((aflag == AP_UNAPPLY) && (!QUERY_FLAG (tmp, 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 (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 skill %s", params);
125	return 0;	143	return 0;
126	}	144	}
127	return change_skill (pl, skill, 0);
128	}
129		145
		146	pl->change_skill (0);
		147	apply_special (pl, skill, AP_APPLY);
		148	return 1;
		149	}
130		150
131	/* These functions (command_search, command_disarm) are really just wrappers for	151	/* These functions (command_search, command_disarm) are really just wrappers for
132	* things like 'use_skill ...'). In fact, they should really be obsoleted	152	* things like 'use_skill ...'). In fact, they should really be obsoleted
133	* and replaced with those.	153	* and replaced with those.
134	*/	154	*/
…		…
142	command_disarm (object *op, char *params)	162	command_disarm (object *op, char *params)
143	{	163	{
144	return use_skill (op, skill_names[SK_DISARM_TRAPS]);	164	return use_skill (op, skill_names[SK_DISARM_TRAPS]);
145	}	165	}
146		166
147
148	/* A little special because we do want to pass the full params along	167	/* A little special because we do want to pass the full params along
149	* as it includes the object to throw.	168	* as it includes the object to throw.
150	*/	169	*/
151	int	170	int
152	command_throw (object *op, char *params)	171	command_throw (object *op, char *params)
153	{	172	{
154	object *skop;
155
156	skop = find_skill_by_name (op, skill_names[SK_THROWING]);	173	if (object *skop = find_skill_by_name (op, skill_names[SK_THROWING]))
157	if (skop)
158	return do_skill (op, op, skop, op->facing, params);	174	return do_skill (op, op, skop, op->facing, params);
159	else	175	else
160	{
161	new_draw_info (NDI_UNIQUE, 0, op, "You have no knowledge of the skill throwing.");	176	new_draw_info (NDI_UNIQUE, 0, op, "You have no knowledge of the skill throwing.");
162	}	177
163	return 0;	178	return 0;
164	}	179	}
165
166		180
167	int	181	int
168	command_apply (object *op, char *params)	182	command_apply (object *op, char *params)
169	{	183	{
170	if (!params)	184	if (!params)
…		…
172	player_apply_below (op);	186	player_apply_below (op);
173	return 0;	187	return 0;
174	}	188	}
175	else	189	else
176	{	190	{
177	apply_flag aflag = (apply_flag) 0;	191	apply_flag aflag = (apply_flag)0;
178	object *inv;
179		192
180	while (*params == ' ')	193	while (*params == ' ')
181	params++;	194	params++;
		195
182	if (!strncmp (params, "-a ", 3))	196	if (!strncmp (params, "-a ", 3))
183	{	197	{
184	aflag = AP_APPLY;	198	aflag = AP_APPLY;
185	params += 3;	199	params += 3;
186	}	200	}
		201
187	if (!strncmp (params, "-u ", 3))	202	if (!strncmp (params, "-u ", 3))
188	{	203	{
189	aflag = AP_UNAPPLY;	204	aflag = AP_UNAPPLY;
190	params += 3;	205	params += 3;
191	}	206	}
		207
192	while (*params == ' ')	208	while (*params == ' ')
193	params++;	209	params++;
194		210
195	inv = find_best_apply_object_match (op, params, aflag);	211	if (object *inv = find_best_apply_object_match (op, params, aflag))
196	if (inv)
197	{
198	player_apply (op, inv, aflag, 0);	212	player_apply (op, inv, aflag, 0);
199	}
200	else	213	else
201	new_draw_info_format (NDI_UNIQUE, 0, op, "Could not find any match to the %s.", params);	214	new_draw_info_format (NDI_UNIQUE, 0, op, "Could not find any match to the %s.", params);
202	}	215	}
		216
203	return 0;	217	return 0;
204	}	218	}
205		219
206	/*	220	/*
207	* Check if an item op can be put into a sack. If pl exists then tell	221	* Check if an item op can be put into a sack. If pl exists then tell
…		…
213	* not need to use split_ob and stuff.	227	* not need to use split_ob and stuff.
214	*/	228	*/
215	int	229	int
216	sack_can_hold (object *pl, object *sack, object *op, uint32 nrof)	230	sack_can_hold (object *pl, object *sack, object *op, uint32 nrof)
217	{	231	{
218
219	if (!QUERY_FLAG (sack, FLAG_APPLIED))	232	if (!QUERY_FLAG (sack, FLAG_APPLIED))
220	{	233	{
221	new_draw_info_format (NDI_UNIQUE, 0, pl, "The %s is not active.", query_name (sack));	234	new_draw_info_format (NDI_UNIQUE, 0, pl, "The %s is not active.", query_name (sack));
222	return 0;	235	return 0;
223	}	236	}
		237
224	if (sack == op)	238	if (sack == op)
225	{	239	{
226	new_draw_info_format (NDI_UNIQUE, 0, pl, "You can't put the %s into itself.", query_name (sack));	240	new_draw_info_format (NDI_UNIQUE, 0, pl, "You can't put the %s into itself.", query_name (sack));
227	return 0;	241	return 0;
228	}	242	}
		243
229	if (sack->race && (sack->race != op->race || op->type == CONTAINER || (sack->stats.food && sack->stats.food != op->type)))	244	if (sack->race && (sack->race != op->race || op->type == CONTAINER || (sack->stats.food && sack->stats.food != op->type)))
230	{	245	{
231	new_draw_info_format (NDI_UNIQUE, 0, pl, "You can put only %s into the %s.", &sack->race, query_name (sack));	246	new_draw_info_format (NDI_UNIQUE, 0, pl, "You can put only %s into the %s.", &sack->race, query_name (sack));
232	return 0;	247	return 0;
233	}	248	}
		249
234	if (op->type == SPECIAL_KEY && sack->slaying && op->slaying)	250	if (op->type == SPECIAL_KEY && sack->slaying && op->slaying)
235	{	251	{
236	new_draw_info_format (NDI_UNIQUE, 0, pl, "You can't put the key into %s.", query_name (sack));	252	new_draw_info_format (NDI_UNIQUE, 0, pl, "You can't put the key into %s.", query_name (sack));
237	return 0;	253	return 0;
238	}	254	}
		255
239	if (sack->weight_limit && (sint32) (sack->carrying + (nrof ? nrof : 1) *	256	if (sack->weight_limit && (sint32) (sack->carrying + (nrof ? nrof : 1) *
240	(op->weight + (op->type == CONTAINER ? (op->carrying * op->stats.Str) : 0))	257	(op->weight + (op->type == CONTAINER ? (op->carrying * op->stats.Str) : 0))
241	* (100 - sack->stats.Str) / 100) > sack->weight_limit)	258	* (100 - sack->stats.Str) / 100) > sack->weight_limit)
242	{	259	{
243	new_draw_info_format (NDI_UNIQUE, 0, pl, "That won't fit in the %s!", query_name (sack));	260	new_draw_info_format (NDI_UNIQUE, 0, pl, "That won't fit in the %s!", query_name (sack));
244	return 0;	261	return 0;
245	}	262	}
		263
246	/* All other checks pass, must be OK */	264	/* All other checks pass, must be OK */
247	return 1;	265	return 1;
248	}	266	}
249		267
250	/* Pick up commands follow */	268	/* Pick up commands follow */
…		…
255	* pick up (0 means all of them)	273	* pick up (0 means all of them)
256	*/	274	*/
257	static void	275	static void
258	pick_up_object (object *pl, object *op, object *tmp, int nrof)	276	pick_up_object (object *pl, object *op, object *tmp, int nrof)
259	{	277	{
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;	278	object *env = tmp->env;
265	uint32 weight, effective_weight_limit;	279	uint32 weight, effective_weight_limit;
266	int tmp_nrof = tmp->nrof ? tmp->nrof : 1;	280	int tmp_nrof = tmp->number_of ();
267		281
268	/* IF the player is flying & trying to take the item out of a container	282	/* IF the player is flying & trying to take the item out of a container
269	* that is in his inventory, let him. tmp->env points to the container	283	* that is in his inventory, let him. tmp->env points to the container
270	* (sack, luggage, etc), tmp->env->env then points to the player (nested	284	* (sack, luggage, etc), tmp->env->env then points to the player (nested
271	* containers not allowed as of now)	285	* containers not allowed as of now)
272	*/	286	*/
273	if ((pl->move_type & MOVE_FLYING) && !QUERY_FLAG (pl, FLAG_WIZ) && is_player_inv (tmp) != pl)	287	if ((pl->move_type & MOVE_FLYING) && !QUERY_FLAG (pl, FLAG_WIZ) && tmp->in_player () != pl)
274	{	288	{
275	new_draw_info (NDI_UNIQUE, 0, pl, "You are levitating, you can't reach the ground!");	289	pl->failmsg ("You are levitating, you can't reach the ground! "
		290	"H<You have to stop levitating first, if you can, either by using your levitation skill, "
		291	"or waiting till the levitation effect wears off.>");
276	return;	292	return;
277	}	293	}
		294
278	if (QUERY_FLAG (tmp, FLAG_NO_DROP))	295	if (QUERY_FLAG (tmp, FLAG_NO_DROP))
279	return;	296	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		297
292	if (nrof > tmp_nrof || nrof == 0)	298	if (nrof > tmp_nrof || nrof <= 0)
293	nrof = tmp_nrof;	299	nrof = tmp_nrof;
		300
294	/* Figure out how much weight this object will add to the player */	301	/* Figure out how much weight this object will add to the player */
295	weight = tmp->weight * nrof;	302	weight = tmp->weight * nrof;
296	if (tmp->inv)	303	if (tmp->inv)
297	weight += tmp->carrying * (100 - tmp->stats.Str) / 100;	304	weight += tmp->carrying * (100 - tmp->stats.Str) / 100;
298	if (pl->stats.Str <= MAX_STAT)	305
299	effective_weight_limit = weight_limit[pl->stats.Str];	306	effective_weight_limit = weight_limit [min (MAX_STAT, pl->stats.Str)];
300	else	307
301	effective_weight_limit = weight_limit[MAX_STAT];
302	if ((pl->weight + pl->carrying + weight) > effective_weight_limit)	308	if ((pl->weight + pl->carrying + weight) > effective_weight_limit)
303	{	309	{
304	new_draw_info (0, 0, pl, "That item is too heavy for you to pick up.");	310	new_draw_info (0, 0, pl, "That item is too heavy for you to pick up.");
305	return;	311	return;
306	}	312	}
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		313
314	tmp = get_split_ob (tmp, nrof);	314	if (!can_split (pl, tmp, nrof))
315	if (!tmp)
316	{
317	new_draw_info (NDI_UNIQUE, 0, pl, errmsg);
318	return;	315	return;
319	}	316
320	/* Tell a client what happened rest of objects */	317	if (QUERY_FLAG (tmp, FLAG_UNPAID))
321	if (pl->type == PLAYER)	318	{
322	{	319	tmp->flag.reset (FLAG_UNPAID);
323	if (was_destroyed (tmp2, tmp2_tag))	320	new_draw_info_format (NDI_UNIQUE, 0, pl, "%s will cost you %s.", query_name (tmp), query_cost_string (tmp, pl, F_BUY | F_SHOP));
324	esrv_del_item (pl->contr, tmp2_tag);	321	tmp->flag.set (FLAG_UNPAID);
325	else
326	esrv_send_item (pl, tmp2);
327	}
328	}	322	}
329	else	323	else
330	{	324	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		325
348	tmp = insert_ob_in_ob (tmp, op);	326	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	}	327	}
370		328
371		329	/* modified slightly to allow monsters use this -b.t. 5-31-95 */
372	void	330	void
373	pick_up (object *op, object *alt)	331	pick_up (object *op, object *alt)
374
375	/* modified slightly to allow monsters use this -b.t. 5-31-95 */
376	{	332	{
377	int need_fix_tmp = 0;	333	int need_fix_tmp = 0;
378	object *tmp = NULL;	334	object *tmp = NULL;
379	mapstruct *tmp_map = NULL;	335	maptile *tmp_map = NULL;
380	int count;	336	int count;
381	tag_t tag;
382		337
383	/* Decide which object to pick. */	338	/* Decide which object to pick. */
384	if (alt)	339	if (alt)
385	{	340	{
386	if (!can_pick (op, alt))	341	if (!can_pick (op, alt))
387	{	342	{
388	new_draw_info_format (NDI_UNIQUE, 0, op, "You can't pick up the %s.", &alt->name);	343	new_draw_info_format (NDI_UNIQUE, 0, op, "You can't pick up the %s.", &alt->name);
389	goto leave;	344	goto leave;
390	}	345	}
		346
391	tmp = alt;	347	tmp = alt;
392	}	348	}
393	else	349	else
394	{	350	{
395	if (op->below == NULL || !can_pick (op, op->below))	351	if (op->below == NULL || !can_pick (op, op->below))
396	{	352	{
397	new_draw_info (NDI_UNIQUE, 0, op, "There is nothing to pick up here.");	353	new_draw_info (NDI_UNIQUE, 0, op, "There is nothing to pick up here.");
398	goto leave;	354	goto leave;
399	}	355	}
		356
400	tmp = op->below;	357	tmp = op->below;
401	}	358	}
402		359
403	/* Try to catch it. */	360	/* Try to catch it. */
404	tmp_map = tmp->map;	361	tmp_map = tmp->map;
405	tmp = stop_item (tmp);	362	tmp = stop_item (tmp);
406	if (tmp == NULL)	363	if (tmp == NULL)
407	goto leave;	364	goto leave;
		365
408	need_fix_tmp = 1;	366	need_fix_tmp = 1;
409	if (!can_pick (op, tmp))	367	if (!can_pick (op, tmp))
410	goto leave;	368	goto leave;
411		369
412	if (op->type == PLAYER)	370	if (op->type == PLAYER)
…		…
417	}	375	}
418	else	376	else
419	count = tmp->nrof;	377	count = tmp->nrof;
420		378
421	/* container is open, so use it */	379	/* container is open, so use it */
		380	if (tmp->flag [FLAG_STARTEQUIP])
		381	alt = op;
422	if (op->container)	382	else if (op->container)
423	{	383	{
424	alt = op->container;	384	alt = op->container;
425	if (alt != tmp->env && !sack_can_hold (op, alt, tmp, count))	385	if (alt != tmp->env && !sack_can_hold (op, alt, tmp, count))
426	goto leave;	386	goto leave;
427	}	387	}
…		…
434		394
435	if (!alt)	395	if (!alt)
436	for (alt = op->inv; alt; alt = alt->below)	396	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))	397	if (alt->type == CONTAINER && QUERY_FLAG (alt, FLAG_APPLIED) && sack_can_hold (NULL, alt, tmp, count))
438	break; /* General container comes next */	398	break; /* General container comes next */
		399
439	if (!alt)	400	if (!alt)
440	alt = op; /* No free containers */	401	alt = op; /* No free containers */
441	}	402	}
		403
442	if (tmp->env == alt)	404	if (tmp->env == alt)
443	{	405	{
444	/* here it could be possible to check rent,	406	/* here it could be possible to check rent,
445	* if someone wants to implement it	407	* if someone wants to implement it
446	*/	408	*/
447	alt = op;	409	alt = op;
448	}	410	}
		411
449	#ifdef PICKUP_DEBUG	412	#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);	413	LOG (llevDebug, "Pick_up(): %s picks %s (%d) and inserts it %s.\n", op->name, tmp->name, op->contr->count, alt->name);
451	#endif	414	#endif
452		415
453	/* startequip items are not allowed to be put into containers: */	416	/* startequip items are not allowed to be put into containers: */
…		…
455	{	418	{
456	new_draw_info (NDI_UNIQUE, 0, op, "This object cannot be put into containers!");	419	new_draw_info (NDI_UNIQUE, 0, op, "This object cannot be put into containers!");
457	goto leave;	420	goto leave;
458	}	421	}
459		422
460	tag = tmp->count;
461	pick_up_object (op, alt, tmp, count);	423	pick_up_object (op, alt, tmp, count);
		424
462	if (was_destroyed (tmp, tag) || tmp->env)	425	if (tmp->destroyed () || tmp->env)
463	need_fix_tmp = 0;	426	need_fix_tmp = 0;
		427
464	if (op->type == PLAYER)	428	if (op->type == PLAYER)
465	op->contr->count = 0;	429	op->contr->count = 0;
		430
466	goto leave;	431	goto leave;
467		432
468	leave:	433	leave:
469	if (need_fix_tmp)	434	if (need_fix_tmp)
470	fix_stopped_item (tmp, tmp_map, op);	435	fix_stopped_item (tmp, tmp_map, op);
471	}	436	}
472
473		437
474	/* This takes (picks up) and item. op is the player	438	/* This takes (picks up) and item. op is the player
475	* who issued the command. params is a string to	439	* who issued the command. params is a string to
476	* match against the item name. Basically, always	440	* match against the item name. Basically, always
477	* returns zero, but that should be improved.	441	* returns zero, but that should be improved.
…		…
486	else	450	else
487	{	451	{
488	tmp = op->above;	452	tmp = op->above;
489	if (tmp)	453	if (tmp)
490	while (tmp->above)	454	while (tmp->above)
491	{
492	tmp = tmp->above;	455	tmp = tmp->above;
493	}	456
494	if (!tmp)	457	if (!tmp)
495	tmp = op->below;	458	tmp = op->below;
496	}	459	}
497		460
498	if (tmp == NULL)	461	if (!tmp)
499	{	462	{
500	new_draw_info (NDI_UNIQUE, 0, op, "Nothing to take!");	463	new_draw_info (NDI_UNIQUE, 0, op, "Nothing to take!");
501	return 0;	464	return 0;
502	}	465	}
503		466
504	/* Makes processing easier */	467	/* Makes processing easier */
505	if (params && *params == '\0')	468	if (params && *params == '\0')
506	params = NULL;	469	params = 0;
		470
		471	int cnt = MAX_ITEM_PER_DROP;
507		472
508	while (tmp)	473	while (tmp)
509	{	474	{
510	next = tmp->below;	475	next = tmp->below;
511		476
512	if (tmp->invisible)	477	if (tmp->invisible)
513	{	478	{
514	tmp = next;	479	tmp = next;
515	continue;	480	continue;
516	}	481	}
		482
517	/* This following two if and else if could be merged into line	483	/* This following two if and else if could be merged into line
518	* but that probably will make it more difficult to read, and	484	* but that probably will make it more difficult to read, and
519	* not make it any more efficient	485	* not make it any more efficient
520	*/	486	*/
521	if (params && item_matched_string (op, tmp, params))	487	if (params && item_matched_string (op, tmp, params))
522	{	488	{
		489	if (--cnt < 0) break;
523	pick_up (op, tmp);	490	pick_up (op, tmp);
524	}	491	}
525	else if (can_pick (op, tmp) && !params)	492	else if (can_pick (op, tmp) && !params)
526	{	493	{
		494	if (--cnt < 0) break;
527	pick_up (op, tmp);	495	pick_up (op, tmp);
528	break;	496	break;
529	}	497	}
		498
530	tmp = next;	499	tmp = next;
531	/* Might as well just skip over the player immediately -	500	}
532	* we know it can't be picked up	501
533	*/	502	if (cnt < 0)
534	if (tmp == op)
535	tmp = tmp->below;
536	}	503	{
		504	op->failmsg ("Couldn't pick up so many items at once.");
		505	return 0;
		506	}
		507
537	if (!params && !tmp)	508	if (!params && !tmp)
538	{	509	{
539	for (tmp = op->below; tmp != NULL; tmp = tmp->next)	510	for (tmp = op->below; tmp; tmp = tmp->below)
540	if (!tmp->invisible)	511	if (!tmp->invisible)
541	{	512	{
542	char buf[MAX_BUF];
543
544	sprintf (buf, "You can't pick up a %s.", &tmp->name);	513	new_draw_info_format (NDI_UNIQUE, 0, op, "You can't pick up a %s.", &tmp->name);
545	new_draw_info (NDI_UNIQUE, 0, op, buf);
546	break;	514	break;
547	}	515	}
		516
548	if (!tmp)	517	if (!tmp)
549	new_draw_info (NDI_UNIQUE, 0, op, "There is nothing to pick up.");	518	new_draw_info (NDI_UNIQUE, 0, op, "There is nothing to pick up.");
550	}	519	}
		520
551	return 0;	521	return 0;
552	}	522	}
553
554		523
555	/*	524	/*
556	* This function was part of drop, now is own function.	525	* This function was part of drop, now is own function.
557	* Player 'op' tries to put object 'tmp' into sack 'sack',	526	* 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.	527	* if nrof is non zero, then nrof objects is tried to put into sack.
…		…
560	* so this function isn't named very good anymore.	529	* so this function isn't named very good anymore.
561	*/	530	*/
562	void	531	void
563	put_object_in_sack (object *op, object *sack, object *tmp, uint32 nrof)	532	put_object_in_sack (object *op, object *sack, object *tmp, uint32 nrof)
564	{	533	{
565	tag_t tmp_tag, tmp2_tag;
566	object *tmp2, *sack2;	534	object *tmp2, *sack2;
567	char buf[MAX_BUF];	535	char buf[MAX_BUF];
568		536
569	if (sack == tmp)	537	if (sack == tmp)
570	return; /* Can't put an object in itself */	538	return; /* Can't put an object in itself */
		539
571	if (QUERY_FLAG (tmp, FLAG_STARTEQUIP))	540	if (QUERY_FLAG (tmp, FLAG_STARTEQUIP))
572	{	541	{
573	new_draw_info_format (NDI_UNIQUE, 0, op, "You cannot put the %s in the %s.", query_name (tmp), query_name (sack));	542	new_draw_info_format (NDI_UNIQUE, 0, op, "You cannot put the %s in the %s.", query_name (tmp), query_name (sack));
574	return;	543	return;
575	}	544	}
		545
576	if (tmp->type == CONTAINER && tmp->inv)	546	if (tmp->type == CONTAINER && tmp->inv)
577	{	547	{
578
579	/* Eneq(@csd.uu.se): If the object to be dropped is a container	548	/* Eneq(@csd.uu.se): If the object to be dropped is a container
580	* we instead move the contents of that container into the active	549	* we instead move the contents of that container into the active
581	* container, this is only done if the object has something in it.	550	* container, this is only done if the object has something in it.
582	*/	551	*/
583	sack2 = tmp;	552	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));	553	new_draw_info_format (NDI_UNIQUE, 0, op, "You move the items from %s into %s.", query_name (tmp), query_name (sack));
		554
585	for (tmp2 = tmp->inv; tmp2; tmp2 = tmp)	555	for (tmp2 = tmp->inv; tmp2; tmp2 = tmp)
586	{	556	{
587	tmp = tmp2->below;	557	tmp = tmp2->below;
		558
588	if ((sack->type == CONTAINER && sack_can_hold (op, op->container, tmp2, tmp2->nrof)))	559	if ((sack->type == CONTAINER && sack_can_hold (op, op->container, tmp2, tmp2->nrof)))
589	{
590	put_object_in_sack (op, sack, tmp2, 0);	560	put_object_in_sack (op, sack, tmp2, 0);
591	}
592	else	561	else
593	{	562	{
594	sprintf (buf, "Your %s fills up.", query_name (sack));	563	sprintf (buf, "Your %s fills up.", query_name (sack));
595	new_draw_info (NDI_UNIQUE, 0, op, buf);	564	new_draw_info (NDI_UNIQUE, 0, op, buf);
596	break;	565	break;
597	}	566	}
598	}	567	}
599	esrv_update_item (UPD_WEIGHT, op, sack2);	568
600	return;	569	return;
601	}	570	}
602		571
603	/* Don't worry about this for containers - our caller should have	572	/* Don't worry about this for containers - our caller should have
604	* already checked this.	573	* already checked this.
605	*/	574	*/
606	if ((sack->type == CONTAINER) && !sack_can_hold (op, sack, tmp, (nrof ? nrof : tmp->nrof)))	575	if ((sack->type == CONTAINER) && !sack_can_hold (op, sack, tmp, (nrof ? nrof : tmp->nrof)))
607	return;	576	return;
608		577
609	if (QUERY_FLAG (tmp, FLAG_APPLIED))	578	if (QUERY_FLAG (tmp, FLAG_APPLIED))
610	{
611	if (apply_special (op, tmp, AP_UNAPPLY | AP_NO_MERGE))	579	if (apply_special (op, tmp, AP_UNAPPLY | AP_NO_MERGE))
612	return;	580	return;
613	}
614		581
615	/* we want to put some portion of the item into the container */	582	/* we want to put some portion of the item into the container */
616	if (nrof && tmp->nrof != nrof)	583	if (!can_split (op, tmp, nrof))
617	{
618	object *tmp2 = tmp;
619
620	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;	584	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		585
637	new_draw_info_format (NDI_UNIQUE, 0, op, "You put the %s in %s.", query_name (tmp), query_name (sack));	586	new_draw_info_format (NDI_UNIQUE, 0, op, "You put the %s in %s.", query_name (tmp), query_name (sack));
638	tmp_tag = tmp->count;	587	sack->insert (tmp);
639	tmp2 = insert_ob_in_ob (tmp, sack);
640	fix_player (op); /* This is overkill, fix_player() is called somewhere */
641	/* in object.c */
642
643	/* If an object merged (and thus, different object), we need to
644	* delete the original.
645	*/
646	if (tmp2 != tmp)
647	esrv_del_item (op->contr, tmp_tag);
648
649	esrv_send_item (op, tmp2);
650
651	/* update the sacks weight */
652	esrv_update_item (UPD_WEIGHT, op, sack);
653	}	588	}
654		589
655	/*	590	/*
656	* This function was part of drop, now is own function.	591	* This function was part of drop, now is own function.
657	* Player 'op' tries to drop object 'tmp', if tmp is non zero, then	592	* Player 'op' tries to drop object 'tmp', if tmp is non zero, then
…		…
659	* This is used when dropping objects onto the floor.	594	* This is used when dropping objects onto the floor.
660	*/	595	*/
661	void	596	void
662	drop_object (object *op, object *tmp, uint32 nrof)	597	drop_object (object *op, object *tmp, uint32 nrof)
663	{	598	{
664	char buf[MAX_BUF];
665	object *floor;
666
667	if (QUERY_FLAG (tmp, FLAG_NO_DROP))	599	if (QUERY_FLAG (tmp, FLAG_NO_DROP))
668	return;	600	return;
669		601
670	if (QUERY_FLAG (tmp, FLAG_APPLIED))	602	if (QUERY_FLAG (tmp, FLAG_APPLIED))
671	if (apply_special (op, tmp, AP_UNAPPLY | AP_NO_MERGE))	603	if (apply_special (op, tmp, AP_UNAPPLY | AP_NO_MERGE))
672	return; /* can't unapply it */	604	return; /* can't unapply it */
673		605
		606	//fprintf (stderr, "ui, on space is %ld\n", op->ms ().volume ());//D
		607
674	/* We are only dropping some of the items. We split the current objec	608	/* We are only dropping some of the items. We split the current object
675	* off	609	* off
676	*/	610	*/
677	if (nrof && tmp->nrof != nrof)	611	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;	612	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		613
702	if (INVOKE_OBJECT (DROP, tmp, ARG_OBJECT (op)))	614	if (INVOKE_OBJECT (DROP, tmp, ARG_OBJECT (op)))
703	return;	615	return;
704		616
705	if (QUERY_FLAG (tmp, FLAG_STARTEQUIP))	617	if (QUERY_FLAG (tmp, FLAG_STARTEQUIP))
706	{	618	{
707	sprintf (buf, "You drop the %s.", query_name (tmp));	619	op->statusmsg (format ("You drop the %s.", query_name (tmp)));
708	new_draw_info (NDI_UNIQUE, 0, op, buf);	620	op->statusmsg ("The god who lent it to you retrieves it.");
709	new_draw_info (NDI_UNIQUE, 0, op, "The gods who lent it to you retrieves it.");	621
710	if (op->type == PLAYER)	622	tmp->destroy ();
711	esrv_del_item (op->contr, tmp->count);	623	op->update_stats ();
712	free_object (tmp);
713	fix_player (op);
714	return;	624	return;
715	}	625	}
716
717	/* If SAVE_INTERVAL is commented out, we never want to save
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	{
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		626
736	/* Call this before we update the various windows/players. At least	627	/* Call this before we update the various windows/players. At least
737	* that we, we know the weight is correct.	628	* that we, we know the weight is correct.
738	*/	629	*/
739	fix_player (op); /* This is overkill, fix_player() is called somewhere */	630	// 2007-11-26: moved op->update_stats away and calling it later after
740	/* in object.c */	631	// all items of a drop command have been processed.
741		632
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)	633	for (object *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)))	634	if (INVOKE_OBJECT (DROP_ON, floor, ARG_OBJECT (tmp), ARG_OBJECT (op)))
751	return;	635	return;
752		636
753	if (is_in_shop (op) && !QUERY_FLAG (tmp, FLAG_UNPAID) && tmp->type != MONEY)	637	if (is_in_shop (op) && !QUERY_FLAG (tmp, FLAG_UNPAID) && tmp->type != MONEY)
		638	{
754	sell_item (tmp, op);	639	if (!sell_item (tmp, op))
		640	{
		641	// if we can't sell it we don't drop it, so give it back to the seller
		642	op->insert (tmp);
		643	return;
		644	}
		645	}
755		646
756	tmp->x = op->x;	647	tmp->x = op->x;
757	tmp->y = op->y;	648	tmp->y = op->y;
758		649
759	insert_ob_in_map (tmp, op->map, op, INS_BELOW_ORIGINATOR);	650	insert_ob_in_map (tmp, op->map, op, INS_BELOW_ORIGINATOR);
…		…
773	if (tmp->env && tmp->env->type != PLAYER)	664	if (tmp->env && tmp->env->type != PLAYER)
774	{	665	{
775	/* Just toss the object - probably shouldn't be hanging	666	/* Just toss the object - probably shouldn't be hanging
776	* around anyways	667	* around anyways
777	*/	668	*/
778	remove_ob (tmp);	669	tmp->destroy ();
779	free_object (tmp);
780	return;	670	return;
781	}	671	}
782	else	672	else
783	{	673	{
784	while (tmp != NULL && tmp->invisible)	674	while (tmp && tmp->invisible)
785	tmp = tmp->below;	675	tmp = tmp->below;
786	}	676	}
787	}	677	}
788		678
789	if (tmp == NULL)	679	if (tmp == NULL)
790	{	680	{
791	new_draw_info (NDI_UNIQUE, 0, op, "You don't have anything to drop.");	681	new_draw_info (NDI_UNIQUE, 0, op, "You don't have anything to drop.");
792	return;	682	return;
793	}	683	}
		684
794	if (QUERY_FLAG (tmp, FLAG_INV_LOCKED))	685	if (QUERY_FLAG (tmp, FLAG_INV_LOCKED))
795	{	686	{
796	new_draw_info (NDI_UNIQUE, 0, op, "This item is locked");	687	new_draw_info (NDI_UNIQUE, 0, op, "This item is locked");
797	return;	688	return;
798	}	689	}
		690
799	if (QUERY_FLAG (tmp, FLAG_NO_DROP))	691	if (QUERY_FLAG (tmp, FLAG_NO_DROP))
800	{	692	{
801	#if 0	693	#if 0
802	/* Eneq(@csd.uu.se): Objects with NO_DROP defined can't be dropped. */	694	/* 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.");	695	new_draw_info (NDI_UNIQUE, 0, op, "This item can't be dropped.");
804	#endif	696	#endif
805	return;	697	return;
806	}	698	}
807		699
808	if (op->type == PLAYER)	700	if (op->type == PLAYER && op->contr->last_used == tmp)
809	{	701	op->contr->last_used = tmp->below ? tmp->below
810	if (op->contr->last_used == tmp && op->contr->last_used_id == tmp->count)	702	: tmp->above ? tmp->above
811	{	703	: 0;
812	object *n = NULL;
813
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		704
826	if (op->container)	705	if (op->container)
827	{	706	{
828	if (op->type == PLAYER)	707	if (op->type == PLAYER)
829	{
830	put_object_in_sack (op, op->container, tmp, op->contr->count);	708	put_object_in_sack (op, op->container, tmp, op->contr->count);
831	}
832	else	709	else
833	{
834	put_object_in_sack (op, op->container, tmp, 0);	710	put_object_in_sack (op, op->container, tmp, 0);
835	};
836	}	711	}
837	else	712	else
838	{	713	{
839	if (op->type == PLAYER)	714	if (op->type == PLAYER)
840	{
841	drop_object (op, tmp, op->contr->count);	715	drop_object (op, tmp, op->contr->count);
842	}
843	else	716	else
844	{
845	drop_object (op, tmp, 0);	717	drop_object (op, tmp, 0);
846	};
847	}	718	}
		719
848	if (op->type == PLAYER)	720	if (op->type == PLAYER)
849	op->contr->count = 0;	721	op->contr->count = 0;
850	}	722	}
851
852
853		723
854	/* Command will drop all items that have not been locked */	724	/* Command will drop all items that have not been locked */
855	int	725	int
856	command_dropall (object *op, char *params)	726	command_dropall (object *op, char *params)
857	{	727	{
858		728
859	object *curinv, *nextinv;
860
861	if (op->inv == NULL)	729	if (op->inv == NULL)
862	{	730	{
863	new_draw_info (NDI_UNIQUE, 0, op, "Nothing to drop!");	731	new_draw_info (NDI_UNIQUE, 0, op, "Nothing to drop!");
864	return 0;	732	return 0;
865	}	733	}
866		734
867	curinv = op->inv;	735	object *curinv = op->inv;
		736	object *nextinv;
868		737
869	/*	738	/*
870	This is the default. Drops everything not locked or considered	739	This is the default. Drops everything not locked or considered
871	not something that should be dropped.	740	not something that should be dropped.
872	*/	741	*/
…		…
874	Care must be taken that the next item pointer is not to money as	743	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	744	the drop() routine will do unknown things to it when dropping
876	in a shop. --Tero.Pelander@utu.fi	745	in a shop. --Tero.Pelander@utu.fi
877	*/	746	*/
878		747
879	if (params == NULL)	748	int cnt = MAX_ITEM_PER_DROP;
		749
		750	if (!params)
880	{	751	{
881	while (curinv != NULL)	752	while (curinv)
882	{	753	{
883	nextinv = curinv->below;	754	nextinv = curinv->below;
		755
884	while (nextinv && nextinv->type == MONEY)	756	while (nextinv && nextinv->type == MONEY)
885	nextinv = nextinv->below;	757	nextinv = nextinv->below;
		758
886	if (!QUERY_FLAG (curinv, FLAG_INV_LOCKED) && curinv->type != MONEY &&	759	if (!QUERY_FLAG (curinv, FLAG_INV_LOCKED) && curinv->type != MONEY &&
887	curinv->type != FOOD && curinv->type != KEY &&	760	curinv->type != FOOD && curinv->type != KEY &&
888	curinv->type != SPECIAL_KEY && curinv->type != GEM &&	761	curinv->type != SPECIAL_KEY && curinv->type != GEM &&
889	!curinv->invisible && (curinv->type != CONTAINER || op->container != curinv))	762	!curinv->invisible && (curinv->type != CONTAINER || op->container != curinv))
890	{	763	{
891	drop (op, curinv);	764	drop (op, curinv);
		765	if (--cnt <= 0) break;
892	}	766	}
		767
893	curinv = nextinv;	768	curinv = nextinv;
894	}	769	}
895	}	770	}
896
897	else if (strcmp (params, "weapons") == 0)	771	else if (strcmp (params, "weapons") == 0)
898	{	772	{
899	while (curinv != NULL)	773	while (curinv)
900	{	774	{
901	nextinv = curinv->below;	775	nextinv = curinv->below;
		776
902	while (nextinv && nextinv->type == MONEY)	777	while (nextinv && nextinv->type == MONEY)
903	nextinv = nextinv->below;	778	nextinv = nextinv->below;
		779
904	if (!QUERY_FLAG (curinv, FLAG_INV_LOCKED) && ((curinv->type == WEAPON) || (curinv->type == BOW) || (curinv->type == ARROW)))	780	if (!QUERY_FLAG (curinv, FLAG_INV_LOCKED) && ((curinv->type == WEAPON) || (curinv->type == BOW) || (curinv->type == ARROW)))
905	{	781	{
906	drop (op, curinv);	782	drop (op, curinv);
		783	if (--cnt <= 0) break;
907	}	784	}
		785
908	curinv = nextinv;	786	curinv = nextinv;
909	}	787	}
910	}	788	}
911
912	else if (strcmp (params, "armor") == 0 || strcmp (params, "armour") == 0)	789	else if (strcmp (params, "armor") == 0 || strcmp (params, "armour") == 0)
913	{	790	{
914	while (curinv != NULL)	791	while (curinv)
915	{	792	{
916	nextinv = curinv->below;	793	nextinv = curinv->below;
		794
917	while (nextinv && nextinv->type == MONEY)	795	while (nextinv && nextinv->type == MONEY)
918	nextinv = nextinv->below;	796	nextinv = nextinv->below;
		797
919	if (!QUERY_FLAG (curinv, FLAG_INV_LOCKED) && ((curinv->type == ARMOUR) || curinv->type == SHIELD || curinv->type == HELMET))	798	if (!QUERY_FLAG (curinv, FLAG_INV_LOCKED) && ((curinv->type == ARMOUR) || curinv->type == SHIELD || curinv->type == HELMET))
920	{	799	{
921	drop (op, curinv);	800	drop (op, curinv);
		801	if (--cnt <= 0) break;
922	}	802	}
		803
923	curinv = nextinv;	804	curinv = nextinv;
924	}	805	}
925	}	806	}
926
927	else if (strcmp (params, "misc") == 0)	807	else if (strcmp (params, "misc") == 0)
928	{	808	{
929	while (curinv != NULL)	809	while (curinv)
930	{	810	{
931	nextinv = curinv->below;	811	nextinv = curinv->below;
		812
932	while (nextinv && nextinv->type == MONEY)	813	while (nextinv && nextinv->type == MONEY)
933	nextinv = nextinv->below;	814	nextinv = nextinv->below;
		815
934	if (!QUERY_FLAG (curinv, FLAG_INV_LOCKED) && !QUERY_FLAG (curinv, FLAG_APPLIED))	816	if (!QUERY_FLAG (curinv, FLAG_INV_LOCKED) && !QUERY_FLAG (curinv, FLAG_APPLIED))
935	{	817	{
936	switch (curinv->type)	818	switch (curinv->type)
937	{	819	{
938	case HORN:	820	case HORN:
939	case BOOK:	821	case BOOK:
940	case SPELLBOOK:	822	case SPELLBOOK:
941	case GIRDLE:	823	case GIRDLE:
942	case AMULET:	824	case AMULET:
943	case RING:	825	case RING:
944	case CLOAK:	826	case CLOAK:
945	case BOOTS:	827	case BOOTS:
946	case GLOVES:	828	case GLOVES:
947	case BRACERS:	829	case BRACERS:
948	case SCROLL:	830	case SCROLL:
949	case ARMOUR_IMPROVER:	831	case ARMOUR_IMPROVER:
950	case WEAPON_IMPROVER:	832	case WEAPON_IMPROVER:
951	case WAND:	833	case WAND:
952	case ROD:	834	case ROD:
953	case POTION:	835	case POTION:
954	drop (op, curinv);	836	drop (op, curinv);
955	curinv = nextinv;	837	curinv = nextinv;
956	break;	838	break;
957	default:	839	default:
958	curinv = nextinv;	840	curinv = nextinv;
959	break;	841	break;
960	}	842	}
		843
		844	if (--cnt <= 0) break;
961	}	845	}
		846
962	curinv = nextinv;	847	curinv = nextinv;
963	}	848	}
964	}	849	}
965	op->contr->socket.update_look = 1;	850
		851	if (cnt <= 0)
		852	op->failmsg ("Only dropped some items, can't drop that many items at once.");
966		853
967	/* draw_look(op);*/	854	/* draw_look(op);*/
968	return 0;	855	return 0;
969	}	856	}
970		857
971	/* Object op wants to drop object(s) params. params can be a	858	/* Object op wants to drop object(s) params. params can be a
972	* comma seperated list.	859	* comma seperated list.
973	*/	860	*/
974
975	int	861	int
976	command_drop (object *op, char *params)	862	command_drop (object *op, char *params)
977	{	863	{
978	object *tmp, *next;	864	object *tmp, *next;
979	int did_one = 0;	865	int did_one = 0;
…		…
983	new_draw_info (NDI_UNIQUE, 0, op, "Drop what?");	869	new_draw_info (NDI_UNIQUE, 0, op, "Drop what?");
984	return 0;	870	return 0;
985	}	871	}
986	else	872	else
987	{	873	{
		874	int cnt = MAX_ITEM_PER_DROP;
		875
988	for (tmp = op->inv; tmp; tmp = next)	876	for (tmp = op->inv; tmp; tmp = next)
989	{	877	{
990	next = tmp->below;	878	next = tmp->below;
991	if (QUERY_FLAG (tmp, FLAG_NO_DROP) || tmp->invisible)	879	if (QUERY_FLAG (tmp, FLAG_NO_DROP) || tmp->invisible)
992	continue;	880	continue;
		881
993	if (item_matched_string (op, tmp, params))	882	if (item_matched_string (op, tmp, params))
994	{	883	{
995	drop (op, tmp);	884	drop (op, tmp);
		885	if (--cnt <= 0) break;
996	did_one = 1;	886	did_one = 1;
997	}	887	}
998	}	888	}
		889
999	if (!did_one)	890	if (!did_one)
1000	new_draw_info (NDI_UNIQUE, 0, op, "Nothing to drop.");	891	new_draw_info (NDI_UNIQUE, 0, op, "Nothing to drop.");
1001	}	892
1002	if (op->type == PLAYER)	893	if (cnt <= 0)
1003	{	894	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	};	895	}
1007		896
1008	/* draw_look(op);*/
1009	return 0;	897	return 0;
1010	}	898	}
1011		899
1012	int	900	int
1013	command_examine (object *op, char *params)	901	command_examine (object *op, char *params)
1014	{	902	{
1015	if (!params)	903	if (!params)
1016	{	904	{
1017	object *tmp = op->below;	905	object *tmp = op->below;
1018		906
1019	while (tmp && !LOOK_OBJ (tmp))	907	while (tmp && !tmp->client_visible ())
1020	tmp = tmp->below;	908	tmp = tmp->below;
		909
1021	if (tmp)	910	if (tmp)
1022	examine (op, tmp);	911	examine (op, tmp);
1023	}	912	}
1024	else	913	else
1025	{	914	{
1026	object *tmp = find_best_object_match (op, params);	915	object *tmp = find_best_object_match (op, params);
1027		916
1028	if (tmp)	917	if (tmp)
1029	examine (op, tmp);	918	examine (op, tmp);
1030	else	919	else
1031	new_draw_info_format (NDI_UNIQUE, 0, op, "Could not find an object that matches %s", params);	920	op->contr->infobox (MSG_CHANNEL ("examine"), format ("Could not find an object that matches %s", params));
1032	}	921	}
		922
1033	return 0;	923	return 0;
1034	}	924	}
1035		925
1036	/* op should be a player.	926	/* op should be a player.
1037	* we return the object the player has marked with the 'mark' command	927	* we return the object the player has marked with the 'mark' command
…		…
1044	{	934	{
1045	object *tmp;	935	object *tmp;
1046		936
1047	if (!op || !op->contr)	937	if (!op || !op->contr)
1048	return NULL;	938	return NULL;
		939
1049	if (!op->contr->mark)	940	if (!op->contr->mark)
1050	{	941	{
1051
1052	/* new_draw_info(NDI_UNIQUE,0,op,"You have no marked object");*/	942	/* new_draw_info(NDI_UNIQUE,0,op,"You have no marked object");*/
1053	return NULL;	943	return 0;
1054	}	944	}
		945
1055	/* This may seem like overkill, but we need to make sure that they	946	/* 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	947	* player hasn't dropped the item. We use count on the off chance that
1057	* an item got reincarnated at some point.	948	* an item got reincarnated at some point.
1058	*/	949	*/
1059	for (tmp = op->inv; tmp; tmp = tmp->below)	950	for (tmp = op->inv; tmp; tmp = tmp->below)
1060	{	951	{
1061	if (tmp->invisible)	952	if (tmp->invisible)
1062	continue;	953	continue;
		954
1063	if (tmp == op->contr->mark)	955	if (tmp == op->contr->mark)
1064	{	956	{
1065	if (tmp->count == op->contr->mark_count)	957	if (!tmp->destroyed ())
1066	return tmp;	958	return tmp;
1067	else	959	else
1068	{	960	{
1069	op->contr->mark = NULL;	961	op->contr->mark = 0;
1070	op->contr->mark_count = 0;
1071
1072	/* new_draw_info(NDI_UNIQUE,0,op,"You have no marked object");*/	962	/* new_draw_info(NDI_UNIQUE,0,op,"You have no marked object");*/
1073	return NULL;	963	return 0;
1074	}	964	}
1075	}	965	}
1076	}	966	}
1077	return NULL;
1078	}
1079		967
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;	968	return 0;
1090	if (!params)	969	}
1091	{
1092	object *mark = find_marked_object (op);
1093		970
1094	if (!mark)	971	std::string
1095	new_draw_info (NDI_UNIQUE, 0, op, "You have no marked object.");	972	object::describe_monster (object *who)
1096	else	973	{
1097	new_draw_info_format (NDI_UNIQUE, 0, op, "%s is marked.", query_name (mark));	974	dynbuf_text buf (512, 512);
1098	}	975
		976	object *mon = head ? head : this;
		977
		978	if (QUERY_FLAG (mon, FLAG_UNDEAD))
		979	buf << "It is an undead force.\r";
		980
		981	if (mon->level > who->level)
		982	buf << "It is likely more powerful than you.\r";
		983	else if (mon->level < who->level)
		984	buf << "It is likely less powerful than you.\r";
1099	else	985	else
		986	buf << "It is probably as powerful as you.\r";
		987
		988	if (mon->attacktype & AT_ACID)
		989	buf << "You seem to smell an acrid odor.\r";
		990
		991	/* Anyone know why this used to use the clone value instead of the
		992	* maxhp field? This seems that it should give more accurate results.
		993	*/
		994	switch ((mon->stats.hp + 1) * 4 / (mon->stats.maxhp + 1))
		995	{ /* From 1-4 */
		996	case 1:
		997	buf << "It is in a bad shape.\r";
		998	break;
		999	case 2:
		1000	buf << "It is hurt.\r";
		1001	break;
		1002	case 3:
		1003	buf << "It is somewhat hurt.\r";
		1004	break;
		1005	case 4:
		1006	buf << "It is in excellent shape.\r";
		1007	break;
1100	{	1008	}
1101	object *mark1 = find_best_object_match (op, params);
1102		1009
1103	if (!mark1)	1010	if (present_in_ob (POISONING, mon))
1104	{	1011	buf << "It looks very ill.\r";
1105	new_draw_info_format (NDI_UNIQUE, 0, op, "Could not find an object that matches %s", params);	1012
1106	return 1;	1013	buf << '\n';
		1014
		1015	return buf;
		1016	}
		1017
		1018	/* tmp is the object being described, pl is who is examing it. */
		1019	const char *
		1020	long_desc (object *tmp, object *pl)
		1021	{
		1022	static std::string s;
		1023
		1024	return (s = tmp->long_desc (pl)).c_str ();
		1025	}
		1026
		1027	std::string
		1028	object::long_desc (object *who)
		1029	{
		1030	std::string buf (query_name (this));
		1031
		1032	switch (type)
		1033	{
		1034	case RING:
		1035	case SKILL:
		1036	case WEAPON:
		1037	case ARMOUR:
		1038	case BRACERS:
		1039	case HELMET:
		1040	case SHIELD:
		1041	case BOOTS:
		1042	case GLOVES:
		1043	case AMULET:
		1044	case GIRDLE:
		1045	case BOW:
		1046	case ARROW:
		1047	case CLOAK:
		1048	case FOOD:
		1049	case DRINK:
		1050	case FLESH:
		1051	case SKILL_TOOL:
		1052	case POWER_CRYSTAL:
1107	}	1053	{
1108	else	1054	const char *cp = ::describe_item (this, who);
		1055
		1056	if (*cp)
		1057	{
		1058	buf.append (" ");
		1059	buf.append (cp);
		1060	}
1109	{	1061	}
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	}	1062	}
1116	return 0; /*shouldnt get here */
1117	}
1118		1063
		1064	return buf;
		1065	}
1119		1066
1120	/* op is the player	1067	/* op is the player
1121	* tmp is the monster being examined.	1068	* tmp is the monster being examined.
1122	*/	1069	*/
1123	void	1070	void
1124	examine_monster (object *op, object *tmp)	1071	examine_monster (object *op, object *tmp)
1125	{	1072	{
1126	object *mon = tmp->head ? tmp->head : tmp;	1073	new_draw_info (NDI_UNIQUE, 0, op, tmp->describe_monster (op).c_str ());
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)
1137	new_draw_info (NDI_UNIQUE, 0, op, "You seem to smell an acrid odor.");
1138
1139	/* 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.
1141	*/
1142	switch ((mon->stats.hp + 1) * 4 / (mon->stats.maxhp + 1))
1143	{ /* From 1-4 */
1144	case 1:
1145	new_draw_info (NDI_UNIQUE, 0, op, "It is in a bad shape.");
1146	break;
1147	case 2:
1148	new_draw_info (NDI_UNIQUE, 0, op, "It is hurt.");
1149	break;
1150	case 3:
1151	new_draw_info (NDI_UNIQUE, 0, op, "It is somewhat hurt.");
1152	break;
1153	case 4:
1154	new_draw_info (NDI_UNIQUE, 0, op, "It is in excellent shape.");
1155	break;
1156	}
1157	if (present_in_ob (POISONING, mon) != NULL)
1158	new_draw_info (NDI_UNIQUE, 0, op, "It looks very ill.");
1159	}	1074	}
1160		1075
1161		1076	std::string
1162	/* tmp is the object being described, pl is who is examing it. */	1077	object::describe (object *who)
1163	char *
1164	long_desc (object *tmp, object *pl)
1165	{	1078	{
1166	static char buf[VERY_BIG_BUF];	1079	dynbuf_text buf (1024, 1024);
1167	char *cp;
1168		1080
1169	if (tmp == NULL)	1081	buf.printf ("That is: %s.\r", long_desc (who).c_str ());
1170	return "";
1171		1082
1172	buf[0] = '\0';
1173	switch (tmp->type)
1174	{
1175	case RING:
1176	case SKILL:
1177	case WEAPON:
1178	case ARMOUR:
1179	case BRACERS:
1180	case HELMET:
1181	case SHIELD:
1182	case BOOTS:
1183	case GLOVES:
1184	case AMULET:
1185	case GIRDLE:
1186	case BOW:
1187	case ARROW:
1188	case CLOAK:
1189	case FOOD:
1190	case DRINK:
1191	case FLESH:
1192	case SKILL_TOOL:
1193	case POWER_CRYSTAL:
1194	if (*(cp = describe_item (tmp, pl)) != '\0')
1195	{
1196	int len;
1197
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	}
1211	}
1212	if (buf[0] == '\0')
1213	{
1214	strncpy (buf, query_name (tmp), VERY_BIG_BUF - 1);
1215	buf[VERY_BIG_BUF - 1] = 0;
1216	}
1217
1218	return buf;
1219	}
1220
1221	void
1222	examine (object *op, object *tmp)
1223	{
1224	char buf[VERY_BIG_BUF];
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)	1083	if (custom_name)
1238	{	1084	buf.printf ("You call it %s.\r", &custom_name);
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		1085
1246	switch (tmp->type)	1086	switch (type)
1247	{	1087	{
1248	case SPELLBOOK:	1088	case SPELLBOOK:
1249	if (QUERY_FLAG (tmp, FLAG_IDENTIFIED) && tmp->inv)	1089	if (flag [FLAG_IDENTIFIED] && inv)
1250	{
1251	sprintf (buf, "%s is a %s level %s spell", &tmp->inv->name, get_levelnumber (tmp->inv->level), &tmp->inv->skill);	1090	buf.printf ("%s is a %s %s spell.\r", &inv->name, get_levelnumber (inv->level), &inv->skill);
1252	}
1253	break;	1091	break;
1254		1092
1255	case BOOK:	1093	case BOOK:
1256	if (tmp->msg != NULL)	1094	if (msg)
1257	strcpy (buf, "Something is written in it.");	1095	buf << "Something is written in it.\r";
1258	break;	1096	break;
1259		1097
1260	case CONTAINER:	1098	case CONTAINER:
1261	if (tmp->race != NULL)	1099	if (race)
1262	{	1100	{
1263	if (tmp->weight_limit && tmp->stats.Str < 100)	1101	if (weight_limit && stats.Str < 100)
1264	sprintf (buf, "It can hold only %s and its weight limit is %.1f kg.",	1102	buf.printf ("It can hold only %s and its weight limit is %.1f kg.\r",
1265	&tmp->race, tmp->weight_limit / (10.0 * (100 - tmp->stats.Str)));	1103	&race, weight_limit / (10.0 * (100 - stats.Str)));
1266	else	1104	else
1267	sprintf (buf, "It can hold only %s.", &tmp->race);	1105	buf.printf ("It can hold only %s.\r", &race);
1268	}	1106	}
1269	else if (tmp->weight_limit && tmp->stats.Str < 100)	1107	else if (weight_limit && stats.Str < 100)
1270	sprintf (buf, "Its weight limit is %.1f kg.", tmp->weight_limit / (10.0 * (100 - tmp->stats.Str)));	1108	buf.printf ("Its weight limit is %.1f kg.\r", weight_limit / (10.0 * (100 - stats.Str)));
1271	break;	1109	break;
1272		1110
1273	case WAND:	1111	case WAND:
1274	if (QUERY_FLAG (tmp, FLAG_IDENTIFIED))	1112	if (flag [FLAG_IDENTIFIED])
1275	sprintf (buf, "It has %d charges left.", tmp->stats.food);	1113	buf.printf ("It has %d charges left.\r", stats.food);
1276	break;	1114	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	{	1115	}
		1116
		1117	if (materialname && !msg)
1284	sprintf (buf, "It is made of: %s.", &tmp->materialname);	1118	buf.printf ("It is made of: %s.\r", &materialname);
1285	new_draw_info (NDI_UNIQUE, 0, op, buf);	1119
1286	}	1120	if (who)
1287	/* Where to wear this item */	1121	/* Where to wear this item */
1288	for (i = 0; i < NUM_BODY_LOCATIONS; i++)	1122	for (int i = 0; i < NUM_BODY_LOCATIONS; i++)
1289	{	1123	if (slot[i].info)
1290	if (tmp->body_info[i] < -1)	1124	{
		1125	buf << (who->slot[i].info ? body_locations[i].use_name : body_locations[i].nonuse_name);
		1126
		1127	if (slot[i].info < -1 && who->slot[i].info)
		1128	buf.printf ("(%d)", -slot[i].info);
		1129
		1130	buf << ".\r";
1291	{	1131	}
1292	if (op->body_info[i])	1132
1293	new_draw_info_format (NDI_UNIQUE, 0, op, "It goes %s (%d)", body_locations[i].use_name, -tmp->body_info[i]);	1133	if (weight)
		1134	buf.printf ("%s %3.3f kg.\r", nrof > 1 ? "They weigh" : "It weighs", weight * (nrof ? nrof : 1) / 1000.0);
		1135
		1136	if (value && !flag [FLAG_STARTEQUIP] && !flag [FLAG_NO_PICK] && who)
		1137	{
		1138	buf.printf ("You reckon %s worth %s.\r", nrof > 1 ? "they are" : "it is", query_cost_string (this, who, F_TRUE | F_APPROX));
		1139
		1140	if (is_in_shop (who))
		1141	{
		1142	if (flag [FLAG_UNPAID])
		1143	buf.printf ("%s would cost you %s.\r", nrof > 1 ? "They" : "It", query_cost_string (this, who, F_BUY | F_SHOP));
1294	else	1144	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");	1145	buf.printf ("You are offered %s for %s.\r", query_cost_string (this, who, F_SELL + F_SHOP), nrof > 1 ? "them" : "it");
1322	new_draw_info (NDI_UNIQUE, 0, op, buf);
1323	}	1146	}
1324	}	1147	}
1325		1148
1326	if (QUERY_FLAG (tmp, FLAG_MONSTER))	1149	if (flag [FLAG_MONSTER])
1327	examine_monster (op, tmp);	1150	buf << describe_monster (who);
1328		1151
1329	/* Is this item buildable? */	1152	/* Is this item buildable? */
1330	if (QUERY_FLAG (tmp, FLAG_IS_BUILDABLE))	1153	if (flag [FLAG_IS_BUILDABLE])
1331	new_draw_info (NDI_UNIQUE, 0, op, "This is a buildable item.");	1154	buf << "This is a buildable item.\r";
1332		1155
1333	/* Does the object have a message? Don't show message for all object	1156	/* Does the object have a message? Don't show message for all object
1334	* types - especially if the first entry is a match	1157	* types - especially if the first entry is a match
1335	*/	1158	*/
1336	if (tmp->msg && tmp->type != EXIT && tmp->type != BOOK && tmp->type != CORPSE && !tmp->move_on && strncasecmp (tmp->msg, "@match", 7))	1159	if (msg && type != EXIT && type != BOOK && type != CORPSE && !move_on && !has_dialogue ())
1337	{	1160	{
1338
1339	/* This is just a hack so when identifying the items, we print	1161	/* This is just a hack so when identifying the items, we print
1340	* out the extra message	1162	* out the extra message
1341	*/	1163	*/
1342	if (need_identify (tmp) && QUERY_FLAG (tmp, FLAG_IDENTIFIED))	1164	if (need_identify (this) && flag [FLAG_IDENTIFIED])
1343	new_draw_info (NDI_UNIQUE, 0, op, "The object has a story:");	1165	buf << "The object has a story:\r";
1344		1166
1345	new_draw_info (NDI_UNIQUE, 0, op, tmp->msg);	1167	buf << msg << '\n';
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	{	1168	}
1364	new_draw_info (NDI_UNIQUE, 0, op, "Inventory of what object?");
1365	return;
1366	}
1367	tmp = inv ? inv->inv : op->inv;
1368		1169
1369	while (tmp)	1170	buf << '\n';
1370	{	1171
1371	if ((!tmp->invisible &&	1172	return std::string (buf.linearise (), buf.size ());
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	}	1173	}
1417		1174
1418	static void	1175	static void
1419	display_new_pickup (object *op)	1176	display_new_pickup (object *op)
1420	{	1177	{
…		…
1457	new_draw_info_format (NDI_UNIQUE, 0, op, "%d MAGICDEVICE", i & PU_MAGIC_DEVICE ? 1 : 0);	1214	new_draw_info_format (NDI_UNIQUE, 0, op, "%d MAGICDEVICE", i & PU_MAGIC_DEVICE ? 1 : 0);
1458		1215
1459	new_draw_info_format (NDI_UNIQUE, 0, op, "%d NOT CURSED", i & PU_NOT_CURSED ? 1 : 0);	1216	new_draw_info_format (NDI_UNIQUE, 0, op, "%d NOT CURSED", i & PU_NOT_CURSED ? 1 : 0);
1460		1217
1461	new_draw_info_format (NDI_UNIQUE, 0, op, "%d JEWELS", i & PU_JEWELS ? 1 : 0);	1218	new_draw_info_format (NDI_UNIQUE, 0, op, "%d JEWELS", i & PU_JEWELS ? 1 : 0);
		1219	new_draw_info_format (NDI_UNIQUE, 0, op, "%d FLESH", i & PU_FLESH ? 1 : 0);
1462		1220
1463	new_draw_info_format (NDI_UNIQUE, 0, op, "");	1221	new_draw_info_format (NDI_UNIQUE, 0, op, "");
1464	}	1222	}
1465		1223
1466	int	1224	int
…		…
1468	{	1226	{
1469	uint32 i;	1227	uint32 i;
1470	static const char *names[] = {	1228	static const char *names[] = {
1471	"debug", "inhibit", "stop", "food", "drink", "valuables", "bow", "arrow", "helmet",	1229	"debug", "inhibit", "stop", "food", "drink", "valuables", "bow", "arrow", "helmet",
1472	"shield", "armour", "boots", "gloves", "cloak", "key", "missile", "allweapon",	1230	"shield", "armour", "boots", "gloves", "cloak", "key", "missile", "allweapon",
1473	"magical", "potion", "spellbook", "skillscroll", "readables", "magicdevice", "notcursed", "jewels", NULL	1231	"magical", "potion", "spellbook", "skillscroll", "readables", "magicdevice", "notcursed",
		1232	"jewels", "flesh", NULL
1474	};	1233	};
1475	static uint32 modes[] = {	1234	static uint32 modes[] = {
1476	PU_DEBUG, PU_INHIBIT, PU_STOP, PU_FOOD, PU_DRINK, PU_VALUABLES, PU_BOW, PU_ARROW, PU_HELMET,	1235	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,	1236	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	1237	PU_MAGICAL, PU_POTION, PU_SPELLBOOK, PU_SKILLSCROLL, PU_READABLES, PU_MAGIC_DEVICE, PU_NOT_CURSED,
		1238	PU_JEWELS, PU_FLESH, 0
1479	};	1239	};
1480		1240
1481	if (!params)	1241	if (!params)
1482	{	1242	{
1483	/* if the new mode is used, just print the settings */	1243	/* if the new mode is used, just print the settings */
…		…
1534	void	1294	void
1535	set_pickup_mode (object *op, int i)	1295	set_pickup_mode (object *op, int i)
1536	{	1296	{
1537	switch (op->contr->mode = i)	1297	switch (op->contr->mode = i)
1538	{	1298	{
1539	case 0:	1299	case 0:
1540	new_draw_info (NDI_UNIQUE, 0, op, "Mode: Don't pick up.");	1300	new_draw_info (NDI_UNIQUE, 0, op, "Mode: Don't pick up.");
1541	break;	1301	break;
1542	case 1:	1302	case 1:
1543	new_draw_info (NDI_UNIQUE, 0, op, "Mode: Pick up one item.");	1303	new_draw_info (NDI_UNIQUE, 0, op, "Mode: Pick up one item.");
1544	break;	1304	break;
1545	case 2:	1305	case 2:
1546	new_draw_info (NDI_UNIQUE, 0, op, "Mode: Pick up one item and stop.");	1306	new_draw_info (NDI_UNIQUE, 0, op, "Mode: Pick up one item and stop.");
1547	break;	1307	break;
1548	case 3:	1308	case 3:
1549	new_draw_info (NDI_UNIQUE, 0, op, "Mode: Stop before picking up.");	1309	new_draw_info (NDI_UNIQUE, 0, op, "Mode: Stop before picking up.");
1550	break;	1310	break;
1551	case 4:	1311	case 4:
1552	new_draw_info (NDI_UNIQUE, 0, op, "Mode: Pick up all items.");	1312	new_draw_info (NDI_UNIQUE, 0, op, "Mode: Pick up all items.");
1553	break;	1313	break;
1554	case 5:	1314	case 5:
1555	new_draw_info (NDI_UNIQUE, 0, op, "Mode: Pick up all items and stop.");	1315	new_draw_info (NDI_UNIQUE, 0, op, "Mode: Pick up all items and stop.");
1556	break;	1316	break;
1557	case 6:	1317	case 6:
1558	new_draw_info (NDI_UNIQUE, 0, op, "Mode: Pick up all magic items.");	1318	new_draw_info (NDI_UNIQUE, 0, op, "Mode: Pick up all magic items.");
1559	break;	1319	break;
1560	case 7:	1320	case 7:
1561	new_draw_info (NDI_UNIQUE, 0, op, "Mode: Pick up all coins and gems");	1321	new_draw_info (NDI_UNIQUE, 0, op, "Mode: Pick up all coins and gems");
1562	break;	1322	break;
1563	}	1323	}
1564	}	1324	}
1565		1325
1566	int	1326	int
1567	command_search_items (object *op, char *params)	1327	command_search_items (object *op, char *params)
…		…
1578	new_draw_info (NDI_UNIQUE, 0, op, "Example: search magic+1");	1338	new_draw_info (NDI_UNIQUE, 0, op, "Example: search magic+1");
1579	new_draw_info (NDI_UNIQUE, 0, op, "Would automatically pick up all");	1339	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'.");	1340	new_draw_info (NDI_UNIQUE, 0, op, "items containing the word 'magic+1'.");
1581	return 1;	1341	return 1;
1582	}	1342	}
		1343
1583	op->contr->search_str[0] = '\0';	1344	op->contr->search_str[0] = '\0';
1584	new_draw_info (NDI_UNIQUE, 0, op, "Search mode turned off.");	1345	new_draw_info (NDI_UNIQUE, 0, op, "Search mode turned off.");
1585	fix_player (op);	1346	op->update_stats ();
1586	return 1;	1347	return 1;
1587	}	1348	}
		1349
1588	if ((int) strlen (params) >= MAX_BUF)	1350	if ((int) strlen (params) >= MAX_BUF)
1589	{	1351	{
1590	new_draw_info (NDI_UNIQUE, 0, op, "Search string too long.");	1352	new_draw_info (NDI_UNIQUE, 0, op, "Search string too long.");
1591	return 1;	1353	return 1;
1592	}	1354	}
		1355
1593	strcpy (op->contr->search_str, params);	1356	strcpy (op->contr->search_str, params);
1594	sprintf (buf, "Searching for '%s'.", op->contr->search_str);	1357	sprintf (buf, "Searching for '%s'.", op->contr->search_str);
1595	new_draw_info (NDI_UNIQUE, 0, op, buf);	1358	new_draw_info (NDI_UNIQUE, 0, op, buf);
1596	fix_player (op);	1359	op->update_stats ();
1597	return 1;	1360	return 1;
1598	}	1361	}
1599		1362
1600	/*
1601	* Changing the custom name of an item
1602	*
1603	* Syntax is: rename <what object> to <new name>
1604	* if '<what object>' is omitted, marked object is used
1605	* if 'to <new name>' is omitted, custom name is cleared
1606	*
1607	* Names are considered for all purpose having a length <=127 (max length sent to client
1608	* by server) */
1609
1610	int
1611	command_rename_item (object *op, char *params)
1612	{
1613	char buf[VERY_BIG_BUF];
1614	int itemnumber;
1615	object *item = NULL;
1616	char *closebrace;
1617	size_t counter;
1618
1619	if (params)
1620	{
1621	/* Let's skip white spaces */
1622	while (' ' == *params)
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
1671	{
1672	/* Use marked item */
1673	item = find_marked_object (op);
1674	if (!item)
1675	{
1676	new_draw_info (NDI_UNIQUE, 0, op, "No marked item to rename.");
1677	return 1;
1678	}
1679	}
1680
1681	/* Now let's find the new name */
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	}
1733	else
1734	{
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	{
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
1757	if (QUERY_FLAG (item, FLAG_UNPAID))
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	}

Diff Legend

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