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.25 by root, Tue Dec 12 21:39:57 2006 UTC vs.
Revision 1.71 by elmex, Thu Apr 24 11:26:41 2008 UTC

1	/*	1	/*
2	CrossFire, A Multiplayer game for X-windows	2	* This file is part of Deliantra, the Roguelike Realtime MMORPG.
3		3	*
		4	* Copyright (©) 2005,2006,2007,2008 Marc Alexander Lehmann / Robin Redeker / the Deliantra team
4	Copyright (C) 2002 Mark Wedel & Crossfire Development Team	5	* Copyright (©) 2002,2007 Mark Wedel & Crossfire Development Team
5	Copyright (C) 1992 Frank Tore Johansen	6	* Copyright (©) 1992,2007 Frank Tore Johansen
6		7	*
7	This program is free software; you can redistribute it and/or modify	8	* Deliantra is free software: you can redistribute it and/or modify
8	it under the terms of the GNU General Public License as published by	9	* it under the terms of the GNU General Public License as published by
9	the Free Software Foundation; either version 2 of the License, or	10	* the Free Software Foundation, either version 3 of the License, or
10	(at your option) any later version.	11	* (at your option) any later version.
11		12	*
12	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,
13	but WITHOUT ANY WARRANTY; without even the implied warranty of	14	* but WITHOUT ANY WARRANTY; without even the implied warranty of
14	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the	15	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15	GNU General Public License for more details.	16	* GNU General Public License for more details.
16		17	*
17	You should have received a copy of the GNU General Public License	18	* You should have received a copy of the GNU General Public License
18	along with this program; if not, write to the Free Software	19	* along with this program. If not, see <http://www.gnu.org/licenses/>.
19	Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.	20	*
		21	* The authors can be reached via e-mail to <support@deliantra.net>
		22	*/
20		23
21	The author can be reached via e-mail to <crossfire@schmorp.de>	24	/*
22
23	Object (handling) commands	25	* Object (handling) commands
24	*/	26	*/
25		27
26	#include <global.h>	28	#include <global.h>
27	#include <loader.h>	29	#include <loader.h>
28	#include <skills.h>	30	#include <skills.h>
29	#ifndef __CEXTRACT__
30	# include <sproto.h>	31	#include <sproto.h>
31	#endif
32	#include <living.h>	32	#include <living.h>
33	#include <math.h>	33	#include <math.h>
34		34
35	/*	35	/*
36	* Object id parsing functions	36	* Object id parsing functions
…		…
56	* only unapply applied, or apply unapplied objects	56	* only unapply applied, or apply unapplied objects
57	**/	57	**/
58	static object *	58	static object *
59	find_best_apply_object_match (object *pl, const char *params, enum apply_flag aflag)	59	find_best_apply_object_match (object *pl, const char *params, enum apply_flag aflag)
60	{	60	{
61	object *tmp, *best = NULL;	61	object *best = 0;
62	int match_val = 0, tmpmatch;	62	int match_val = 0;
63		63
64	for (tmp = pl->inv; tmp; tmp = tmp->below)	64	for (object *tmp = pl->inv; tmp; tmp = tmp->below)
65	{	65	{
66	if (tmp->invisible)	66	if (tmp->invisible)
67	continue;	67	continue;
		68
68	if ((tmpmatch = item_matched_string (pl, tmp, params)) > match_val)	69	int tmpmatch = item_matched_string (pl, tmp, params);
		70
		71	if (tmpmatch > match_val)
69	{	72	{
70	if ((aflag == AP_APPLY) && (QUERY_FLAG (tmp, FLAG_APPLIED)))	73	if ((aflag == AP_APPLY) && (QUERY_FLAG (tmp, FLAG_APPLIED)))
71	continue;	74	continue;
		75
72	if ((aflag == AP_UNAPPLY) && (!QUERY_FLAG (tmp, FLAG_APPLIED)))	76	if ((aflag == AP_UNAPPLY) && (!QUERY_FLAG (tmp, FLAG_APPLIED)))
73	continue;	77	continue;
		78
74	match_val = tmpmatch;	79	match_val = tmpmatch;
75	best = tmp;	80	best = tmp;
76	}	81	}
77	}	82	}
		83
78	return best;	84	return best;
79	}	85	}
80		86
81	/**	87	/**
82	* Shortcut to find_best_apply_object_match(pl, params, AF_NULL);	88	* Shortcut to find_best_apply_object_match(pl, params, AF_NULL);
83	**/	89	**/
84	object *	90	object *
85	find_best_object_match (object *pl, const char *params)	91	find_best_object_match (object *pl, const char *params)
86	{	92	{
87	return find_best_apply_object_match (pl, params, AP_NULL);	93	return find_best_apply_object_match (pl, params, AP_TOGGLE);
		94	}
		95
		96	static bool
		97	can_split (object *pl, object *&op, sint32 nrof)
		98	{
		99	if (object *tmp = op->split (nrof ? nrof : op->number_of ()))
		100	{
		101	op = tmp;
		102	return true;
		103	}
		104	else
		105	{
		106	if (op->nrof > 1)
		107	new_draw_info_format (NDI_UNIQUE, 0, pl, "There are only %d %s.", op->nrof, &op->name_pl);
		108	else
		109	new_draw_info_format (NDI_UNIQUE, 0, pl, "There is only one %s.", &op->name);
		110
		111	return false;
		112	}
88	}	113	}
89		114
90	int	115	int
91	command_uskill (object *pl, char *params)	116	command_uskill (object *pl, char *params)
92	{	117	{
93	if (!params)	118	if (!params)
94	{	119	{
95	new_draw_info (NDI_UNIQUE, 0, pl, "Usage: use_skill <skill name>");	120	new_draw_info (NDI_UNIQUE, 0, pl, "Usage: use_skill <skill name>");
96	return 0;	121	return 0;
97	}	122	}
		123
98	return use_skill (pl, params);	124	return use_skill (pl, params);
99	}	125	}
100		126
101	int	127	int
102	command_rskill (object *pl, char *params)	128	command_rskill (object *pl, char *params)
…		…
106	if (!params)	132	if (!params)
107	{	133	{
108	new_draw_info (NDI_UNIQUE, 0, pl, "Usage: ready_skill <skill name>");	134	new_draw_info (NDI_UNIQUE, 0, pl, "Usage: ready_skill <skill name>");
109	return 0;	135	return 0;
110	}	136	}
		137
111	skill = find_skill_by_name (pl, params);	138	skill = find_skill_by_name (pl, params);
112		139
113	if (!skill)	140	if (!skill)
114	{	141	{
115	new_draw_info_format (NDI_UNIQUE, 0, pl, "You have no knowledge of the skill %s", params);	142	new_draw_info_format (NDI_UNIQUE, 0, pl, "You have no knowledge of the skill %s", params);
116	return 0;	143	return 0;
117	}	144	}
118	return change_skill (pl, skill, 0);
119	}
120		145
		146	pl->change_skill (0);
		147	apply_special (pl, skill, AP_APPLY);
		148	return 1;
		149	}
121		150
122	/* These functions (command_search, command_disarm) are really just wrappers for	151	/* These functions (command_search, command_disarm) are really just wrappers for
123	* things like 'use_skill ...'). In fact, they should really be obsoleted	152	* things like 'use_skill ...'). In fact, they should really be obsoleted
124	* and replaced with those.	153	* and replaced with those.
125	*/	154	*/
…		…
133	command_disarm (object *op, char *params)	162	command_disarm (object *op, char *params)
134	{	163	{
135	return use_skill (op, skill_names[SK_DISARM_TRAPS]);	164	return use_skill (op, skill_names[SK_DISARM_TRAPS]);
136	}	165	}
137		166
138
139	/* A little special because we do want to pass the full params along	167	/* A little special because we do want to pass the full params along
140	* as it includes the object to throw.	168	* as it includes the object to throw.
141	*/	169	*/
142	int	170	int
143	command_throw (object *op, char *params)	171	command_throw (object *op, char *params)
144	{	172	{
145	object *skop;
146
147	skop = find_skill_by_name (op, skill_names[SK_THROWING]);	173	if (object *skop = find_skill_by_name (op, skill_names[SK_THROWING]))
148	if (skop)
149	return do_skill (op, op, skop, op->facing, params);	174	return do_skill (op, op, skop, op->facing, params);
150	else	175	else
151	{
152	new_draw_info (NDI_UNIQUE, 0, op, "You have no knowledge of the skill throwing.");	176	new_draw_info (NDI_UNIQUE, 0, op, "You have no knowledge of the skill throwing.");
153	}	177
154	return 0;	178	return 0;
155	}	179	}
156
157		180
158	int	181	int
159	command_apply (object *op, char *params)	182	command_apply (object *op, char *params)
160	{	183	{
161	if (!params)	184	if (!params)
…		…
163	player_apply_below (op);	186	player_apply_below (op);
164	return 0;	187	return 0;
165	}	188	}
166	else	189	else
167	{	190	{
168	apply_flag aflag = (apply_flag) 0;	191	apply_flag aflag = (apply_flag)0;
169	object *inv;
170		192
171	while (*params == ' ')	193	while (*params == ' ')
172	params++;	194	params++;
		195
173	if (!strncmp (params, "-a ", 3))	196	if (!strncmp (params, "-a ", 3))
174	{	197	{
175	aflag = AP_APPLY;	198	aflag = AP_APPLY;
176	params += 3;	199	params += 3;
177	}	200	}
		201
178	if (!strncmp (params, "-u ", 3))	202	if (!strncmp (params, "-u ", 3))
179	{	203	{
180	aflag = AP_UNAPPLY;	204	aflag = AP_UNAPPLY;
181	params += 3;	205	params += 3;
182	}	206	}
		207
183	while (*params == ' ')	208	while (*params == ' ')
184	params++;	209	params++;
185		210
186	inv = find_best_apply_object_match (op, params, aflag);	211	if (object *inv = find_best_apply_object_match (op, params, aflag))
187	if (inv)
188	{
189	player_apply (op, inv, aflag, 0);	212	player_apply (op, inv, aflag, 0);
190	}
191	else	213	else
192	new_draw_info_format (NDI_UNIQUE, 0, op, "Could not find any match to the %s.", params);	214	new_draw_info_format (NDI_UNIQUE, 0, op, "Could not find any match to the %s.", params);
193	}	215	}
		216
