ViewVC Help

View File | Revision Log | Show Annotations | Download File

/cvs/deliantra/server/server/c_object.C

Comparing deliantra/server/server/c_object.C (file contents):
Revision 1.56 by root, Tue Jun 5 13:05:02 2007 UTC vs.
Revision 1.119 by root, Sat Apr 10 04:54:09 2010 UTC

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