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.22 by root, Sun Dec 3 00:59:58 2006 UTC vs.
Revision 1.89 by elmex, Mon Jan 12 00:17:23 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) && is_player_inv (tmp) != 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	if (!QUERY_FLAG (tmp, FLAG_REMOVED))
282	remove_ob (tmp);
283
284	free_object (tmp);
285	return;
286	}
287
288	if (nrof > tmp_nrof || nrof == 0)	282	if (nrof > tmp_nrof || nrof <= 0)
289	nrof = tmp_nrof;	283	nrof = tmp_nrof;
290		284
291	/* 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 */
292	weight = tmp->weight * nrof;	286	weight = tmp->weight * nrof;
293	if (tmp->inv)	287	if (tmp->inv)
294	weight += tmp->carrying * (100 - tmp->stats.Str) / 100;	288	weight += tmp->carrying * (100 - tmp->stats.Str) / 100;
295		289
296	if (pl->stats.Str <= MAX_STAT)
297	effective_weight_limit = weight_limit[pl->stats.Str];	290	effective_weight_limit = weight_limit [min (MAX_STAT, pl->stats.Str)];
298	else
299	effective_weight_limit = weight_limit[MAX_STAT];
300		291
301	if ((pl->weight + pl->carrying + weight) > effective_weight_limit)	292	if ((pl->weight + pl->carrying + weight) > effective_weight_limit)
302	{	293	{
303	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.");
304	return;	295	return;
305	}	296	}
306		297
307	if (settings.real_wiz == FALSE && QUERY_FLAG (pl, FLAG_WAS_WIZ))	298	if (!can_split (pl, tmp, nrof))
308	SET_FLAG (tmp, FLAG_WAS_WIZ);
309
310	if (nrof != tmp_nrof)
311	{
312	object *tmp2 = tmp;
313
314	tmp = get_split_ob (tmp, nrof);
315	if (!tmp)
316	{
317	new_draw_info (NDI_UNIQUE, 0, pl, errmsg);
318	return;	299	return;
319	}
320		300
321	/* Tell a client what happened rest of objects */	301	if (QUERY_FLAG (tmp, FLAG_UNPAID))
322	if (pl->type == PLAYER)	302	{
323	{	303	tmp->flag.reset (FLAG_UNPAID);
324	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));
325	esrv_del_item (pl->contr, tmp2->count);	305	tmp->flag.set (FLAG_UNPAID);
326	else
327	esrv_send_item (pl, tmp2);
328	}
329	}	306	}
330	else	307	else
331	{	308	new_draw_info_format (NDI_UNIQUE, 0, pl, "You pick up the %s.", query_name (tmp));
332	/* If the object is in a container, send a delete to the client.
333	* - we are moving all the items from the container to elsewhere,
334	* so it needs to be deleted.
335	*/
336	if (!QUERY_FLAG (tmp, FLAG_REMOVED))
337	{
338	if (tmp->env && pl->type == PLAYER)
339	esrv_del_item (pl->contr, tmp->count);
340	remove_ob (tmp); /* Unlink it */
341	}
342	}
343	if (QUERY_FLAG (tmp, FLAG_UNPAID))
344	(void) sprintf (buf, "%s will cost you %s.", query_name (tmp), query_cost_string (tmp, pl, F_BUY | F_SHOP));
345	else
346	(void) sprintf (buf, "You pick up the %s.", query_name (tmp));
347	new_draw_info (NDI_UNIQUE, 0, pl, buf);
348		309
349	tmp = insert_ob_in_ob (tmp, op);	310	op->insert (tmp);
350
351	/* All the stuff below deals with client/server code, and is only
352	* usable by players
353	*/
354	if (pl->type != PLAYER)
355	return;
356
357	esrv_send_item (pl, tmp);
358	/* These are needed to update the weight for the container we
359	* are putting the object in.
360	*/
361	if (op != pl)
362	{
363	esrv_update_item (UPD_WEIGHT, pl, op);
364	esrv_send_item (pl, pl);
365	}
366
367	/* Update the container the object was in */
368	if (env && env != pl && env != op)
369	esrv_update_item (UPD_WEIGHT, pl, env);
370	}	311	}
371		312
372	/* 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 */
373	void	314	void
374	pick_up (object *op, object *alt)	315	pick_up (object *op, object *alt)
…		…
384	if (!can_pick (op, alt))	325	if (!can_pick (op, alt))
385	{	326	{
386	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);
387	goto leave;	328	goto leave;
388	}	329	}
		330
389	tmp = alt;	331	tmp = alt;
390	}	332	}
391	else	333	else
392	{	334	{
393	if (op->below == NULL || !can_pick (op, op->below))	335	if (op->below == NULL || !can_pick (op, op->below))
…		…
402	/* Try to catch it. */	344	/* Try to catch it. */
403	tmp_map = tmp->map;	345	tmp_map = tmp->map;
404	tmp = stop_item (tmp);	346	tmp = stop_item (tmp);
405	if (tmp == NULL)	347	if (tmp == NULL)
406	goto leave;	348	goto leave;
		349
407	need_fix_tmp = 1;	350	need_fix_tmp = 1;
408	if (!can_pick (op, tmp))	351	if (!can_pick (op, tmp))
409	goto leave;	352	goto leave;
410		353
411	if (op->type == PLAYER)	354	if (op->type == PLAYER)
…		…
416	}	359	}
417	else	360	else
418	count = tmp->nrof;	361	count = tmp->nrof;
419		362
420	/* container is open, so use it */	363	/* container is open, so use it */
		364	if (tmp->flag [FLAG_STARTEQUIP])
		365	alt = op;
421	if (op->container)	366	else if (op->container)
422	{	367	{
423	alt = op->container;	368	alt = op->container;
424	if (alt != tmp->env && !sack_can_hold (op, alt, tmp, count))	369	if (alt != tmp->env && !sack_can_hold (op, alt, tmp, count))
425	goto leave;	370	goto leave;
426	}	371	}
…		…
433		378
434	if (!alt)	379	if (!alt)
435	for (alt = op->inv; alt; alt = alt->below)	380	for (alt = op->inv; alt; alt = alt->below)
436	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))
437	break; /* General container comes next */	382	break; /* General container comes next */
		383
438	if (!alt)	384	if (!alt)
439	alt = op; /* No free containers */	385	alt = op; /* No free containers */
440	}	386	}
441		387
442	if (tmp->env == alt)	388	if (tmp->env == alt)
…		…
444	/* here it could be possible to check rent,	390	/* here it could be possible to check rent,
445	* if someone wants to implement it	391	* if someone wants to implement it
446	*/	392	*/
447	alt = op;	393	alt = op;
448	}	394	}
		395
449	#ifdef PICKUP_DEBUG	396	#ifdef PICKUP_DEBUG
450	LOG (llevDebug, "Pick_up(): %s picks %s (%d) and inserts it %s.\n", op->name, tmp->name, op->contr->count, alt->name);	397	LOG (llevDebug, "Pick_up(): %s picks %s (%d) and inserts it %s.\n", op->name, tmp->name, op->contr->count, alt->name);
451	#endif	398	#endif
452		399
453	/* startequip items are not allowed to be put into containers: */	400	/* startequip items are not allowed to be put into containers: */
…		…
469		416
470	leave:	417	leave:
471	if (need_fix_tmp)	418	if (need_fix_tmp)
472	fix_stopped_item (tmp, tmp_map, op);	419	fix_stopped_item (tmp, tmp_map, op);
473	}	420	}
474
475		421
476	/* This takes (picks up) and item. op is the player	422	/* This takes (picks up) and item. op is the player
477	* who issued the command. params is a string to	423	* who issued the command. params is a string to
478	* match against the item name. Basically, always	424	* match against the item name. Basically, always
479	* returns zero, but that should be improved.	425	* returns zero, but that should be improved.
…		…
494		440
495	if (!tmp)	441	if (!tmp)
496	tmp = op->below;	442	tmp = op->below;
497	}	443	}
498		444
499	if (tmp == NULL)	445	if (!tmp)
500	{	446	{
501	new_draw_info (NDI_UNIQUE, 0, op, "Nothing to take!");	447	new_draw_info (NDI_UNIQUE, 0, op, "Nothing to take!");
502	return 0;	448	return 0;
503	}	449	}
504		450
505	/* Makes processing easier */	451	/* Makes processing easier */
506	if (params && *params == '\0')	452	if (params && *params == '\0')
507	params = NULL;	453	params = 0;
		454
		455	int cnt = MAX_ITEM_PER_DROP;
