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

Diff Legend

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