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.61 by elmex, Mon Nov 26 11:41:02 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)
…		…
491	}	449	}
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;
		454
		455	int cnt = MAX_ITEM_PER_ACTION;
496		456
497	while (tmp)	457	while (tmp)
498	{	458	{
499	next = tmp->below;	459	next = tmp->below;
500		460
…		…
507	/* This following two if and else if could be merged into line	467	/* This following two if and else if could be merged into line
508	* but that probably will make it more difficult to read, and	468	* but that probably will make it more difficult to read, and
509	* not make it any more efficient	469	* not make it any more efficient
510	*/	470	*/
511	if (params && item_matched_string (op, tmp, params))	471	if (params && item_matched_string (op, tmp, params))
		472	{
		473	if (--cnt < 0) break;
512	pick_up (op, tmp);	474	pick_up (op, tmp);
		475	}
513	else if (can_pick (op, tmp) && !params)	476	else if (can_pick (op, tmp) && !params)
514	{	477	{
		478	if (--cnt < 0) break;
515	pick_up (op, tmp);	479	pick_up (op, tmp);
516	break;	480	break;
517	}	481	}
518		482
519	tmp = next;	483	tmp = next;
		484	}
		485
		486	if (cnt < 0)
		487	{
		488	op->failmsg ("Couldn't pick up so many items at once.");
		489	return 0;
520	}	490	}
521		491
522	if (!params && !tmp)	492	if (!params && !tmp)
523	{	493	{
524	for (tmp = op->below; tmp; tmp = tmp->below)	494	for (tmp = op->below; tmp; tmp = tmp->below)
525	if (!tmp->invisible)	495	if (!tmp->invisible)
526	{	496	{
527	char buf[MAX_BUF];
528
529	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);
530	new_draw_info (NDI_UNIQUE, 0, op, buf);
531	break;	498	break;
532	}	499	}
533		500
534	if (!tmp)	501	if (!tmp)
535	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.");
536	}	503	}
537		504
538	return 0;	505	return 0;
539	}	506	}
540		507
541
542	/*	508	/*
543	* This function was part of drop, now is own function.	509	* This function was part of drop, now is own function.
544	* Player 'op' tries to put object 'tmp' into sack 'sack',	510	* Player 'op' tries to put object 'tmp' into sack 'sack',
545	* 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	*
546	* Note that the 'sack' in question can now be a transport,	513	* Note that the 'sack' in question can now be a transport,
547	* so this function isn't named very good anymore.	514	* so this function isn't named very good anymore.
548	*/	515	*/
549	void	516	void
550	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)
551	{	518	{
552	object *tmp2, *sack2;	519	object *tmp2;
553	char buf[MAX_BUF];	520	char buf[MAX_BUF];
554		521
555	if (sack == tmp)	522	if (sack == tmp)
556	return; /* Can't put an object in itself */	523	return; /* Can't put an object in itself */
557		524
558	if (QUERY_FLAG (tmp, FLAG_STARTEQUIP))	525	if (tmp->flag [FLAG_STARTEQUIP] || tmp->flag [FLAG_NO_DROP])
559	{	526	{
560	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));
561	return;	528	return;
562	}	529	}
563		530
564	if (tmp->type == CONTAINER && tmp->inv)	531	if (tmp->type == CONTAINER && tmp->inv)
565	{	532	{
566
567	/* 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
568	* we instead move the contents of that container into the active	534	* we instead move the contents of that container into the active
569	* 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.
570	*/	536	*/
571	sack2 = tmp;
572	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));
573		538
574	for (tmp2 = tmp->inv; tmp2; tmp2 = tmp)	539	for (tmp2 = tmp->inv; tmp2; tmp2 = tmp)
575	{	540	{
576	tmp = tmp2->below;	541	tmp = tmp2->below;
577		542
578	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)))
579	{
580	put_object_in_sack (op, sack, tmp2, 0);	544	put_object_in_sack (op, sack, tmp2, 0);
581	}
582	else	545	else
583	{	546	{
584	sprintf (buf, "Your %s fills up.", query_name (sack));	547	sprintf (buf, "Your %s fills up.", query_name (sack));
585	new_draw_info (NDI_UNIQUE, 0, op, buf);	548	new_draw_info (NDI_UNIQUE, 0, op, buf);
586	break;	549	break;
587	}	550	}
588	}	551	}
589		552
590	esrv_update_item (UPD_WEIGHT, op, sack2);
591	return;	553	return;
592	}	554	}
593		555
594	/* Don't worry about this for containers - our caller should have	556	/* Don't worry about this for containers - our caller should have
595	* already checked this.	557	* already checked this.
596	*/	558	*/
597	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)))
598	return;	560	return;
599		561
600	if (QUERY_FLAG (tmp, FLAG_APPLIED))	562	if (tmp->flag [FLAG_APPLIED])
601	if (apply_special (op, tmp, AP_UNAPPLY | AP_NO_MERGE))	563	if (!op->apply (tmp, AP_UNAPPLY | AP_NO_MERGE))
602	return;	564	return;
603		565
604	/* 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 */
605	if (nrof && tmp->nrof != nrof)	567	if (!can_split (op, tmp, nrof))
606	{
607	object *tmp2 = tmp;
608
609	tmp = get_split_ob (tmp, nrof);
610
611	if (!tmp)
612	{
613	new_draw_info (NDI_UNIQUE, 0, op, errmsg);
614	return;	568	return;
615	}
616	/* Tell a client what happened other objects */
617	if (tmp2->destroyed ())
618	esrv_del_item (op->contr, tmp2->count);
619	else /* this can proably be replaced with an update */
620	esrv_send_item (op, tmp2);
621	}
622	else
623	tmp->remove ();
624		569
625	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));
626	tmp2 = insert_ob_in_ob (tmp, sack);	571	sack->insert (tmp);
627	op->update_stats (); /* This is overkill, fix_player() is called somewhere */	572	}
628	/* in object.c */
629		573
630	/* If an object merged (and thus, different object), we need to	574	/* In contrast to drop_object (op, tmp, nrof) above this function takes the
631	* delete the original.	575	* already split off object, and feeds it to the event handlers and does
		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;
		592
		593	if (obj->flag [FLAG_STARTEQUIP])
		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:
632	*/	621	*/
633	if (tmp2 != tmp)
634	esrv_del_item (op->contr, tmp->count);
635		622
636	esrv_send_item (op, tmp2);	623	obj->x = dropper->x;
		624	obj->y = dropper->y;