508		456
509	while (tmp)	457	while (tmp)
510	{	458	{
511	next = tmp->below;	459	next = tmp->below;
512		460
513	if (tmp->invisible)	461	if (tmp->invisible)
514	{	462	{
515	tmp = next;	463	tmp = next;
516	continue;	464	continue;
517	}	465	}
		466
518	/* 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
519	* but that probably will make it more difficult to read, and	468	* but that probably will make it more difficult to read, and
520	* not make it any more efficient	469	* not make it any more efficient
521	*/	470	*/
522	if (params && item_matched_string (op, tmp, params))	471	if (params && item_matched_string (op, tmp, params))
523	{	472	{
		473	if (--cnt < 0) break;
524	pick_up (op, tmp);	474	pick_up (op, tmp);
525	}	475	}
526	else if (can_pick (op, tmp) && !params)	476	else if (can_pick (op, tmp) && !params)
527	{	477	{
		478	if (--cnt < 0) break;
528	pick_up (op, tmp);	479	pick_up (op, tmp);
529	break;	480	break;
530	}	481	}
		482
531	tmp = next;	483	tmp = next;
532	/* Might as well just skip over the player immediately -	484	}
533	* we know it can't be picked up	485
534	*/	486	if (cnt < 0)
535	if (tmp == op)
536	tmp = tmp->below;
537	}	487	{
		488	op->failmsg ("Couldn't pick up so many items at once.");
		489	return 0;
		490	}
		491
538	if (!params && !tmp)	492	if (!params && !tmp)
539	{	493	{
540	for (tmp = op->below; tmp != NULL; tmp = tmp->next)	494	for (tmp = op->below; tmp; tmp = tmp->below)
541	if (!tmp->invisible)	495	if (!tmp->invisible)
542	{	496	{
543	char buf[MAX_BUF];
544
545	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);
546	new_draw_info (NDI_UNIQUE, 0, op, buf);
547	break;	498	break;
548	}	499	}
		500
549	if (!tmp)	501	if (!tmp)
550	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.");
551	}	503	}
		504
