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.76 by root, Sun Sep 7 21:31:23 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;
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		612
702	if (INVOKE_OBJECT (DROP, tmp, ARG_OBJECT (op)))	613	if (INVOKE_OBJECT (DROP, tmp, ARG_OBJECT (op)))
703	return;	614	return;
704		615
705	if (QUERY_FLAG (tmp, FLAG_STARTEQUIP))	616	if (QUERY_FLAG (tmp, FLAG_STARTEQUIP))
706	{	617	{
707	sprintf (buf, "You drop the %s.", query_name (tmp));	618	op->statusmsg (format ("You drop the %s.", query_name (tmp)));
708	new_draw_info (NDI_UNIQUE, 0, op, buf);	619	op->statusmsg ("The gods who lent it to you retrieves it.");
709	new_draw_info (NDI_UNIQUE, 0, op, "The gods who lent it to you retrieves it.");	620
710	if (op->type == PLAYER)	621	tmp->destroy ();
711	esrv_del_item (op->contr, tmp->count);	622	op->update_stats ();
712	free_object (tmp);
713	fix_player (op);
714	return;	623	return;
715	}	624	}
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		625
736	/* Call this before we update the various windows/players. At least	626	/* Call this before we update the various windows/players. At least
737	* that we, we know the weight is correct.	627	* that we, we know the weight is correct.
738	*/	628	*/
739	fix_player (op); /* This is overkill, fix_player() is called somewhere */	629	// 2007-11-26: moved op->update_stats away and calling it later after
740	/* in object.c */	630	// all items of a drop command have been processed.
741		631
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)	632	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)))	633	if (INVOKE_OBJECT (DROP_ON, floor, ARG_OBJECT (tmp), ARG_OBJECT (op)))
751	return;	634	return;
752		635
753	if (is_in_shop (op) && !QUERY_FLAG (tmp, FLAG_UNPAID) && tmp->type != MONEY)	636	if (is_in_shop (op) && !QUERY_FLAG (tmp, FLAG_UNPAID) && tmp->type != MONEY)
		637	{
754	sell_item (tmp, op);	638	if (!sell_item (tmp, op))
		639	return; // if we can't sell it we don't drop it
		640	}
755		641
756	tmp->x = op->x;	642	tmp->x = op->x;
757	tmp->y = op->y;	643	tmp->y = op->y;
758		644
759	insert_ob_in_map (tmp, op->map, op, INS_BELOW_ORIGINATOR);	645	insert_ob_in_map (tmp, op->map, op, INS_BELOW_ORIGINATOR);
…		…
773	if (tmp->env && tmp->env->type != PLAYER)	659	if (tmp->env && tmp->env->type != PLAYER)
774	{	660	{
775	/* Just toss the object - probably shouldn't be hanging	661	/* Just toss the object - probably shouldn't be hanging
776	* around anyways	662	* around anyways
777	*/	663	*/
778	remove_ob (tmp);	664	tmp->remove ();
779	free_object (tmp);	665	tmp->destroy ();
780	return;	666	return;
781	}	667	}
782	else	668	else
783	{	669	{
784	while (tmp != NULL && tmp->invisible)	670	while (tmp && tmp->invisible)
785	tmp = tmp->below;	671	tmp = tmp->below;
786	}	672	}
787	}	673	}
788		674
789	if (tmp == NULL)	675	if (tmp == NULL)
790	{	676	{
791	new_draw_info (NDI_UNIQUE, 0, op, "You don't have anything to drop.");	677	new_draw_info (NDI_UNIQUE, 0, op, "You don't have anything to drop.");
792	return;	678	return;
793	}	679	}
		680
794	if (QUERY_FLAG (tmp, FLAG_INV_LOCKED))	681	if (QUERY_FLAG (tmp, FLAG_INV_LOCKED))
795	{	682	{
796	new_draw_info (NDI_UNIQUE, 0, op, "This item is locked");	683	new_draw_info (NDI_UNIQUE, 0, op, "This item is locked");
797	return;	684	return;
798	}	685	}
		686
