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