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.62 by elmex, Mon Nov 26 12:54:32 2007 UTC vs.
Revision 1.134 by root, Sat Nov 17 23:40:03 2018 UTC

1	/*	1	/*
2	* This file is part of Deliantra, the Roguelike Realtime MMORPG.	2	* This file is part of Deliantra, the Roguelike Realtime MMORPG.
3	*	3	*
4	* Copyright (©) 2005,2006,2007 Marc Alexander Lehmann / Robin Redeker / the Deliantra team	4	* Copyright (©) 2017,2018 Marc Alexander Lehmann / the Deliantra team
		5	* Copyright (©) 2005,2006,2007,2008,2009,2010,2011,2012,2013,2014,2015,2016 Marc Alexander Lehmann / Robin Redeker / the Deliantra team
5	* Copyright (©) 2002,2007 Mark Wedel & Crossfire Development Team	6	* Copyright (©) 2002 Mark Wedel & Crossfire Development Team
6	* Copyright (©) 1992,2007 Frank Tore Johansen	7	* Copyright (©) 1992 Frank Tore Johansen
7	*	8	*
8	* Deliantra is free software: you can redistribute it and/or modify	9	* Deliantra is free software: you can redistribute it and/or modify it under
9	* it under the terms of the GNU General Public License as published by	10	* the terms of the Affero GNU General Public License as published by the
10	* the Free Software Foundation, either version 3 of the License, or	11	* Free Software Foundation, either version 3 of the License, or (at your
11	* (at your option) any later version.	12	* option) any later version.
12	*	13	*
13	* This program is distributed in the hope that it will be useful,	14	* This program is distributed in the hope that it will be useful,
14	* but WITHOUT ANY WARRANTY; without even the implied warranty of	15	* but WITHOUT ANY WARRANTY; without even the implied warranty of
15	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the	16	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16	* GNU General Public License for more details.	17	* GNU General Public License for more details.
17	*	18	*
18	* You should have received a copy of the GNU General Public License	19	* You should have received a copy of the Affero GNU General Public License
19	* along with this program. If not, see <http://www.gnu.org/licenses/>.	20	* and the GNU General Public License along with this program. If not, see
		21	* <http://www.gnu.org/licenses/>.
20	*	22	*
21	* The authors can be reached via e-mail to <support@deliantra.net>	23	* The authors can be reached via e-mail to <support@deliantra.net>
22	*/	24	*/
23		25
24	/*	26	/*
25	* Object (handling) commands	27	* Object (handling) commands
26	*/	28	*/
27		29
28	#include <global.h>	30	#include <global.h>
29	#include <loader.h>
30	#include <skills.h>	31	#include <skills.h>
31	#include <sproto.h>	32	#include <sproto.h>
32	#include <living.h>	33	#include <living.h>
33	#include <math.h>
34		34
35	/*	35	/*
36	* Object id parsing functions	36	* Object id parsing functions
37	*/	37	*/
38		38
…		…
68		68
69	int tmpmatch = item_matched_string (pl, tmp, params);	69	int tmpmatch = item_matched_string (pl, tmp, params);
70		70
71	if (tmpmatch > match_val)	71	if (tmpmatch > match_val)
72	{	72	{
73	if ((aflag == AP_APPLY) && (QUERY_FLAG (tmp, FLAG_APPLIED)))	73	if ((aflag == AP_APPLY) && (tmp->flag [FLAG_APPLIED]))
74	continue;	74	continue;
75		75
76	if ((aflag == AP_UNAPPLY) && (!QUERY_FLAG (tmp, FLAG_APPLIED)))	76	if ((aflag == AP_UNAPPLY) && (!tmp->flag [FLAG_APPLIED]))
77	continue;	77	continue;
78		78
79	match_val = tmpmatch;	79	match_val = tmpmatch;
80	best = tmp;	80	best = tmp;
81	}	81	}
…		…
91	find_best_object_match (object *pl, const char *params)	91	find_best_object_match (object *pl, const char *params)
92	{	92	{
93	return find_best_apply_object_match (pl, params, AP_TOGGLE);	93	return find_best_apply_object_match (pl, params, AP_TOGGLE);
94	}	94	}
95		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	}
		113	}
		114