799	if (QUERY_FLAG (tmp, FLAG_NO_DROP))	687	if (QUERY_FLAG (tmp, FLAG_NO_DROP))
800	{	688	{
801	#if 0	689	#if 0
802	/* Eneq(@csd.uu.se): Objects with NO_DROP defined can't be dropped. */	690	/* 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.");	691	new_draw_info (NDI_UNIQUE, 0, op, "This item can't be dropped.");
804	#endif	692	#endif
805	return;	693	return;
806	}	694	}
807		695
808	if (op->type == PLAYER)	696	if (op->type == PLAYER && op->contr->last_used == tmp)
809	{	697	op->contr->last_used = tmp->below ? tmp->below
810	if (op->contr->last_used == tmp && op->contr->last_used_id == tmp->count)	698	: tmp->above ? tmp->above
811	{	699	: 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		700
826	if (op->container)	701	if (op->container)
827	{	702	{
828	if (op->type == PLAYER)	703	if (op->type == PLAYER)
829	{
830	put_object_in_sack (op, op->container, tmp, op->contr->count);	704	put_object_in_sack (op, op->container, tmp, op->contr->count);
831	}
832	else	705	else
833	{
834	put_object_in_sack (op, op->container, tmp, 0);	706	put_object_in_sack (op, op->container, tmp, 0);
835	};
836	}	707	}
837	else	708	else
838	{	709	{
839	if (op->type == PLAYER)	710	if (op->type == PLAYER)
840	{
841	drop_object (op, tmp, op->contr->count);	711	drop_object (op, tmp, op->contr->count);
842	}
843	else	712	else
844	{
845	drop_object (op, tmp, 0);	713	drop_object (op, tmp, 0);
846	};
847	}	714	}
		715
848	if (op->type == PLAYER)	716	if (op->type == PLAYER)
849	op->contr->count = 0;	717	op->contr->count = 0;
850	}	718	}
851
852
853		719
854	/* Command will drop all items that have not been locked */	720	/* Command will drop all items that have not been locked */
855	int	721	int
856	command_dropall (object *op, char *params)	722	command_dropall (object *op, char *params)
857	{	723	{
858		724
859	object *curinv, *nextinv;
860
861	if (op->inv == NULL)	725	if (op->inv == NULL)
862	{	726	{
863	new_draw_info (NDI_UNIQUE, 0, op, "Nothing to drop!");	727	new_draw_info (NDI_UNIQUE, 0, op, "Nothing to drop!");
864	return 0;	728	return 0;
865	}	729	}
866		730
867	curinv = op->inv;	731	object *curinv = op->inv;
		732	object *nextinv;
868		733
869	/*	734	/*
870	This is the default. Drops everything not locked or considered	735	This is the default. Drops everything not locked or considered
871	not something that should be dropped.	736	not something that should be dropped.
872	*/	737	*/
…		…
874	Care must be taken that the next item pointer is not to money as	739	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	740	the drop() routine will do unknown things to it when dropping
876	in a shop. --Tero.Pelander@utu.fi	741	in a shop. --Tero.Pelander@utu.fi
877	*/	742	*/
878		743
879	if (params == NULL)	744	int cnt = MAX_ITEM_PER_DROP;
		745
		746	if (!params)
880	{	747	{
881	while (curinv != NULL)	748	while (curinv)
882	{	749	{
883	nextinv = curinv->below;	750	nextinv = curinv->below;
		751
884	while (nextinv && nextinv->type == MONEY)	752	while (nextinv && nextinv->type == MONEY)
885	nextinv = nextinv->below;	753	nextinv = nextinv->below;
		754
886	if (!QUERY_FLAG (curinv, FLAG_INV_LOCKED) && curinv->type != MONEY &&	755	if (!QUERY_FLAG (curinv, FLAG_INV_LOCKED) && curinv->type != MONEY &&
887	curinv->type != FOOD && curinv->type != KEY &&	756	curinv->type != FOOD && curinv->type != KEY &&
888	curinv->type != SPECIAL_KEY && curinv->type != GEM &&	757	curinv->type != SPECIAL_KEY && curinv->type != GEM &&
889	!curinv->invisible && (curinv->type != CONTAINER || op->container != curinv))	758	!curinv->invisible && (curinv->type != CONTAINER || op->container != curinv))
890	{	759	{
891	drop (op, curinv);	760	drop (op, curinv);
		761	if (--cnt <= 0) break;
892	}	762	}
		763
893	curinv = nextinv;	764	curinv = nextinv;
894	}	765	}
895	}	766	}
896
897	else if (strcmp (params, "weapons") == 0)	767	else if (strcmp (params, "weapons") == 0)
898	{	768	{
899	while (curinv != NULL)	769	while (curinv)
900	{	770	{
901	nextinv = curinv->below;	771	nextinv = curinv->below;
		772
902	while (nextinv && nextinv->type == MONEY)	773	while (nextinv && nextinv->type == MONEY)
903	nextinv = nextinv->below;	774	nextinv = nextinv->below;
		775
904	if (!QUERY_FLAG (curinv, FLAG_INV_LOCKED) && ((curinv->type == WEAPON) || (curinv->type == BOW) || (curinv->type == ARROW)))	776	if (!QUERY_FLAG (curinv, FLAG_INV_LOCKED) && ((curinv->type == WEAPON) || (curinv->type == BOW) || (curinv->type == ARROW)))
905	{	777	{
906	drop (op, curinv);	778	drop (op, curinv);
		779	if (--cnt <= 0) break;
907	}	780	}
		781
908	curinv = nextinv;	782	curinv = nextinv;
909	}	783	}
910	}	784	}
911
912	else if (strcmp (params, "armor") == 0 || strcmp (params, "armour") == 0)	785	else if (strcmp (params, "armor") == 0 || strcmp (params, "armour") == 0)
913	{	786	{
914	while (curinv != NULL)	787	while (curinv)
915	{	788	{
916	nextinv = curinv->below;	789	nextinv = curinv->below;
		790
917	while (nextinv && nextinv->type == MONEY)	791	while (nextinv && nextinv->type == MONEY)
918	nextinv = nextinv->below;	792	nextinv = nextinv->below;
		793
919	if (!QUERY_FLAG (curinv, FLAG_INV_LOCKED) && ((curinv->type == ARMOUR) || curinv->type == SHIELD || curinv->type == HELMET))	794	if (!QUERY_FLAG (curinv, FLAG_INV_LOCKED) && ((curinv->type == ARMOUR) || curinv->type == SHIELD || curinv->type == HELMET))
920	{	795	{
921	drop (op, curinv);	796	drop (op, curinv);
		797	if (--cnt <= 0) break;
922	}	798	}
		799
923	curinv = nextinv;	800	curinv = nextinv;
924	}	801	}
925	}	802	}
926
927	else if (strcmp (params, "misc") == 0)	803	else if (strcmp (params, "misc") == 0)
928	{	804	{
929	while (curinv != NULL)	805	while (curinv)
930	{	806	{
931	nextinv = curinv->below;	807	nextinv = curinv->below;
		808
932	while (nextinv && nextinv->type == MONEY)	809	while (nextinv && nextinv->type == MONEY)
933	nextinv = nextinv->below;	810	nextinv = nextinv->below;
		811
934	if (!QUERY_FLAG (curinv, FLAG_INV_LOCKED) && !QUERY_FLAG (curinv, FLAG_APPLIED))	812	if (!QUERY_FLAG (curinv, FLAG_INV_LOCKED) && !QUERY_FLAG (curinv, FLAG_APPLIED))
935	{	813	{
936	switch (curinv->type)	814	switch (curinv->type)
937	{	815	{
938	case HORN:	816	case HORN:
939	case BOOK:	817	case BOOK:
940	case SPELLBOOK:	818	case SPELLBOOK:
941	case GIRDLE:	819	case GIRDLE:
942	case AMULET:	820	case AMULET:
943	case RING:	821	case RING:
944	case CLOAK:	822	case CLOAK:
945	case BOOTS:	823	case BOOTS:
946	case GLOVES:	824	case GLOVES:
947	case BRACERS:	825	case BRACERS:
948	case SCROLL:	826	case SCROLL:
949	case ARMOUR_IMPROVER:	827	case ARMOUR_IMPROVER:
950	case WEAPON_IMPROVER:	828	case WEAPON_IMPROVER:
951	case WAND:	829	case WAND:
952	case ROD:	830	case ROD:
953	case POTION:	831	case POTION:
954	drop (op, curinv);	832	drop (op, curinv);
955	curinv = nextinv;	833	curinv = nextinv;
956	break;	834	break;
957	default:	835	default:
958	curinv = nextinv;	836	curinv = nextinv;
959	break;	837	break;
960	}	838	}
		839
		840	if (--cnt <= 0) break;
961	}	841	}
		842
962	curinv = nextinv;	843	curinv = nextinv;
963	}	844	}
964	}	845	}
965	op->contr->socket.update_look = 1;	846
		847	if (cnt <= 0)
		848	op->failmsg ("Only dropped some items, can't drop that many items at once.");
966		849
967	/* draw_look(op);*/	850	/* draw_look(op);*/
968	return 0;	851	return 0;
969	}	852	}
970		853
971	/* Object op wants to drop object(s) params. params can be a	854	/* Object op wants to drop object(s) params. params can be a
972	* comma seperated list.	855	* comma seperated list.
973	*/	856	*/
974
975	int	857	int
976	command_drop (object *op, char *params)	858	command_drop (object *op, char *params)
977	{	859	{
978	object *tmp, *next;	860	object *tmp, *next;
979	int did_one = 0;	861	int did_one = 0;
…		…
983	new_draw_info (NDI_UNIQUE, 0, op, "Drop what?");	865	new_draw_info (NDI_UNIQUE, 0, op, "Drop what?");
984	return 0;	866	return 0;
985	}	867	}
986	else	868	else
987	{	869	{
		870	int cnt = MAX_ITEM_PER_DROP;
		871
988	for (tmp = op->inv; tmp; tmp = next)	872	for (tmp = op->inv; tmp; tmp = next)
989	{	873	{
990	next = tmp->below;	874	next = tmp->below;
991	if (QUERY_FLAG (tmp, FLAG_NO_DROP) || tmp->invisible)	875	if (QUERY_FLAG (tmp, FLAG_NO_DROP) || tmp->invisible)
992	continue;	876	continue;
		877
993	if (item_matched_string (op, tmp, params))	878	if (item_matched_string (op, tmp, params))
994	{	879	{
995	drop (op, tmp);	880	drop (op, tmp);
		881	if (--cnt <= 0) break;
996	did_one = 1;	882	did_one = 1;
997	}	883	}
998	}	884	}
		885
999	if (!did_one)	886	if (!did_one)
1000	new_draw_info (NDI_UNIQUE, 0, op, "Nothing to drop.");	887	new_draw_info (NDI_UNIQUE, 0, op, "Nothing to drop.");
1001	}	888
1002	if (op->type == PLAYER)	889	if (cnt <= 0)
1003	{	890	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	};	891	}
1007		892
1008	/* draw_look(op);*/
1009	return 0;	893	return 0;
1010	}	894	}
1011		895
1012	int	896	int
1013	command_examine (object *op, char *params)	897	command_examine (object *op, char *params)
1014	{	898	{
1015	if (!params)	899	if (!params)
1016	{	900	{
1017	object *tmp = op->below;	901	object *tmp = op->below;
1018		902
1019	while (tmp && !LOOK_OBJ (tmp))	903	while (tmp && !tmp->client_visible ())
1020	tmp = tmp->below;	904	tmp = tmp->below;
		905
1021	if (tmp)	906	if (tmp)
1022	examine (op, tmp);	907	examine (op, tmp);
1023	}	908	}
1024	else	909	else
1025	{	910	{
1026	object *tmp = find_best_object_match (op, params);	911	object *tmp = find_best_object_match (op, params);
1027		912
1028	if (tmp)	913	if (tmp)
1029	examine (op, tmp);	914	examine (op, tmp);
1030	else	915	else
1031	new_draw_info_format (NDI_UNIQUE, 0, op, "Could not find an object that matches %s", params);	916	op->contr->infobox (MSG_CHANNEL ("examine"), format ("Could not find an object that matches %s", params));
1032	}	917	}
		918
1033	return 0;	919	return 0;
1034	}	920	}
1035		921
1036	/* op should be a player.	922	/* op should be a player.
1037	* we return the object the player has marked with the 'mark' command	923	* we return the object the player has marked with the 'mark' command
…		…
1044	{	930	{
1045	object *tmp;	931	object *tmp;
1046		932
1047	if (!op || !op->contr)	933	if (!op || !op->contr)
1048	return NULL;	934	return NULL;
		935
1049	if (!op->contr->mark)	936	if (!op->contr->mark)
1050	{	937	{
1051
1052	/* new_draw_info(NDI_UNIQUE,0,op,"You have no marked object");*/	938	/* new_draw_info(NDI_UNIQUE,0,op,"You have no marked object");*/
1053	return NULL;	939	return 0;
1054	}	940	}
		941