194	return 0;	217	return 0;
195	}	218	}
196		219
197	/*	220	/*
198	* Check if an item op can be put into a sack. If pl exists then tell	221	* Check if an item op can be put into a sack. If pl exists then tell
…		…
204	* not need to use split_ob and stuff.	227	* not need to use split_ob and stuff.
205	*/	228	*/
206	int	229	int
207	sack_can_hold (object *pl, object *sack, object *op, uint32 nrof)	230	sack_can_hold (object *pl, object *sack, object *op, uint32 nrof)
208	{	231	{
209
210	if (!QUERY_FLAG (sack, FLAG_APPLIED))	232	if (!QUERY_FLAG (sack, FLAG_APPLIED))
211	{	233	{
212	new_draw_info_format (NDI_UNIQUE, 0, pl, "The %s is not active.", query_name (sack));	234	new_draw_info_format (NDI_UNIQUE, 0, pl, "The %s is not active.", query_name (sack));
213	return 0;	235	return 0;
214	}	236	}
		237
215	if (sack == op)	238	if (sack == op)
216	{	239	{
217	new_draw_info_format (NDI_UNIQUE, 0, pl, "You can't put the %s into itself.", query_name (sack));	240	new_draw_info_format (NDI_UNIQUE, 0, pl, "You can't put the %s into itself.", query_name (sack));
218	return 0;	241	return 0;
219	}	242	}
		243
220	if (sack->race && (sack->race != op->race || op->type == CONTAINER || (sack->stats.food && sack->stats.food != op->type)))	244	if (sack->race && (sack->race != op->race || op->type == CONTAINER || (sack->stats.food && sack->stats.food != op->type)))
221	{	245	{
222	new_draw_info_format (NDI_UNIQUE, 0, pl, "You can put only %s into the %s.", &sack->race, query_name (sack));	246	new_draw_info_format (NDI_UNIQUE, 0, pl, "You can put only %s into the %s.", &sack->race, query_name (sack));
223	return 0;	247	return 0;
224	}	248	}
		249
225	if (op->type == SPECIAL_KEY && sack->slaying && op->slaying)	250	if (op->type == SPECIAL_KEY && sack->slaying && op->slaying)
226	{	251	{
227	new_draw_info_format (NDI_UNIQUE, 0, pl, "You can't put the key into %s.", query_name (sack));	252	new_draw_info_format (NDI_UNIQUE, 0, pl, "You can't put the key into %s.", query_name (sack));
228	return 0;	253	return 0;
229	}	254	}
		255
230	if (sack->weight_limit && (sint32) (sack->carrying + (nrof ? nrof : 1) *	256	if (sack->weight_limit && (sint32) (sack->carrying + (nrof ? nrof : 1) *
231	(op->weight + (op->type == CONTAINER ? (op->carrying * op->stats.Str) : 0))	257	(op->weight + (op->type == CONTAINER ? (op->carrying * op->stats.Str) : 0))
232	* (100 - sack->stats.Str) / 100) > sack->weight_limit)	258	* (100 - sack->stats.Str) / 100) > sack->weight_limit)
233	{	259	{
234	new_draw_info_format (NDI_UNIQUE, 0, pl, "That won't fit in the %s!", query_name (sack));	260	new_draw_info_format (NDI_UNIQUE, 0, pl, "That won't fit in the %s!", query_name (sack));
235	return 0;	261	return 0;
236	}	262	}
		263
237	/* All other checks pass, must be OK */	264	/* All other checks pass, must be OK */
238	return 1;	265	return 1;
239	}	266	}
240		267
241	/* Pick up commands follow */	268	/* Pick up commands follow */
…		…
246	* pick up (0 means all of them)	273	* pick up (0 means all of them)
247	*/	274	*/
248	static void	275	static void
249	pick_up_object (object *pl, object *op, object *tmp, int nrof)	276	pick_up_object (object *pl, object *op, object *tmp, int nrof)
250	{	277	{
251	/* buf needs to be big (more than 256 chars) because you can get
252	* very long item names.
253	*/
254	char buf[HUGE_BUF];
255	object *env = tmp->env;	278	object *env = tmp->env;
256	uint32 weight, effective_weight_limit;	279	uint32 weight, effective_weight_limit;
257	int tmp_nrof = tmp->nrof ? tmp->nrof : 1;	280	int tmp_nrof = tmp->number_of ();
258		281
259	/* IF the player is flying & trying to take the item out of a container	282	/* IF the player is flying & trying to take the item out of a container
260	* that is in his inventory, let him. tmp->env points to the container	283	* that is in his inventory, let him. tmp->env points to the container
261	* (sack, luggage, etc), tmp->env->env then points to the player (nested	284	* (sack, luggage, etc), tmp->env->env then points to the player (nested
262	* containers not allowed as of now)	285	* containers not allowed as of now)
263	*/	286	*/
264	if ((pl->move_type & MOVE_FLYING) && !QUERY_FLAG (pl, FLAG_WIZ) && is_player_inv (tmp) != pl)	287	if ((pl->move_type & MOVE_FLYING) && !QUERY_FLAG (pl, FLAG_WIZ) && tmp->in_player () != pl)
265	{	288	{
266	new_draw_info (NDI_UNIQUE, 0, pl, "You are levitating, you can't reach the ground!");	289	new_draw_info (NDI_UNIQUE, 0, pl, "You are levitating, you can't reach the ground!");
267	return;	290	return;
268	}	291	}
269		292
270	if (QUERY_FLAG (tmp, FLAG_NO_DROP))	293	if (QUERY_FLAG (tmp, FLAG_NO_DROP))
271	return;	294	return;
272		295
273	if (QUERY_FLAG (tmp, FLAG_WAS_WIZ) && !QUERY_FLAG (pl, FLAG_WAS_WIZ))
274	{
275	new_draw_info (NDI_UNIQUE, 0, pl, "The object disappears in a puff of smoke!");
276	new_draw_info (NDI_UNIQUE, 0, pl, "It must have been an illusion.");
277
278	if (pl->type == PLAYER)
279	esrv_del_item (pl->contr, tmp->count);
280
281	tmp->destroy ();
282	return;
283	}
284
285	if (nrof > tmp_nrof || nrof == 0)	296	if (nrof > tmp_nrof || nrof <= 0)
286	nrof = tmp_nrof;	297	nrof = tmp_nrof;
287		298
288	/* Figure out how much weight this object will add to the player */	299	/* Figure out how much weight this object will add to the player */
289	weight = tmp->weight * nrof;	300	weight = tmp->weight * nrof;
290	if (tmp->inv)	301	if (tmp->inv)
291	weight += tmp->carrying * (100 - tmp->stats.Str) / 100;	302	weight += tmp->carrying * (100 - tmp->stats.Str) / 100;
292		303
293	if (pl->stats.Str <= MAX_STAT)
294	effective_weight_limit = weight_limit[pl->stats.Str];	304	effective_weight_limit = weight_limit [min (MAX_STAT, pl->stats.Str)];
295	else
296	effective_weight_limit = weight_limit[MAX_STAT];
297		305
298	if ((pl->weight + pl->carrying + weight) > effective_weight_limit)	306	if ((pl->weight + pl->carrying + weight) > effective_weight_limit)
299	{	307	{
300	new_draw_info (0, 0, pl, "That item is too heavy for you to pick up.");	308	new_draw_info (0, 0, pl, "That item is too heavy for you to pick up.");
301	return;	309	return;
302	}	310	}
303		311
304	if (settings.real_wiz == FALSE && QUERY_FLAG (pl, FLAG_WAS_WIZ))	312	if (!can_split (pl, tmp, nrof))
305	SET_FLAG (tmp, FLAG_WAS_WIZ);
306
307	if (nrof != tmp_nrof)
308	{
309	object *tmp2 = tmp;
310
311	tmp = get_split_ob (tmp, nrof);
312	if (!tmp)
313	{
314	new_draw_info (NDI_UNIQUE, 0, pl, errmsg);
315	return;	313	return;
316	}
317		314
318	/* Tell a client what happened rest of objects */	315	if (QUERY_FLAG (tmp, FLAG_UNPAID))
319	if (pl->type == PLAYER)	316	{
320	{	317	tmp->flag.reset (FLAG_UNPAID);
321	if (tmp2->destroyed ())	318	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));
322	esrv_del_item (pl->contr, tmp2->count);	319	tmp->flag.set (FLAG_UNPAID);
323	else
324	esrv_send_item (pl, tmp2);
325	}
326	}	320	}
327	else	321	else
328	{	322	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	tmp->remove (); /* Unlink it */
338	}
339	}
340	if (QUERY_FLAG (tmp, FLAG_UNPAID))
341	(void) sprintf (buf, "%s will cost you %s.", query_name (tmp), query_cost_string (tmp, pl, F_BUY | F_SHOP));
342	else
343	(void) sprintf (buf, "You pick up the %s.", query_name (tmp));
344	new_draw_info (NDI_UNIQUE, 0, pl, buf);
345		323
346	tmp = insert_ob_in_ob (tmp, op);	324	op->insert (tmp);
347
348	/* All the stuff below deals with client/server code, and is only
349	* usable by players
350	*/
351	if (pl->type != PLAYER)
352	return;
353
354	esrv_send_item (pl, tmp);
355	/* These are needed to update the weight for the container we
356	* are putting the object in.
357	*/
358	if (op != pl)
359	{
360	esrv_update_item (UPD_WEIGHT, pl, op);
361	esrv_send_item (pl, pl);
362	}
363
364	/* Update the container the object was in */
365	if (env && env != pl && env != op)
366	esrv_update_item (UPD_WEIGHT, pl, env);
367	}	325	}
368		326
369	/* modified slightly to allow monsters use this -b.t. 5-31-95 */	327	/* modified slightly to allow monsters use this -b.t. 5-31-95 */
370	void	328	void
371	pick_up (object *op, object *alt)	329	pick_up (object *op, object *alt)
…		…
381	if (!can_pick (op, alt))	339	if (!can_pick (op, alt))
382	{	340	{
383	new_draw_info_format (NDI_UNIQUE, 0, op, "You can't pick up the %s.", &alt->name);	341	new_draw_info_format (NDI_UNIQUE, 0, op, "You can't pick up the %s.", &alt->name);
384	goto leave;	342	goto leave;
385	}	343	}
		344