552	return 0;	505	return 0;
553	}	506	}
554		507
555
556	/*	508	/*
557	* This function was part of drop, now is own function.	509	* This function was part of drop, now is own function.
558	* Player 'op' tries to put object 'tmp' into sack 'sack',	510	* Player 'op' tries to put object 'tmp' into sack 'sack',
559	* 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	*
560	* Note that the 'sack' in question can now be a transport,	513	* Note that the 'sack' in question can now be a transport,
561	* so this function isn't named very good anymore.	514	* so this function isn't named very good anymore.
562	*/	515	*/
563	void	516	void
564	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)
…		…
575	return;	528	return;
576	}	529	}
577		530
578	if (tmp->type == CONTAINER && tmp->inv)	531	if (tmp->type == CONTAINER && tmp->inv)
579	{	532	{
580
581	/* 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
582	* we instead move the contents of that container into the active	534	* we instead move the contents of that container into the active
583	* 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.
584	*/	536	*/
585	sack2 = tmp;	537	sack2 = tmp;
…		…
588	for (tmp2 = tmp->inv; tmp2; tmp2 = tmp)	540	for (tmp2 = tmp->inv; tmp2; tmp2 = tmp)
589	{	541	{
590	tmp = tmp2->below;	542	tmp = tmp2->below;
591		543
592	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)))
593	{
594	put_object_in_sack (op, sack, tmp2, 0);	545	put_object_in_sack (op, sack, tmp2, 0);
595	}
596	else	546	else
597	{	547	{
598	sprintf (buf, "Your %s fills up.", query_name (sack));	548	sprintf (buf, "Your %s fills up.", query_name (sack));
599	new_draw_info (NDI_UNIQUE, 0, op, buf);	549	new_draw_info (NDI_UNIQUE, 0, op, buf);
600	break;	550	break;
601	}	551	}
602	}	552	}
603		553
604	esrv_update_item (UPD_WEIGHT, op, sack2);
605	return;	554	return;
606	}	555	}
607		556
608	/* Don't worry about this for containers - our caller should have	557	/* Don't worry about this for containers - our caller should have
609	* already checked this.	558	* already checked this.
…		…
614	if (QUERY_FLAG (tmp, FLAG_APPLIED))	563	if (QUERY_FLAG (tmp, FLAG_APPLIED))
615	if (apply_special (op, tmp, AP_UNAPPLY | AP_NO_MERGE))	564	if (apply_special (op, tmp, AP_UNAPPLY | AP_NO_MERGE))
616	return;	565	return;
617		566
618	/* 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 */
619	if (nrof && tmp->nrof != nrof)	568	if (!can_split (op, tmp, nrof))
620	{
621	object *tmp2 = tmp;
622
623	tmp = get_split_ob (tmp, nrof);
624
625	if (!tmp)
626	{
627	new_draw_info (NDI_UNIQUE, 0, op, errmsg);
628	return;	569	return;
629	}
630	/* Tell a client what happened other objects */
631	if (tmp2->destroyed ())
632	esrv_del_item (op->contr, tmp2->count);
633	else /* this can proably be replaced with an update */
634	esrv_send_item (op, tmp2);
635	}
636	else
637	remove_ob (tmp);
638		570
639	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));
640	tmp2 = insert_ob_in_ob (tmp, sack);	572	sack->insert (tmp);
641	fix_player (op); /* This is overkill, fix_player() is called somewhere */
642	/* in object.c */
643
644	/* If an object merged (and thus, different object), we need to
645	* delete the original.
646	*/
647	if (tmp2 != tmp)
648	esrv_del_item (op->contr, tmp->count);
649
650	esrv_send_item (op, tmp2);
651
652	/* update the sacks weight */
653	esrv_update_item (UPD_WEIGHT, op, sack);
654	}	573	}
655		574
656	/*	575	/*
657	* This function was part of drop, now is own function.	576	* This function was part of drop, now is own function.
658	* 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
…		…
660	* This is used when dropping objects onto the floor.	579	* This is used when dropping objects onto the floor.
661	*/	580	*/
662	void	581	void
663	drop_object (object *op, object *tmp, uint32 nrof)	582	drop_object (object *op, object *tmp, uint32 nrof)
664	{	583	{
665	char buf[MAX_BUF];
666	object *floor;
667
668	if (QUERY_FLAG (tmp, FLAG_NO_DROP))	584	if (QUERY_FLAG (tmp, FLAG_NO_DROP))
669	return;	585	return;
670		586
671	if (QUERY_FLAG (tmp, FLAG_APPLIED))	587	if (QUERY_FLAG (tmp, FLAG_APPLIED))
672	if (apply_special (op, tmp, AP_UNAPPLY | AP_NO_MERGE))	588	if (apply_special (op, tmp, AP_UNAPPLY | AP_NO_MERGE))
673	return; /* can't unapply it */	589	return; /* can't unapply it */
674		590
		591	//fprintf (stderr, "ui, on space is %ld\n", op->ms ().volume ());//D
		592
675	/* We are only dropping some of the items. We split the current objec	593	/* We are only dropping some of the items. We split the current object
676	* off	594	* off
677	*/	595	*/
678	if (nrof && tmp->nrof != nrof)	596	if (!can_split (op, tmp, nrof))
679	{
680	object *tmp2 = tmp;
681
682	tmp = get_split_ob (tmp, nrof);
683	if (!tmp)
684	{
685	new_draw_info (NDI_UNIQUE, 0, op, errmsg);
686	return;
687	}
688	/* Tell a client what happened rest of objects. tmp2 is now the
689	* original object
690	*/
691	if (op->type == PLAYER)
692	{
693	if (tmp2->destroyed ())
694	esrv_del_item (op->contr, tmp2->count);
695	else
696	esrv_send_item (op, tmp2);
697	}
698	}
699	else
700	remove_ob (tmp);
701
702	if (INVOKE_OBJECT (DROP, tmp, ARG_OBJECT (op)))
703	return;	597	return;
704		598
		599	drop_object (op, tmp);
		600
		601	if (!tmp->destroyed () && !tmp->is_inserted ())
		602	{
		603	// if nothing happened with the object we give it back
		604	op->insert (tmp);
		605	}
		606	}
		607
		608	/* In contrast to drop_object (op, tmp, nrof) above this function takes the
		609	* already split off object, and feeds it to the event handlers and does
		610	* other magic with it.
		611	*
		612	* <droppper> is the object that dropped this object and <obj> is the
		613	* object that was dropped.
		614	*
		615	* Make sure to check what happened with <obj> after this function returns!
		616	* Otherwise you may leak this object.
		617	*/
		618
		619	void
		620	drop_object (object *dropper, object *obj)
		621	{
		622	if (INVOKE_OBJECT (DROP, obj, ARG_OBJECT (dropper)))
		623	return;
		624
		625	if (obj->destroyed () || obj->is_inserted ())
		626	return;
		627
705	if (QUERY_FLAG (tmp, FLAG_STARTEQUIP))	628	if (QUERY_FLAG (obj, FLAG_STARTEQUIP))
706	{	629	{
707	sprintf (buf, "You drop the %s.", query_name (tmp));	630	dropper->statusmsg (format ("You drop the %s.", query_name (obj)));
708	new_draw_info (NDI_UNIQUE, 0, op, buf);	631	dropper->statusmsg ("The god who lent it to you retrieves it.");
709	new_draw_info (NDI_UNIQUE, 0, op, "The gods who lent it to you retrieves it.");	632
710	if (op->type == PLAYER)	633	obj->destroy ();
711	esrv_del_item (op->contr, tmp->count);	634	dropper->update_stats ();
712	free_object (tmp);
713	fix_player (op);
714	return;	635	return;
715	}	636	}
716		637
717	/* If SAVE_INTERVAL is commented out, we never want to save	638	for (object *floor = GET_MAP_OB (dropper->map, dropper->x, dropper->y);
718	* the player here.	639	floor;
719	*/	640	floor = floor->above)
720	#ifdef SAVE_INTERVAL	641	if (INVOKE_OBJECT (DROP_ON, floor, ARG_OBJECT (obj), ARG_OBJECT (dropper)))
721	/* I'm not sure why there is a value check - since the save	642	return;
722	* is done every SAVE_INTERVAL seconds, why care the value	643
723	* of what he is dropping?	644	if (obj->destroyed () || obj->is_inserted ())
		645	return;
		646
		647	if (is_in_shop (dropper) && !QUERY_FLAG (obj, FLAG_UNPAID) && obj->type != MONEY)
		648	if (!sell_item (obj, dropper))
		649	return;
		650
		651	/* If nothing special happened with this object, the default action is to
		652	* insert it below the dropper:
724	*/	653	*/
725	if (op->type == PLAYER && !QUERY_FLAG (tmp, FLAG_UNPAID) &&
726	(tmp->nrof ? tmp->value * tmp->nrof : tmp->value > 2000) && (op->contr->last_save_time + SAVE_INTERVAL) <= time (NULL))
727	{
728	save_player (op, 1);
729	op->contr->last_save_time = time (NULL);
730	}
731	#endif /* SAVE_INTERVAL */
732		654
733	if (op->type == PLAYER)	655	obj->x = dropper->x;
734	esrv_del_item (op->contr, tmp->count);	656	obj->y = dropper->y;
735		657
736	/* Call this before we update the various windows/players. At least
737	* that we, we know the weight is correct.
738	*/
739	fix_player (op); /* This is overkill, fix_player() is called somewhere */
740	/* in object.c */
741
742	if (op->type == PLAYER)
743	{
744	op->contr->socket.update_look = 1;
745	/* Need to update the weight for the player */
746	esrv_send_item (op, op);
747	}
748
749	for (floor = get_map_ob (op->map, op->x, op->y); floor; floor = floor->above)
750	if (INVOKE_OBJECT (DROP_ON, floor, ARG_OBJECT (tmp), ARG_OBJECT (op)))
751	return;
752
753	if (is_in_shop (op) && !QUERY_FLAG (tmp, FLAG_UNPAID) && tmp->type != MONEY)
754	sell_item (tmp, op);
755
756	tmp->x = op->x;
757	tmp->y = op->y;
758
759	insert_ob_in_map (tmp, op->map, op, INS_BELOW_ORIGINATOR);	658	insert_ob_in_map (obj, dropper->map, dropper, INS_BELOW_ORIGINATOR);
760	}	659	}
761		660
762	void	661	void
763	drop (object *op, object *tmp)	662	drop (object *op, object *tmp)
764	{	663	{
…		…
773	if (tmp->env && tmp->env->type != PLAYER)	672	if (tmp->env && tmp->env->type != PLAYER)
774	{	673	{
775	/* Just toss the object - probably shouldn't be hanging	674	/* Just toss the object - probably shouldn't be hanging
776	* around anyways	675	* around anyways
777	*/	676	*/
778	remove_ob (tmp);	677	tmp->destroy ();
779	free_object (tmp);
780	return;	678	return;
781	}	679	}
782	else	680	else
783	{	681	{
784	while (tmp != NULL && tmp->invisible)	682	while (tmp && tmp->invisible)
785	tmp = tmp->below;	683	tmp = tmp->below;
786	}	684	}
787	}	685	}
788		686
789	if (tmp == NULL)	687	if (tmp == NULL)
790	{	688	{
791	new_draw_info (NDI_UNIQUE, 0, op, "You don't have anything to drop.");	689	new_draw_info (NDI_UNIQUE, 0, op, "You don't have anything to drop.");
792	return;	690	return;
793	}	691	}
		692
794	if (QUERY_FLAG (tmp, FLAG_INV_LOCKED))	693	if (QUERY_FLAG (tmp, FLAG_INV_LOCKED))
795	{	694	{
796	new_draw_info (NDI_UNIQUE, 0, op, "This item is locked");	695	new_draw_info (NDI_UNIQUE, 0, op, "This item is locked");
797	return;	696	return;
798	}	697	}
		698
799	if (QUERY_FLAG (tmp, FLAG_NO_DROP))	699	if (QUERY_FLAG (tmp, FLAG_NO_DROP))
800	{	700	{
801	#if 0	701	#if 0
802	/* Eneq(@csd.uu.se): Objects with NO_DROP defined can't be dropped. */	702	/* Eneq(@csd.uu.se): Objects with NO_DROP defined can't be dropped. */
803	new_draw_info (NDI_UNIQUE, 0, op, "This item can't be dropped.");	703	new_draw_info (NDI_UNIQUE, 0, op, "This item can't be dropped.");
804	#endif	704	#endif
805	return;	705	return;
806	}	706	}
807		707
808	if (op->type == PLAYER)	708	if (op->type == PLAYER && op->contr->last_used == tmp)
809	{	709	op->contr->last_used = tmp->below ? tmp->below
810	if (op->contr->last_used == tmp && op->contr->last_used_id == tmp->count)	710	: tmp->above ? tmp->above
811	{	711	: 0;
812	object *n = NULL;
813
814	if (tmp->below != NULL)
815	n = tmp->below;
816	else if (tmp->above != NULL)
817	n = tmp->above;
818	op->contr->last_used = n;
819	if (n != NULL)
820	op->contr->last_used_id = n->count;
821	else
822	op->contr->last_used_id = 0;
823	}
824	};
825		712
826	if (op->container)	713	if (op->container)
827	{	714	{
828	if (op->type == PLAYER)	715	if (op->type == PLAYER)
829	{
830	put_object_in_sack (op, op->container, tmp, op->contr->count);	716	put_object_in_sack (op, op->container, tmp, op->contr->count);
831	}
832	else	717	else
833	{
834	put_object_in_sack (op, op->container, tmp, 0);	718	put_object_in_sack (op, op->container, tmp, 0);
835	};
836	}	719	}
837	else	720	else
838	{	721	{
839	if (op->type == PLAYER)	722	if (op->type == PLAYER)
840	{
841	drop_object (op, tmp, op->contr->count);	723	drop_object (op, tmp, op->contr->count);
842	}
843	else	724	else
844	{
845	drop_object (op, tmp, 0);	725	drop_object (op, tmp, 0);
846	};
847	}	726	}
		727