96	int	115	int
97	command_uskill (object *pl, char *params)	116	command_uskill (object *pl, char *params)
98	{	117	{
99	if (!params)	118	if (!params)
100	{	119	{
…		…
114	{	133	{
115	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>");
116	return 0;	135	return 0;
117	}	136	}
118		137
119	skill = find_skill_by_name (pl, params);	138	skill = find_skill_by_name_fuzzy (pl, params);
120		139
121	if (!skill)	140	if (!skill)
122	{	141	{
123	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 %s skill.", params);
124	return 0;	143	return 0;
125	}	144	}
126		145
127	pl->change_skill (0);	146	pl->apply (skill);
128	apply_special (pl, skill, AP_APPLY);
129	return 1;	147	return 1;
130	}
131
132	/* These functions (command_search, command_disarm) are really just wrappers for
133	* things like 'use_skill ...'). In fact, they should really be obsoleted
134	* and replaced with those.
135	*/
136	int
137	command_search (object *op, char *params)
138	{
139	return use_skill (op, skill_names[SK_FIND_TRAPS]);
140	}
141
142	int
143	command_disarm (object *op, char *params)
144	{
145	return use_skill (op, skill_names[SK_DISARM_TRAPS]);
146	}	148	}
147		149
148	/* A little special because we do want to pass the full params along	150	/* A little special because we do want to pass the full params along
149	* as it includes the object to throw.	151	* as it includes the object to throw.
150	*/	152	*/
151	int	153	int
152	command_throw (object *op, char *params)	154	command_throw (object *op, char *params)
153	{	155	{
154	if (object *skop = find_skill_by_name (op, skill_names[SK_THROWING]))	156	if (object *skop = find_skill_by_name (op, shstr_throwing))
155	return do_skill (op, op, skop, op->facing, params);	157	return do_skill (op, op, skop, op->facing, params);
156	else	158	else
157	new_draw_info (NDI_UNIQUE, 0, op, "You have no knowledge of the skill throwing.");	159	new_draw_info (NDI_UNIQUE, 0, op, "You have no knowledge of the throwing skill.");
158		160
159	return 0;	161	return 0;
160	}	162	}
161		163
162	int	164	int
…		…
188		190
189	while (*params == ' ')	191	while (*params == ' ')
190	params++;	192	params++;
191		193
192	if (object *inv = find_best_apply_object_match (op, params, aflag))	194	if (object *inv = find_best_apply_object_match (op, params, aflag))
193	player_apply (op, inv, aflag, 0);	195	op->apply (inv, aflag);
194	else	196	else
195	new_draw_info_format (NDI_UNIQUE, 0, op, "Could not find any match to the %s.", params);	197	op->failmsgf ("Could not find any match to the %s.", params);
196	}	198	}
197		199
198	return 0;	200	return 0;
199	}	201	}
200		202
…		…
208	* not need to use split_ob and stuff.	210	* not need to use split_ob and stuff.
209	*/	211	*/
210	int	212	int
211	sack_can_hold (object *pl, object *sack, object *op, uint32 nrof)	213	sack_can_hold (object *pl, object *sack, object *op, uint32 nrof)
212	{	214	{
213		215	if (!sack->flag [FLAG_APPLIED])
214	if (!QUERY_FLAG (sack, FLAG_APPLIED))
215	{	216	{
216	new_draw_info_format (NDI_UNIQUE, 0, pl, "The %s is not active.", query_name (sack));	217	new_draw_info_format (NDI_UNIQUE, 0, pl, "The %s is not active.", query_name (sack));
217	return 0;	218	return 0;
218	}	219	}
		220
219	if (sack == op)	221	if (sack == op)
220	{	222	{
221	new_draw_info_format (NDI_UNIQUE, 0, pl, "You can't put the %s into itself.", query_name (sack));	223	new_draw_info_format (NDI_UNIQUE, 0, pl, "You can't put the %s into itself.", query_name (sack));
222	return 0;	224	return 0;
223	}	225	}
		226
224	if (sack->race && (sack->race != op->race || op->type == CONTAINER || (sack->stats.food && sack->stats.food != op->type)))	227	if (sack->race && (sack->race != op->race || op->type == CONTAINER || (sack->stats.food && sack->stats.food != op->type)))
225	{	228	{
226	new_draw_info_format (NDI_UNIQUE, 0, pl, "You can put only %s into the %s.", &sack->race, query_name (sack));	229	new_draw_info_format (NDI_UNIQUE, 0, pl, "You can only put objects of type '%s' into the %s.", &sack->race, query_name (sack));
227	return 0;	230	return 0;
228	}	231	}
		232
229	if (op->type == SPECIAL_KEY && sack->slaying && op->slaying)	233	if (op->type == SPECIAL_KEY && sack->slaying && op->slaying)
230	{	234	{
231	new_draw_info_format (NDI_UNIQUE, 0, pl, "You can't put the key into %s.", query_name (sack));	235	new_draw_info_format (NDI_UNIQUE, 0, pl, "You can't put the key into %s.", query_name (sack));
232	return 0;	236	return 0;
233	}	237	}
234	if (sack->weight_limit && (sint32) (sack->carrying + (nrof ? nrof : 1) *	238
		239	if (sack->weight_limit
		240	&& weight_t (sack->carrying
		241	+ sack->number_of ()
235	(op->weight + (op->type == CONTAINER ? (op->carrying * op->stats.Str) : 0))	242	* (op->weight + (op->type == CONTAINER ? (op->carrying * op->stats.Str) : 0))
236	* (100 - sack->stats.Str) / 100) > sack->weight_limit)	243	* (100 - sack->stats.Str) / 100)
		244	> sack->weight_limit)
237	{	245	{
238	new_draw_info_format (NDI_UNIQUE, 0, pl, "That won't fit in the %s!", query_name (sack));	246	new_draw_info_format (NDI_UNIQUE, 0, pl, "That won't fit in the %s!", query_name (sack));
239	return 0;	247	return 0;
240	}	248	}
		249
241	/* All other checks pass, must be OK */	250	/* All other checks pass, must be OK */
242	return 1;	251	return 1;
243	}	252	}
244		253
245	/* Pick up commands follow */	254	/* Pick up commands follow */
246		255
247	/* pl = player (not always - monsters can use this now)	256	/* pl = player (not always - monsters can use this now)
248	* op is the object to put tmp into,	257	* op is the object to put tmp into,
249	* tmp is the object to pick up, nrof is the number to	258	* tmp is the object to pick up, nrof is the number to
250	* pick up (0 means all of them)	259	* pick up (0 means all of them)
251	*/	260	*/
252	static void	261	static void
253	pick_up_object (object *pl, object *op, object *tmp, int nrof)	262	pick_up_object (object *pl, object *op, object *tmp, int nrof)
254	{	263	{
255	/* buf needs to be big (more than 256 chars) because you can get
256	* very long item names.
257	*/
258	char buf[HUGE_BUF];
259	object *env = tmp->env;
260	uint32 weight, effective_weight_limit;	264	weight_t weight, effective_weight_limit;
261	int tmp_nrof = tmp->nrof ? tmp->nrof : 1;	265	int tmp_nrof = tmp->number_of ();
262		266
263	/* IF the player is flying & trying to take the item out of a container	267	/* IF the player is flying & trying to take the item out of a container
264	* that is in his inventory, let him. tmp->env points to the container	268	* that is in his inventory, let him. tmp->env points to the container
265	* (sack, luggage, etc), tmp->env->env then points to the player (nested	269	* (sack, luggage, etc), tmp->env->env then points to the player (nested
266	* containers not allowed as of now)	270	* containers not allowed as of now)
267	*/	271	*/
268	if ((pl->move_type & MOVE_FLYING) && !QUERY_FLAG (pl, FLAG_WIZ) && tmp->in_player () != pl)	272	if ((pl->move_type & MOVE_FLYING) && !pl->flag [FLAG_WIZ] && tmp->in_player () != pl)
269	{	273	{
270	new_draw_info (NDI_UNIQUE, 0, pl, "You are levitating, you can't reach the ground!");	274	pl->failmsg ("You are levitating, you can't reach the ground! "
		275	"H<You have to stop levitating first, if you can, either by using your levitation skill, "
		276	"or waiting till the levitation effect wears off.>");
271	return;	277	return;
272	}	278	}
273		279
274	if (QUERY_FLAG (tmp, FLAG_NO_DROP))	280	if (tmp->flag [FLAG_NO_DROP])
275	return;	281	return;
276		282
277	if (nrof > tmp_nrof || nrof == 0)	283	if (nrof > tmp_nrof || nrof <= 0)
278	nrof = tmp_nrof;	284	nrof = tmp_nrof;
279		285
280	/* Figure out how much weight this object will add to the player */	286	/* Figure out how much weight this object will add to the player */
281	weight = tmp->weight * nrof;	287	weight = tmp->weight * nrof;
282	if (tmp->inv)	288	if (tmp->inv)
283	weight += tmp->carrying * (100 - tmp->stats.Str) / 100;	289	weight += tmp->carrying * (100 - tmp->stats.Str) / 100;
284		290
285	if (pl->stats.Str <= MAX_STAT)
286	effective_weight_limit = weight_limit[pl->stats.Str];	291	effective_weight_limit = weight_limit [min (MAX_STAT, pl->stats.Str)];
287	else
288	effective_weight_limit = weight_limit[MAX_STAT];
289		292
290	if ((pl->weight + pl->carrying + weight) > effective_weight_limit)	293	if ((pl->weight + pl->carrying + weight) > effective_weight_limit)
291	{	294	{
292	new_draw_info (0, 0, pl, "That item is too heavy for you to pick up.");	295	new_draw_info (0, 0, pl, "That item is too heavy for you to pick up.");
293	return;	296	return;
294	}	297	}
295		298
296	if (nrof != tmp_nrof)	299	if (!can_split (pl, tmp, nrof))
297	{
298	object *tmp2 = tmp;
299
300	tmp = get_split_ob (tmp, nrof);
301	if (!tmp)
302	{
303	new_draw_info (NDI_UNIQUE, 0, pl, errmsg);
304	return;	300	return;
305	}
306		301
307	/* Tell the client what happened to the rest of objects */	302	if (tmp->flag [FLAG_UNPAID])
308	if (pl->contr)	303	{
309	if (tmp2->destroyed ())	304	tmp->flag.reset (FLAG_UNPAID);
310	esrv_del_item (pl->contr, tmp2->count);	305	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));
311	else	306	tmp->flag.set (FLAG_UNPAID);
312	esrv_update_item (UPD_NROF, pl, tmp2);
313	}	307	}
314	else	308	else
315	{	309	new_draw_info_format (NDI_UNIQUE, 0, pl, "You pick up the %s.", query_name (tmp));
316	/* If the object is in a container, send a delete to the client.
317	* - we are moving all the items from the container to elsewhere,
318	* so it needs to be deleted.
319	*/
320	if (!QUERY_FLAG (tmp, FLAG_REMOVED))
321	{
322	if (tmp->env && pl->type == PLAYER)
323	esrv_del_item (pl->contr, tmp->count);
324		310
325	tmp->remove (); /* Unlink it */	311	op->insert (tmp);
326	}
327	}
328
329	if (QUERY_FLAG (tmp, FLAG_UNPAID))
330	sprintf (buf, "%s will cost you %s.", query_name (tmp), query_cost_string (tmp, pl, F_BUY | F_SHOP));
331	else
332	sprintf (buf, "You pick up the %s.", query_name (tmp));
333
334	new_draw_info (NDI_UNIQUE, 0, pl, buf);
335
336	tmp = insert_ob_in_ob (tmp, op);
337
338	/* All the stuff below deals with client/server code, and is only
339	* usable by players
340	*/
341	if (pl->contr)
342	{
343	esrv_send_item (pl, tmp);
344
345	/* These are needed to update the weight for the container we
346	* are putting the object in.
347	*/
348	if (op != pl)
349	{
350	esrv_update_item (UPD_WEIGHT, pl, op);
351	esrv_send_item (pl, pl);
352	}
353
354	/* Update the container the object was in */
355	if (env && env != pl && env != op)
356	esrv_update_item (UPD_WEIGHT, pl, env);
357	}
358	}	312	}
359		313
360	/* modified slightly to allow monsters use this -b.t. 5-31-95 */	314	/* modified slightly to allow monsters use this -b.t. 5-31-95 */
361	void	315	void
362	pick_up (object *op, object *alt)	316	pick_up (object *op, object *alt)
…		…
372	if (!can_pick (op, alt))	326	if (!can_pick (op, alt))
373	{	327	{
374	new_draw_info_format (NDI_UNIQUE, 0, op, "You can't pick up the %s.", &alt->name);	328	new_draw_info_format (NDI_UNIQUE, 0, op, "You can't pick up the %s.", &alt->name);
375	goto leave;	329	goto leave;
376	}	330	}
		331
