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

Diff Legend

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