637		625
638	/* update the sacks weight */	626	insert_ob_in_map (obj, dropper->map, dropper, INS_BELOW_ORIGINATOR);
639	esrv_update_item (UPD_WEIGHT, op, sack);
640	}	627	}
641		628
642	/*	629	/*
643	* This function was part of drop, now is own function.	630	* This function was part of drop, now is own function.
644	* 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
645	* nrof objects is tried to dropped.	632	* nrof objects are tried to drop.
646	* This is used when dropping objects onto the floor.	633	* This is used when dropping objects onto the floor.
647	*/	634	*/
648	void	635	void
649	drop_object (object *op, object *tmp, uint32 nrof)	636	drop_object (object *op, object *tmp, uint32 nrof)
650	{	637	{
651	char buf[MAX_BUF];	638	if (tmp->flag [FLAG_NO_DROP])
652	object *floor;
653
654	if (QUERY_FLAG (tmp, FLAG_NO_DROP))
655	return;	639	return;
656		640
657	if (QUERY_FLAG (tmp, FLAG_APPLIED))	641	if (tmp->flag [FLAG_APPLIED])
658	if (apply_special (op, tmp, AP_UNAPPLY | AP_NO_MERGE))	642	if (!op->apply (tmp, AP_UNAPPLY | AP_NO_MERGE))
659	return; /* can't unapply it */	643	return; /* can't unapply it */
660
661	//fprintf (stderr, "ui, on space is %ld\n", op->ms ().volume ());//D
662		644
663	/* 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
664	* off	646	* off
665	*/	647	*/
666	if (nrof && tmp->nrof != nrof)	648	if (!can_split (op, tmp, nrof))
667	{
668	object *tmp2 = tmp;
669
670	tmp = get_split_ob (tmp, nrof);
671	if (!tmp)
672	{
673	new_draw_info (NDI_UNIQUE, 0, op, errmsg);
674	return;
675	}
676	/* Tell a client what happened rest of objects. tmp2 is now the
677	* original object
678	*/
679	if (op->type == PLAYER)
680	{
681	if (tmp2->destroyed ())
682	esrv_del_item (op->contr, tmp2->count);
683	else
684	esrv_send_item (op, tmp2);
685	}
686	}
687	else
688	tmp->remove ();
689
690	if (INVOKE_OBJECT (DROP, tmp, ARG_OBJECT (op)))
691	return;	649	return;
692		650
693	if (QUERY_FLAG (tmp, FLAG_STARTEQUIP))	651	drop_object (op, tmp);
694	{
695	sprintf (buf, "You drop the %s.", query_name (tmp));
696	new_draw_info (NDI_UNIQUE, 0, op, buf);
697	new_draw_info (NDI_UNIQUE, 0, op, "The gods who lent it to you retrieves it.");
698		652
699	if (op->type == PLAYER)	653	if (!tmp->destroyed () && !tmp->is_inserted ())
700	esrv_del_item (op->contr, tmp->count);
701
702	tmp->destroy ();
703	op->update_stats ();
704	return;
705	}	654	{
706		655	// if nothing happened with the object we give it back
707	if (op->type == PLAYER)	656	op->insert (tmp);
708	esrv_del_item (op->contr, tmp->count);
709
710	/* Call this before we update the various windows/players. At least
711	* that we, we know the weight is correct.
712	*/
713	op->update_stats (); /* This is overkill, fix_player() is called somewhere */
714	/* in object.c */
715
716	if (op->type == PLAYER)
717	{	657	}
718	/* Need to update the weight for the player */
719	esrv_send_item (op, op);
720	op->contr->ns->floorbox_update ();
721	}
722
723	for (floor = GET_MAP_OB (op->map, op->x, op->y); floor; floor = floor->above)
724	if (INVOKE_OBJECT (DROP_ON, floor, ARG_OBJECT (tmp), ARG_OBJECT (op)))
725	return;
726
727	if (is_in_shop (op) && !QUERY_FLAG (tmp, FLAG_UNPAID) && tmp->type != MONEY)
728	sell_item (tmp, op);
729
730	tmp->x = op->x;
731	tmp->y = op->y;
732
733	insert_ob_in_map (tmp, op->map, op, INS_BELOW_ORIGINATOR);
734	}	658	}
735		659
736	void	660	void
737	drop (object *op, object *tmp)	661	drop (object *op, object *tmp)
738	{	662	{
…		…
747	if (tmp->env && tmp->env->type != PLAYER)	671	if (tmp->env && tmp->env->type != PLAYER)
748	{	672	{
749	/* Just toss the object - probably shouldn't be hanging	673	/* Just toss the object - probably shouldn't be hanging
750	* around anyways	674	* around anyways
751	*/	675	*/
752	tmp->remove ();
753	tmp->destroy ();	676	tmp->destroy ();
754	return;	677	return;
755	}	678	}
756	else	679	else
757	{
758	while (tmp != NULL && tmp->invisible)	680	while (tmp && tmp->invisible)
759	tmp = tmp->below;	681	tmp = tmp->below;
760	}
761	}	682	}
762		683
763	if (tmp == NULL)	684	if (!tmp)
764	{	685	{
765	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.");
766	return;	687	return;
767	}	688	}
768	if (QUERY_FLAG (tmp, FLAG_INV_LOCKED))	689
		690	if (tmp->flag [FLAG_INV_LOCKED])