848	if (op->type == PLAYER)	728	if (op->type == PLAYER)
849	op->contr->count = 0;	729	op->contr->count = 0;
850	}	730	}
851
852
853		731
854	/* Command will drop all items that have not been locked */	732	/* Command will drop all items that have not been locked */
855	int	733	int
856	command_dropall (object *op, char *params)	734	command_dropall (object *op, char *params)
857	{	735	{
858		736
859	object *curinv, *nextinv;
860
861	if (op->inv == NULL)	737	if (op->inv == NULL)
862	{	738	{
863	new_draw_info (NDI_UNIQUE, 0, op, "Nothing to drop!");	739	new_draw_info (NDI_UNIQUE, 0, op, "Nothing to drop!");
864	return 0;	740	return 0;
865	}	741	}
866		742
867	curinv = op->inv;	743	object *curinv = op->inv;
		744	object *nextinv;
868		745
869	/*	746	/*
870	This is the default. Drops everything not locked or considered	747	This is the default. Drops everything not locked or considered
871	not something that should be dropped.	748	not something that should be dropped.
872	*/	749	*/
…		…
874	Care must be taken that the next item pointer is not to money as	751	Care must be taken that the next item pointer is not to money as
875	the drop() routine will do unknown things to it when dropping	752	the drop() routine will do unknown things to it when dropping
876	in a shop. --Tero.Pelander@utu.fi	753	in a shop. --Tero.Pelander@utu.fi
877	*/	754	*/
878		755
879	if (params == NULL)	756	int cnt = MAX_ITEM_PER_DROP;
		757
		758	if (!params)
880	{	759	{
881	while (curinv != NULL)	760	while (curinv)
882	{	761	{
883	nextinv = curinv->below;	762	nextinv = curinv->below;
		763
884	while (nextinv && nextinv->type == MONEY)	764	while (nextinv && nextinv->type == MONEY)
885	nextinv = nextinv->below;	765	nextinv = nextinv->below;
		766
886	if (!QUERY_FLAG (curinv, FLAG_INV_LOCKED) && curinv->type != MONEY &&	767	if (!QUERY_FLAG (curinv, FLAG_INV_LOCKED) && curinv->type != MONEY &&
887	curinv->type != FOOD && curinv->type != KEY &&	768	curinv->type != FOOD && curinv->type != KEY &&
888	curinv->type != SPECIAL_KEY && curinv->type != GEM &&	769	curinv->type != SPECIAL_KEY && curinv->type != GEM &&
889	!curinv->invisible && (curinv->type != CONTAINER || op->container != curinv))	770	!curinv->invisible && (curinv->type != CONTAINER || op->container != curinv))
890	{	771	{
891	drop (op, curinv);	772	drop (op, curinv);
		773	if (--cnt <= 0) break;
892	}	774	}
		775
893	curinv = nextinv;	776	curinv = nextinv;
894	}	777	}
895	}	778	}
896
897	else if (strcmp (params, "weapons") == 0)	779	else if (strcmp (params, "weapons") == 0)
898	{	780	{
899	while (curinv != NULL)	781	while (curinv)
900	{	782	{
901	nextinv = curinv->below;	783	nextinv = curinv->below;
		784
902	while (nextinv && nextinv->type == MONEY)	785	while (nextinv && nextinv->type == MONEY)
903	nextinv = nextinv->below;	786	nextinv = nextinv->below;
		787
904	if (!QUERY_FLAG (curinv, FLAG_INV_LOCKED) && ((curinv->type == WEAPON) || (curinv->type == BOW) || (curinv->type == ARROW)))	788	if (!QUERY_FLAG (curinv, FLAG_INV_LOCKED) && ((curinv->type == WEAPON) || (curinv->type == BOW) || (curinv->type == ARROW)))
905	{	789	{
906	drop (op, curinv);	790	drop (op, curinv);
		791	if (--cnt <= 0) break;
907	}	792	}
		793
908	curinv = nextinv;	794	curinv = nextinv;
909	}	795	}
910	}	796	}
911
912	else if (strcmp (params, "armor") == 0 || strcmp (params, "armour") == 0)	797	else if (strcmp (params, "armor") == 0 || strcmp (params, "armour") == 0)
913	{	798	{
914	while (curinv != NULL)	799	while (curinv)
915	{	800	{
916	nextinv = curinv->below;	801	nextinv = curinv->below;
		802
917	while (nextinv && nextinv->type == MONEY)	803	while (nextinv && nextinv->type == MONEY)
918	nextinv = nextinv->below;	804	nextinv = nextinv->below;
		805
919	if (!QUERY_FLAG (curinv, FLAG_INV_LOCKED) && ((curinv->type == ARMOUR) || curinv->type == SHIELD || curinv->type == HELMET))	806	if (!QUERY_FLAG (curinv, FLAG_INV_LOCKED) && ((curinv->type == ARMOUR) || curinv->type == SHIELD || curinv->type == HELMET))
920	{	807	{
921	drop (op, curinv);	808	drop (op, curinv);
		809	if (--cnt <= 0) break;
922	}	810	}
		811
923	curinv = nextinv;	812	curinv = nextinv;
924	}	813	}
925	}	814	}
926
927	else if (strcmp (params, "misc") == 0)	815	else if (strcmp (params, "misc") == 0)
928	{	816	{
929	while (curinv != NULL)	817	while (curinv)
930	{	818	{
931	nextinv = curinv->below;	819	nextinv = curinv->below;
		820
932	while (nextinv && nextinv->type == MONEY)	821	while (nextinv && nextinv->type == MONEY)
933	nextinv = nextinv->below;	822	nextinv = nextinv->below;
		823
934	if (!QUERY_FLAG (curinv, FLAG_INV_LOCKED) && !QUERY_FLAG (curinv, FLAG_APPLIED))	824	if (!QUERY_FLAG (curinv, FLAG_INV_LOCKED) && !QUERY_FLAG (curinv, FLAG_APPLIED))
935	{	825	{
936	switch (curinv->type)	826	switch (curinv->type)
937	{	827	{
938	case HORN:	828	case HORN:
…		…
956	break;	846	break;
957	default:	847	default:
958	curinv = nextinv;	848	curinv = nextinv;
959	break;	849	break;
960	}	850	}
		851
		852	if (--cnt <= 0) break;
961	}	853	}
		854
962	curinv = nextinv;	855	curinv = nextinv;
963	}	856	}
964	}	857	}
965	op->contr->socket.update_look = 1;	858
		859	if (cnt <= 0)
		860	op->failmsg ("Only dropped some items, can't drop that many items at once.");
966		861
967	/* draw_look(op);*/	862	/* draw_look(op);*/
968	return 0;	863	return 0;
		864	}
		865
		866
		867	/* This function tries to drop all objects in the <objs> vector.
		868	* <dropper> is the object that wants to drop them.
		869	* <cnt> can be a 0 pointer or a pointer to the maximum number of
		870	* drop operations to perform.
		871	*
		872	* Returns true if at least one item was dropped.
		873	*/
		874	bool
		875	drop_vector (object *dropper, vector<object *> &objs, int *cnt)
		876	{
		877	vector<object *>::iterator i;
		878
		879	bool did_one = false;
		880
		881	for (i = objs.begin (); i != objs.end (); i++)
		882	{
		883	drop (dropper, *i);
		884	if (cnt && --*cnt <= 0) break;
		885	did_one = true;
		886	}
		887
		888	return did_one;
969	}	889	}
970		890
971	/* Object op wants to drop object(s) params. params can be a	891	/* Object op wants to drop object(s) params. params can be a
972	* comma seperated list.	892	* comma seperated list.
973	*/	893	*/
974
975	int	894	int
976	command_drop (object *op, char *params)	895	command_drop (object *op, char *params)
977	{	896	{
978	object *tmp, *next;	897	object *tmp, *next;
979	int did_one = 0;	898	int did_one = 0;
…		…
983	new_draw_info (NDI_UNIQUE, 0, op, "Drop what?");	902	new_draw_info (NDI_UNIQUE, 0, op, "Drop what?");
984	return 0;	903	return 0;
985	}	904	}
986	else	905	else
987	{	906	{
		907	vector<object *> matched_objs;
		908
988	for (tmp = op->inv; tmp; tmp = next)	909	for (tmp = op->inv; tmp; tmp = next)
989	{	910	{
990	next = tmp->below;	911	next = tmp->below;
991	if (QUERY_FLAG (tmp, FLAG_NO_DROP) || tmp->invisible)	912	if (QUERY_FLAG (tmp, FLAG_NO_DROP) || tmp->invisible)
992	continue;	913	continue;
		914
993	if (item_matched_string (op, tmp, params))	915	if (item_matched_string (op, tmp, params))
994	{	916	matched_objs.push_back (tmp);
995	drop (op, tmp);
996	did_one = 1;
997	}	917	}
998	}	918
999	if (!did_one)	919	int cnt = MAX_ITEM_PER_DROP;
		920
		921	if (!drop_vector (op, matched_objs, &cnt))
1000	new_draw_info (NDI_UNIQUE, 0, op, "Nothing to drop.");	922	new_draw_info (NDI_UNIQUE, 0, op, "Nothing to drop.");
1001	}	923
1002	if (op->type == PLAYER)	924	if (cnt <= 0)
1003	{	925	op->failmsg ("Only dropped some items, can't drop that many items at once.");
1004	op->contr->count = 0;
1005	op->contr->socket.update_look = 1;
1006	};	926	}
1007		927
1008	/* draw_look(op);*/
1009	return 0;	928	return 0;
1010	}	929	}
1011		930
1012	int	931	int
1013	command_examine (object *op, char *params)	932	command_examine (object *op, char *params)
1014	{	933	{
1015	if (!params)	934	if (!params)
1016	{	935	{
1017	object *tmp = op->below;	936	object *tmp = op->below;
1018		937
1019	while (tmp && !LOOK_OBJ (tmp))	938	while (tmp && !tmp->client_visible ())
1020	tmp = tmp->below;	939	tmp = tmp->below;
		940
1021	if (tmp)	941	if (tmp)
1022	examine (op, tmp);	942	examine (op, tmp);
1023	}	943	}
1024	else	944	else
1025	{	945	{
1026	object *tmp = find_best_object_match (op, params);	946	object *tmp = find_best_object_match (op, params);
1027		947
1028	if (tmp)	948	if (tmp)
1029	examine (op, tmp);	949	examine (op, tmp);
1030	else	950	else
1031	new_draw_info_format (NDI_UNIQUE, 0, op, "Could not find an object that matches %s", params);	951	op->contr->infobox (MSG_CHANNEL ("examine"), format ("Could not find an object that matches %s", params));
1032	}	952	}
		953
1033	return 0;	954	return 0;
1034	}	955	}
1035		956
1036	/* op should be a player.	957	/* op should be a player.
1037	* we return the object the player has marked with the 'mark' command	958	* we return the object the player has marked with the 'mark' command
…		…
1076	}	997	}
1077		998
1078	return 0;	999	return 0;
1079	}	1000	}
1080		1001
1081		1002	std::string
1082	/* op should be a player, params is any params.	1003	object::describe_monster (object *who)
1083	* If no params given, we print out the currently marked object.
1084	* otherwise, try to find a matching object - try best match first.
1085	*/
1086	int
1087	command_mark (object *op, char *params)
1088	{	1004	{
1089	if (!op->contr)	1005	dynbuf_text buf (512, 512);
1090	return 1;
1091		1006
1092	if (!params)	1007	object *mon = head ? head : this;
1093	{
1094	object *mark = find_marked_object (op);
1095		1008
1096	if (!mark)	1009	if (QUERY_FLAG (mon, FLAG_UNDEAD))
1097	new_draw_info (NDI_UNIQUE, 0, op, "You have no marked object.");	1010	buf << "It is an undead force.\r";
1098	else	1011
1099	new_draw_info_format (NDI_UNIQUE, 0, op, "%s is marked.", query_name (mark));	1012	if (mon->level > who->level)
1100	}	1013	buf << "It is likely more powerful than you.\r";
		1014	else if (mon->level < who->level)
		1015	buf << "It is likely less powerful than you.\r";
1101	else	1016	else
1102	{	1017	buf << "It is probably as powerful as you.\r";
1103	object *mark1 = find_best_object_match (op, params);
1104		1018
1105	if (!mark1)
1106	{
1107	new_draw_info_format (NDI_UNIQUE, 0, op, "Could not find an object that matches %s", params);
1108	return 1;
1109	}
1110	else
1111	{
1112	op->contr->mark = mark1;
1113	new_draw_info_format (NDI_UNIQUE, 0, op, "Marked item %s", query_name (mark1));
1114	return 0;
1115	}
1116	}
1117
1118	return 0; /*shouldnt get here */
1119	}
1120
1121
1122	/* op is the player
1123	* tmp is the monster being examined.
1124	*/
1125	void
1126	examine_monster (object *op, object *tmp)
1127	{
1128	object *mon = tmp->head ? tmp->head : tmp;
1129
1130	if (QUERY_FLAG (mon, FLAG_UNDEAD))
1131	new_draw_info (NDI_UNIQUE, 0, op, "It is an undead force.");
1132	if (mon->level > op->level)
1133	new_draw_info (NDI_UNIQUE, 0, op, "It is likely more powerful than you.");
1134	else if (mon->level < op->level)
1135	new_draw_info (NDI_UNIQUE, 0, op, "It is likely less powerful than you.");
1136	else
1137	new_draw_info (NDI_UNIQUE, 0, op, "It is probably as powerful as you.");
1138	if (mon->attacktype & AT_ACID)	1019	if (mon->attacktype & AT_ACID)
1139	new_draw_info (NDI_UNIQUE, 0, op, "You seem to smell an acrid odor.");	1020	buf << "You seem to smell an acrid odor.\r";
1140		1021
1141	/* Anyone know why this used to use the clone value instead of the	1022	/* Anyone know why this used to use the clone value instead of the
1142	* maxhp field? This seems that it should give more accurate results.	1023	* maxhp field? This seems that it should give more accurate results.
1143	*/	1024	*/
1144	switch ((mon->stats.hp + 1) * 4 / (mon->stats.maxhp + 1))	1025	switch ((mon->stats.hp + 1) * 4 / (mon->stats.maxhp + 1))
1145	{ /* From 1-4 */	1026	{ /* From 1-4 */
1146	case 1:	1027	case 1:
1147	new_draw_info (NDI_UNIQUE, 0, op, "It is in a bad shape.");	1028	buf << "It is in a bad shape.\r";
1148	break;	1029	break;
1149	case 2:	1030	case 2:
1150	new_draw_info (NDI_UNIQUE, 0, op, "It is hurt.");	1031	buf << "It is hurt.\r";
1151	break;	1032	break;
1152	case 3:	1033	case 3:
1153	new_draw_info (NDI_UNIQUE, 0, op, "It is somewhat hurt.");	1034	buf << "It is somewhat hurt.\r";
1154	break;	1035	break;
1155	case 4:	1036	case 4:
1156	new_draw_info (NDI_UNIQUE, 0, op, "It is in excellent shape.");	1037	buf << "It is in excellent shape.\r";
1157	break;	1038	break;
1158	}	1039	}
		1040
1159	if (present_in_ob (POISONING, mon) != NULL)	1041	if (present_in_ob (POISONING, mon))
1160	new_draw_info (NDI_UNIQUE, 0, op, "It looks very ill.");	1042	buf << "It looks very ill.\r";
1161	}
1162		1043
		1044	buf << '\n';
		1045
		1046	return buf;
		1047	}
