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.15 by root, Tue Sep 12 19:20:08 2006 UTC vs.
Revision 1.76 by root, Sun Sep 7 21:31:23 2008 UTC

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

Diff Legend

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