769	{	691	{
770	new_draw_info (NDI_UNIQUE, 0, op, "This item is locked");	692	new_draw_info (NDI_UNIQUE, 0, op, "This item is locked");
771	return;	693	return;
772	}	694	}
773	if (QUERY_FLAG (tmp, FLAG_NO_DROP))	695
		696	if (tmp->flag [FLAG_NO_DROP])
774	{	697	{
775	#if 0	698	#if 0
776	/* 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. */
777	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.");
778	#endif	701	#endif
…		…
780	}	703	}
781		704
782	if (op->type == PLAYER && op->contr->last_used == tmp)	705	if (op->type == PLAYER && op->contr->last_used == tmp)
783	op->contr->last_used = tmp->below ? tmp->below	706	op->contr->last_used = tmp->below ? tmp->below
784	: tmp->above ? tmp->above	707	: tmp->above ? tmp->above
785	: 0;	708	: (object *)0;
786		709
787	if (op->container)	710	if (op->container_ ())
788	{	711	{
789	if (op->type == PLAYER)	712	if (op->type == PLAYER)
790	put_object_in_sack (op, op->container, tmp, op->contr->count);	713	put_object_in_sack (op, op->container_ (), tmp, op->contr->count);
791	else	714	else
792	put_object_in_sack (op, op->container, tmp, 0);	715	put_object_in_sack (op, op->container_ (), tmp, 0);
793	}	716	}
794	else	717	else
795	{	718	{
796	if (op->type == PLAYER)	719	if (op->type == PLAYER)
797	drop_object (op, tmp, op->contr->count);	720	drop_object (op, tmp, op->contr->count);
…		…
801		724
802	if (op->type == PLAYER)	725	if (op->type == PLAYER)
803	op->contr->count = 0;	726	op->contr->count = 0;
804	}	727	}
805		728
806
807
808	/* Command will drop all items that have not been locked */	729	/* Command will drop all items that have not been locked */
809	int	730	int
810	command_dropall (object *op, char *params)	731	command_dropall (object *op, char *params)
811	{	732	{
812		733
813	object *curinv, *nextinv;
814
815	if (op->inv == NULL)	734	if (op->inv == NULL)
816	{	735	{
817	new_draw_info (NDI_UNIQUE, 0, op, "Nothing to drop!");	736	new_draw_info (NDI_UNIQUE, 0, op, "Nothing to drop!");
818	return 0;	737	return 0;
819	}	738	}
820		739
821	curinv = op->inv;	740	object *curinv = op->inv;
		741	object *nextinv;
822		742
823	/*	743	/*
824	This is the default. Drops everything not locked or considered	744	This is the default. Drops everything not locked or considered
825	not something that should be dropped.	745	not something that should be dropped.
826	*/	746	*/
827	/*	747	/*
828	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
829	the drop() routine will do unknown things to it when dropping	749	the drop() routine will do unknown things to it when dropping
830	in a shop. --Tero.Pelander@utu.fi	750	in a shop. --Tero.Pelander@utu.fi
831	*/	751	*/
832
833	int cnt = MAX_ITEM_PER_DROP;	752	int cnt = MAX_ITEM_PER_ACTION;
834		753
835	if (params == NULL)	754	if (!params)
836	{	755	{
837	while (curinv != NULL)	756	while (curinv)
838	{	757	{
839	nextinv = curinv->below;	758	nextinv = curinv->below;
		759
840	while (nextinv && nextinv->type == MONEY)	760	while (nextinv && nextinv->type == MONEY)
841	nextinv = nextinv->below;	761	nextinv = nextinv->below;
842	if (!QUERY_FLAG (curinv, FLAG_INV_LOCKED) && curinv->type != MONEY &&	762
843	curinv->type != FOOD && curinv->type != KEY &&	763	if (!curinv->flag [FLAG_INV_LOCKED]
844	curinv->type != SPECIAL_KEY && curinv->type != GEM &&	764	&& !curinv->invisible
845	!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)
846	{	771	{
847	drop (op, curinv);	772	drop (op, curinv);
848	if (--cnt <= 0) break;	773	if (--cnt <= 0) break;
849	}	774	}
		775
850	curinv = nextinv;	776	curinv = nextinv;
851	}	777	}
852	}	778	}
853
854	else if (strcmp (params, "weapons") == 0)	779	else if (strcmp (params, "weapons") == 0)
855	{	780	{
856	while (curinv != NULL)	781	while (curinv)
857	{	782	{
858	nextinv = curinv->below;	783	nextinv = curinv->below;
		784
859	while (nextinv && nextinv->type == MONEY)	785	while (nextinv && nextinv->type == MONEY)
860	nextinv = nextinv->below;	786	nextinv = nextinv->below;
		787
861	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)))
862	{	789	{
863	drop (op, curinv);	790	drop (op, curinv);
864	if (--cnt <= 0) break;	791	if (--cnt <= 0) break;
865	}	792	}
		793
866	curinv = nextinv;	794	curinv = nextinv;
867	}	795	}
868	}	796	}
869
870	else if (strcmp (params, "armor") == 0 || strcmp (params, "armour") == 0)	797	else if (strcmp (params, "armor") == 0 || strcmp (params, "armour") == 0)
871	{	798	{
872	while (curinv != NULL)	799	while (curinv)
873	{	800	{
874	nextinv = curinv->below;	801	nextinv = curinv->below;
		802
875	while (nextinv && nextinv->type == MONEY)	803	while (nextinv && nextinv->type == MONEY)
876	nextinv = nextinv->below;	804	nextinv = nextinv->below;
		805
877	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))
878	{	807	{
879	drop (op, curinv);	808	drop (op, curinv);
880	if (--cnt <= 0) break;	809	if (--cnt <= 0) break;
881	}	810	}
		811
882	curinv = nextinv;	812	curinv = nextinv;
883	}	813	}
884	}	814	}
885
886	else if (strcmp (params, "misc") == 0)	815	else if (strcmp (params, "misc") == 0)
887	{	816	{
888	while (curinv != NULL)	817	while (curinv)
889	{	818	{
890	nextinv = curinv->below;	819	nextinv = curinv->below;
		820
891	while (nextinv && nextinv->type == MONEY)	821	while (nextinv && nextinv->type == MONEY)
892	nextinv = nextinv->below;	822	nextinv = nextinv->below;
893	if (!QUERY_FLAG (curinv, FLAG_INV_LOCKED) && !QUERY_FLAG (curinv, FLAG_APPLIED))	823
		824	if (!curinv->flag [FLAG_INV_LOCKED] && !curinv->flag [FLAG_APPLIED])
894	{	825	{
895	switch (curinv->type)	826	switch (curinv->type)
896	{	827	{
897	case HORN:	828	case HORN:
898	case BOOK:	829	case BOOK:
…		…
915	break;	846	break;
916	default:	847	default:
917	curinv = nextinv;	848	curinv = nextinv;
918	break;	849	break;
919	}	850	}
		851
920	if (--cnt <= 0) break;	852	if (--cnt <= 0) break;
921	}	853	}
		854
922	curinv = nextinv;	855	curinv = nextinv;
923	}	856	}
924	}	857	}
925		858
926	if (cnt <= 0)	859	if (cnt <= 0)
927	op->failmsg (format (	860	op->failmsg ("Only dropped some items, can't drop that many items at once.");
928	"Droppped only %d items, you can't drop more than that at once.",
929	MAX_ITEM_PER_DROP
930	));
931
932	op->contr->ns->floorbox_update ();
933		861
934	/* draw_look(op);*/	862	/* draw_look(op);*/
935	return 0;	863	return 0;
936	}	864	}
937		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
938	/* 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
939	* comma seperated list.	892	* comma seperated list.
940	*/	893	*/
941
942	int	894	int
943	command_drop (object *op, char *params)	895	command_drop (object *op, char *params)
944	{	896	{
945	object *tmp, *next;	897	object *tmp, *next;
946	int did_one = 0;
947		898
948	if (!params)	899	if (!params)
949	{	900	{
950	new_draw_info (NDI_UNIQUE, 0, op, "Drop what?");	901	new_draw_info (NDI_UNIQUE, 0, op, "Drop what?");
951	return 0;	902	return 0;
952	}	903	}
953	else	904	else
954	{	905	{
955	int cnt = MAX_ITEM_PER_DROP;	906	vector<object *> matched_objs;
956		907
957	for (tmp = op->inv; tmp; tmp = next)	908	for (tmp = op->inv; tmp; tmp = next)
958	{	909	{
959	next = tmp->below;	910	next = tmp->below;
960	if (QUERY_FLAG (tmp, FLAG_NO_DROP) || tmp->invisible)	911	if (tmp->flag [FLAG_NO_DROP] || tmp->invisible)
961	continue;	912	continue;
962		913
963	if (item_matched_string (op, tmp, params))	914	if (item_matched_string (op, tmp, params))
964	{	915	matched_objs.push_back (tmp);
965	drop (op, tmp);
966	if (--cnt <= 0) break;
967	did_one = 1;
968	}	916	}
969	}
970		917
971	if (!did_one)	918	int cnt = MAX_ITEM_PER_ACTION;
		919
		920	if (!drop_vector (op, matched_objs, &cnt))
972	new_draw_info (NDI_UNIQUE, 0, op, "Nothing to drop.");	921	new_draw_info (NDI_UNIQUE, 0, op, "Nothing to drop.");
973		922
974	if (cnt <= 0)	923	if (cnt <= 0)
975	op->failmsg (format (	924	op->failmsg ("Only dropped some items, can't drop that many items at once.");
976	"Droppped only %d items, you can't drop more than that at once.",
977	MAX_ITEM_PER_DROP
978	));
979	}
980	if (op->type == PLAYER)
981	{
982	op->contr->count = 0;
983	op->contr->ns->floorbox_update ();
984	};	925	}
985		926
986	/* draw_look(op);*/
987	return 0;	927	return 0;
988	}	928	}
989		929
990	int	930	int
991	command_examine (object *op, char *params)	931	command_examine (object *op, char *params)
…		…
994	{	934	{
995	object *tmp = op->below;	935	object *tmp = op->below;
996		936
997	while (tmp && !tmp->client_visible ())	937	while (tmp && !tmp->client_visible ())
998	tmp = tmp->below;	938	tmp = tmp->below;
		939
999	if (tmp)	940	if (tmp)
1000	examine (op, tmp);	941	examine (op, tmp);
1001	}	942	}
1002	else	943	else
1003	{	944	{
1004	object *tmp = find_best_object_match (op, params);	945	object *tmp = find_best_object_match (op, params);
1005		946
1006	if (tmp)	947	if (tmp)
1007	examine (op, tmp);	948	examine (op, tmp);
1008	else	949	else
1009	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));
1010	}
1011	return 0;
1012	}
1013
1014	/* op should be a player.
1015	* we return the object the player has marked with the 'mark' command
1016	* below. If no match is found (or object has changed), we return
1017	* NULL. We leave it up to the calling function to print messages if
1018	* nothing is found.
1019	*/
1020	object *
1021	find_marked_object (object *op)
1022	{
1023	object *tmp;
1024
1025	if (!op || !op->contr)
1026	return NULL;
1027
1028	if (!op->contr->mark)
1029	{
1030	/* new_draw_info(NDI_UNIQUE,0,op,"You have no marked object");*/
1031	return 0;
1032	}
1033
1034	/* This may seem like overkill, but we need to make sure that they
1035	* player hasn't dropped the item. We use count on the off chance that
1036	* an item got reincarnated at some point.
1037	*/
1038	for (tmp = op->inv; tmp; tmp = tmp->below)
1039	{
1040	if (tmp->invisible)
1041	continue;
1042
1043	if (tmp == op->contr->mark)
1044	{
1045	if (!tmp->destroyed ())
1046	return tmp;
1047	else
1048	{
1049	op->contr->mark = 0;
1050	/* new_draw_info(NDI_UNIQUE,0,op,"You have no marked object");*/
1051	return 0;
1052	}
1053	}
1054	}	951	}
1055		952
1056	return 0;	953	return 0;
1057	}	954	}
1058		955
…		…
1061	{	958	{
1062	dynbuf_text buf (512, 512);	959	dynbuf_text buf (512, 512);
1063		960
1064	object *mon = head ? head : this;	961	object *mon = head ? head : this;
1065		962
1066	if (QUERY_FLAG (mon, FLAG_UNDEAD))	963	if (mon->flag [FLAG_UNDEAD])
1067	buf << "It is an undead force.\n";	964	buf << "It is an undead force.\r";
1068		965
1069	if (mon->level > who->level)	966	if (mon->level > who->level)
1070	buf << "It is likely more powerful than you.\n";	967	buf << "It is likely more powerful than you.\r";
1071	else if (mon->level < who->level)	968	else if (mon->level < who->level)
1072	buf << "It is likely less powerful than you.\n";	969	buf << "It is likely less powerful than you.\r";
1073	else	970	else
1074	buf << "It is probably as powerful as you.\n";	971	buf << "It is probably as powerful as you.\r";
1075		972
1076	if (mon->attacktype & AT_ACID)	973	if (mon->attacktype & AT_ACID)
1077	buf << "You seem to smell an acrid odor.\n";	974	buf << "You seem to smell an acrid odor.\r";
1078		975
1079	/* 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
1080	* maxhp field? This seems that it should give more accurate results.	977	* maxhp field? This seems that it should give more accurate results.
1081	*/	978	*/
1082	switch ((mon->stats.hp + 1) * 4 / (mon->stats.maxhp + 1))	979	switch ((mon->stats.hp + 1) * 4 / (mon->stats.maxhp + 1))
1083	{ /* From 1-4 */	980	{ /* From 1-4 */
1084	case 1:	981	case 1:
1085	buf << "It is in a bad shape.\n";	982	buf << "It is in a bad shape.\r";
1086	break;	983	break;
1087	case 2:	984	case 2:
1088	buf << "It is hurt.\n";	985	buf << "It is hurt.\r";
1089	break;	986	break;
1090	case 3:	987	case 3:
1091	buf << "It is somewhat hurt.\n";	988	buf << "It is somewhat hurt.\r";
1092	break;	989	break;
1093	case 4:	990	case 4:
1094	buf << "It is in excellent shape.\n";	991	buf << "It is in excellent shape.\r";
1095	break;	992	break;
1096	}	993	}
1097		994
1098	if (present_in_ob (POISONING, mon))	995	if (present_in_ob (POISONING, mon))
1099	buf << "It looks very ill.\n";	996	buf << "It looks very ill.\r";
		997
		998	buf << '\n';
1100		999
1101	return buf;	1000	return buf;
1102	}	1001	}
1103		1002
1104	/* 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. */
…		…
1111	}	1010	}
1112		1011
1113	std::string	1012	std::string
1114	object::long_desc (object *who)	1013	object::long_desc (object *who)
1115	{	1014	{
1116	std::string buf (query_name (this));	1015	std::string buf (query_name ());
1117		1016
1118	switch (type)	1017	switch (type)
1119	{	1018	{
1120	case RING:	1019	case RING:
1121	case SKILL:	1020	case SKILL:
…		…
1126	case SHIELD:	1025	case SHIELD:
1127	case BOOTS:	1026	case BOOTS:
1128	case GLOVES:	1027	case GLOVES:
1129	case AMULET:	1028	case AMULET:
1130	case GIRDLE:	1029	case GIRDLE:
		1030	case RANGED:
1131	case BOW:	1031	case BOW:
1132	case ARROW:	1032	case ARROW:
1133	case CLOAK:	1033	case CLOAK:
1134	case FOOD:	1034	case FOOD:
1135	case DRINK:	1035	case DRINK:
1136	case FLESH:	1036	case FLESH:
1137	case SKILL_TOOL:	1037	case SKILL_TOOL:
		1038	case LAMP:
1138	case POWER_CRYSTAL:	1039	case POWER_CRYSTAL:
1139	{	1040	{
1140	const char *cp = ::describe_item (this, who);	1041	const char *cp = ::describe_item (this, who);
1141		1042
1142	if (*cp)	1043	if (*cp)
…		…
1157	examine_monster (object *op, object *tmp)	1058	examine_monster (object *op, object *tmp)
1158	{	1059	{
1159	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 ());
1160	}	1061	}
1161		1062
1162	std::string
1163	object::describe (object *who)
1164	{
1165	dynbuf_text buf (1024, 1024);
1166
1167	buf.printf ("That is: %s.\n", long_desc (who).c_str ());
1168
1169	if (custom_name)
1170	buf.printf ("You call it %s\n", &custom_name);
1171
1172	switch (type)
1173	{
1174	case SPELLBOOK:
1175	if (flag [FLAG_IDENTIFIED] && inv)
1176	buf.printf ("%s is a %s %s spell\n", &inv->name, get_levelnumber (inv->level), &inv->skill);
1177	break;
1178
1179	case BOOK:
1180	if (msg)
1181	buf << "Something is written in it.\n";
1182	break;
1183
1184	case CONTAINER:
1185	if (race != NULL)
1186	{
1187	if (weight_limit && stats.Str < 100)
1188	buf.printf ("It can hold only %s and its weight limit is %.1f kg.\n",
1189	&race, weight_limit / (10.0 * (100 - stats.Str)));
1190	else
1191	buf.printf ("It can hold only %s.\n", &race);
1192	}
1193	else if (weight_limit && stats.Str < 100)
1194	buf.printf ("Its weight limit is %.1f kg.\n", weight_limit / (10.0 * (100 - stats.Str)));
1195	break;
1196
1197	case WAND:
1198	if (flag [FLAG_IDENTIFIED])
1199	buf.printf ("It has %d charges left.\n", stats.food);
1200	break;
1201	}
1202
1203	if (materialname && !msg)
1204	buf.printf ("It is made of: %s.\n", &materialname);
1205
1206	if (who)
1207	/* Where to wear this item */
1208	for (int i = 0; i < NUM_BODY_LOCATIONS; i++)
1209	if (slot[i].info)
1210	{
1211	buf << (who->slot[i].info ? body_locations[i].use_name : body_locations[i].nonuse_name);
1212
1213	if (slot[i].info < -1 && who->slot[i].info)
1214	buf.printf ("(%d)", -slot[i].info);
1215
1216	buf << ".\n";
1217	}
1218
1219	if (weight)
1220	buf.printf (nrof > 1 ? "They weigh %3.3f kg.\n" : "It weighs %3.3f kg.\n", weight * (nrof ? nrof : 1) / 1000.0);
1221
1222	if (value && !flag [FLAG_STARTEQUIP] && !flag [FLAG_NO_PICK] && who)
1223	{
1224	buf.printf ("You reckon %s worth %s.\n", nrof > 1 ? "they are" : "it is", query_cost_string (this, who, F_TRUE | F_APPROX));
1225
1226	if (is_in_shop (who))
1227	{
1228	if (flag [FLAG_UNPAID])
1229	buf.printf ("%s would cost you %s.\n", nrof > 1 ? "They" : "It", query_cost_string (this, who, F_BUY | F_SHOP));
1230	else
1231	buf.printf ("You are offered %s for %s.\n", query_cost_string (this, who, F_SELL + F_SHOP), nrof > 1 ? "them" : "it");
1232	}
1233	}
1234
1235	if (flag [FLAG_MONSTER])
1236	buf << describe_monster (who);
1237
1238	/* Is this item buildable? */
1239	if (flag [FLAG_IS_BUILDABLE])
1240	buf << "This is a buildable item.\n";
1241
1242	/* Does the object have a message? Don't show message for all object
1243	* types - especially if the first entry is a match
1244	*/
1245	if (msg && type != EXIT && type != BOOK && type != CORPSE && !move_on && strncasecmp (msg, "@match", 7))
1246	{
1247	/* This is just a hack so when identifying the items, we print
1248	* out the extra message
1249	*/
1250	if (need_identify (this) && flag [FLAG_IDENTIFIED])
1251	buf << "The object has a story:\n";
1252
1253	buf << msg << '\n';
1254	}
1255
1256	buf << '\n';
1257
1258	return std::string (buf.linearise (), buf.size ());
1259	}
1260
1261	static void	1063	static void
1262	display_new_pickup (object *op)	1064	display_new_pickup (object *op)
1263	{	1065	{
1264	int i = op->contr->mode;	1066	int i = op->contr->mode;
1265		1067
1266	if (!(i & PU_NEWMODE))
1267	return;
1268
1269	new_draw_info_format (NDI_UNIQUE, 0, op, "%d NEWMODE", i & PU_NEWMODE ? 1 : 0);
1270	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);
1271	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);
1272	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);
1273		1071
1274	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);
…		…
1325	};	1123	};
1326		1124
1327	if (!params)	1125	if (!params)
1328	{	1126	{
1329	/* if the new mode is used, just print the settings */	1127	/* if the new mode is used, just print the settings */
1330	if (op->contr->mode & PU_NEWMODE)
1331	{
1332	display_new_pickup (op);	1128	display_new_pickup (op);
1333	return 1;
1334	}
1335	if (1)
1336	LOG (llevDebug, "command_pickup: !params\n");
1337	set_pickup_mode (op, (op->contr->mode > 6) ? 0 : op->contr->mode + 1);
1338	return 0;	1129	return 0;
1339	}	1130	}
1340		1131
1341	while (*params == ' ' && *params)	1132	while (*params == ' ' && *params)
1342	params++;	1133	params++;
…		…
1348	for (mode = 0; names[mode]; mode++)	1139	for (mode = 0; names[mode]; mode++)
1349	{	1140	{
1350	if (!strcmp (names[mode], params + 1))	1141	if (!strcmp (names[mode], params + 1))
1351	{	1142	{
1352	i = op->contr->mode;	1143	i = op->contr->mode;
1353	if (!(i & PU_NEWMODE))	1144
1354	i = PU_NEWMODE;
1355	if (*params == '+')	1145	if (*params == '+')
1356	i = i | modes[mode];	1146	i = i | modes[mode];
1357	else	1147	else
1358	i = i & ~modes[mode];	1148	i = i & ~modes[mode];
		1149
1359	op->contr->mode = i;	1150	op->contr->mode = i;
1360	display_new_pickup (op);	1151	display_new_pickup (op);
1361	return 1;	1152	return 1;
1362	}	1153	}
1363	}	1154	}
…		…
1365	return 1;	1156	return 1;
1366	}	1157	}
1367		1158
1368	if (sscanf (params, "%u", &i) != 1)	1159	if (sscanf (params, "%u", &i) != 1)
1369	{	1160	{
1370	if (1)
1371	LOG (llevDebug, "command_pickup: params==NULL\n");
1372	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.");
1373	return 1;	1162	return 1;
1374	}	1163	}
1375	set_pickup_mode (op, i);	1164
		1165	if (i <= PU_RATIO)
		1166	i |= op->contr->mode & ~PU_RATIO;
		1167
		1168	op->contr->mode = i;