377	tmp = alt;	332	tmp = alt;
378	}	333	}
379	else	334	else
380	{	335	{
381	if (op->below == NULL || !can_pick (op, op->below))	336	if (op->below == NULL || !can_pick (op, op->below))
…		…
390	/* Try to catch it. */	345	/* Try to catch it. */
391	tmp_map = tmp->map;	346	tmp_map = tmp->map;
392	tmp = stop_item (tmp);	347	tmp = stop_item (tmp);
393	if (tmp == NULL)	348	if (tmp == NULL)
394	goto leave;	349	goto leave;
		350
395	need_fix_tmp = 1;	351	need_fix_tmp = 1;
396	if (!can_pick (op, tmp))	352	if (!can_pick (op, tmp))
397	goto leave;	353	goto leave;
398		354
399	if (op->type == PLAYER)	355	if (op->type == PLAYER)
…		…
404	}	360	}
405	else	361	else
406	count = tmp->nrof;	362	count = tmp->nrof;
407		363
408	/* container is open, so use it */	364	/* container is open, so use it */
409	if (op->container)	365	if (tmp->flag [FLAG_STARTEQUIP])
		366	alt = op;
		367	else if ((alt = op->container_ ()))
410	{	368	{
411	alt = op->container;
412	if (alt != tmp->env && !sack_can_hold (op, alt, tmp, count))	369	if (alt != tmp->env && !sack_can_hold (op, alt, tmp, count))
413	goto leave;	370	goto leave;
414	}	371	}
415	else	372	else
416	{ /* non container pickup */	373	{ /* non container pickup */
417	for (alt = op->inv; alt; alt = alt->below)	374	for (alt = op->inv; alt; alt = alt->below)
418	if (alt->type == CONTAINER && QUERY_FLAG (alt, FLAG_APPLIED) &&	375	if (alt->type == CONTAINER && alt->flag [FLAG_APPLIED] &&
419	alt->race && alt->race == tmp->race && sack_can_hold (NULL, alt, tmp, count))	376	alt->race && alt->race == tmp->race && sack_can_hold (NULL, alt, tmp, count))
420	break; /* perfect match */	377	break; /* perfect match */
421		378
422	if (!alt)	379	if (!alt)
423	for (alt = op->inv; alt; alt = alt->below)	380	for (alt = op->inv; alt; alt = alt->below)
424	if (alt->type == CONTAINER && QUERY_FLAG (alt, FLAG_APPLIED) && sack_can_hold (NULL, alt, tmp, count))	381	if (alt->type == CONTAINER && alt->flag [FLAG_APPLIED] && sack_can_hold (NULL, alt, tmp, count))
425	break; /* General container comes next */	382	break; /* General container comes next */
426		383
427	if (!alt)	384	if (!alt)
428	alt = op; /* No free containers */	385	alt = op; /* No free containers */
429	}	386	}
…		…
433	/* here it could be possible to check rent,	390	/* here it could be possible to check rent,
434	* if someone wants to implement it	391	* if someone wants to implement it
435	*/	392	*/
436	alt = op;	393	alt = op;
437	}	394	}
		395