1055	/* This may seem like overkill, but we need to make sure that they	942	/* 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	943	* player hasn't dropped the item. We use count on the off chance that
1057	* an item got reincarnated at some point.	944	* an item got reincarnated at some point.
1058	*/	945	*/
1059	for (tmp = op->inv; tmp; tmp = tmp->below)	946	for (tmp = op->inv; tmp; tmp = tmp->below)
1060	{	947	{
1061	if (tmp->invisible)	948	if (tmp->invisible)
1062	continue;	949	continue;
		950
1063	if (tmp == op->contr->mark)	951	if (tmp == op->contr->mark)
1064	{	952	{
1065	if (tmp->count == op->contr->mark_count)	953	if (!tmp->destroyed ())
1066	return tmp;	954	return tmp;
1067	else	955	else
1068	{	956	{
1069	op->contr->mark = NULL;	957	op->contr->mark = 0;
1070	op->contr->mark_count = 0;
1071
1072	/* new_draw_info(NDI_UNIQUE,0,op,"You have no marked object");*/	958	/* new_draw_info(NDI_UNIQUE,0,op,"You have no marked object");*/
1073	return NULL;	959	return 0;
1074	}	960	}
1075	}	961	}
1076	}	962	}
1077	return NULL;
1078	}
1079		963
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;	964	return 0;
1090	if (!params)	965	}
1091	{
1092	object *mark = find_marked_object (op);
1093		966
1094	if (!mark)	967	std::string
1095	new_draw_info (NDI_UNIQUE, 0, op, "You have no marked object.");	968	object::describe_monster (object *who)
1096	else	969	{
1097	new_draw_info_format (NDI_UNIQUE, 0, op, "%s is marked.", query_name (mark));	970	dynbuf_text buf (512, 512);
1098	}	971
		972	object *mon = head ? head : this;
		973
		974	if (QUERY_FLAG (mon, FLAG_UNDEAD))
		975	buf << " - It is an undead force.\n";
		976
		977	if (mon->level > who->level)
		978	buf << " - It is likely more powerful than you.\n";
		979	else if (mon->level < who->level)
		980	buf << " - It is likely less powerful than you.\n";
1099	else	981	else
		982	buf << " - It is probably as powerful as you.\n";
		983
		984	if (mon->attacktype & AT_ACID)
		985	buf << " - You seem to smell an acrid odor.\n";
		986
		987	/* Anyone know why this used to use the clone value instead of the
		988	* maxhp field? This seems that it should give more accurate results.
		989	*/
		990	switch ((mon->stats.hp + 1) * 4 / (mon->stats.maxhp + 1))
		991	{ /* From 1-4 */
		992	case 1:
		993	buf << " - It is in a bad shape.\n";
		994	break;
		995	case 2:
		996	buf << " - It is hurt.\n";
		997	break;
		998	case 3:
		999	buf << " - It is somewhat hurt.\n";
		1000	break;
		1001	case 4:
		1002	buf << " - It is in excellent shape.\n";
		1003	break;
1100	{	1004	}
1101	object *mark1 = find_best_object_match (op, params);
1102		1005
1103	if (!mark1)	1006	if (present_in_ob (POISONING, mon))
1104	{	1007	buf << " - It looks very ill.\n";
1105	new_draw_info_format (NDI_UNIQUE, 0, op, "Could not find an object that matches %s", params);	1008
1106	return 1;	1009	return buf;
		1010	}
		1011
		1012	/* tmp is the object being described, pl is who is examing it. */
		1013	const char *
		1014	long_desc (object *tmp, object *pl)
		1015	{
		1016	static std::string s;
		1017
		1018	return (s = tmp->long_desc (pl)).c_str ();
		1019	}
		1020
		1021	std::string
		1022	object::long_desc (object *who)
		1023	{
		1024	std::string buf (query_name (this));
		1025
		1026	switch (type)
		1027	{
		1028	case RING:
		1029	case SKILL:
		1030	case WEAPON:
		1031	case ARMOUR:
		1032	case BRACERS:
		1033	case HELMET:
		1034	case SHIELD:
		1035	case BOOTS:
		1036	case GLOVES:
		1037	case AMULET:
		1038	case GIRDLE:
		1039	case BOW:
		1040	case ARROW:
		1041	case CLOAK:
		1042	case FOOD:
		1043	case DRINK:
		1044	case FLESH:
		1045	case SKILL_TOOL:
		1046	case POWER_CRYSTAL:
1107	}	1047	{
1108	else	1048	const char *cp = ::describe_item (this, who);
		1049
		1050	if (*cp)
		1051	{
		1052	buf.append (" ");
		1053	buf.append (cp);
		1054	}
1109	{	1055	}
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	}	1056	}
1116	return 0; /*shouldnt get here */
1117	}
1118		1057
		1058	return buf;
		1059	}