386	tmp = alt;	345	tmp = alt;
387	}	346	}
388	else	347	else
389	{	348	{
390	if (op->below == NULL || !can_pick (op, op->below))	349	if (op->below == NULL || !can_pick (op, op->below))
…		…
399	/* Try to catch it. */	358	/* Try to catch it. */
400	tmp_map = tmp->map;	359	tmp_map = tmp->map;
401	tmp = stop_item (tmp);	360	tmp = stop_item (tmp);
402	if (tmp == NULL)	361	if (tmp == NULL)
403	goto leave;	362	goto leave;
		363
404	need_fix_tmp = 1;	364	need_fix_tmp = 1;
405	if (!can_pick (op, tmp))	365	if (!can_pick (op, tmp))
406	goto leave;	366	goto leave;
407		367
408	if (op->type == PLAYER)	368	if (op->type == PLAYER)
…		…
413	}	373	}
414	else	374	else
415	count = tmp->nrof;	375	count = tmp->nrof;
416		376
417	/* container is open, so use it */	377	/* container is open, so use it */
		378	if (tmp->flag [FLAG_STARTEQUIP])
		379	alt = op;
418	if (op->container)	380	else if (op->container)
419	{	381	{
420	alt = op->container;	382	alt = op->container;
421	if (alt != tmp->env && !sack_can_hold (op, alt, tmp, count))	383	if (alt != tmp->env && !sack_can_hold (op, alt, tmp, count))
422	goto leave;	384	goto leave;
423	}	385	}
…		…
430		392
431	if (!alt)	393	if (!alt)
432	for (alt = op->inv; alt; alt = alt->below)	394	for (alt = op->inv; alt; alt = alt->below)
433	if (alt->type == CONTAINER && QUERY_FLAG (alt, FLAG_APPLIED) && sack_can_hold (NULL, alt, tmp, count))	395	if (alt->type == CONTAINER && QUERY_FLAG (alt, FLAG_APPLIED) && sack_can_hold (NULL, alt, tmp, count))
434	break; /* General container comes next */	396	break; /* General container comes next */
		397
435	if (!alt)	398	if (!alt)
436	alt = op; /* No free containers */	399	alt = op; /* No free containers */
437	}	400	}
438		401
439	if (tmp->env == alt)	402	if (tmp->env == alt)
…		…
441	/* here it could be possible to check rent,	404	/* here it could be possible to check rent,
442	* if someone wants to implement it	405	* if someone wants to implement it
443	*/	406	*/
444	alt = op;	407	alt = op;
445	}	408	}
		409
446	#ifdef PICKUP_DEBUG	410	#ifdef PICKUP_DEBUG
447	LOG (llevDebug, "Pick_up(): %s picks %s (%d) and inserts it %s.\n", op->name, tmp->name, op->contr->count, alt->name);	411	LOG (llevDebug, "Pick_up(): %s picks %s (%d) and inserts it %s.\n", op->name, tmp->name, op->contr->count, alt->name);
448	#endif	412	#endif
449		413
450	/* startequip items are not allowed to be put into containers: */	414	/* startequip items are not allowed to be put into containers: */
…		…
466		430
467	leave:	431	leave:
468	if (need_fix_tmp)	432	if (need_fix_tmp)
469	fix_stopped_item (tmp, tmp_map, op);	433	fix_stopped_item (tmp, tmp_map, op);
470	}	434	}
471
472		435
473	/* This takes (picks up) and item. op is the player	436	/* This takes (picks up) and item. op is the player
474	* who issued the command. params is a string to	437	* who issued the command. params is a string to
475	* match against the item name. Basically, always	438	* match against the item name. Basically, always
476	* returns zero, but that should be improved.	439	* returns zero, but that should be improved.
…		…
491		454
492	if (!tmp)	455	if (!tmp)
493	tmp = op->below;	456	tmp = op->below;
494	}	457	}
495		458
496	if (tmp == NULL)	459	if (!tmp)
497	{	460	{
498	new_draw_info (NDI_UNIQUE, 0, op, "Nothing to take!");	461	new_draw_info (NDI_UNIQUE, 0, op, "Nothing to take!");
499	return 0;	462	return 0;
500	}	463	}
501		464
502	/* Makes processing easier */	465	/* Makes processing easier */
503	if (params && *params == '\0')	466	if (params && *params == '\0')
504	params = NULL;	467	params = 0;
		468
		469	int cnt = MAX_ITEM_PER_DROP;