438	#ifdef PICKUP_DEBUG	396	#ifdef PICKUP_DEBUG
439	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);
440	#endif	398	#endif
441		399
442	/* startequip items are not allowed to be put into containers: */	400	/* startequip items are not allowed to be put into containers: */
443	if (op->type == PLAYER && alt->type == CONTAINER && QUERY_FLAG (tmp, FLAG_STARTEQUIP))	401	if (op->type == PLAYER && alt->type == CONTAINER && tmp->flag [FLAG_STARTEQUIP])
444	{	402	{
445	new_draw_info (NDI_UNIQUE, 0, op, "This object cannot be put into containers!");	403	new_draw_info (NDI_UNIQUE, 0, op, "This object cannot be put into containers!");
446	goto leave;	404	goto leave;
447	}	405	}
448		406
…		…
469	int	427	int
470	command_take (object *op, char *params)	428	command_take (object *op, char *params)
471	{	429	{
472	object *tmp, *next;	430	object *tmp, *next;
473		431
474	if (op->container)	432	if (op->container_ ())
475	tmp = op->container->inv;	433	tmp = op->container_ ()->inv;
476	else	434	else
477	{	435	{
478	tmp = op->above;	436	tmp = op->above;
479	if (tmp)	437	if (tmp)
480	while (tmp->above)	438	while (tmp->above)
…		…
492		450
493	/* Makes processing easier */	451	/* Makes processing easier */
494	if (params && *params == '\0')	452	if (params && *params == '\0')
495	params = 0;	453	params = 0;
496		454
497	int cnt = MAX_ITEM_PER_DROP;	455	int cnt = MAX_ITEM_PER_ACTION;
498		456
499	while (tmp)	457	while (tmp)
500	{	458	{
501	next = tmp->below;	459	next = tmp->below;
502		460
…		…
510	* but that probably will make it more difficult to read, and	468	* but that probably will make it more difficult to read, and
511	* not make it any more efficient	469	* not make it any more efficient
512	*/	470	*/
513	if (params && item_matched_string (op, tmp, params))	471	if (params && item_matched_string (op, tmp, params))
514	{	472	{
		473	if (--cnt < 0) break;
515	pick_up (op, tmp);	474	pick_up (op, tmp);
516	if (--cnt <= 0) break;
517	}	475	}
518	else if (can_pick (op, tmp) && !params)	476	else if (can_pick (op, tmp) && !params)
519	{	477	{
		478	if (--cnt < 0) break;
520	pick_up (op, tmp);	479	pick_up (op, tmp);
521	break;	480	break;
522	}	481	}
523		482
524	tmp = next;	483	tmp = next;
525	}	484	}
526		485
527	if (cnt <= 0)	486	if (cnt < 0)
528	{	487	{
529	op->failmsg ("Couldn't pick up so many items at once.");	488	op->failmsg ("Couldn't pick up so many items at once.");
530	return 0;	489	return 0;
531	}	490	}
532		491
533	if (!params && !tmp)	492	if (!params && !tmp)
534	{	493	{
535	for (tmp = op->below; tmp; tmp = tmp->below)	494	for (tmp = op->below; tmp; tmp = tmp->below)
536	if (!tmp->invisible)	495	if (!tmp->invisible)
537	{	496	{
538	char buf[MAX_BUF];
539
540	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);
541	new_draw_info (NDI_UNIQUE, 0, op, buf);
542	break;	498	break;
543	}	499	}
544		500
545	if (!tmp)	501	if (!tmp)
546	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.");
547	}	503	}
548		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)
562	{	518	{
563	object *tmp2, *sack2;	519	object *tmp2;
564	char buf[MAX_BUF];	520	char buf[MAX_BUF];
565		521
566	if (sack == tmp)	522	if (sack == tmp)
567	return; /* Can't put an object in itself */	523	return; /* Can't put an object in itself */
568		524
569	if (QUERY_FLAG (tmp, FLAG_STARTEQUIP))	525	if (tmp->flag [FLAG_STARTEQUIP] || tmp->flag [FLAG_NO_DROP])
570	{	526	{
571	new_draw_info_format (NDI_UNIQUE, 0, op, "You cannot put the %s in the %s.", query_name (tmp), query_name (sack));	527	new_draw_info_format (NDI_UNIQUE, 0, op, "You cannot put the %s in the %s.", query_name (tmp), query_name (sack));
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;
583	new_draw_info_format (NDI_UNIQUE, 0, op, "You move the items from %s into %s.", query_name (tmp), query_name (sack));	537	new_draw_info_format (NDI_UNIQUE, 0, op, "You move the items from %s into %s.", query_name (tmp), query_name (sack));
584		538
585	for (tmp2 = tmp->inv; tmp2; tmp2 = tmp)	539	for (tmp2 = tmp->inv; tmp2; tmp2 = tmp)
586	{	540	{
587	tmp = tmp2->below;	541	tmp = tmp2->below;
588		542
589	if ((sack->type == CONTAINER && sack_can_hold (op, op->container, tmp2, tmp2->nrof)))	543	if ((sack->type == CONTAINER && sack_can_hold (op, op->container_ (), tmp2, tmp2->nrof)))
590	{
591	put_object_in_sack (op, sack, tmp2, 0);	544	put_object_in_sack (op, sack, tmp2, 0);
592	}
593	else	545	else
594	{	546	{
595	sprintf (buf, "Your %s fills up.", query_name (sack));	547	sprintf (buf, "Your %s fills up.", query_name (sack));
596	new_draw_info (NDI_UNIQUE, 0, op, buf);	548	new_draw_info (NDI_UNIQUE, 0, op, buf);
597	break;	549	break;
598	}	550	}
599	}	551	}
600		552
601	esrv_update_item (UPD_WEIGHT, op, sack2);
602	return;	553	return;
603	}	554	}
604		555
605	/* Don't worry about this for containers - our caller should have	556	/* Don't worry about this for containers - our caller should have
606	* already checked this.	557	* already checked this.
607	*/	558	*/
608	if ((sack->type == CONTAINER) && !sack_can_hold (op, sack, tmp, (nrof ? nrof : tmp->nrof)))	559	if ((sack->type == CONTAINER) && !sack_can_hold (op, sack, tmp, (nrof ? nrof : tmp->nrof)))
609	return;	560	return;
610		561
611	if (QUERY_FLAG (tmp, FLAG_APPLIED))	562	if (tmp->flag [FLAG_APPLIED])
612	if (apply_special (op, tmp, AP_UNAPPLY | AP_NO_MERGE))	563	if (!op->apply (tmp, AP_UNAPPLY | AP_NO_MERGE))
613	return;	564	return;
614		565
615	/* we want to put some portion of the item into the container */	566	/* we want to put some portion of the item into the container */
616	if (nrof && tmp->nrof != nrof)	567	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;	568	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		569
636	new_draw_info_format (NDI_UNIQUE, 0, op, "You put the %s in %s.", query_name (tmp), query_name (sack));	570	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);	571	sack->insert (tmp);
		572	}
638		573
639	// elmex: 2007-11-26: removed update_stats and replaced	574	/* In contrast to drop_object (op, tmp, nrof) above this function takes the
640	// it by update_after_inventory_change () in the caller	575	* already split off object, and feeds it to the event handlers and does
641	// of this function	576	* other magic with it.
		577	*
		578	* <droppper> is the object that dropped this object and <obj> is the
		579	* object that was dropped.
		580	*
		581	* Make sure to check what happened with <obj> after this function returns!
		582	* Otherwise you may leak this object.
		583	*/
		584	void
		585	drop_object (object *dropper, object *obj)
		586	{
		587	if (INVOKE_OBJECT (DROP, obj, ARG_OBJECT (dropper)))
		588	return;
		589
		590	if (obj->destroyed () || obj->is_inserted ())
		591	return;
642		592
643	/* If an object merged (and thus, different object), we need to	593	if (obj->flag [FLAG_STARTEQUIP])
644	* delete the original.	594	{
		595	dropper->statusmsg (format ("You drop the %s.", query_name (obj)));
		596	dropper->statusmsg ("The god who lent it to you retrieves it.");
		597
		598	obj->destroy ();
		599	dropper->update_stats ();
		600	return;
		601	}
		602
		603	for (object *floor = GET_MAP_OB (dropper->map, dropper->x, dropper->y);
		604	floor;
		605	floor = floor->above)
		606	if (INVOKE_OBJECT (DROP_ON, floor, ARG_OBJECT (obj), ARG_OBJECT (dropper)))
		607	return;
		608
		609	if (obj->destroyed () || obj->is_inserted ())
		610	return;
		611
		612	if (dropper->is_in_shop () && !obj->flag [FLAG_UNPAID] && obj->type != MONEY)
		613	if (!sell_item (obj, dropper))
		614	return;
		615
		616	if (!obj->can_drop_at (dropper->map, dropper->x, dropper->y, dropper))
		617	return;
		618
		619	/* If nothing special happened with this object, the default action is to
		620	* insert it below the dropper:
645	*/	621	*/
646	if (tmp2 != tmp)
647	esrv_del_item (op->contr, tmp->count);
648		622
649	esrv_send_item (op, tmp2);	623	obj->x = dropper->x;
		624	obj->y = dropper->y;
650		625
651	/* update the sacks weight */	626	insert_ob_in_map (obj, dropper->map, dropper, INS_BELOW_ORIGINATOR);
652	esrv_update_item (UPD_WEIGHT, op, sack);
653	}	627	}
654		628
655	/*	629	/*
656	* This function was part of drop, now is own function.	630	* This function was part of drop, now is own function.
657	* Player 'op' tries to drop object 'tmp', if tmp is non zero, then	631	* Player 'op' tries to drop object 'tmp', if tmp is non zero, then
658	* nrof objects is tried to dropped.	632	* nrof objects are tried to drop.
659	* This is used when dropping objects onto the floor.	633	* This is used when dropping objects onto the floor.
660	*/	634	*/
661	void	635	void
662	drop_object (object *op, object *tmp, uint32 nrof)	636	drop_object (object *op, object *tmp, uint32 nrof)
663	{	637	{
664	object *floor;	638	if (tmp->flag [FLAG_NO_DROP])
665
666	if (QUERY_FLAG (tmp, FLAG_NO_DROP))
667	return;	639	return;
668		640
669	if (QUERY_FLAG (tmp, FLAG_APPLIED))	641	if (tmp->flag [FLAG_APPLIED])
670	if (apply_special (op, tmp, AP_UNAPPLY | AP_NO_MERGE))	642	if (!op->apply (tmp, AP_UNAPPLY | AP_NO_MERGE))
671	return; /* can't unapply it */	643	return; /* can't unapply it */
672
673	//fprintf (stderr, "ui, on space is %ld\n", op->ms ().volume ());//D
674		644
675	/* We are only dropping some of the items. We split the current object	645	/* We are only dropping some of the items. We split the current object
676	* off	646	* off
677	*/	647	*/
678	if (nrof && tmp->nrof != nrof)	648	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	tmp->remove ();
701
702	if (INVOKE_OBJECT (DROP, tmp, ARG_OBJECT (op)))
703	return;	649	return;
704		650
705	if (QUERY_FLAG (tmp, FLAG_STARTEQUIP))	651	drop_object (op, tmp);
706	{
707	op->statusmsg (format ("You drop the %s.", query_name (tmp)));
708	op->statusmsg ("The gods who lent it to you retrieves it.");
709		652
710	if (op->type == PLAYER)	653	if (!tmp->destroyed () && !tmp->is_inserted ())
711	esrv_del_item (op->contr, tmp->count);
712
713	tmp->destroy ();
714	op->update_stats ();
715	return;
716	}	654	{
717		655	// if nothing happened with the object we give it back
718	if (op->type == PLAYER)	656	op->insert (tmp);
719	esrv_del_item (op->contr, tmp->count);
720
721	/* Call this before we update the various windows/players. At least
722	* that we, we know the weight is correct.
723	*/
724	// 2007-11-26: moved op->update_stats away and calling it later after
725	// all items of a drop command have been processed.
726
727	for (floor = GET_MAP_OB (op->map, op->x, op->y); floor; floor = floor->above)
728	if (INVOKE_OBJECT (DROP_ON, floor, ARG_OBJECT (tmp), ARG_OBJECT (op)))
729	return;
730
731	if (is_in_shop (op) && !QUERY_FLAG (tmp, FLAG_UNPAID) && tmp->type != MONEY)
732	sell_item (tmp, op);
733
734	tmp->x = op->x;
735	tmp->y = op->y;
736
737	insert_ob_in_map (tmp, op->map, op, INS_BELOW_ORIGINATOR);
738	}
739
740	void update_after_inventory_change (object *op)
741	{
742	/* Call this before we update the various windows/players. At least
743	* that we, we know the weight is correct.
744	*/
745	op->update_stats ();
746
747	// elmex: kept this for now, i have no idea what happens when i remove it:
748	if (op->type == PLAYER)
749	{
750	/* Need to update the weight for the player */
751	esrv_send_item (op, op);
752	op->contr->ns->floorbox_update ();
753	}	657	}
754	}	658	}
755		659
756	void	660	void
757	drop (object *op, object *tmp)	661	drop (object *op, object *tmp)
…		…
767	if (tmp->env && tmp->env->type != PLAYER)	671	if (tmp->env && tmp->env->type != PLAYER)
768	{	672	{
769	/* Just toss the object - probably shouldn't be hanging	673	/* Just toss the object - probably shouldn't be hanging
770	* around anyways	674	* around anyways
771	*/	675	*/
772	tmp->remove ();
773	tmp->destroy ();	676	tmp->destroy ();
774	return;	677	return;
775	}	678	}
776	else	679	else
777	{
778	while (tmp != NULL && tmp->invisible)	680	while (tmp && tmp->invisible)
779	tmp = tmp->below;	681	tmp = tmp->below;
780	}
781	}	682	}
782		683
783	if (tmp == NULL)	684	if (!tmp)
784	{	685	{
785	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.");
786	return;	687	return;
787	}	688	}
788	if (QUERY_FLAG (tmp, FLAG_INV_LOCKED))	689
		690	if (tmp->flag [FLAG_INV_LOCKED])