1119		1060
1120	/* op is the player	1061	/* op is the player
1121	* tmp is the monster being examined.	1062	* tmp is the monster being examined.
1122	*/	1063	*/
1123	void	1064	void
1124	examine_monster (object *op, object *tmp)	1065	examine_monster (object *op, object *tmp)
1125	{	1066	{
1126	object *mon = tmp->head ? tmp->head : tmp;	1067	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	}	1068	}
1160		1069
1161		1070	std::string
1162	/* tmp is the object being described, pl is who is examing it. */	1071	object::describe (object *who)
1163	char *
1164	long_desc (object *tmp, object *pl)
1165	{	1072	{
1166	static char buf[VERY_BIG_BUF];	1073	dynbuf_text buf (1024, 1024);
1167	char *cp;
1168		1074
1169	if (tmp == NULL)	1075	buf.printf ("That is: %s.\n\n", long_desc (who).c_str ());
1170	return "";
1171		1076
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)	1077	if (custom_name)
1238	{	1078	buf.printf ("You call it %s.\n\n", &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		1079
1246	switch (tmp->type)	1080	switch (type)
1247	{	1081	{
1248	case SPELLBOOK:	1082	case SPELLBOOK:
1249	if (QUERY_FLAG (tmp, FLAG_IDENTIFIED) && tmp->inv)	1083	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);	1084	buf.printf ("%s is a %s %s spell.\n", &inv->name, get_levelnumber (inv->level), &inv->skill);
1252	}
1253	break;	1085	break;
1254		1086
1255	case BOOK:	1087	case BOOK:
1256	if (tmp->msg != NULL)	1088	if (msg)
1257	strcpy (buf, "Something is written in it.");	1089	buf << "Something is written in it.\n";
1258	break;	1090	break;
1259		1091
1260	case CONTAINER:	1092	case CONTAINER:
1261	if (tmp->race != NULL)	1093	if (race != NULL)
1262	{	1094	{
1263	if (tmp->weight_limit && tmp->stats.Str < 100)	1095	if (weight_limit && stats.Str < 100)
1264	sprintf (buf, "It can hold only %s and its weight limit is %.1f kg.",	1096	buf.printf ("It can hold only %s and its weight limit is %.1f kg.\n",
1265	&tmp->race, tmp->weight_limit / (10.0 * (100 - tmp->stats.Str)));	1097	&race, weight_limit / (10.0 * (100 - stats.Str)));
1266	else	1098	else
1267	sprintf (buf, "It can hold only %s.", &tmp->race);	1099	buf.printf ("It can hold only %s.\n", &race);
1268	}	1100	}
1269	else if (tmp->weight_limit && tmp->stats.Str < 100)	1101	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)));	1102	buf.printf ("Its weight limit is %.1f kg.\n", weight_limit / (10.0 * (100 - stats.Str)));
1271	break;	1103	break;
1272		1104
1273	case WAND:	1105	case WAND:
1274	if (QUERY_FLAG (tmp, FLAG_IDENTIFIED))	1106	if (flag [FLAG_IDENTIFIED])
1275	sprintf (buf, "It has %d charges left.", tmp->stats.food);	1107	buf.printf ("It has %d charges left.\n", stats.food);
1276	break;	1108	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	{	1109	}
		1110
		1111	if (materialname && !msg)