505		470
506	while (tmp)	471	while (tmp)
507	{	472	{
508	next = tmp->below;	473	next = tmp->below;
509		474
510	if (tmp->invisible)	475	if (tmp->invisible)
511	{	476	{
512	tmp = next;	477	tmp = next;
513	continue;	478	continue;
514	}	479	}
		480
515	/* This following two if and else if could be merged into line	481	/* This following two if and else if could be merged into line
516	* but that probably will make it more difficult to read, and	482	* but that probably will make it more difficult to read, and
517	* not make it any more efficient	483	* not make it any more efficient
518	*/	484	*/
519	if (params && item_matched_string (op, tmp, params))	485	if (params && item_matched_string (op, tmp, params))
520	{	486	{
521	pick_up (op, tmp);	487	pick_up (op, tmp);
		488	if (--cnt <= 0) break;
522	}	489	}
523	else if (can_pick (op, tmp) && !params)	490	else if (can_pick (op, tmp) && !params)
524	{	491	{
525	pick_up (op, tmp);	492	pick_up (op, tmp);
526	break;	493	break;
527	}	494	}
		495
528	tmp = next;	496	tmp = next;
529	/* Might as well just skip over the player immediately -	497	}
530	* we know it can't be picked up	498
531	*/	499	if (cnt <= 0)
532	if (tmp == op)
533	tmp = tmp->below;
534	}	500	{
		501	op->failmsg ("Couldn't pick up so many items at once.");
		502	return 0;
		503	}
		504
535	if (!params && !tmp)	505	if (!params && !tmp)
536	{	506	{
537	for (tmp = op->below; tmp != NULL; tmp = tmp->next)	507	for (tmp = op->below; tmp; tmp = tmp->below)
538	if (!tmp->invisible)	508	if (!tmp->invisible)
539	{	509	{
540	char buf[MAX_BUF];
541
542	sprintf (buf, "You can't pick up a %s.", &tmp->name);	510	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;	511	break;
545	}	512	}
		513
546	if (!tmp)	514	if (!tmp)
547	new_draw_info (NDI_UNIQUE, 0, op, "There is nothing to pick up.");	515	new_draw_info (NDI_UNIQUE, 0, op, "There is nothing to pick up.");
548	}	516	}
		517
549	return 0;	518	return 0;
550	}	519	}
551
552		520
553	/*	521	/*
554	* This function was part of drop, now is own function.	522	* This function was part of drop, now is own function.
555	* Player 'op' tries to put object 'tmp' into sack 'sack',	523	* Player 'op' tries to put object 'tmp' into sack 'sack',
556	* if nrof is non zero, then nrof objects is tried to put into sack.	524	* if nrof is non zero, then nrof objects is tried to put into sack.
…		…
572	return;	540	return;
573	}	541	}
574		542
575	if (tmp->type == CONTAINER && tmp->inv)	543	if (tmp->type == CONTAINER && tmp->inv)
576	{	544	{
577
578	/* Eneq(@csd.uu.se): If the object to be dropped is a container	545	/* Eneq(@csd.uu.se): If the object to be dropped is a container
579	* we instead move the contents of that container into the active	546	* we instead move the contents of that container into the active
580	* container, this is only done if the object has something in it.	547	* container, this is only done if the object has something in it.
581	*/	548	*/
582	sack2 = tmp;	549	sack2 = tmp;
…		…
585	for (tmp2 = tmp->inv; tmp2; tmp2 = tmp)	552	for (tmp2 = tmp->inv; tmp2; tmp2 = tmp)
586	{	553	{
587	tmp = tmp2->below;	554	tmp = tmp2->below;
588		555
589	if ((sack->type == CONTAINER && sack_can_hold (op, op->container, tmp2, tmp2->nrof)))	556	if ((sack->type == CONTAINER && sack_can_hold (op, op->container, tmp2, tmp2->nrof)))
590	{
591	put_object_in_sack (op, sack, tmp2, 0);	557	put_object_in_sack (op, sack, tmp2, 0);
592	}
593	else	558	else
594	{	559	{
595	sprintf (buf, "Your %s fills up.", query_name (sack));	560	sprintf (buf, "Your %s fills up.", query_name (sack));
596	new_draw_info (NDI_UNIQUE, 0, op, buf);	561	new_draw_info (NDI_UNIQUE, 0, op, buf);
597	break;	562	break;
598	}	563	}
599	}	564	}
600		565
601	esrv_update_item (UPD_WEIGHT, op, sack2);
602	return;	566	return;
603	}	567	}
604		568
605	/* Don't worry about this for containers - our caller should have	569	/* Don't worry about this for containers - our caller should have
606	* already checked this.	570	* already checked this.
…		…
611	if (QUERY_FLAG (tmp, FLAG_APPLIED))	575	if (QUERY_FLAG (tmp, FLAG_APPLIED))
612	if (apply_special (op, tmp, AP_UNAPPLY | AP_NO_MERGE))	576	if (apply_special (op, tmp, AP_UNAPPLY | AP_NO_MERGE))
613	return;	577	return;
614		578
615	/* we want to put some portion of the item into the container */	579	/* we want to put some portion of the item into the container */
616	if (nrof && tmp->nrof != nrof)	580	if (!can_split (op, tmp, nrof))
617	{
618	object *tmp2 = tmp;
619
620	tmp = get_split_ob (tmp, nrof);
621
622	if (!tmp)
623	{
624	new_draw_info (NDI_UNIQUE, 0, op, errmsg);
625	return;	581	return;
626	}
627	/* Tell a client what happened other objects */
628	if (tmp2->destroyed ())
629	esrv_del_item (op->contr, tmp2->count);
630	else /* this can proably be replaced with an update */
631	esrv_send_item (op, tmp2);
632	}
633	else
634	tmp->remove ();
635		582
636	new_draw_info_format (NDI_UNIQUE, 0, op, "You put the %s in %s.", query_name (tmp), query_name (sack));	583	new_draw_info_format (NDI_UNIQUE, 0, op, "You put the %s in %s.", query_name (tmp), query_name (sack));
637	tmp2 = insert_ob_in_ob (tmp, sack);	584	sack->insert (tmp);
638	fix_player (op); /* This is overkill, fix_player() is called somewhere */
639	/* in object.c */
640
641	/* If an object merged (and thus, different object), we need to
642	* delete the original.
643	*/
644	if (tmp2 != tmp)
645	esrv_del_item (op->contr, tmp->count);
646
647	esrv_send_item (op, tmp2);
648
649	/* update the sacks weight */
650	esrv_update_item (UPD_WEIGHT, op, sack);
651	}	585	}
652		586
653	/*	587	/*
654	* This function was part of drop, now is own function.	588	* This function was part of drop, now is own function.
655	* Player 'op' tries to drop object 'tmp', if tmp is non zero, then	589	* Player 'op' tries to drop object 'tmp', if tmp is non zero, then
…		…
657	* This is used when dropping objects onto the floor.	591	* This is used when dropping objects onto the floor.
658	*/	592	*/
659	void	593	void
660	drop_object (object *op, object *tmp, uint32 nrof)	594	drop_object (object *op, object *tmp, uint32 nrof)
661	{	595	{
662	char buf[MAX_BUF];
663	object *floor;
664
665	if (QUERY_FLAG (tmp, FLAG_NO_DROP))	596	if (QUERY_FLAG (tmp, FLAG_NO_DROP))
666	return;	597	return;
667		598
668	if (QUERY_FLAG (tmp, FLAG_APPLIED))	599	if (QUERY_FLAG (tmp, FLAG_APPLIED))
669	if (apply_special (op, tmp, AP_UNAPPLY | AP_NO_MERGE))	600	if (apply_special (op, tmp, AP_UNAPPLY | AP_NO_MERGE))
670	return; /* can't unapply it */	601	return; /* can't unapply it */
671		602
		603	//fprintf (stderr, "ui, on space is %ld\n", op->ms ().volume ());//D
		604
672	/* We are only dropping some of the items. We split the current object	605	/* We are only dropping some of the items. We split the current object
673	* off	606	* off
674	*/	607	*/
675	if (nrof && tmp->nrof != nrof)	608	if (!can_split (op, tmp, nrof))
676	{
677	object *tmp2 = tmp;
678
679	tmp = get_split_ob (tmp, nrof);
680	if (!tmp)
681	{
682	new_draw_info (NDI_UNIQUE, 0, op, errmsg);
683	return;
684	}
685	/* Tell a client what happened rest of objects. tmp2 is now the
686	* original object
687	*/
688	if (op->type == PLAYER)
689	{
690	if (tmp2->destroyed ())
691	esrv_del_item (op->contr, tmp2->count);
692	else
693	esrv_send_item (op, tmp2);
694	}
695	}
696	else
697	tmp->remove ();
698		609
699	if (INVOKE_OBJECT (DROP, tmp, ARG_OBJECT (op)))	610	if (INVOKE_OBJECT (DROP, tmp, ARG_OBJECT (op)))
700	return;	611	return;
701		612
702	if (QUERY_FLAG (tmp, FLAG_STARTEQUIP))	613	if (QUERY_FLAG (tmp, FLAG_STARTEQUIP))
703	{	614	{
704	sprintf (buf, "You drop the %s.", query_name (tmp));	615	op->statusmsg (format ("You drop the %s.", query_name (tmp)));
705	new_draw_info (NDI_UNIQUE, 0, op, buf);	616	op->statusmsg ("The gods who lent it to you retrieves it.");
706	new_draw_info (NDI_UNIQUE, 0, op, "The gods who lent it to you retrieves it.");	617
707	if (op->type == PLAYER)
708	esrv_del_item (op->contr, tmp->count);
709	tmp->destroy ();	618	tmp->destroy ();
710	fix_player (op);	619	op->update_stats ();
711	return;	620	return;
712	}	621	}
713
714	/* If SAVE_INTERVAL is commented out, we never want to save
715	* the player here.
716	*/
717	#ifdef SAVE_INTERVAL
718	/* I'm not sure why there is a value check - since the save
719	* is done every SAVE_INTERVAL seconds, why care the value
720	* of what he is dropping?
721	*/
722	if (op->type == PLAYER && !QUERY_FLAG (tmp, FLAG_UNPAID) &&
723	(tmp->nrof ? tmp->value * tmp->nrof : tmp->value > 2000) && (op->contr->last_save_time + SAVE_INTERVAL) <= time (NULL))
724	{
725	save_player (op, 1);
726	op->contr->last_save_time = time (NULL);
727	}
728	#endif /* SAVE_INTERVAL */
729
730	if (op->type == PLAYER)
731	esrv_del_item (op->contr, tmp->count);
732		622
733	/* Call this before we update the various windows/players. At least	623	/* Call this before we update the various windows/players. At least
734	* that we, we know the weight is correct.	624	* that we, we know the weight is correct.
735	*/	625	*/
736	fix_player (op); /* This is overkill, fix_player() is called somewhere */	626	// 2007-11-26: moved op->update_stats away and calling it later after
737	/* in object.c */	627	// all items of a drop command have been processed.
738		628
739	if (op->type == PLAYER)
740	{
741	op->contr->socket.update_look = 1;
742	/* Need to update the weight for the player */
743	esrv_send_item (op, op);
744	}
745
746	for (floor = get_map_ob (op->map, op->x, op->y); floor; floor = floor->above)	629	for (object *floor = GET_MAP_OB (op->map, op->x, op->y); floor; floor = floor->above)
747	if (INVOKE_OBJECT (DROP_ON, floor, ARG_OBJECT (tmp), ARG_OBJECT (op)))	630	if (INVOKE_OBJECT (DROP_ON, floor, ARG_OBJECT (tmp), ARG_OBJECT (op)))
748	return;	631	return;
749		632
750	if (is_in_shop (op) && !QUERY_FLAG (tmp, FLAG_UNPAID) && tmp->type != MONEY)	633	if (is_in_shop (op) && !QUERY_FLAG (tmp, FLAG_UNPAID) && tmp->type != MONEY)
		634	{
751	sell_item (tmp, op);	635	if (!sell_item (tmp, op))
		636	return; // if we can't sell it we don't drop it
		637	}
752		638
753	tmp->x = op->x;	639	tmp->x = op->x;
754	tmp->y = op->y;	640	tmp->y = op->y;
755		641
756	insert_ob_in_map (tmp, op->map, op, INS_BELOW_ORIGINATOR);	642	insert_ob_in_map (tmp, op->map, op, INS_BELOW_ORIGINATOR);
…		…
776	tmp->destroy ();	662	tmp->destroy ();
777	return;	663	return;
778	}	664	}
779	else	665	else
780	{	666	{
781	while (tmp != NULL && tmp->invisible)	667	while (tmp && tmp->invisible)
782	tmp = tmp->below;	668	tmp = tmp->below;
783	}	669	}
784	}	670	}
785		671
786	if (tmp == NULL)	672	if (tmp == NULL)
787	{	673	{
788	new_draw_info (NDI_UNIQUE, 0, op, "You don't have anything to drop.");	674	new_draw_info (NDI_UNIQUE, 0, op, "You don't have anything to drop.");
789	return;	675	return;
790	}	676	}
		677