789	{	691	{
790	new_draw_info (NDI_UNIQUE, 0, op, "This item is locked");	692	new_draw_info (NDI_UNIQUE, 0, op, "This item is locked");
791	return;	693	return;
792	}	694	}
793	if (QUERY_FLAG (tmp, FLAG_NO_DROP))	695
		696	if (tmp->flag [FLAG_NO_DROP])
794	{	697	{
795	#if 0	698	#if 0
796	/* 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. */
797	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.");
798	#endif	701	#endif
…		…
800	}	703	}
801		704
802	if (op->type == PLAYER && op->contr->last_used == tmp)	705	if (op->type == PLAYER && op->contr->last_used == tmp)
803	op->contr->last_used = tmp->below ? tmp->below	706	op->contr->last_used = tmp->below ? tmp->below
804	: tmp->above ? tmp->above	707	: tmp->above ? tmp->above
805	: 0;	708	: (object *)0;
806		709
807	if (op->container)	710	if (op->container_ ())
808	{	711	{
809	if (op->type == PLAYER)	712	if (op->type == PLAYER)
810	put_object_in_sack (op, op->container, tmp, op->contr->count);	713	put_object_in_sack (op, op->container_ (), tmp, op->contr->count);
811	else	714	else
812	put_object_in_sack (op, op->container, tmp, 0);	715	put_object_in_sack (op, op->container_ (), tmp, 0);
813	}	716	}
814	else	717	else
815	{	718	{
816	if (op->type == PLAYER)	719	if (op->type == PLAYER)
817	drop_object (op, tmp, op->contr->count);	720	drop_object (op, tmp, op->contr->count);
…		…
821		724
822	if (op->type == PLAYER)	725	if (op->type == PLAYER)
823	op->contr->count = 0;	726	op->contr->count = 0;
824	}	727	}
825		728
826
827
828	/* Command will drop all items that have not been locked */	729	/* Command will drop all items that have not been locked */
829	int	730	int
830	command_dropall (object *op, char *params)	731	command_dropall (object *op, char *params)
831	{	732	{
832		733
833	object *curinv, *nextinv;
834
835	if (op->inv == NULL)	734	if (op->inv == NULL)
836	{	735	{
837	new_draw_info (NDI_UNIQUE, 0, op, "Nothing to drop!");	736	new_draw_info (NDI_UNIQUE, 0, op, "Nothing to drop!");
838	return 0;	737	return 0;
839	}	738	}
840		739
841	curinv = op->inv;	740	object *curinv = op->inv;
		741	object *nextinv;
842		742
843	/*	743	/*
844	This is the default. Drops everything not locked or considered	744	This is the default. Drops everything not locked or considered
845	not something that should be dropped.	745	not something that should be dropped.
846	*/	746	*/
847	/*	747	/*
848	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
849	the drop() routine will do unknown things to it when dropping	749	the drop() routine will do unknown things to it when dropping
850	in a shop. --Tero.Pelander@utu.fi	750	in a shop. --Tero.Pelander@utu.fi
851	*/	751	*/
852
853	int cnt = MAX_ITEM_PER_DROP;	752	int cnt = MAX_ITEM_PER_ACTION;
854		753
855	if (params == NULL)	754	if (!params)
856	{	755	{
857	while (curinv != NULL)	756	while (curinv)
858	{	757	{
859	nextinv = curinv->below;	758	nextinv = curinv->below;
		759
860	while (nextinv && nextinv->type == MONEY)	760	while (nextinv && nextinv->type == MONEY)
861	nextinv = nextinv->below;	761	nextinv = nextinv->below;
862	if (!QUERY_FLAG (curinv, FLAG_INV_LOCKED) && curinv->type != MONEY &&	762
863	curinv->type != FOOD && curinv->type != KEY &&	763	if (!curinv->flag [FLAG_INV_LOCKED]
864	curinv->type != SPECIAL_KEY && curinv->type != GEM &&	764	&& !curinv->invisible
865	!curinv->invisible && (curinv->type != CONTAINER || op->container != curinv))	765	&& curinv->type != MONEY
		766	&& curinv->type != FOOD
		767	&& curinv->type != KEY
		768	&& curinv->type != SPECIAL_KEY
		769	&& curinv->type != GEM
		770	&& curinv->type != CONTAINER)
866	{	771	{
867	drop (op, curinv);	772	drop (op, curinv);
868	if (--cnt <= 0) break;	773	if (--cnt <= 0) break;
869	}	774	}
		775
870	curinv = nextinv;	776	curinv = nextinv;
871	}	777	}
872	}	778	}
873
874	else if (strcmp (params, "weapons") == 0)	779	else if (strcmp (params, "weapons") == 0)
875	{	780	{
876	while (curinv != NULL)	781	while (curinv)
877	{	782	{
878	nextinv = curinv->below;	783	nextinv = curinv->below;
		784
879	while (nextinv && nextinv->type == MONEY)	785	while (nextinv && nextinv->type == MONEY)
880	nextinv = nextinv->below;	786	nextinv = nextinv->below;
		787
881	if (!QUERY_FLAG (curinv, FLAG_INV_LOCKED) && ((curinv->type == WEAPON) || (curinv->type == BOW) || (curinv->type == ARROW)))	788	if (!curinv->flag [FLAG_INV_LOCKED] && ((curinv->type == WEAPON) || (curinv->type == BOW) || (curinv->type == ARROW)))
882	{	789	{
883	drop (op, curinv);	790	drop (op, curinv);
884	if (--cnt <= 0) break;	791	if (--cnt <= 0) break;
885	}	792	}
		793
886	curinv = nextinv;	794	curinv = nextinv;
887	}	795	}
888	}	796	}
889
890	else if (strcmp (params, "armor") == 0 || strcmp (params, "armour") == 0)	797	else if (strcmp (params, "armor") == 0 || strcmp (params, "armour") == 0)
891	{	798	{
892	while (curinv != NULL)	799	while (curinv)
893	{	800	{
894	nextinv = curinv->below;	801	nextinv = curinv->below;
		802
895	while (nextinv && nextinv->type == MONEY)	803	while (nextinv && nextinv->type == MONEY)
896	nextinv = nextinv->below;	804	nextinv = nextinv->below;
		805
897	if (!QUERY_FLAG (curinv, FLAG_INV_LOCKED) && ((curinv->type == ARMOUR) || curinv->type == SHIELD || curinv->type == HELMET))	806	if (!curinv->flag [FLAG_INV_LOCKED] && ((curinv->type == ARMOUR) || curinv->type == SHIELD || curinv->type == HELMET))
898	{	807	{
899	drop (op, curinv);	808	drop (op, curinv);
900	if (--cnt <= 0) break;	809	if (--cnt <= 0) break;
901	}	810	}
		811
902	curinv = nextinv;	812	curinv = nextinv;
903	}	813	}
904	}	814	}
905
906	else if (strcmp (params, "misc") == 0)	815	else if (strcmp (params, "misc") == 0)
907	{	816	{
908	while (curinv != NULL)	817	while (curinv)
909	{	818	{
910	nextinv = curinv->below;	819	nextinv = curinv->below;
		820
911	while (nextinv && nextinv->type == MONEY)	821	while (nextinv && nextinv->type == MONEY)
912	nextinv = nextinv->below;	822	nextinv = nextinv->below;
913	if (!QUERY_FLAG (curinv, FLAG_INV_LOCKED) && !QUERY_FLAG (curinv, FLAG_APPLIED))	823
		824	if (!curinv->flag [FLAG_INV_LOCKED] && !curinv->flag [FLAG_APPLIED])
914	{	825	{
915	switch (curinv->type)	826	switch (curinv->type)
916	{	827	{
917	case HORN:	828	case HORN:
918	case BOOK:	829	case BOOK:
…		…
935	break;	846	break;
936	default:	847	default:
937	curinv = nextinv;	848	curinv = nextinv;
938	break;	849	break;
939	}	850	}
		851
940	if (--cnt <= 0) break;	852	if (--cnt <= 0) break;
941	}	853	}
		854
942	curinv = nextinv;	855	curinv = nextinv;
943	}	856	}
944	}	857	}
945		858
946	if (cnt <= 0)	859	if (cnt <= 0)
947	op->failmsg ("Only dropped some items, can't drop that many items at once.");	860	op->failmsg ("Only dropped some items, can't drop that many items at once.");
948		861
949	update_after_inventory_change (op);
950
951	/* draw_look(op);*/	862	/* draw_look(op);*/
952	return 0;	863	return 0;
953	}	864	}
954		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	static 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;
		889	}
		890
