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.50 by root, Mon May 7 07:47:33 2007 UTC vs.
Revision 1.119 by root, Sat Apr 10 04:54:09 2010 UTC

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

Diff Legend

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