791	if (QUERY_FLAG (tmp, FLAG_INV_LOCKED))	678	if (QUERY_FLAG (tmp, FLAG_INV_LOCKED))
792	{	679	{
793	new_draw_info (NDI_UNIQUE, 0, op, "This item is locked");	680	new_draw_info (NDI_UNIQUE, 0, op, "This item is locked");
794	return;	681	return;
795	}	682	}
		683
796	if (QUERY_FLAG (tmp, FLAG_NO_DROP))	684	if (QUERY_FLAG (tmp, FLAG_NO_DROP))
797	{	685	{
798	#if 0	686	#if 0
799	/* Eneq(@csd.uu.se): Objects with NO_DROP defined can't be dropped. */	687	/* Eneq(@csd.uu.se): Objects with NO_DROP defined can't be dropped. */
800	new_draw_info (NDI_UNIQUE, 0, op, "This item can't be dropped.");	688	new_draw_info (NDI_UNIQUE, 0, op, "This item can't be dropped.");
801	#endif	689	#endif
802	return;	690	return;
803	}	691	}
804		692
805	if (op->type == PLAYER)	693	if (op->type == PLAYER && op->contr->last_used == tmp)
806	{	694	op->contr->last_used = tmp->below ? tmp->below
807	if (op->contr->last_used == tmp && op->contr->last_used_id == tmp->count)	695	: tmp->above ? tmp->above
808	{	696	: 0;
809	object *n = NULL;
810
811	if (tmp->below != NULL)
812	n = tmp->below;
813	else if (tmp->above != NULL)
814	n = tmp->above;
815	op->contr->last_used = n;
816	if (n != NULL)
817	op->contr->last_used_id = n->count;
818	else
819	op->contr->last_used_id = 0;
820	}
821	};
822		697
823	if (op->container)	698	if (op->container)
824	{	699	{
825	if (op->type == PLAYER)	700	if (op->type == PLAYER)
826	{
827	put_object_in_sack (op, op->container, tmp, op->contr->count);	701	put_object_in_sack (op, op->container, tmp, op->contr->count);
828	}
829	else	702	else
830	{
831	put_object_in_sack (op, op->container, tmp, 0);	703	put_object_in_sack (op, op->container, tmp, 0);
832	};
833	}	704	}
834	else	705	else
835	{	706	{
836	if (op->type == PLAYER)	707	if (op->type == PLAYER)
837	{
838	drop_object (op, tmp, op->contr->count);	708	drop_object (op, tmp, op->contr->count);
839	}
840	else	709	else
841	{
842	drop_object (op, tmp, 0);	710	drop_object (op, tmp, 0);
843	};
844	}	711	}
		712