955	/* 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
956	* comma seperated list.	892	* comma seperated list.
957	*/	893	*/
958
959	int	894	int
960	command_drop (object *op, char *params)	895	command_drop (object *op, char *params)
961	{	896	{
962	object *tmp, *next;	897	object *tmp, *next;
963	int did_one = 0;
964		898
965	if (!params)	899	if (!params)
966	{	900	{
967	new_draw_info (NDI_UNIQUE, 0, op, "Drop what?");	901	new_draw_info (NDI_UNIQUE, 0, op, "Drop what?");
968	return 0;	902	return 0;
969	}	903	}
970	else	904	else
971	{	905	{
972	int cnt = MAX_ITEM_PER_DROP;	906	vector<object *> matched_objs;
973		907
974	for (tmp = op->inv; tmp; tmp = next)	908	for (tmp = op->inv; tmp; tmp = next)
975	{	909	{
976	next = tmp->below;	910	next = tmp->below;
977	if (QUERY_FLAG (tmp, FLAG_NO_DROP) || tmp->invisible)	911	if (tmp->flag [FLAG_NO_DROP] || tmp->invisible)
978	continue;	912	continue;
979		913
980	if (item_matched_string (op, tmp, params))	914	if (item_matched_string (op, tmp, params))
981	{	915	matched_objs.push_back (tmp);
982	drop (op, tmp);
983	if (--cnt <= 0) break;
984	did_one = 1;
985	}	916	}
986	}
987		917
988	if (!did_one)	918	int cnt = MAX_ITEM_PER_ACTION;
		919
		920	if (!drop_vector (op, matched_objs, &cnt))
989	new_draw_info (NDI_UNIQUE, 0, op, "Nothing to drop.");	921	new_draw_info (NDI_UNIQUE, 0, op, "Nothing to drop.");
990		922
991	if (cnt <= 0)	923	if (cnt <= 0)
992	op->failmsg ("Only dropped some items, can't drop that many items at once.");	924	op->failmsg ("Only dropped some items, can't drop that many items at once.");
993
994	update_after_inventory_change (op);
995	}	925	}
996		926
997	return 0;	927	return 0;
998	}	928	}
999		929
…		…
1004	{	934	{
1005	object *tmp = op->below;	935	object *tmp = op->below;
1006		936
1007	while (tmp && !tmp->client_visible ())	937	while (tmp && !tmp->client_visible ())
1008	tmp = tmp->below;	938	tmp = tmp->below;
		939
1009	if (tmp)	940	if (tmp)
1010	examine (op, tmp);	941	examine (op, tmp);
1011	}	942	}
1012	else	943	else
1013	{	944	{
1014	object *tmp = find_best_object_match (op, params);	945	object *tmp = find_best_object_match (op, params);
1015		946
1016	if (tmp)	947	if (tmp)
1017	examine (op, tmp);	948	examine (op, tmp);
1018	else	949	else
1019	new_draw_info_format (NDI_UNIQUE, 0, op, "Could not find an object that matches %s", params);	950	op->contr->infobox (MSG_CHANNEL ("examine"), format ("Could not find an object that matches %s", params));
1020	}
1021	return 0;
1022	}
1023
1024	/* op should be a player.
1025	* we return the object the player has marked with the 'mark' command
1026	* below. If no match is found (or object has changed), we return
1027	* NULL. We leave it up to the calling function to print messages if
1028	* nothing is found.
1029	*/
1030	object *
1031	find_marked_object (object *op)
1032	{
1033	object *tmp;
1034
1035	if (!op || !op->contr)
1036	return NULL;
1037
1038	if (!op->contr->mark)
1039	{
1040	/* new_draw_info(NDI_UNIQUE,0,op,"You have no marked object");*/
1041	return 0;
1042	}
1043
1044	/* This may seem like overkill, but we need to make sure that they
1045	* player hasn't dropped the item. We use count on the off chance that
1046	* an item got reincarnated at some point.
1047	*/
1048	for (tmp = op->inv; tmp; tmp = tmp->below)
1049	{
1050	if (tmp->invisible)
1051	continue;
1052
1053	if (tmp == op->contr->mark)
1054	{
1055	if (!tmp->destroyed ())
1056	return tmp;
1057	else
1058	{
1059	op->contr->mark = 0;
1060	/* new_draw_info(NDI_UNIQUE,0,op,"You have no marked object");*/
1061	return 0;
1062	}
1063	}
1064	}	951	}
1065		952
1066	return 0;	953	return 0;
1067	}	954	}
1068		955
…		…
1071	{	958	{
1072	dynbuf_text buf (512, 512);	959	dynbuf_text buf (512, 512);
1073		960
1074	object *mon = head ? head : this;	961	object *mon = head ? head : this;
1075		962
1076	if (QUERY_FLAG (mon, FLAG_UNDEAD))	963	if (mon->flag [FLAG_UNDEAD])
1077	buf << "It is an undead force.\n";	964	buf << "It is an undead force.\r";
1078		965
1079	if (mon->level > who->level)	966	if (mon->level > who->level)
1080	buf << "It is likely more powerful than you.\n";	967	buf << "It is likely more powerful than you.\r";
1081	else if (mon->level < who->level)	968	else if (mon->level < who->level)
1082	buf << "It is likely less powerful than you.\n";	969	buf << "It is likely less powerful than you.\r";
1083	else	970	else
1084	buf << "It is probably as powerful as you.\n";	971	buf << "It is probably as powerful as you.\r";
1085		972
1086	if (mon->attacktype & AT_ACID)	973	if (mon->attacktype & AT_ACID)
1087	buf << "You seem to smell an acrid odor.\n";	974	buf << "You seem to smell an acrid odor.\r";
1088		975
1089	/* Anyone know why this used to use the clone value instead of the	976	/* Anyone know why this used to use the clone value instead of the
1090	* maxhp field? This seems that it should give more accurate results.	977	* maxhp field? This seems that it should give more accurate results.
1091	*/	978	*/
1092	switch ((mon->stats.hp + 1) * 4 / (mon->stats.maxhp + 1))	979	switch ((mon->stats.hp + 1) * 4 / (mon->stats.maxhp + 1))
1093	{ /* From 1-4 */	980	{ /* From 1-4 */
1094	case 1:	981	case 1:
1095	buf << "It is in a bad shape.\n";	982	buf << "It is in a bad shape.\r";
1096	break;	983	break;
1097	case 2:	984	case 2:
1098	buf << "It is hurt.\n";	985	buf << "It is hurt.\r";
1099	break;	986	break;
1100	case 3:	987	case 3:
1101	buf << "It is somewhat hurt.\n";	988	buf << "It is somewhat hurt.\r";
1102	break;	989	break;
1103	case 4:	990	case 4:
1104	buf << "It is in excellent shape.\n";	991	buf << "It is in excellent shape.\r";
1105	break;	992	break;
1106	}	993	}
1107		994
1108	if (present_in_ob (POISONING, mon))	995	if (present_in_ob (POISONING, mon))
1109	buf << "It looks very ill.\n";	996	buf << "It looks very ill.\r";
		997
		998	buf << '\n';
1110		999
1111	return buf;	1000	return buf;
1112	}	1001	}
1113		1002
1114	/* tmp is the object being described, pl is who is examing it. */	1003	/* tmp is the object being described, pl is who is examing it. */
…		…
1121	}	1010	}
1122		1011
1123	std::string	1012	std::string
1124	object::long_desc (object *who)	1013	object::long_desc (object *who)
1125	{	1014	{
1126	std::string buf (query_name (this));	1015	std::string buf (query_name ());
1127		1016
1128	switch (type)	1017	switch (type)
1129	{	1018	{
1130	case RING:	1019	case RING:
1131	case SKILL:	1020	case SKILL:
…		…
1136	case SHIELD:	1025	case SHIELD:
1137	case BOOTS:	1026	case BOOTS:
1138	case GLOVES:	1027	case GLOVES:
1139	case AMULET:	1028	case AMULET:
1140	case GIRDLE:	1029	case GIRDLE:
		1030	case RANGED:
1141	case BOW:	1031	case BOW:
1142	case ARROW:	1032	case ARROW:
1143	case CLOAK:	1033	case CLOAK:
1144	case FOOD:	1034	case FOOD:
1145	case DRINK:	1035	case DRINK:
1146	case FLESH:	1036	case FLESH:
1147	case SKILL_TOOL:	1037	case SKILL_TOOL:
		1038	case LAMP:
1148	case POWER_CRYSTAL:	1039	case POWER_CRYSTAL:
1149	{	1040	{
1150	const char *cp = ::describe_item (this, who);	1041	const char *cp = ::describe_item (this, who);
1151		1042
1152	if (*cp)	1043	if (*cp)
…		…
1167	examine_monster (object *op, object *tmp)	1058	examine_monster (object *op, object *tmp)
1168	{	1059	{
1169	new_draw_info (NDI_UNIQUE, 0, op, tmp->describe_monster (op).c_str ());	1060	new_draw_info (NDI_UNIQUE, 0, op, tmp->describe_monster (op).c_str ());
1170	}	1061	}
1171		1062
1172	std::string
1173	object::describe (object *who)
1174	{
1175	dynbuf_text buf (1024, 1024);
1176
1177	buf.printf ("That is: %s.\n", long_desc (who).c_str ());
1178
1179	if (custom_name)
1180	buf.printf ("You call it %s\n", &custom_name);
1181
1182	switch (type)
1183	{
1184	case SPELLBOOK:
1185	if (flag [FLAG_IDENTIFIED] && inv)
1186	buf.printf ("%s is a %s %s spell\n", &inv->name, get_levelnumber (inv->level), &inv->skill);
1187	break;
1188
1189	case BOOK:
1190	if (msg)
1191	buf << "Something is written in it.\n";
1192	break;
1193
1194	case CONTAINER:
1195	if (race != NULL)
1196	{
1197	if (weight_limit && stats.Str < 100)
1198	buf.printf ("It can hold only %s and its weight limit is %.1f kg.\n",
1199	&race, weight_limit / (10.0 * (100 - stats.Str)));
1200	else
1201	buf.printf ("It can hold only %s.\n", &race);
1202	}
1203	else if (weight_limit && stats.Str < 100)
1204	buf.printf ("Its weight limit is %.1f kg.\n", weight_limit / (10.0 * (100 - stats.Str)));
1205	break;
1206
1207	case WAND:
1208	if (flag [FLAG_IDENTIFIED])
1209	buf.printf ("It has %d charges left.\n", stats.food);
1210	break;
1211	}
1212
1213	if (materialname && !msg)
1214	buf.printf ("It is made of: %s.\n", &materialname);
1215
1216	if (who)
1217	/* Where to wear this item */
1218	for (int i = 0; i < NUM_BODY_LOCATIONS; i++)
1219	if (slot[i].info)
1220	{
1221	buf << (who->slot[i].info ? body_locations[i].use_name : body_locations[i].nonuse_name);
1222
1223	if (slot[i].info < -1 && who->slot[i].info)
1224	buf.printf ("(%d)", -slot[i].info);
1225
1226	buf << ".\n";
1227	}
1228
1229	if (weight)
1230	buf.printf (nrof > 1 ? "They weigh %3.3f kg.\n" : "It weighs %3.3f kg.\n", weight * (nrof ? nrof : 1) / 1000.0);
1231
1232	if (value && !flag [FLAG_STARTEQUIP] && !flag [FLAG_NO_PICK] && who)
1233	{
1234	buf.printf ("You reckon %s worth %s.\n", nrof > 1 ? "they are" : "it is", query_cost_string (this, who, F_TRUE | F_APPROX));
1235
1236	if (is_in_shop (who))
1237	{
1238	if (flag [FLAG_UNPAID])
1239	buf.printf ("%s would cost you %s.\n", nrof > 1 ? "They" : "It", query_cost_string (this, who, F_BUY | F_SHOP));
1240	else
1241	buf.printf ("You are offered %s for %s.\n", query_cost_string (this, who, F_SELL + F_SHOP), nrof > 1 ? "them" : "it");
1242	}
1243	}
1244
1245	if (flag [FLAG_MONSTER])
1246	buf << describe_monster (who);
1247
1248	/* Is this item buildable? */
1249	if (flag [FLAG_IS_BUILDABLE])
1250	buf << "This is a buildable item.\n";
1251
1252	/* Does the object have a message? Don't show message for all object
1253	* types - especially if the first entry is a match
1254	*/
1255	if (msg && type != EXIT && type != BOOK && type != CORPSE && !move_on && strncasecmp (msg, "@match", 7))
1256	{
1257	/* This is just a hack so when identifying the items, we print
1258	* out the extra message
1259	*/
1260	if (need_identify (this) && flag [FLAG_IDENTIFIED])
1261	buf << "The object has a story:\n";
1262
1263	buf << msg << '\n';
1264	}
1265
1266	buf << '\n';
1267
1268	return std::string (buf.linearise (), buf.size ());
1269	}
1270
1271	static void	1063	static void
1272	display_new_pickup (object *op)	1064	display_new_pickup (object *op)
1273	{	1065	{
1274	int i = op->contr->mode;	1066	int i = op->contr->mode;
1275		1067
1276	if (!(i & PU_NEWMODE))
1277	return;
1278
1279	new_draw_info_format (NDI_UNIQUE, 0, op, "%d NEWMODE", i & PU_NEWMODE ? 1 : 0);
1280	new_draw_info_format (NDI_UNIQUE, 0, op, "%d DEBUG", i & PU_DEBUG ? 1 : 0);	1068	new_draw_info_format (NDI_UNIQUE, 0, op, "%d DEBUG", i & PU_DEBUG ? 1 : 0);
1281	new_draw_info_format (NDI_UNIQUE, 0, op, "%d INHIBIT", i & PU_INHIBIT ? 1 : 0);	1069	new_draw_info_format (NDI_UNIQUE, 0, op, "%d INHIBIT", i & PU_INHIBIT ? 1 : 0);
1282	new_draw_info_format (NDI_UNIQUE, 0, op, "%d STOP", i & PU_STOP ? 1 : 0);	1070	new_draw_info_format (NDI_UNIQUE, 0, op, "%d STOP", i & PU_STOP ? 1 : 0);
1283		1071
1284	new_draw_info_format (NDI_UNIQUE, 0, op, "%d <= x pickup weight/value RATIO (0==off)", (i & PU_RATIO) * 5);	1072	new_draw_info_format (NDI_UNIQUE, 0, op, "%d <= x pickup weight/value RATIO (0==off)", (i & PU_RATIO) * 5);
…		…
1335	};	1123	};
1336		1124
1337	if (!params)	1125	if (!params)
1338	{	1126	{
1339	/* if the new mode is used, just print the settings */	1127	/* if the new mode is used, just print the settings */
1340	if (op->contr->mode & PU_NEWMODE)
1341	{
1342	display_new_pickup (op);	1128	display_new_pickup (op);
1343	return 1;
1344	}
1345	if (1)
1346	LOG (llevDebug, "command_pickup: !params\n");
1347	set_pickup_mode (op, (op->contr->mode > 6) ? 0 : op->contr->mode + 1);
1348	return 0;	1129	return 0;
1349	}	1130	}
1350		1131
1351	while (*params == ' ' && *params)	1132	while (*params == ' ' && *params)
1352	params++;	1133	params++;
…		…
1358	for (mode = 0; names[mode]; mode++)	1139	for (mode = 0; names[mode]; mode++)
1359	{	1140	{
1360	if (!strcmp (names[mode], params + 1))	1141	if (!strcmp (names[mode], params + 1))
1361	{	1142	{
1362	i = op->contr->mode;	1143	i = op->contr->mode;
1363	if (!(i & PU_NEWMODE))	1144
1364	i = PU_NEWMODE;
1365	if (*params == '+')	1145	if (*params == '+')
1366	i = i | modes[mode];	1146	i = i | modes[mode];
1367	else	1147	else
1368	i = i & ~modes[mode];	1148	i = i & ~modes[mode];
		1149
1369	op->contr->mode = i;	1150	op->contr->mode = i;
1370	display_new_pickup (op);	1151	display_new_pickup (op);
1371	return 1;	1152	return 1;
1372	}	1153	}
1373	}	1154	}
…		…
1375	return 1;	1156	return 1;
1376	}	1157	}
1377		1158
1378	if (sscanf (params, "%u", &i) != 1)	1159	if (sscanf (params, "%u", &i) != 1)
1379	{	1160	{
1380	if (1)
1381	LOG (llevDebug, "command_pickup: params==NULL\n");
1382	new_draw_info (NDI_UNIQUE, 0, op, "Usage: pickup <0-7> or <value_density> .");	1161	new_draw_info (NDI_UNIQUE, 0, op, "Usage: pickup <value_density> or [+-]type.");
1383	return 1;	1162	return 1;
1384	}	1163	}
1385	set_pickup_mode (op, i);	1164
		1165	if (i <= PU_RATIO)
		1166	i |= op->contr->mode & ~PU_RATIO;
		1167
		1168	op->contr->mode = i;
1386		1169
1387	return 1;	1170	return 1;
1388	}	1171	}
1389		1172
1390	void
1391	set_pickup_mode (object *op, int i)
1392	{
1393	switch (op->contr->mode = i)
1394	{
1395	case 0:
1396	new_draw_info (NDI_UNIQUE, 0, op, "Mode: Don't pick up.");
1397	break;
1398	case 1:
1399	new_draw_info (NDI_UNIQUE, 0, op, "Mode: Pick up one item.");
1400	break;
1401	case 2:
1402	new_draw_info (NDI_UNIQUE, 0, op, "Mode: Pick up one item and stop.");
1403	break;
1404	case 3:
1405	new_draw_info (NDI_UNIQUE, 0, op, "Mode: Stop before picking up.");
1406	break;
1407	case 4:
1408	new_draw_info (NDI_UNIQUE, 0, op, "Mode: Pick up all items.");
1409	break;
1410	case 5:
1411	new_draw_info (NDI_UNIQUE, 0, op, "Mode: Pick up all items and stop.");
1412	break;
1413	case 6:
1414	new_draw_info (NDI_UNIQUE, 0, op, "Mode: Pick up all magic items.");
1415	break;
1416	case 7:
1417	new_draw_info (NDI_UNIQUE, 0, op, "Mode: Pick up all coins and gems");
1418	break;
1419	}
1420	}
1421
1422	int	1173	int
1423	command_search_items (object *op, char *params)	1174	command_search_items (object *op, char *params)
1424	{	1175	{
1425	char buf[MAX_BUF];
1426
1427	if (settings.search_items == FALSE)
1428	return 1;
1429
1430	if (params == NULL)	1176	if (params == NULL)
1431	{	1177	{
1432	if (op->contr->search_str[0] == '\0')	1178	if (op->contr->search_str[0] == '\0')
1433	{	1179	{
1434	new_draw_info (NDI_UNIQUE, 0, op, "Example: search magic+1");	1180	new_draw_info (NDI_UNIQUE, 0, op, "Example: search-items magic+1");
1435	new_draw_info (NDI_UNIQUE, 0, op, "Would automatically pick up all");	1181	new_draw_info (NDI_UNIQUE, 0, op, "Would automatically pick up all");
1436	new_draw_info (NDI_UNIQUE, 0, op, "items containing the word 'magic+1'.");	1182	new_draw_info (NDI_UNIQUE, 0, op, "items containing the word 'magic+1'.");
1437	return 1;	1183	return 1;
1438	}	1184	}
1439		1185
1440	op->contr->search_str[0] = '\0';	1186	op->contr->search_str[0] = '\0';
1441	new_draw_info (NDI_UNIQUE, 0, op, "Search mode turned off.");	1187	new_draw_info (NDI_UNIQUE, 0, op, "Search mode turned off.");
1442	op->update_stats ();	1188	op->contr->queue_stats_update ();
1443	return 1;	1189	return 1;
1444	}	1190	}
1445		1191
1446	if ((int) strlen (params) >= MAX_BUF)	1192	if (strlen (params) >= sizeof (op->contr->search_str))
1447	{	1193	{
1448	new_draw_info (NDI_UNIQUE, 0, op, "Search string too long.");	1194	new_draw_info (NDI_UNIQUE, 0, op, "Search string too long.");
1449	return 1;	1195	return 1;
1450	}	1196	}
1451		1197
1452	strcpy (op->contr->search_str, params);	1198	strcpy (op->contr->search_str, params);
1453	sprintf (buf, "Searching for '%s'.", op->contr->search_str);	1199	new_draw_info (NDI_UNIQUE, 0, op, format ("Now searching for '%s'.", op->contr->search_str));
1454	new_draw_info (NDI_UNIQUE, 0, op, buf);	1200	op->contr->queue_stats_update ();
1455	op->update_stats ();	1201
1456	return 1;	1202	return 1;
1457	}	1203	}
1458		1204
		1205	int
		1206	command_unlock (object *op, char *params)
		1207	{
		1208	/* if the unlock command typed with nothing, unlock everything,
		1209	* this might be bad
		1210	*/
		1211	if (params == NULL)
		1212	{
		1213	for (object *item = op->inv; item; item = item->below)
		1214	{
		1215	item->clr_flag (FLAG_INV_LOCKED);
		1216	//d// new_draw_info (NDI_UNIQUE, 0, op, "unlocked items with null param.");
		1217	esrv_update_item (UPD_FLAGS, op, item);
		1218	}
		1219	return 0;
		1220	}
		1221
		1222	/* if the unlock command is used with a param,
		1223	* unlock what matches. i.e. unlock material, should unlock all the materials
		1224	*/
		1225	for (object *item = op->inv; item; item = item->below)
		1226	if (item->name.contains (params))
		1227	{
		1228	item->clr_flag (FLAG_INV_LOCKED);
		1229	//d// new_draw_info (NDI_UNIQUE, 0, op, "unlocked items with a param.");
		1230	esrv_update_item (UPD_FLAGS, op, item);
		1231	}
		1232
		1233	return 0;
		1234	}
		1235
		1236	int
		1237	command_lock (object *op, char *params)
		1238	{
		1239	/* if the lock command is typed by itself, lock everything
		1240	*/
		1241	if (params == NULL)
		1242	{
		1243	for (object *item = op->inv; item; item = item->below)
		1244	{
		1245	item->set_flag (FLAG_INV_LOCKED);
		1246	//d// new_draw_info (NDI_UNIQUE, 0, op, "locked items with null param.");
		1247	esrv_update_item (UPD_FLAGS, op, item);
		1248	}
		1249	return 0;
		1250	}
		1251
		1252	/* if the lock command is used with a param, lock what matches.
		1253	* i.e. lock material, should lock all the materials
		1254	*/
		1255	for (object *item = op->inv; item; item = item->below)
		1256	if (item->name.contains (params))
		1257	{
		1258	item->set_flag (FLAG_INV_LOCKED);
		1259	//d// new_draw_info (NDI_UNIQUE, 0, op, "locked items with param.");
		1260	esrv_update_item (UPD_FLAGS, op, item);
		1261	}
		1262
		1263	return 0;
		1264	}
		1265
		1266	/* op should be a player, params is any params.
		1267	* If no params given, we print out the currently marked object.
		1268	* otherwise, try to find a matching object - try best match first.
		1269	*/
		1270	int
		1271	command_mark (object *op, char *params)
		1272	{
		1273	if (!params)
		1274	{
		1275	if (object *mark = op->mark ())
		1276	op->statusmsg (format ("%s is marked.", query_name (mark)));
		1277	else
		1278	op->failmsg ("You have no marked object.");
		1279	}
		1280	else
		1281	{
		1282	if (object *mark = find_best_object_match (op, params))
		1283	{
		1284	op->contr->mark = mark;
		1285	op->statusmsg (format ("Marked item %s", query_name (mark)));
		1286	}
		1287	else
		1288	op->failmsgf ("Could not find an object that matches %s", params);
		1289	}
		1290
		1291	return 0; /*shouldnt get here */
		1292	}
		1293

Diff Legend

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