1284	sprintf (buf, "It is made of: %s.", &tmp->materialname);	1112	buf.printf ("It is made of: %s.\n", &materialname);
1285	new_draw_info (NDI_UNIQUE, 0, op, buf);	1113
1286	}	1114	if (who)
1287	/* Where to wear this item */	1115	/* Where to wear this item */
1288	for (i = 0; i < NUM_BODY_LOCATIONS; i++)	1116	for (int i = 0; i < NUM_BODY_LOCATIONS; i++)
1289	{	1117	if (slot[i].info)
1290	if (tmp->body_info[i] < -1)	1118	{
		1119	buf << (who->slot[i].info ? body_locations[i].use_name : body_locations[i].nonuse_name);
		1120
		1121	if (slot[i].info < -1 && who->slot[i].info)
		1122	buf.printf ("(%d)", -slot[i].info);
		1123
		1124	buf << ".\n";
1291	{	1125	}
1292	if (op->body_info[i])	1126
1293	new_draw_info_format (NDI_UNIQUE, 0, op, "It goes %s (%d)", body_locations[i].use_name, -tmp->body_info[i]);	1127	if (weight)
		1128	buf.printf (nrof > 1 ? "They weigh %3.3f kg.\n" : "It weighs %3.3f kg.\n", weight * (nrof ? nrof : 1) / 1000.0);
		1129
		1130	if (value && !flag [FLAG_STARTEQUIP] && !flag [FLAG_NO_PICK] && who)
		1131	{
		1132	buf.printf ("You reckon %s worth %s.\n", nrof > 1 ? "they are" : "it is", query_cost_string (this, who, F_TRUE | F_APPROX));
		1133
		1134	if (is_in_shop (who))
		1135	{
		1136	if (flag [FLAG_UNPAID])
		1137	buf.printf ("%s would cost you %s.\n", nrof > 1 ? "They" : "It", query_cost_string (this, who, F_BUY | F_SHOP));
1294	else	1138	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");	1139	buf.printf ("You are offered %s for %s.\n", query_cost_string (this, who, F_SELL + F_SHOP), nrof > 1 ? "them" : "it");
1322	new_draw_info (NDI_UNIQUE, 0, op, buf);
1323	}	1140	}
1324	}	1141	}
1325		1142
1326	if (QUERY_FLAG (tmp, FLAG_MONSTER))	1143	if (flag [FLAG_MONSTER])
1327	examine_monster (op, tmp);	1144	buf << describe_monster (who);
1328		1145
1329	/* Is this item buildable? */	1146	/* Is this item buildable? */
1330	if (QUERY_FLAG (tmp, FLAG_IS_BUILDABLE))	1147	if (flag [FLAG_IS_BUILDABLE])
1331	new_draw_info (NDI_UNIQUE, 0, op, "This is a buildable item.");	1148	buf << "This is a buildable item.\n";
1332		1149
1333	/* Does the object have a message? Don't show message for all object	1150	/* Does the object have a message? Don't show message for all object
1334	* types - especially if the first entry is a match	1151	* types - especially if the first entry is a match
1335	*/	1152	*/
1336	if (tmp->msg && tmp->type != EXIT && tmp->type != BOOK && tmp->type != CORPSE && !tmp->move_on && strncasecmp (tmp->msg, "@match", 7))	1153	if (msg && type != EXIT && type != BOOK && type != CORPSE && !move_on && !has_dialogue ())
1337	{	1154	{
1338
1339	/* This is just a hack so when identifying the items, we print	1155	/* This is just a hack so when identifying the items, we print
1340	* out the extra message	1156	* out the extra message
1341	*/	1157	*/
1342	if (need_identify (tmp) && QUERY_FLAG (tmp, FLAG_IDENTIFIED))	1158	if (need_identify (this) && flag [FLAG_IDENTIFIED])
1343	new_draw_info (NDI_UNIQUE, 0, op, "The object has a story:");	1159	buf << "The object has a story:\n\n";
1344		1160
1345	new_draw_info (NDI_UNIQUE, 0, op, tmp->msg);	1161	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	{	1162	}
1364	new_draw_info (NDI_UNIQUE, 0, op, "Inventory of what object?");
1365	return;
1366	}
1367	tmp = inv ? inv->inv : op->inv;
1368		1163
1369	while (tmp)	1164	buf << '\n';
1370	{	1165
1371	if ((!tmp->invisible &&	1166	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	}	1167	}
1417		1168
1418	static void	1169	static void
1419	display_new_pickup (object *op)	1170	display_new_pickup (object *op)
1420	{	1171	{
…		…
1457	new_draw_info_format (NDI_UNIQUE, 0, op, "%d MAGICDEVICE", i & PU_MAGIC_DEVICE ? 1 : 0);	1208	new_draw_info_format (NDI_UNIQUE, 0, op, "%d MAGICDEVICE", i & PU_MAGIC_DEVICE ? 1 : 0);
1458		1209
1459	new_draw_info_format (NDI_UNIQUE, 0, op, "%d NOT CURSED", i & PU_NOT_CURSED ? 1 : 0);	1210	new_draw_info_format (NDI_UNIQUE, 0, op, "%d NOT CURSED", i & PU_NOT_CURSED ? 1 : 0);
1460		1211
1461	new_draw_info_format (NDI_UNIQUE, 0, op, "%d JEWELS", i & PU_JEWELS ? 1 : 0);	1212	new_draw_info_format (NDI_UNIQUE, 0, op, "%d JEWELS", i & PU_JEWELS ? 1 : 0);
		1213	new_draw_info_format (NDI_UNIQUE, 0, op, "%d FLESH", i & PU_FLESH ? 1 : 0);
1462		1214
1463	new_draw_info_format (NDI_UNIQUE, 0, op, "");	1215	new_draw_info_format (NDI_UNIQUE, 0, op, "");
1464	}	1216	}
1465		1217
1466	int	1218	int
…		…
1468	{	1220	{
1469	uint32 i;	1221	uint32 i;
1470	static const char *names[] = {	1222	static const char *names[] = {
1471	"debug", "inhibit", "stop", "food", "drink", "valuables", "bow", "arrow", "helmet",	1223	"debug", "inhibit", "stop", "food", "drink", "valuables", "bow", "arrow", "helmet",
1472	"shield", "armour", "boots", "gloves", "cloak", "key", "missile", "allweapon",	1224	"shield", "armour", "boots", "gloves", "cloak", "key", "missile", "allweapon",
1473	"magical", "potion", "spellbook", "skillscroll", "readables", "magicdevice", "notcursed", "jewels", NULL	1225	"magical", "potion", "spellbook", "skillscroll", "readables", "magicdevice", "notcursed",
		1226	"jewels", "flesh", NULL
1474	};	1227	};
1475	static uint32 modes[] = {	1228	static uint32 modes[] = {
1476	PU_DEBUG, PU_INHIBIT, PU_STOP, PU_FOOD, PU_DRINK, PU_VALUABLES, PU_BOW, PU_ARROW, PU_HELMET,	1229	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,	1230	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	1231	PU_MAGICAL, PU_POTION, PU_SPELLBOOK, PU_SKILLSCROLL, PU_READABLES, PU_MAGIC_DEVICE, PU_NOT_CURSED,
		1232	PU_JEWELS, PU_FLESH, 0
1479	};	1233	};
1480		1234
1481	if (!params)	1235	if (!params)
1482	{	1236	{
1483	/* if the new mode is used, just print the settings */	1237	/* if the new mode is used, just print the settings */
…		…
1534	void	1288	void
1535	set_pickup_mode (object *op, int i)	1289	set_pickup_mode (object *op, int i)
1536	{	1290	{
1537	switch (op->contr->mode = i)	1291	switch (op->contr->mode = i)
1538	{	1292	{
1539	case 0:	1293	case 0:
1540	new_draw_info (NDI_UNIQUE, 0, op, "Mode: Don't pick up.");	1294	new_draw_info (NDI_UNIQUE, 0, op, "Mode: Don't pick up.");
1541	break;	1295	break;
1542	case 1:	1296	case 1:
1543	new_draw_info (NDI_UNIQUE, 0, op, "Mode: Pick up one item.");	1297	new_draw_info (NDI_UNIQUE, 0, op, "Mode: Pick up one item.");
1544	break;	1298	break;
1545	case 2:	1299	case 2:
1546	new_draw_info (NDI_UNIQUE, 0, op, "Mode: Pick up one item and stop.");	1300	new_draw_info (NDI_UNIQUE, 0, op, "Mode: Pick up one item and stop.");
1547	break;	1301	break;
1548	case 3:	1302	case 3:
1549	new_draw_info (NDI_UNIQUE, 0, op, "Mode: Stop before picking up.");	1303	new_draw_info (NDI_UNIQUE, 0, op, "Mode: Stop before picking up.");
1550	break;	1304	break;
1551	case 4:	1305	case 4:
1552	new_draw_info (NDI_UNIQUE, 0, op, "Mode: Pick up all items.");	1306	new_draw_info (NDI_UNIQUE, 0, op, "Mode: Pick up all items.");
1553	break;	1307	break;
1554	case 5:	1308	case 5:
1555	new_draw_info (NDI_UNIQUE, 0, op, "Mode: Pick up all items and stop.");	1309	new_draw_info (NDI_UNIQUE, 0, op, "Mode: Pick up all items and stop.");
1556	break;	1310	break;
1557	case 6:	1311	case 6:
1558	new_draw_info (NDI_UNIQUE, 0, op, "Mode: Pick up all magic items.");	1312	new_draw_info (NDI_UNIQUE, 0, op, "Mode: Pick up all magic items.");
1559	break;	1313	break;
1560	case 7:	1314	case 7:
1561	new_draw_info (NDI_UNIQUE, 0, op, "Mode: Pick up all coins and gems");	1315	new_draw_info (NDI_UNIQUE, 0, op, "Mode: Pick up all coins and gems");
1562	break;	1316	break;
1563	}	1317	}
1564	}	1318	}
1565		1319
1566	int	1320	int
1567	command_search_items (object *op, char *params)	1321	command_search_items (object *op, char *params)
…		…
1578	new_draw_info (NDI_UNIQUE, 0, op, "Example: search magic+1");	1332	new_draw_info (NDI_UNIQUE, 0, op, "Example: search magic+1");
1579	new_draw_info (NDI_UNIQUE, 0, op, "Would automatically pick up all");	1333	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'.");	1334	new_draw_info (NDI_UNIQUE, 0, op, "items containing the word 'magic+1'.");
1581	return 1;	1335	return 1;
1582	}	1336	}
		1337
1583	op->contr->search_str[0] = '\0';	1338	op->contr->search_str[0] = '\0';
1584	new_draw_info (NDI_UNIQUE, 0, op, "Search mode turned off.");	1339	new_draw_info (NDI_UNIQUE, 0, op, "Search mode turned off.");
1585	fix_player (op);	1340	op->update_stats ();
1586	return 1;	1341	return 1;
1587	}	1342	}
		1343
1588	if ((int) strlen (params) >= MAX_BUF)	1344	if ((int) strlen (params) >= MAX_BUF)
1589	{	1345	{
1590	new_draw_info (NDI_UNIQUE, 0, op, "Search string too long.");	1346	new_draw_info (NDI_UNIQUE, 0, op, "Search string too long.");
1591	return 1;	1347	return 1;
1592	}	1348	}
		1349
1593	strcpy (op->contr->search_str, params);	1350	strcpy (op->contr->search_str, params);
1594	sprintf (buf, "Searching for '%s'.", op->contr->search_str);	1351	sprintf (buf, "Searching for '%s'.", op->contr->search_str);
1595	new_draw_info (NDI_UNIQUE, 0, op, buf);	1352	new_draw_info (NDI_UNIQUE, 0, op, buf);
1596	fix_player (op);	1353	op->update_stats ();
1597	return 1;	1354	return 1;
1598	}	1355	}
1599		1356
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