1163		1048
1164	/* tmp is the object being described, pl is who is examing it. */	1049	/* tmp is the object being described, pl is who is examing it. */
1165	char *	1050	const char *
1166	long_desc (object *tmp, object *pl)	1051	long_desc (object *tmp, object *pl)
1167	{	1052	{
1168	static char buf[VERY_BIG_BUF];	1053	static std::string s;
1169	char *cp;
1170		1054
1171	if (tmp == NULL)	1055	return (s = tmp->long_desc (pl)).c_str ();
1172	return "";	1056	}
1173		1057
1174	buf[0] = '\0';	1058	std::string
		1059	object::long_desc (object *who)
		1060	{
		1061	std::string buf (query_name ());
		1062
1175	switch (tmp->type)	1063	switch (type)
1176	{	1064	{
1177	case RING:	1065	case RING:
1178	case SKILL:	1066	case SKILL:
1179	case WEAPON:	1067	case WEAPON:
1180	case ARMOUR:	1068	case ARMOUR:
…		…
1190	case CLOAK:	1078	case CLOAK:
1191	case FOOD:	1079	case FOOD:
1192	case DRINK:	1080	case DRINK:
1193	case FLESH:	1081	case FLESH:
1194	case SKILL_TOOL:	1082	case SKILL_TOOL:
		1083	case LAMP:
1195	case POWER_CRYSTAL:	1084	case POWER_CRYSTAL:
1196	if (*(cp = describe_item (tmp, pl)) != '\0')	1085	{
		1086	const char *cp = ::describe_item (this, who);
		1087
		1088	if (*cp)
		1089	{
		1090	buf.append (" ");
		1091	buf.append (cp);
		1092	}
		1093	}
		1094	}
		1095
		1096	return buf;
		1097	}
		1098
		1099	/* op is the player
		1100	* tmp is the monster being examined.
		1101	*/
		1102	void
		1103	examine_monster (object *op, object *tmp)
		1104	{
		1105	new_draw_info (NDI_UNIQUE, 0, op, tmp->describe_monster (op).c_str ());
		1106	}
		1107
		1108	std::string
		1109	object::describe (object *who)
		1110	{
		1111	dynbuf_text buf (1024, 1024);
		1112
		1113	buf.printf ("That is: %s.\r", long_desc (who).c_str ());
		1114
		1115	if (custom_name)
		1116	buf.printf ("You call it %s.\r", &custom_name);
		1117
		1118	switch (type)
		1119	{
		1120	case SPELLBOOK:
		1121	if (flag [FLAG_IDENTIFIED] && inv)
		1122	buf.printf ("%s is a level %s %s spell.\r", &inv->name, get_levelnumber (inv->level), &inv->skill);
		1123	break;
		1124
		1125	case BOOK:
		1126	if (msg)
		1127	buf << "Something is written in it.\r";
		1128	break;
		1129
		1130	case CONTAINER:
		1131	if (race)
1197	{	1132	{
		1133	if (weight_limit && stats.Str < 100)
		1134	buf.printf ("It can hold only %s and its weight limit is %.1f kg.\r",
		1135	&race, weight_limit / (10.0 * (100 - stats.Str)));
1198	int len;	1136	else
1199		1137	buf.printf ("It can hold only %s.\r", &race);
1200	assign (buf, query_name (tmp));
1201	len = strlen (buf);
1202	if (len < VERY_BIG_BUF - 5)
1203	{
1204	/* Since we know the length, we save a few cpu cycles by using
1205	* it instead of calling strcat */
1206	strcpy (buf + len, " ");
1207	len++;
1208	assign (buf + len, cp, VERY_BIG_BUF - len - 1);
1209	}
1210	}	1138	}
1211	}	1139	else if (weight_limit && stats.Str < 100)
1212		1140	buf.printf ("Its weight limit is %.1f kg.\r", weight_limit / (10.0 * (100 - stats.Str)));
1213	if (buf[0] == '\0')
1214	assign (buf, query_name (tmp));
1215
1216	return buf;
1217	}
1218
1219	void
1220	examine (object *op, object *tmp)
1221	{
1222	char buf[VERY_BIG_BUF];
1223	int i;
1224
1225	if (tmp == NULL || tmp->type == CLOSE_CON)
1226	return;
1227
1228	strcpy (buf, "That is ");
1229	strncat (buf, long_desc (tmp, op), VERY_BIG_BUF - strlen (buf) - 1);
1230	buf[VERY_BIG_BUF - 1] = 0;
1231
1232	new_draw_info (NDI_UNIQUE, 0, op, buf);
1233	buf[0] = '\0';
1234
1235	if (tmp->custom_name)
1236	{
1237	strcpy (buf, "You call it ");
1238	strncat (buf, tmp->custom_name, VERY_BIG_BUF - strlen (buf) - 1);
1239	buf[VERY_BIG_BUF - 1] = 0;
1240	new_draw_info (NDI_UNIQUE, 0, op, buf);
1241	buf[0] = '\0';
1242	}
1243
1244	switch (tmp->type)
1245	{
1246	case SPELLBOOK:
1247	if (QUERY_FLAG (tmp, FLAG_IDENTIFIED) && tmp->inv)
1248	{
1249	sprintf (buf, "%s is a %s level %s spell", &tmp->inv->name, get_levelnumber (tmp->inv->level), &tmp->inv->skill);
1250	}
1251	break;	1141	break;
1252		1142
1253	case BOOK:	1143	case WAND:
1254	if (tmp->msg != NULL)	1144	if (flag [FLAG_IDENTIFIED])
1255	strcpy (buf, "Something is written in it.");	1145	buf.printf ("It has %d charges left.\r", stats.food);
1256	break;	1146	break;
1257
1258	case CONTAINER:
1259	if (tmp->race != NULL)
1260	{
1261	if (tmp->weight_limit && tmp->stats.Str < 100)
1262	sprintf (buf, "It can hold only %s and its weight limit is %.1f kg.",
1263	&tmp->race, tmp->weight_limit / (10.0 * (100 - tmp->stats.Str)));
1264	else
1265	sprintf (buf, "It can hold only %s.", &tmp->race);
1266	}
1267	else if (tmp->weight_limit && tmp->stats.Str < 100)
1268	sprintf (buf, "Its weight limit is %.1f kg.", tmp->weight_limit / (10.0 * (100 - tmp->stats.Str)));
1269	break;
1270
1271	case WAND:
1272	if (QUERY_FLAG (tmp, FLAG_IDENTIFIED))
1273	sprintf (buf, "It has %d charges left.", tmp->stats.food);
1274	break;
1275	}
1276
1277	if (buf[0] != '\0')
1278	new_draw_info (NDI_UNIQUE, 0, op, buf);
1279
1280	if (tmp->materialname != NULL && !tmp->msg)
1281	{	1147	}
		1148
		1149	if (materialname && !msg)
1282	sprintf (buf, "It is made of: %s.", &tmp->materialname);	1150	buf.printf ("It is made of: %s.\r", &materialname);
1283	new_draw_info (NDI_UNIQUE, 0, op, buf);	1151
1284	}	1152	if (who)
1285	/* Where to wear this item */	1153	/* Where to wear this item */
1286	for (i = 0; i < NUM_BODY_LOCATIONS; i++)	1154	for (int i = 0; i < NUM_BODY_LOCATIONS; i++)
1287	{	1155	if (slot[i].info)
1288	if (tmp->body_info[i] < -1)	1156	{
		1157	buf << (who->slot[i].info ? body_locations[i].use_name : body_locations[i].nonuse_name);
		1158
		1159	if (slot[i].info < -1 && who->slot[i].info)
		1160	buf.printf ("(%d)", -slot[i].info);
		1161
		1162	buf << ".\r";
1289	{	1163	}
1290	if (op->body_info[i])	1164
1291	new_draw_info_format (NDI_UNIQUE, 0, op, "It goes %s (%d)", body_locations[i].use_name, -tmp->body_info[i]);	1165	if (weight)
		1166	buf.printf ("%s %3.3f kg.\r", nrof > 1 ? "They weigh" : "It weighs", weight * (nrof ? nrof : 1) / 1000.0);
		1167
		1168	if (value && !flag [FLAG_STARTEQUIP] && !flag [FLAG_NO_PICK] && who)
		1169	{
		1170	buf.printf ("You reckon %s worth %s.\r", nrof > 1 ? "they are" : "it is", query_cost_string (this, who, F_TRUE | F_APPROX));
		1171
		1172	if (is_in_shop (who))
		1173	{
		1174	if (flag [FLAG_UNPAID])
		1175	buf.printf ("%s would cost you %s.\r", nrof > 1 ? "They" : "It", query_cost_string (this, who, F_BUY | F_SHOP));
1292	else	1176	else
1293	new_draw_info_format (NDI_UNIQUE, 0, op, "It goes %s", body_locations[i].nonuse_name);
1294	}
1295	else if (tmp->body_info[i])
1296	{
1297	if (op->body_info[i])
1298	new_draw_info_format (NDI_UNIQUE, 0, op, "It goes %s", body_locations[i].use_name);
1299	else
1300	new_draw_info_format (NDI_UNIQUE, 0, op, "It goes %s", body_locations[i].nonuse_name);
1301	}
1302	}
1303
1304	if (tmp->weight)
1305	{
1306	sprintf (buf, tmp->nrof > 1 ? "They weigh %3.3f kg." : "It weighs %3.3f kg.", tmp->weight * (tmp->nrof ? tmp->nrof : 1) / 1000.0);
1307	new_draw_info (NDI_UNIQUE, 0, op, buf);
1308	}
1309
1310	if (tmp->value && !QUERY_FLAG (tmp, FLAG_STARTEQUIP) && !QUERY_FLAG (tmp, FLAG_NO_PICK))
1311	{
1312	sprintf (buf, "You reckon %s worth %s.", tmp->nrof > 1 ? "they are" : "it is", query_cost_string (tmp, op, F_TRUE | F_APPROX));
1313	new_draw_info (NDI_UNIQUE, 0, op, buf);
1314	if (is_in_shop (op))
1315	{
1316	if (QUERY_FLAG (tmp, FLAG_UNPAID))
1317	sprintf (buf, "%s would cost you %s.", tmp->nrof > 1 ? "They" : "It", query_cost_string (tmp, op, F_BUY | F_SHOP));
1318	else
1319	sprintf (buf, "You are offered %s for %s.", query_cost_string (tmp, op, F_SELL + F_SHOP), tmp->nrof > 1 ? "them" : "it");	1177	buf.printf ("You are offered %s for %s.\r", query_cost_string (this, who, F_SELL + F_SHOP), nrof > 1 ? "them" : "it");
1320	new_draw_info (NDI_UNIQUE, 0, op, buf);
1321	}	1178	}
1322	}	1179	}
1323		1180
1324	if (QUERY_FLAG (tmp, FLAG_MONSTER))	1181	if (flag [FLAG_MONSTER])
1325	examine_monster (op, tmp);	1182	buf << describe_monster (who);
1326		1183
1327	/* Is this item buildable? */	1184	/* Is this item buildable? */
1328	if (QUERY_FLAG (tmp, FLAG_IS_BUILDABLE))	1185	if (flag [FLAG_IS_BUILDABLE])
1329	new_draw_info (NDI_UNIQUE, 0, op, "This is a buildable item.");	1186	buf << "This is a buildable item.\r";
1330		1187
1331	/* Does the object have a message? Don't show message for all object	1188	/* Does the object have a message? Don't show message for all object
1332	* types - especially if the first entry is a match	1189	* types - especially if the first entry is a match
1333	*/	1190	*/
1334	if (tmp->msg && tmp->type != EXIT && tmp->type != BOOK && tmp->type != CORPSE && !tmp->move_on && strncasecmp (tmp->msg, "@match", 7))	1191	if (msg && type != EXIT && type != BOOK && type != CORPSE && !move_on && !has_dialogue ())
1335	{	1192	{
1336
1337	/* This is just a hack so when identifying the items, we print	1193	/* This is just a hack so when identifying the items, we print
1338	* out the extra message	1194	* out the extra message
1339	*/	1195	*/
1340	if (need_identify (tmp) && QUERY_FLAG (tmp, FLAG_IDENTIFIED))	1196	if (need_identify (this) && flag [FLAG_IDENTIFIED])
1341	new_draw_info (NDI_UNIQUE, 0, op, "The object has a story:");	1197	buf << "The object has a story:\r";
1342		1198
1343	new_draw_info (NDI_UNIQUE, 0, op, tmp->msg);	1199	buf << msg << '\n';
1344	}
1345	new_draw_info (NDI_UNIQUE, 0, op, " "); /* Blank line */
1346	}
1347
1348	/*
1349	* inventory prints object's inventory. If inv==NULL then print player's
1350	* inventory.
1351	* [ Only items which are applied are showed. Tero.Haatanen@lut.fi ]
1352	*/
1353	void
1354	inventory (object *op, object *inv)
1355	{
1356	object *tmp;
1357	char *in;
1358	int items = 0, length;
1359
1360	if (inv == NULL && op == NULL)
1361	{	1200	}
1362	new_draw_info (NDI_UNIQUE, 0, op, "Inventory of what object?");
1363	return;
1364	}
1365	tmp = inv ? inv->inv : op->inv;
1366		1201
1367	while (tmp)	1202	buf << '\n';
1368	{	1203
1369	if ((!tmp->invisible &&	1204	return std::string (buf.linearise (), buf.size ());
1370	(inv == NULL || inv->type == CONTAINER || QUERY_FLAG (tmp, FLAG_APPLIED))) || (!op || QUERY_FLAG (op, FLAG_WIZ)))
1371	items++;
1372	tmp = tmp->below;
1373	}
1374	if (inv == NULL)
1375	{ /* player's inventory */
1376	if (items == 0)
1377	{
1378	new_draw_info (NDI_UNIQUE, 0, op, "You carry nothing.");
1379	return;
1380	}
1381	else
1382	{
1383	length = 28;
1384	in = "";
1385	if (op)
1386	clear_win_info (op);
1387	new_draw_info (NDI_UNIQUE, 0, op, "Inventory:");
1388	}
1389	}
1390	else
1391	{
1392	if (items == 0)
1393	return;
1394	else
1395	{
1396	length = 28;
1397	in = " ";
1398	}
1399	}
1400	for (tmp = inv ? inv->inv : op->inv; tmp; tmp = tmp->below)
1401	{
1402	if ((!op || !QUERY_FLAG (op, FLAG_WIZ)) && (tmp->invisible || (inv && inv->type != CONTAINER && !QUERY_FLAG (tmp, FLAG_APPLIED))))
1403	continue;
1404	if ((!op || QUERY_FLAG (op, FLAG_WIZ)))
1405	new_draw_info_format (NDI_UNIQUE, 0, op, "%s- %-*.*s (%5d) %-8s", in, length, length,
1406	query_name (tmp), tmp->count, query_weight (tmp));
1407	else
1408	new_draw_info_format (NDI_UNIQUE, 0, op, "%s- %-*.*s %-8s", in, length + 8, length + 8, query_name (tmp), query_weight (tmp));
1409	}
1410	if (!inv && op)
1411	{
1412	new_draw_info_format (NDI_UNIQUE, 0, op, "%-*s %-8s", 41, "Total weight :", query_weight (op));
1413	}
1414	}	1205	}
1415		1206
1416	static void	1207	static void
1417	display_new_pickup (object *op)	1208	display_new_pickup (object *op)
1418	{	1209	{
1419	int i = op->contr->mode;	1210	int i = op->contr->mode;
1420		1211
1421	if (!(i & PU_NEWMODE))
1422	return;
1423
1424	new_draw_info_format (NDI_UNIQUE, 0, op, "%d NEWMODE", i & PU_NEWMODE ? 1 : 0);
1425	new_draw_info_format (NDI_UNIQUE, 0, op, "%d DEBUG", i & PU_DEBUG ? 1 : 0);	1212	new_draw_info_format (NDI_UNIQUE, 0, op, "%d DEBUG", i & PU_DEBUG ? 1 : 0);
1426	new_draw_info_format (NDI_UNIQUE, 0, op, "%d INHIBIT", i & PU_INHIBIT ? 1 : 0);	1213	new_draw_info_format (NDI_UNIQUE, 0, op, "%d INHIBIT", i & PU_INHIBIT ? 1 : 0);
1427	new_draw_info_format (NDI_UNIQUE, 0, op, "%d STOP", i & PU_STOP ? 1 : 0);	1214	new_draw_info_format (NDI_UNIQUE, 0, op, "%d STOP", i & PU_STOP ? 1 : 0);
1428		1215
1429	new_draw_info_format (NDI_UNIQUE, 0, op, "%d <= x pickup weight/value RATIO (0==off)", (i & PU_RATIO) * 5);	1216	new_draw_info_format (NDI_UNIQUE, 0, op, "%d <= x pickup weight/value RATIO (0==off)", (i & PU_RATIO) * 5);
…		…
1480	};	1267	};
1481		1268
1482	if (!params)	1269	if (!params)
1483	{	1270	{
1484	/* if the new mode is used, just print the settings */	1271	/* if the new mode is used, just print the settings */
1485	if (op->contr->mode & PU_NEWMODE)
1486	{
1487	display_new_pickup (op);	1272	display_new_pickup (op);
1488	return 1;
1489	}
1490	if (1)
1491	LOG (llevDebug, "command_pickup: !params\n");
1492	set_pickup_mode (op, (op->contr->mode > 6) ? 0 : op->contr->mode + 1);
1493	return 0;	1273	return 0;
1494	}	1274	}
1495		1275
1496	while (*params == ' ' && *params)	1276	while (*params == ' ' && *params)
1497	params++;	1277	params++;
…		…
1503	for (mode = 0; names[mode]; mode++)	1283	for (mode = 0; names[mode]; mode++)
1504	{	1284	{
1505	if (!strcmp (names[mode], params + 1))	1285	if (!strcmp (names[mode], params + 1))
1506	{	1286	{
1507	i = op->contr->mode;	1287	i = op->contr->mode;
1508	if (!(i & PU_NEWMODE))	1288
1509	i = PU_NEWMODE;
1510	if (*params == '+')	1289	if (*params == '+')
1511	i = i | modes[mode];	1290	i = i | modes[mode];
1512	else	1291	else
1513	i = i & ~modes[mode];	1292	i = i & ~modes[mode];
		1293
1514	op->contr->mode = i;	1294	op->contr->mode = i;
1515	display_new_pickup (op);	1295	display_new_pickup (op);
1516	return 1;	1296	return 1;
1517	}	1297	}
1518	}	1298	}
…		…
1520	return 1;	1300	return 1;
1521	}	1301	}
1522		1302
1523	if (sscanf (params, "%u", &i) != 1)	1303	if (sscanf (params, "%u", &i) != 1)
1524	{	1304	{
1525	if (1)
1526	LOG (llevDebug, "command_pickup: params==NULL\n");
1527	new_draw_info (NDI_UNIQUE, 0, op, "Usage: pickup <0-7> or <value_density> .");	1305	new_draw_info (NDI_UNIQUE, 0, op, "Usage: pickup <value_density> or [+-]type.");
1528	return 1;	1306	return 1;
1529	}	1307	}
1530	set_pickup_mode (op, i);	1308
		1309	if (i <= PU_RATIO)
		1310	i |= op->contr->mode & ~PU_RATIO;
		1311
		1312	op->contr->mode = i;