1376		1169
1377	return 1;	1170	return 1;
1378	}	1171	}
1379		1172
1380	void
1381	set_pickup_mode (object *op, int i)
1382	{
1383	switch (op->contr->mode = i)
1384	{
1385	case 0:
1386	new_draw_info (NDI_UNIQUE, 0, op, "Mode: Don't pick up.");
1387	break;
1388	case 1:
1389	new_draw_info (NDI_UNIQUE, 0, op, "Mode: Pick up one item.");
1390	break;
1391	case 2:
1392	new_draw_info (NDI_UNIQUE, 0, op, "Mode: Pick up one item and stop.");
1393	break;
1394	case 3:
1395	new_draw_info (NDI_UNIQUE, 0, op, "Mode: Stop before picking up.");
1396	break;
1397	case 4:
1398	new_draw_info (NDI_UNIQUE, 0, op, "Mode: Pick up all items.");
1399	break;
1400	case 5:
1401	new_draw_info (NDI_UNIQUE, 0, op, "Mode: Pick up all items and stop.");
1402	break;
1403	case 6:
1404	new_draw_info (NDI_UNIQUE, 0, op, "Mode: Pick up all magic items.");
1405	break;
1406	case 7:
1407	new_draw_info (NDI_UNIQUE, 0, op, "Mode: Pick up all coins and gems");
1408	break;
1409	}
1410	}
1411
1412	int	1173	int
1413	command_search_items (object *op, char *params)	1174	command_search_items (object *op, char *params)
1414	{	1175	{
1415	char buf[MAX_BUF];
1416
1417	if (settings.search_items == FALSE)
1418	return 1;
1419
1420	if (params == NULL)	1176	if (params == NULL)
1421	{	1177	{
1422	if (op->contr->search_str[0] == '\0')	1178	if (op->contr->search_str[0] == '\0')
1423	{	1179	{
1424	new_draw_info (NDI_UNIQUE, 0, op, "Example: search magic+1");	1180	new_draw_info (NDI_UNIQUE, 0, op, "Example: search-items magic+1");
1425	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");
1426	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'.");
1427	return 1;	1183	return 1;
1428	}	1184	}
1429		1185
1430	op->contr->search_str[0] = '\0';	1186	op->contr->search_str[0] = '\0';
1431	new_draw_info (NDI_UNIQUE, 0, op, "Search mode turned off.");	1187	new_draw_info (NDI_UNIQUE, 0, op, "Search mode turned off.");
1432	op->update_stats ();	1188	op->contr->queue_stats_update ();
1433	return 1;	1189	return 1;
1434	}	1190	}
1435		1191
1436	if ((int) strlen (params) >= MAX_BUF)	1192	if (strlen (params) >= sizeof (op->contr->search_str))
1437	{	1193	{
1438	new_draw_info (NDI_UNIQUE, 0, op, "Search string too long.");	1194	new_draw_info (NDI_UNIQUE, 0, op, "Search string too long.");
1439	return 1;	1195	return 1;
1440	}	1196	}
1441		1197
1442	strcpy (op->contr->search_str, params);	1198	strcpy (op->contr->search_str, params);
1443	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));
1444	new_draw_info (NDI_UNIQUE, 0, op, buf);	1200	op->contr->queue_stats_update ();
1445	op->update_stats ();	1201
1446	return 1;	1202	return 1;
1447	}	1203	}
1448		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