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.56 by root, Tue Jun 5 13:05:02 2007 UTC vs.
Revision 1.133 by root, Sun Jan 29 02:47:05 2017 UTC

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