845	if (op->type == PLAYER)	713	if (op->type == PLAYER)
846	op->contr->count = 0;	714	op->contr->count = 0;
847	}	715	}
848
849
850		716
851	/* Command will drop all items that have not been locked */	717	/* Command will drop all items that have not been locked */
852	int	718	int
853	command_dropall (object *op, char *params)	719	command_dropall (object *op, char *params)
854	{	720	{
855		721
856	object *curinv, *nextinv;
857
858	if (op->inv == NULL)	722	if (op->inv == NULL)
859	{	723	{
860	new_draw_info (NDI_UNIQUE, 0, op, "Nothing to drop!");	724	new_draw_info (NDI_UNIQUE, 0, op, "Nothing to drop!");
861	return 0;	725	return 0;
862	}	726	}
863		727
864	curinv = op->inv;	728	object *curinv = op->inv;
		729	object *nextinv;
865		730
866	/*	731	/*
867	This is the default. Drops everything not locked or considered	732	This is the default. Drops everything not locked or considered
868	not something that should be dropped.	733	not something that should be dropped.
869	*/	734	*/
…		…
871	Care must be taken that the next item pointer is not to money as	736	Care must be taken that the next item pointer is not to money as
872	the drop() routine will do unknown things to it when dropping	737	the drop() routine will do unknown things to it when dropping
873	in a shop. --Tero.Pelander@utu.fi	738	in a shop. --Tero.Pelander@utu.fi
874	*/	739	*/
875		740
876	if (params == NULL)	741	int cnt = MAX_ITEM_PER_DROP;
		742
		743	if (!params)
877	{	744	{
878	while (curinv != NULL)	745	while (curinv)
879	{	746	{
880	nextinv = curinv->below;	747	nextinv = curinv->below;
		748
881	while (nextinv && nextinv->type == MONEY)	749	while (nextinv && nextinv->type == MONEY)
882	nextinv = nextinv->below;	750	nextinv = nextinv->below;
		751
883	if (!QUERY_FLAG (curinv, FLAG_INV_LOCKED) && curinv->type != MONEY &&	752	if (!QUERY_FLAG (curinv, FLAG_INV_LOCKED) && curinv->type != MONEY &&
884	curinv->type != FOOD && curinv->type != KEY &&	753	curinv->type != FOOD && curinv->type != KEY &&
885	curinv->type != SPECIAL_KEY && curinv->type != GEM &&	754	curinv->type != SPECIAL_KEY && curinv->type != GEM &&
886	!curinv->invisible && (curinv->type != CONTAINER || op->container != curinv))	755	!curinv->invisible && (curinv->type != CONTAINER || op->container != curinv))
887	{	756	{
888	drop (op, curinv);	757	drop (op, curinv);
		758	if (--cnt <= 0) break;
889	}	759	}
		760
890	curinv = nextinv;	761	curinv = nextinv;
891	}	762	}
892	}	763	}
893
894	else if (strcmp (params, "weapons") == 0)	764	else if (strcmp (params, "weapons") == 0)
895	{	765	{
896	while (curinv != NULL)	766	while (curinv)
897	{	767	{
898	nextinv = curinv->below;	768	nextinv = curinv->below;
		769
899	while (nextinv && nextinv->type == MONEY)	770	while (nextinv && nextinv->type == MONEY)
900	nextinv = nextinv->below;	771	nextinv = nextinv->below;
		772
901	if (!QUERY_FLAG (curinv, FLAG_INV_LOCKED) && ((curinv->type == WEAPON) || (curinv->type == BOW) || (curinv->type == ARROW)))	773	if (!QUERY_FLAG (curinv, FLAG_INV_LOCKED) && ((curinv->type == WEAPON) || (curinv->type == BOW) || (curinv->type == ARROW)))
902	{	774	{
903	drop (op, curinv);	775	drop (op, curinv);
		776	if (--cnt <= 0) break;
904	}	777	}
		778
905	curinv = nextinv;	779	curinv = nextinv;
906	}	780	}
907	}	781	}
908
909	else if (strcmp (params, "armor") == 0 || strcmp (params, "armour") == 0)	782	else if (strcmp (params, "armor") == 0 || strcmp (params, "armour") == 0)
910	{	783	{
911	while (curinv != NULL)	784	while (curinv)
912	{	785	{
913	nextinv = curinv->below;	786	nextinv = curinv->below;
		787
914	while (nextinv && nextinv->type == MONEY)	788	while (nextinv && nextinv->type == MONEY)
915	nextinv = nextinv->below;	789	nextinv = nextinv->below;
		790
916	if (!QUERY_FLAG (curinv, FLAG_INV_LOCKED) && ((curinv->type == ARMOUR) || curinv->type == SHIELD || curinv->type == HELMET))	791	if (!QUERY_FLAG (curinv, FLAG_INV_LOCKED) && ((curinv->type == ARMOUR) || curinv->type == SHIELD || curinv->type == HELMET))
917	{	792	{
918	drop (op, curinv);	793	drop (op, curinv);
		794	if (--cnt <= 0) break;
919	}	795	}
		796
920	curinv = nextinv;	797	curinv = nextinv;
921	}	798	}
922	}	799	}
923
924	else if (strcmp (params, "misc") == 0)	800	else if (strcmp (params, "misc") == 0)
925	{	801	{
926	while (curinv != NULL)	802	while (curinv)
927	{	803	{
928	nextinv = curinv->below;	804	nextinv = curinv->below;
		805
929	while (nextinv && nextinv->type == MONEY)	806	while (nextinv && nextinv->type == MONEY)
930	nextinv = nextinv->below;	807	nextinv = nextinv->below;
		808
931	if (!QUERY_FLAG (curinv, FLAG_INV_LOCKED) && !QUERY_FLAG (curinv, FLAG_APPLIED))	809	if (!QUERY_FLAG (curinv, FLAG_INV_LOCKED) && !QUERY_FLAG (curinv, FLAG_APPLIED))
932	{	810	{
933	switch (curinv->type)	811	switch (curinv->type)
934	{	812	{
935	case HORN:	813	case HORN:
…		…
953	break;	831	break;
954	default:	832	default:
955	curinv = nextinv;	833	curinv = nextinv;
956	break;	834	break;
957	}	835	}
		836
		837	if (--cnt <= 0) break;
958	}	838	}
		839
959	curinv = nextinv;	840	curinv = nextinv;
960	}	841	}
961	}	842	}
962	op->contr->socket.update_look = 1;	843
		844	if (cnt <= 0)
		845	op->failmsg ("Only dropped some items, can't drop that many items at once.");
963		846
964	/* draw_look(op);*/	847	/* draw_look(op);*/
965	return 0;	848	return 0;
966	}	849	}
967		850
968	/* Object op wants to drop object(s) params. params can be a	851	/* Object op wants to drop object(s) params. params can be a
969	* comma seperated list.	852	* comma seperated list.
970	*/	853	*/
971
972	int	854	int
973	command_drop (object *op, char *params)	855	command_drop (object *op, char *params)
974	{	856	{
975	object *tmp, *next;	857	object *tmp, *next;
976	int did_one = 0;	858	int did_one = 0;
…		…
980	new_draw_info (NDI_UNIQUE, 0, op, "Drop what?");	862	new_draw_info (NDI_UNIQUE, 0, op, "Drop what?");
981	return 0;	863	return 0;
982	}	864	}
983	else	865	else
984	{	866	{
		867	int cnt = MAX_ITEM_PER_DROP;
		868
985	for (tmp = op->inv; tmp; tmp = next)	869	for (tmp = op->inv; tmp; tmp = next)
986	{	870	{
987	next = tmp->below;	871	next = tmp->below;
988	if (QUERY_FLAG (tmp, FLAG_NO_DROP) || tmp->invisible)	872	if (QUERY_FLAG (tmp, FLAG_NO_DROP) || tmp->invisible)
989	continue;	873	continue;
		874
990	if (item_matched_string (op, tmp, params))	875	if (item_matched_string (op, tmp, params))
991	{	876	{
992	drop (op, tmp);	877	drop (op, tmp);
		878	if (--cnt <= 0) break;
993	did_one = 1;	879	did_one = 1;
994	}	880	}
995	}	881	}
		882
996	if (!did_one)	883	if (!did_one)
997	new_draw_info (NDI_UNIQUE, 0, op, "Nothing to drop.");	884	new_draw_info (NDI_UNIQUE, 0, op, "Nothing to drop.");
998	}	885
999	if (op->type == PLAYER)	886	if (cnt <= 0)
1000	{	887	op->failmsg ("Only dropped some items, can't drop that many items at once.");
1001	op->contr->count = 0;
1002	op->contr->socket.update_look = 1;
1003	};	888	}
1004		889
1005	/* draw_look(op);*/
1006	return 0;	890	return 0;
1007	}	891	}
1008		892
1009	int	893	int
1010	command_examine (object *op, char *params)	894	command_examine (object *op, char *params)
1011	{	895	{
1012	if (!params)	896	if (!params)
1013	{	897	{
1014	object *tmp = op->below;	898	object *tmp = op->below;
1015		899
1016	while (tmp && !LOOK_OBJ (tmp))	900	while (tmp && !tmp->client_visible ())
1017	tmp = tmp->below;	901	tmp = tmp->below;
		902
1018	if (tmp)	903	if (tmp)
1019	examine (op, tmp);	904	examine (op, tmp);
1020	}	905	}
1021	else	906	else
1022	{	907	{
1023	object *tmp = find_best_object_match (op, params);	908	object *tmp = find_best_object_match (op, params);
1024		909
1025	if (tmp)	910	if (tmp)
1026	examine (op, tmp);	911	examine (op, tmp);
1027	else	912	else
1028	new_draw_info_format (NDI_UNIQUE, 0, op, "Could not find an object that matches %s", params);	913	op->contr->infobox (MSG_CHANNEL ("examine"), format ("Could not find an object that matches %s", params));
1029	}	914	}
		915
1030	return 0;	916	return 0;
1031	}	917	}
1032		918
1033	/* op should be a player.	919	/* op should be a player.
1034	* we return the object the player has marked with the 'mark' command	920	* we return the object the player has marked with the 'mark' command
…		…
1073	}	959	}
1074		960
1075	return 0;	961	return 0;
1076	}	962	}
1077		963
1078		964	std::string
1079	/* op should be a player, params is any params.	965	object::describe_monster (object *who)
1080	* If no params given, we print out the currently marked object.
1081	* otherwise, try to find a matching object - try best match first.
1082	*/
1083	int
1084	command_mark (object *op, char *params)
1085	{	966	{
1086	if (!op->contr)	967	dynbuf_text buf (512, 512);
1087	return 1;
1088		968
1089	if (!params)	969	object *mon = head ? head : this;
1090	{
1091	object *mark = find_marked_object (op);
1092		970
1093	if (!mark)	971	if (QUERY_FLAG (mon, FLAG_UNDEAD))
1094	new_draw_info (NDI_UNIQUE, 0, op, "You have no marked object.");	972	buf << "It is an undead force.\n";
1095	else	973
1096	new_draw_info_format (NDI_UNIQUE, 0, op, "%s is marked.", query_name (mark));	974	if (mon->level > who->level)
1097	}	975	buf << "It is likely more powerful than you.\n";
		976	else if (mon->level < who->level)
		977	buf << "It is likely less powerful than you.\n";
1098	else	978	else
1099	{	979	buf << "It is probably as powerful as you.\n";
1100	object *mark1 = find_best_object_match (op, params);
1101		980
1102	if (!mark1)
1103	{
1104	new_draw_info_format (NDI_UNIQUE, 0, op, "Could not find an object that matches %s", params);
1105	return 1;
1106	}
1107	else
1108	{
1109	op->contr->mark = mark1;
1110	new_draw_info_format (NDI_UNIQUE, 0, op, "Marked item %s", query_name (mark1));
1111	return 0;
1112	}
1113	}
1114
1115	return 0; /*shouldnt get here */
1116	}
1117
1118
1119	/* op is the player
1120	* tmp is the monster being examined.
1121	*/
1122	void
1123	examine_monster (object *op, object *tmp)
1124	{
1125	object *mon = tmp->head ? tmp->head : tmp;
1126
1127	if (QUERY_FLAG (mon, FLAG_UNDEAD))
1128	new_draw_info (NDI_UNIQUE, 0, op, "It is an undead force.");
1129	if (mon->level > op->level)
1130	new_draw_info (NDI_UNIQUE, 0, op, "It is likely more powerful than you.");
1131	else if (mon->level < op->level)
1132	new_draw_info (NDI_UNIQUE, 0, op, "It is likely less powerful than you.");
1133	else
1134	new_draw_info (NDI_UNIQUE, 0, op, "It is probably as powerful as you.");
1135	if (mon->attacktype & AT_ACID)	981	if (mon->attacktype & AT_ACID)
1136	new_draw_info (NDI_UNIQUE, 0, op, "You seem to smell an acrid odor.");	982	buf << "You seem to smell an acrid odor.\n";
1137		983
1138	/* Anyone know why this used to use the clone value instead of the	984	/* Anyone know why this used to use the clone value instead of the
1139	* maxhp field? This seems that it should give more accurate results.	985	* maxhp field? This seems that it should give more accurate results.
1140	*/	986	*/
1141	switch ((mon->stats.hp + 1) * 4 / (mon->stats.maxhp + 1))	987	switch ((mon->stats.hp + 1) * 4 / (mon->stats.maxhp + 1))
1142	{ /* From 1-4 */	988	{ /* From 1-4 */
1143	case 1:	989	case 1:
1144	new_draw_info (NDI_UNIQUE, 0, op, "It is in a bad shape.");	990	buf << "It is in a bad shape.\n";
1145	break;	991	break;
1146	case 2:	992	case 2:
1147	new_draw_info (NDI_UNIQUE, 0, op, "It is hurt.");	993	buf << "It is hurt.\n";
1148	break;	994	break;
1149	case 3:	995	case 3:
1150	new_draw_info (NDI_UNIQUE, 0, op, "It is somewhat hurt.");	996	buf << "It is somewhat hurt.\n";
1151	break;	997	break;
1152	case 4:	998	case 4:
1153	new_draw_info (NDI_UNIQUE, 0, op, "It is in excellent shape.");	999	buf << "It is in excellent shape.\n";
1154	break;	1000	break;
1155	}	1001	}
		1002
1156	if (present_in_ob (POISONING, mon) != NULL)	1003	if (present_in_ob (POISONING, mon))
1157	new_draw_info (NDI_UNIQUE, 0, op, "It looks very ill.");	1004	buf << "It looks very ill.\n";
1158	}
1159		1005
		1006	return buf;
		1007	}
