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

Diff Legend

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