1531		1313
1532	return 1;	1314	return 1;
1533	}
1534
1535	void
1536	set_pickup_mode (object *op, int i)
1537	{
1538	switch (op->contr->mode = i)
1539	{
1540	case 0:
1541	new_draw_info (NDI_UNIQUE, 0, op, "Mode: Don't pick up.");
1542	break;
1543	case 1:
1544	new_draw_info (NDI_UNIQUE, 0, op, "Mode: Pick up one item.");
1545	break;
1546	case 2:
1547	new_draw_info (NDI_UNIQUE, 0, op, "Mode: Pick up one item and stop.");
1548	break;
1549	case 3:
1550	new_draw_info (NDI_UNIQUE, 0, op, "Mode: Stop before picking up.");
1551	break;
1552	case 4:
1553	new_draw_info (NDI_UNIQUE, 0, op, "Mode: Pick up all items.");
1554	break;
1555	case 5:
1556	new_draw_info (NDI_UNIQUE, 0, op, "Mode: Pick up all items and stop.");
1557	break;
1558	case 6:
1559	new_draw_info (NDI_UNIQUE, 0, op, "Mode: Pick up all magic items.");
1560	break;
1561	case 7:
1562	new_draw_info (NDI_UNIQUE, 0, op, "Mode: Pick up all coins and gems");
1563	break;
1564	}
1565	}	1315	}
1566		1316
1567	int	1317	int
1568	command_search_items (object *op, char *params)	1318	command_search_items (object *op, char *params)
1569	{	1319	{
1570	char buf[MAX_BUF];	1320	char buf[MAX_BUF];
1571		1321
1572	if (settings.search_items == FALSE)
1573	return 1;
1574
1575	if (params == NULL)	1322	if (params == NULL)
1576	{	1323	{
1577	if (op->contr->search_str[0] == '\0')	1324	if (op->contr->search_str[0] == '\0')
1578	{	1325	{
1579	new_draw_info (NDI_UNIQUE, 0, op, "Example: search magic+1");	1326	new_draw_info (NDI_UNIQUE, 0, op, "Example: search-items magic+1");
1580	new_draw_info (NDI_UNIQUE, 0, op, "Would automatically pick up all");	1327	new_draw_info (NDI_UNIQUE, 0, op, "Would automatically pick up all");
1581	new_draw_info (NDI_UNIQUE, 0, op, "items containing the word 'magic+1'.");	1328	new_draw_info (NDI_UNIQUE, 0, op, "items containing the word 'magic+1'.");
1582	return 1;	1329	return 1;
1583	}	1330	}
		1331
1584	op->contr->search_str[0] = '\0';	1332	op->contr->search_str[0] = '\0';
1585	new_draw_info (NDI_UNIQUE, 0, op, "Search mode turned off.");	1333	new_draw_info (NDI_UNIQUE, 0, op, "Search mode turned off.");
1586	fix_player (op);	1334	op->update_stats ();
1587	return 1;	1335	return 1;
1588	}	1336	}
		1337
1589	if ((int) strlen (params) >= MAX_BUF)	1338	if (strlen (params) >= MAX_BUF)
1590	{	1339	{
1591	new_draw_info (NDI_UNIQUE, 0, op, "Search string too long.");	1340	new_draw_info (NDI_UNIQUE, 0, op, "Search string too long.");
1592	return 1;	1341	return 1;
1593	}	1342	}
		1343
1594	strcpy (op->contr->search_str, params);	1344	strcpy (op->contr->search_str, params);
1595	sprintf (buf, "Searching for '%s'.", op->contr->search_str);	1345	sprintf (buf, "Now searching for '%s'.", op->contr->search_str);
1596	new_draw_info (NDI_UNIQUE, 0, op, buf);	1346	new_draw_info (NDI_UNIQUE, 0, op, buf);
1597	fix_player (op);	1347	op->update_stats ();
		1348
1598	return 1;	1349	return 1;
1599	}	1350	}
1600		1351

Diff Legend

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