1160		1008
1161	/* tmp is the object being described, pl is who is examing it. */	1009	/* tmp is the object being described, pl is who is examing it. */
1162	char *	1010	const char *
1163	long_desc (object *tmp, object *pl)	1011	long_desc (object *tmp, object *pl)
1164	{	1012	{
1165	static char buf[VERY_BIG_BUF];	1013	static std::string s;
1166	char *cp;
1167		1014
1168	if (tmp == NULL)	1015	return (s = tmp->long_desc (pl)).c_str ();
1169	return "";	1016	}
1170		1017
1171	buf[0] = '\0';	1018	std::string
		1019	object::long_desc (object *who)
		1020	{
		1021	std::string buf (query_name (this));
		1022
1172	switch (tmp->type)	1023	switch (type)
1173	{	1024	{
1174	case RING:	1025	case RING:
1175	case SKILL:	1026	case SKILL:
1176	case WEAPON:	1027	case WEAPON:
1177	case ARMOUR:	1028	case ARMOUR:
…		…
1188	case FOOD:	1039	case FOOD:
1189	case DRINK:	1040	case DRINK:
1190	case FLESH:	1041	case FLESH:
1191	case SKILL_TOOL:	1042	case SKILL_TOOL:
1192	case POWER_CRYSTAL:	1043	case POWER_CRYSTAL:
1193	if (*(cp = describe_item (tmp, pl)) != '\0')	1044	{
		1045	const char *cp = ::describe_item (this, who);
		1046
		1047	if (*cp)
		1048	{
		1049	buf.append (" ");
		1050	buf.append (cp);
		1051	}
		1052	}
		1053	}
		1054
		1055	return buf;
		1056	}
		1057
		1058	/* op is the player
		1059	* tmp is the monster being examined.
		1060	*/
		1061	void
		1062	examine_monster (object *op, object *tmp)
		1063	{
		1064	new_draw_info (NDI_UNIQUE, 0, op, tmp->describe_monster (op).c_str ());
		1065	}
		1066
		1067	std::string
		1068	object::describe (object *who)
		1069	{
		1070	dynbuf_text buf (1024, 1024);
		1071
		1072	buf.printf ("That is: %s.\n", long_desc (who).c_str ());
		1073
		1074	if (custom_name)
		1075	buf.printf ("You call it %s\n", &custom_name);
		1076
		1077	switch (type)
		1078	{
		1079	case SPELLBOOK:
		1080	if (flag [FLAG_IDENTIFIED] && inv)
		1081	buf.printf ("%s is a %s %s spell\n", &inv->name, get_levelnumber (inv->level), &inv->skill);
		1082	break;
		1083
		1084	case BOOK:
		1085	if (msg)
		1086	buf << "Something is written in it.\n";
		1087	break;
		1088
		1089	case CONTAINER:
		1090	if (race != NULL)
1194	{	1091	{
		1092	if (weight_limit && stats.Str < 100)
		1093	buf.printf ("It can hold only %s and its weight limit is %.1f kg.\n",
		1094	&race, weight_limit / (10.0 * (100 - stats.Str)));
1195	int len;	1095	else
1196		1096	buf.printf ("It can hold only %s.\n", &race);
1197	assign (buf, query_name (tmp));
1198	len = strlen (buf);
1199	if (len < VERY_BIG_BUF - 5)
1200	{
1201	/* Since we know the length, we save a few cpu cycles by using
1202	* it instead of calling strcat */
1203	strcpy (buf + len, " ");
1204	len++;
1205	assign (buf + len, cp, VERY_BIG_BUF - len - 1);
1206	}
1207	}	1097	}
1208	}
1209
1210	if (buf[0] == '\0')
1211	assign (buf, query_name (tmp));
1212
1213	return buf;
1214	}
1215
1216	void
1217	examine (object *op, object *tmp)
1218	{
1219	char buf[VERY_BIG_BUF];
1220	int i;
1221
1222	if (tmp == NULL || tmp->type == CLOSE_CON)
1223	return;
1224
1225	strcpy (buf, "That is ");
1226	strncat (buf, long_desc (tmp, op), VERY_BIG_BUF - strlen (buf) - 1);
1227	buf[VERY_BIG_BUF - 1] = 0;
1228
1229	new_draw_info (NDI_UNIQUE, 0, op, buf);
1230	buf[0] = '\0';
1231
1232	if (tmp->custom_name)
1233	{
1234	strcpy (buf, "You call it ");
1235	strncat (buf, tmp->custom_name, VERY_BIG_BUF - strlen (buf) - 1);
1236	buf[VERY_BIG_BUF - 1] = 0;
1237	new_draw_info (NDI_UNIQUE, 0, op, buf);
1238	buf[0] = '\0';
1239	}
1240
1241	switch (tmp->type)
1242	{
1243	case SPELLBOOK:
1244	if (QUERY_FLAG (tmp, FLAG_IDENTIFIED) && tmp->inv)
1245	{
1246	sprintf (buf, "%s is a %s level %s spell", &tmp->inv->name, get_levelnumber (tmp->inv->level), &tmp->inv->skill);
1247	}
1248	break;
1249
1250	case BOOK:
1251	if (tmp->msg != NULL)
1252	strcpy (buf, "Something is written in it.");
1253	break;
1254
1255	case CONTAINER:
1256	if (tmp->race != NULL)
1257	{
1258	if (tmp->weight_limit && tmp->stats.Str < 100)
1259	sprintf (buf, "It can hold only %s and its weight limit is %.1f kg.",
1260	&tmp->race, tmp->weight_limit / (10.0 * (100 - tmp->stats.Str)));
1261	else
1262	sprintf (buf, "It can hold only %s.", &tmp->race);
1263	}
1264	else if (tmp->weight_limit && tmp->stats.Str < 100)	1098	else if (weight_limit && stats.Str < 100)
1265	sprintf (buf, "Its weight limit is %.1f kg.", tmp->weight_limit / (10.0 * (100 - tmp->stats.Str)));	1099	buf.printf ("Its weight limit is %.1f kg.\n", weight_limit / (10.0 * (100 - stats.Str)));
1266	break;	1100	break;
1267		1101
1268	case WAND:	1102	case WAND:
1269	if (QUERY_FLAG (tmp, FLAG_IDENTIFIED))	1103	if (flag [FLAG_IDENTIFIED])
1270	sprintf (buf, "It has %d charges left.", tmp->stats.food);	1104	buf.printf ("It has %d charges left.\n", stats.food);
1271	break;	1105	break;
1272	}
1273
1274	if (buf[0] != '\0')
1275	new_draw_info (NDI_UNIQUE, 0, op, buf);
1276
1277	if (tmp->materialname != NULL && !tmp->msg)
1278	{	1106	}
		1107
		1108	if (materialname && !msg)
1279	sprintf (buf, "It is made of: %s.", &tmp->materialname);	1109	buf.printf ("It is made of: %s.\n", &materialname);
1280	new_draw_info (NDI_UNIQUE, 0, op, buf);	1110
1281	}	1111	if (who)
1282	/* Where to wear this item */	1112	/* Where to wear this item */
1283	for (i = 0; i < NUM_BODY_LOCATIONS; i++)	1113	for (int i = 0; i < NUM_BODY_LOCATIONS; i++)
1284	{	1114	if (slot[i].info)
1285	if (tmp->body_info[i] < -1)	1115	{
		1116	buf << (who->slot[i].info ? body_locations[i].use_name : body_locations[i].nonuse_name);
		1117
		1118	if (slot[i].info < -1 && who->slot[i].info)
		1119	buf.printf ("(%d)", -slot[i].info);
		1120
		1121	buf << ".\n";
1286	{	1122	}
1287	if (op->body_info[i])	1123
1288	new_draw_info_format (NDI_UNIQUE, 0, op, "It goes %s (%d)", body_locations[i].use_name, -tmp->body_info[i]);	1124	if (weight)
		1125	buf.printf (nrof > 1 ? "They weigh %3.3f kg.\n" : "It weighs %3.3f kg.\n", weight * (nrof ? nrof : 1) / 1000.0);
		1126
		1127	if (value && !flag [FLAG_STARTEQUIP] && !flag [FLAG_NO_PICK] && who)
		1128	{
		1129	buf.printf ("You reckon %s worth %s.\n", nrof > 1 ? "they are" : "it is", query_cost_string (this, who, F_TRUE | F_APPROX));
		1130
		1131	if (is_in_shop (who))
		1132	{
		1133	if (flag [FLAG_UNPAID])
		1134	buf.printf ("%s would cost you %s.\n", nrof > 1 ? "They" : "It", query_cost_string (this, who, F_BUY | F_SHOP));
1289	else	1135	else
1290	new_draw_info_format (NDI_UNIQUE, 0, op, "It goes %s", body_locations[i].nonuse_name);
1291	}
1292	else if (tmp->body_info[i])
1293	{
1294	if (op->body_info[i])
1295	new_draw_info_format (NDI_UNIQUE, 0, op, "It goes %s", body_locations[i].use_name);
1296	else
1297	new_draw_info_format (NDI_UNIQUE, 0, op, "It goes %s", body_locations[i].nonuse_name);
1298	}
1299	}
1300
1301	if (tmp->weight)
1302	{
1303	sprintf (buf, tmp->nrof > 1 ? "They weigh %3.3f kg." : "It weighs %3.3f kg.", tmp->weight * (tmp->nrof ? tmp->nrof : 1) / 1000.0);
1304	new_draw_info (NDI_UNIQUE, 0, op, buf);
1305	}
1306
1307	if (tmp->value && !QUERY_FLAG (tmp, FLAG_STARTEQUIP) && !QUERY_FLAG (tmp, FLAG_NO_PICK))
1308	{
1309	sprintf (buf, "You reckon %s worth %s.", tmp->nrof > 1 ? "they are" : "it is", query_cost_string (tmp, op, F_TRUE | F_APPROX));
1310	new_draw_info (NDI_UNIQUE, 0, op, buf);
1311	if (is_in_shop (op))
1312	{
1313	if (QUERY_FLAG (tmp, FLAG_UNPAID))
1314	sprintf (buf, "%s would cost you %s.", tmp->nrof > 1 ? "They" : "It", query_cost_string (tmp, op, F_BUY | F_SHOP));
1315	else
1316	sprintf (buf, "You are offered %s for %s.", query_cost_string (tmp, op, F_SELL + F_SHOP), tmp->nrof > 1 ? "them" : "it");	1136	buf.printf ("You are offered %s for %s.\n", query_cost_string (this, who, F_SELL + F_SHOP), nrof > 1 ? "them" : "it");
1317	new_draw_info (NDI_UNIQUE, 0, op, buf);
1318	}	1137	}
1319	}	1138	}
1320		1139
1321	if (QUERY_FLAG (tmp, FLAG_MONSTER))	1140	if (flag [FLAG_MONSTER])
1322	examine_monster (op, tmp);	1141	buf << describe_monster (who);
1323		1142
1324	/* Is this item buildable? */	1143	/* Is this item buildable? */
1325	if (QUERY_FLAG (tmp, FLAG_IS_BUILDABLE))	1144	if (flag [FLAG_IS_BUILDABLE])
1326	new_draw_info (NDI_UNIQUE, 0, op, "This is a buildable item.");	1145	buf << "This is a buildable item.\n";
1327		1146
1328	/* Does the object have a message? Don't show message for all object	1147	/* Does the object have a message? Don't show message for all object
1329	* types - especially if the first entry is a match	1148	* types - especially if the first entry is a match
1330	*/	1149	*/
1331	if (tmp->msg && tmp->type != EXIT && tmp->type != BOOK && tmp->type != CORPSE && !tmp->move_on && strncasecmp (tmp->msg, "@match", 7))	1150	if (msg && type != EXIT && type != BOOK && type != CORPSE && !move_on && *msg != '@')
1332	{	1151	{
1333
1334	/* This is just a hack so when identifying the items, we print	1152	/* This is just a hack so when identifying the items, we print
1335	* out the extra message	1153	* out the extra message
1336	*/	1154	*/
1337	if (need_identify (tmp) && QUERY_FLAG (tmp, FLAG_IDENTIFIED))	1155	if (need_identify (this) && flag [FLAG_IDENTIFIED])
1338	new_draw_info (NDI_UNIQUE, 0, op, "The object has a story:");	1156	buf << "The object has a story:\n";
1339		1157
1340	new_draw_info (NDI_UNIQUE, 0, op, tmp->msg);	1158	buf << msg << '\n';
1341	}
1342	new_draw_info (NDI_UNIQUE, 0, op, " "); /* Blank line */
1343	}
1344
1345	/*
1346	* inventory prints object's inventory. If inv==NULL then print player's
1347	* inventory.
1348	* [ Only items which are applied are showed. Tero.Haatanen@lut.fi ]
1349	*/
1350	void
1351	inventory (object *op, object *inv)
1352	{
1353	object *tmp;
1354	char *in;
1355	int items = 0, length;
1356
1357	if (inv == NULL && op == NULL)
1358	{	1159	}
1359	new_draw_info (NDI_UNIQUE, 0, op, "Inventory of what object?");
1360	return;
1361	}
1362	tmp = inv ? inv->inv : op->inv;
1363		1160
1364	while (tmp)	1161	buf << '\n';
1365	{	1162
1366	if ((!tmp->invisible &&	1163	return std::string (buf.linearise (), buf.size ());
1367	(inv == NULL || inv->type == CONTAINER || QUERY_FLAG (tmp, FLAG_APPLIED))) || (!op || QUERY_FLAG (op, FLAG_WIZ)))
1368	items++;
1369	tmp = tmp->below;
1370	}
1371	if (inv == NULL)
1372	{ /* player's inventory */
1373	if (items == 0)
1374	{
1375	new_draw_info (NDI_UNIQUE, 0, op, "You carry nothing.");
1376	return;
1377	}
1378	else
1379	{
1380	length = 28;
1381	in = "";
1382	if (op)
1383	clear_win_info (op);
1384	new_draw_info (NDI_UNIQUE, 0, op, "Inventory:");
1385	}
1386	}
1387	else
1388	{
1389	if (items == 0)
1390	return;
1391	else
1392	{
1393	length = 28;
1394	in = " ";
1395	}
1396	}
1397	for (tmp = inv ? inv->inv : op->inv; tmp; tmp = tmp->below)
1398	{
1399	if ((!op || !QUERY_FLAG (op, FLAG_WIZ)) && (tmp->invisible || (inv && inv->type != CONTAINER && !QUERY_FLAG (tmp, FLAG_APPLIED))))
1400	continue;
1401	if ((!op || QUERY_FLAG (op, FLAG_WIZ)))
1402	new_draw_info_format (NDI_UNIQUE, 0, op, "%s- %-*.*s (%5d) %-8s", in, length, length,
1403	query_name (tmp), tmp->count, query_weight (tmp));
1404	else
1405	new_draw_info_format (NDI_UNIQUE, 0, op, "%s- %-*.*s %-8s", in, length + 8, length + 8, query_name (tmp), query_weight (tmp));
1406	}
1407	if (!inv && op)
1408	{
1409	new_draw_info_format (NDI_UNIQUE, 0, op, "%-*s %-8s", 41, "Total weight :", query_weight (op));
1410	}
1411	}	1164	}
1412		1165
1413	static void	1166	static void
1414	display_new_pickup (object *op)	1167	display_new_pickup (object *op)
1415	{	1168	{
…		…
1576	new_draw_info (NDI_UNIQUE, 0, op, "Example: search magic+1");	1329	new_draw_info (NDI_UNIQUE, 0, op, "Example: search magic+1");
1577	new_draw_info (NDI_UNIQUE, 0, op, "Would automatically pick up all");	1330	new_draw_info (NDI_UNIQUE, 0, op, "Would automatically pick up all");
1578	new_draw_info (NDI_UNIQUE, 0, op, "items containing the word 'magic+1'.");	1331	new_draw_info (NDI_UNIQUE, 0, op, "items containing the word 'magic+1'.");
1579	return 1;	1332	return 1;
1580	}	1333	}
		1334
1581	op->contr->search_str[0] = '\0';	1335	op->contr->search_str[0] = '\0';
1582	new_draw_info (NDI_UNIQUE, 0, op, "Search mode turned off.");	1336	new_draw_info (NDI_UNIQUE, 0, op, "Search mode turned off.");
1583	fix_player (op);	1337	op->update_stats ();
1584	return 1;	1338	return 1;
1585	}	1339	}
		1340
1586	if ((int) strlen (params) >= MAX_BUF)	1341	if ((int) strlen (params) >= MAX_BUF)
1587	{	1342	{
1588	new_draw_info (NDI_UNIQUE, 0, op, "Search string too long.");	1343	new_draw_info (NDI_UNIQUE, 0, op, "Search string too long.");
1589	return 1;	1344	return 1;
1590	}	1345	}
		1346
1591	strcpy (op->contr->search_str, params);	1347	strcpy (op->contr->search_str, params);
1592	sprintf (buf, "Searching for '%s'.", op->contr->search_str);	1348	sprintf (buf, "Searching for '%s'.", op->contr->search_str);
1593	new_draw_info (NDI_UNIQUE, 0, op, buf);	1349	new_draw_info (NDI_UNIQUE, 0, op, buf);
1594	fix_player (op);	1350	op->update_stats ();
1595	return 1;	1351	return 1;
1596	}	1352	}
1597		1353

Diff Legend

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