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.31 by root, Fri Dec 22 16:34:00 2006 UTC vs.
Revision 1.84 by root, Mon Dec 22 21:11:27 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) && tmp->in_player () != 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	pl->failmsg ("You are levitating, you can't reach the ground! "
		290	"H<You have to stop levitating first, if you can, either by using your levitation skill, "
		291	"or waiting till the levitation effect wears off.>");
267	return;	292	return;
268	}	293	}
269		294
270	if (QUERY_FLAG (tmp, FLAG_NO_DROP))	295	if (QUERY_FLAG (tmp, FLAG_NO_DROP))
271	return;	296	return;
272		297
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)	298	if (nrof > tmp_nrof || nrof <= 0)
286	nrof = tmp_nrof;	299	nrof = tmp_nrof;
287		300
288	/* Figure out how much weight this object will add to the player */	301	/* Figure out how much weight this object will add to the player */
289	weight = tmp->weight * nrof;	302	weight = tmp->weight * nrof;
290	if (tmp->inv)	303	if (tmp->inv)
291	weight += tmp->carrying * (100 - tmp->stats.Str) / 100;	304	weight += tmp->carrying * (100 - tmp->stats.Str) / 100;
292		305
293	if (pl->stats.Str <= MAX_STAT)
294	effective_weight_limit = weight_limit[pl->stats.Str];	306	effective_weight_limit = weight_limit [min (MAX_STAT, pl->stats.Str)];
295	else
296	effective_weight_limit = weight_limit[MAX_STAT];
297		307
298	if ((pl->weight + pl->carrying + weight) > effective_weight_limit)	308	if ((pl->weight + pl->carrying + weight) > effective_weight_limit)
299	{	309	{
300	new_draw_info (0, 0, pl, "That item is too heavy for you to pick up.");	310	new_draw_info (0, 0, pl, "That item is too heavy for you to pick up.");
301	return;	311	return;
302	}	312	}
303		313
304	if (settings.real_wiz == FALSE && QUERY_FLAG (pl, FLAG_WAS_WIZ))	314	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;	315	return;
316	}
317		316
318	/* Tell a client what happened rest of objects */	317	if (QUERY_FLAG (tmp, FLAG_UNPAID))
319	if (pl->type == PLAYER)	318	{
320	{	319	tmp->flag.reset (FLAG_UNPAID);
321	if (tmp2->destroyed ())	320	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);	321	tmp->flag.set (FLAG_UNPAID);
323	else
324	esrv_send_item (pl, tmp2);
325	}
326	}	322	}
327	else	323	else
328	{	324	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		325
346	tmp = insert_ob_in_ob (tmp, op);	326	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	}	327	}
368		328
369	/* modified slightly to allow monsters use this -b.t. 5-31-95 */	329	/* modified slightly to allow monsters use this -b.t. 5-31-95 */
370	void	330	void
371	pick_up (object *op, object *alt)	331	pick_up (object *op, object *alt)
…		…
381	if (!can_pick (op, alt))	341	if (!can_pick (op, alt))
382	{	342	{
383	new_draw_info_format (NDI_UNIQUE, 0, op, "You can't pick up the %s.", &alt->name);	343	new_draw_info_format (NDI_UNIQUE, 0, op, "You can't pick up the %s.", &alt->name);
384	goto leave;	344	goto leave;
385	}	345	}
		346
386	tmp = alt;	347	tmp = alt;
387	}	348	}
388	else	349	else
389	{	350	{
390	if (op->below == NULL || !can_pick (op, op->below))	351	if (op->below == NULL || !can_pick (op, op->below))
…		…
399	/* Try to catch it. */	360	/* Try to catch it. */
400	tmp_map = tmp->map;	361	tmp_map = tmp->map;
401	tmp = stop_item (tmp);	362	tmp = stop_item (tmp);
402	if (tmp == NULL)	363	if (tmp == NULL)
403	goto leave;	364	goto leave;
		365
404	need_fix_tmp = 1;	366	need_fix_tmp = 1;
405	if (!can_pick (op, tmp))	367	if (!can_pick (op, tmp))
406	goto leave;	368	goto leave;
407		369
408	if (op->type == PLAYER)	370	if (op->type == PLAYER)
…		…
413	}	375	}
414	else	376	else
415	count = tmp->nrof;	377	count = tmp->nrof;
416		378
417	/* container is open, so use it */	379	/* container is open, so use it */
		380	if (tmp->flag [FLAG_STARTEQUIP])
		381	alt = op;
418	if (op->container)	382	else if (op->container)
419	{	383	{
420	alt = op->container;	384	alt = op->container;
421	if (alt != tmp->env && !sack_can_hold (op, alt, tmp, count))	385	if (alt != tmp->env && !sack_can_hold (op, alt, tmp, count))
422	goto leave;	386	goto leave;
423	}	387	}
…		…
430		394
431	if (!alt)	395	if (!alt)
432	for (alt = op->inv; alt; alt = alt->below)	396	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))	397	if (alt->type == CONTAINER && QUERY_FLAG (alt, FLAG_APPLIED) && sack_can_hold (NULL, alt, tmp, count))
434	break; /* General container comes next */	398	break; /* General container comes next */
		399
435	if (!alt)	400	if (!alt)
436	alt = op; /* No free containers */	401	alt = op; /* No free containers */
437	}	402	}
438		403
439	if (tmp->env == alt)	404	if (tmp->env == alt)
…		…
441	/* here it could be possible to check rent,	406	/* here it could be possible to check rent,
442	* if someone wants to implement it	407	* if someone wants to implement it
443	*/	408	*/
444	alt = op;	409	alt = op;
445	}	410	}
		411
446	#ifdef PICKUP_DEBUG	412	#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);	413	LOG (llevDebug, "Pick_up(): %s picks %s (%d) and inserts it %s.\n", op->name, tmp->name, op->contr->count, alt->name);
448	#endif	414	#endif
449		415
450	/* startequip items are not allowed to be put into containers: */	416	/* startequip items are not allowed to be put into containers: */
…		…
466		432
467	leave:	433	leave:
468	if (need_fix_tmp)	434	if (need_fix_tmp)
469	fix_stopped_item (tmp, tmp_map, op);	435	fix_stopped_item (tmp, tmp_map, op);
470	}	436	}
471
472		437
473	/* This takes (picks up) and item. op is the player	438	/* This takes (picks up) and item. op is the player
474	* who issued the command. params is a string to	439	* who issued the command. params is a string to
475	* match against the item name. Basically, always	440	* match against the item name. Basically, always
476	* returns zero, but that should be improved.	441	* returns zero, but that should be improved.
…		…
491		456
492	if (!tmp)	457	if (!tmp)
493	tmp = op->below;	458	tmp = op->below;
494	}	459	}
495		460
496	if (tmp == NULL)	461	if (!tmp)
497	{	462	{
498	new_draw_info (NDI_UNIQUE, 0, op, "Nothing to take!");	463	new_draw_info (NDI_UNIQUE, 0, op, "Nothing to take!");
499	return 0;	464	return 0;
500	}	465	}
501		466
502	/* Makes processing easier */	467	/* Makes processing easier */
503	if (params && *params == '\0')	468	if (params && *params == '\0')
504	params = NULL;	469	params = 0;
		470
		471	int cnt = MAX_ITEM_PER_DROP;
505		472
506	while (tmp)	473	while (tmp)
507	{	474	{
508	next = tmp->below;	475	next = tmp->below;
509		476
510	if (tmp->invisible)	477	if (tmp->invisible)
511	{	478	{
512	tmp = next;	479	tmp = next;
513	continue;	480	continue;
514	}	481	}
		482
515	/* This following two if and else if could be merged into line	483	/* This following two if and else if could be merged into line
516	* but that probably will make it more difficult to read, and	484	* but that probably will make it more difficult to read, and
517	* not make it any more efficient	485	* not make it any more efficient
518	*/	486	*/
519	if (params && item_matched_string (op, tmp, params))	487	if (params && item_matched_string (op, tmp, params))
520	{	488	{
		489	if (--cnt < 0) break;
521	pick_up (op, tmp);	490	pick_up (op, tmp);
522	}	491	}
523	else if (can_pick (op, tmp) && !params)	492	else if (can_pick (op, tmp) && !params)
524	{	493	{
		494	if (--cnt < 0) break;
525	pick_up (op, tmp);	495	pick_up (op, tmp);
526	break;	496	break;
527	}	497	}
		498
528	tmp = next;	499	tmp = next;
529	/* Might as well just skip over the player immediately -	500	}
530	* we know it can't be picked up	501
531	*/	502	if (cnt < 0)
532	if (tmp == op)
533	tmp = tmp->below;
534	}	503	{
		504	op->failmsg ("Couldn't pick up so many items at once.");
		505	return 0;
		506	}
		507
535	if (!params && !tmp)	508	if (!params && !tmp)
536	{	509	{
537	for (tmp = op->below; tmp != NULL; tmp = tmp->next)	510	for (tmp = op->below; tmp; tmp = tmp->below)
538	if (!tmp->invisible)	511	if (!tmp->invisible)
539	{	512	{
540	char buf[MAX_BUF];
541
542	sprintf (buf, "You can't pick up a %s.", &tmp->name);	513	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;	514	break;
545	}	515	}
		516
546	if (!tmp)	517	if (!tmp)
547	new_draw_info (NDI_UNIQUE, 0, op, "There is nothing to pick up.");	518	new_draw_info (NDI_UNIQUE, 0, op, "There is nothing to pick up.");
548	}	519	}
		520
549	return 0;	521	return 0;
550	}	522	}
551		523
552
553	/*	524	/*
554	* This function was part of drop, now is own function.	525	* This function was part of drop, now is own function.
555	* Player 'op' tries to put object 'tmp' into sack 'sack',	526	* 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.	527	* if nrof is non zero, then nrof objects is tried to put into sack.
		528	*
557	* Note that the 'sack' in question can now be a transport,	529	* Note that the 'sack' in question can now be a transport,
558	* so this function isn't named very good anymore.	530	* so this function isn't named very good anymore.
559	*/	531	*/
560	void	532	void
561	put_object_in_sack (object *op, object *sack, object *tmp, uint32 nrof)	533	put_object_in_sack (object *op, object *sack, object *tmp, uint32 nrof)
…		…
572	return;	544	return;
573	}	545	}
574		546
575	if (tmp->type == CONTAINER && tmp->inv)	547	if (tmp->type == CONTAINER && tmp->inv)
576	{	548	{
577
578	/* Eneq(@csd.uu.se): If the object to be dropped is a container	549	/* 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	550	* we instead move the contents of that container into the active
580	* container, this is only done if the object has something in it.	551	* container, this is only done if the object has something in it.
581	*/	552	*/
582	sack2 = tmp;	553	sack2 = tmp;
…		…
585	for (tmp2 = tmp->inv; tmp2; tmp2 = tmp)	556	for (tmp2 = tmp->inv; tmp2; tmp2 = tmp)
586	{	557	{
587	tmp = tmp2->below;	558	tmp = tmp2->below;
588		559
589	if ((sack->type == CONTAINER && sack_can_hold (op, op->container, tmp2, tmp2->nrof)))	560	if ((sack->type == CONTAINER && sack_can_hold (op, op->container, tmp2, tmp2->nrof)))
590	{
591	put_object_in_sack (op, sack, tmp2, 0);	561	put_object_in_sack (op, sack, tmp2, 0);
592	}
593	else	562	else
594	{	563	{
595	sprintf (buf, "Your %s fills up.", query_name (sack));	564	sprintf (buf, "Your %s fills up.", query_name (sack));
596	new_draw_info (NDI_UNIQUE, 0, op, buf);	565	new_draw_info (NDI_UNIQUE, 0, op, buf);
597	break;	566	break;
598	}	567	}
599	}	568	}
600		569
601	esrv_update_item (UPD_WEIGHT, op, sack2);
602	return;	570	return;
603	}	571	}
604		572
605	/* Don't worry about this for containers - our caller should have	573	/* Don't worry about this for containers - our caller should have
606	* already checked this.	574	* already checked this.
…		…
611	if (QUERY_FLAG (tmp, FLAG_APPLIED))	579	if (QUERY_FLAG (tmp, FLAG_APPLIED))
612	if (apply_special (op, tmp, AP_UNAPPLY | AP_NO_MERGE))	580	if (apply_special (op, tmp, AP_UNAPPLY | AP_NO_MERGE))
613	return;	581	return;
614		582
615	/* we want to put some portion of the item into the container */	583	/* we want to put some portion of the item into the container */
616	if (nrof && tmp->nrof != nrof)	584	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;	585	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		586
636	new_draw_info_format (NDI_UNIQUE, 0, op, "You put the %s in %s.", query_name (tmp), query_name (sack));	587	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);	588	sack->insert (tmp);
638	op->update_stats (); /* 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	}	589	}
652		590
653	/*	591	/*
654	* This function was part of drop, now is own function.	592	* This function was part of drop, now is own function.
655	* Player 'op' tries to drop object 'tmp', if tmp is non zero, then	593	* Player 'op' tries to drop object 'tmp', if tmp is non zero, then
…		…
657	* This is used when dropping objects onto the floor.	595	* This is used when dropping objects onto the floor.
658	*/	596	*/
659	void	597	void
660	drop_object (object *op, object *tmp, uint32 nrof)	598	drop_object (object *op, object *tmp, uint32 nrof)
661	{	599	{
662	char buf[MAX_BUF];
663	object *floor;
664
665	if (QUERY_FLAG (tmp, FLAG_NO_DROP))	600	if (QUERY_FLAG (tmp, FLAG_NO_DROP))
666	return;	601	return;
667		602
668	if (QUERY_FLAG (tmp, FLAG_APPLIED))	603	if (QUERY_FLAG (tmp, FLAG_APPLIED))
669	if (apply_special (op, tmp, AP_UNAPPLY | AP_NO_MERGE))	604	if (apply_special (op, tmp, AP_UNAPPLY | AP_NO_MERGE))
670	return; /* can't unapply it */	605	return; /* can't unapply it */
671		606
		607	//fprintf (stderr, "ui, on space is %ld\n", op->ms ().volume ());//D
		608
672	/* We are only dropping some of the items. We split the current object	609	/* We are only dropping some of the items. We split the current object
673	* off	610	* off
674	*/	611	*/
675	if (nrof && tmp->nrof != nrof)	612	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
699	if (INVOKE_OBJECT (DROP, tmp, ARG_OBJECT (op)))
700	return;	613	return;
701		614
		615	drop_object (op, tmp);
		616
		617	if (!tmp->destroyed () && !tmp->is_inserted ())
		618	{
		619	// if nothing happened with the object we give it back
		620	op->insert (tmp);
		621	}
		622	}
		623
		624	/* In contrast to drop_object (op, tmp, nrof) above this function takes the
		625	* already split off object, and feeds it to the event handlers and does
		626	* other magic with it.
		627	*
		628	* <droppper> is the object that dropped this object and <obj> is the
		629	* object that was dropped.
		630	*
		631	* Make sure to check what happened with <obj> after this function returns!
		632	* Otherwise you may leak this object.
		633	*/
		634
		635	void
		636	drop_object (object *dropper, object *obj)
		637	{
		638	if (INVOKE_OBJECT (DROP, obj, ARG_OBJECT (dropper)))
		639	return;
		640
		641	if (obj->destroyed () || obj->is_inserted ())
		642	return;
		643
702	if (QUERY_FLAG (tmp, FLAG_STARTEQUIP))	644	if (QUERY_FLAG (obj, FLAG_STARTEQUIP))
703	{	645	{
704	sprintf (buf, "You drop the %s.", query_name (tmp));	646	dropper->statusmsg (format ("You drop the %s.", query_name (obj)));
705	new_draw_info (NDI_UNIQUE, 0, op, buf);	647	dropper->statusmsg ("The god who lent it to you retrieves it.");
706	new_draw_info (NDI_UNIQUE, 0, op, "The gods who lent it to you retrieves it.");
707		648
708	if (op->type == PLAYER)
709	esrv_del_item (op->contr, tmp->count);
710
711	tmp->destroy ();	649	obj->destroy ();
712	op->update_stats ();	650	dropper->update_stats ();
713	return;	651	return;
714	}	652	}
715		653
716	/* If SAVE_INTERVAL is commented out, we never want to save	654	for (object *floor = GET_MAP_OB (dropper->map, dropper->x, dropper->y);
717	* the player here.	655	floor;
718	*/	656	floor = floor->above)
719	#ifdef SAVE_INTERVAL	657	if (INVOKE_OBJECT (DROP_ON, floor, ARG_OBJECT (obj), ARG_OBJECT (dropper)))
720	/* I'm not sure why there is a value check - since the save	658	return;
721	* is done every SAVE_INTERVAL seconds, why care the value	659
722	* of what he is dropping?	660	if (obj->destroyed () || obj->is_inserted ())
		661	return;
		662
		663	if (is_in_shop (dropper) && !QUERY_FLAG (obj, FLAG_UNPAID) && obj->type != MONEY)
		664	if (!sell_item (obj, dropper))
		665	return;
		666
		667	/* If nothing special happened with this object, the default action is to
		668	* insert it below the dropper:
723	*/	669	*/
724	if (op->type == PLAYER && !QUERY_FLAG (tmp, FLAG_UNPAID) &&
725	(tmp->nrof ? tmp->value * tmp->nrof : tmp->value > 2000) && (op->contr->last_save_time + SAVE_INTERVAL) <= time (NULL))
726	{
727	op->contr->save ();
728	op->contr->last_save_time = time (NULL);
729	}
730	#endif /* SAVE_INTERVAL */
731		670
732	if (op->type == PLAYER)	671	obj->x = dropper->x;
733	esrv_del_item (op->contr, tmp->count);	672	obj->y = dropper->y;
734		673
735	/* Call this before we update the various windows/players. At least
736	* that we, we know the weight is correct.
737	*/
738	op->update_stats (); /* This is overkill, fix_player() is called somewhere */
739	/* in object.c */
740
741	if (op->type == PLAYER)
742	{
743	/* Need to update the weight for the player */
744	esrv_send_item (op, op);
745	op->contr->ns->floorbox_update ();
746	}
747
748	for (floor = GET_MAP_OB (op->map, op->x, op->y); floor; floor = floor->above)
749	if (INVOKE_OBJECT (DROP_ON, floor, ARG_OBJECT (tmp), ARG_OBJECT (op)))
750	return;
751
752	if (is_in_shop (op) && !QUERY_FLAG (tmp, FLAG_UNPAID) && tmp->type != MONEY)
753	sell_item (tmp, op);
754
755	tmp->x = op->x;
756	tmp->y = op->y;
757
758	insert_ob_in_map (tmp, op->map, op, INS_BELOW_ORIGINATOR);	674	insert_ob_in_map (obj, dropper->map, dropper, INS_BELOW_ORIGINATOR);
759	}	675	}
760		676
761	void	677	void
762	drop (object *op, object *tmp)	678	drop (object *op, object *tmp)
763	{	679	{
…		…
772	if (tmp->env && tmp->env->type != PLAYER)	688	if (tmp->env && tmp->env->type != PLAYER)
773	{	689	{
774	/* Just toss the object - probably shouldn't be hanging	690	/* Just toss the object - probably shouldn't be hanging
775	* around anyways	691	* around anyways
776	*/	692	*/
777	tmp->remove ();
778	tmp->destroy ();	693	tmp->destroy ();
779	return;	694	return;
780	}	695	}
781	else	696	else
782	{	697	{
783	while (tmp != NULL && tmp->invisible)	698	while (tmp && tmp->invisible)
784	tmp = tmp->below;	699	tmp = tmp->below;
785	}	700	}
786	}	701	}
787		702
788	if (tmp == NULL)	703	if (tmp == NULL)
789	{	704	{
790	new_draw_info (NDI_UNIQUE, 0, op, "You don't have anything to drop.");	705	new_draw_info (NDI_UNIQUE, 0, op, "You don't have anything to drop.");
791	return;	706	return;
792	}	707	}
		708
793	if (QUERY_FLAG (tmp, FLAG_INV_LOCKED))	709	if (QUERY_FLAG (tmp, FLAG_INV_LOCKED))
794	{	710	{
795	new_draw_info (NDI_UNIQUE, 0, op, "This item is locked");	711	new_draw_info (NDI_UNIQUE, 0, op, "This item is locked");
796	return;	712	return;
797	}	713	}
		714
798	if (QUERY_FLAG (tmp, FLAG_NO_DROP))	715	if (QUERY_FLAG (tmp, FLAG_NO_DROP))
799	{	716	{
800	#if 0	717	#if 0
801	/* Eneq(@csd.uu.se): Objects with NO_DROP defined can't be dropped. */	718	/* Eneq(@csd.uu.se): Objects with NO_DROP defined can't be dropped. */
802	new_draw_info (NDI_UNIQUE, 0, op, "This item can't be dropped.");	719	new_draw_info (NDI_UNIQUE, 0, op, "This item can't be dropped.");
…		…
826		743
827	if (op->type == PLAYER)	744	if (op->type == PLAYER)
828	op->contr->count = 0;	745	op->contr->count = 0;
829	}	746	}
830		747
831
832
833	/* Command will drop all items that have not been locked */	748	/* Command will drop all items that have not been locked */
834	int	749	int
835	command_dropall (object *op, char *params)	750	command_dropall (object *op, char *params)
836	{	751	{
837		752
838	object *curinv, *nextinv;
839
840	if (op->inv == NULL)	753	if (op->inv == NULL)
841	{	754	{
842	new_draw_info (NDI_UNIQUE, 0, op, "Nothing to drop!");	755	new_draw_info (NDI_UNIQUE, 0, op, "Nothing to drop!");
843	return 0;	756	return 0;
844	}	757	}
845		758
846	curinv = op->inv;	759	object *curinv = op->inv;
		760	object *nextinv;
847		761
848	/*	762	/*
849	This is the default. Drops everything not locked or considered	763	This is the default. Drops everything not locked or considered
850	not something that should be dropped.	764	not something that should be dropped.
851	*/	765	*/
…		…
853	Care must be taken that the next item pointer is not to money as	767	Care must be taken that the next item pointer is not to money as
854	the drop() routine will do unknown things to it when dropping	768	the drop() routine will do unknown things to it when dropping
855	in a shop. --Tero.Pelander@utu.fi	769	in a shop. --Tero.Pelander@utu.fi
856	*/	770	*/
857		771
858	if (params == NULL)	772	int cnt = MAX_ITEM_PER_DROP;
		773
		774	if (!params)
859	{	775	{
860	while (curinv != NULL)	776	while (curinv)
861	{	777	{
862	nextinv = curinv->below;	778	nextinv = curinv->below;
		779
863	while (nextinv && nextinv->type == MONEY)	780	while (nextinv && nextinv->type == MONEY)
864	nextinv = nextinv->below;	781	nextinv = nextinv->below;
		782
865	if (!QUERY_FLAG (curinv, FLAG_INV_LOCKED) && curinv->type != MONEY &&	783	if (!QUERY_FLAG (curinv, FLAG_INV_LOCKED) && curinv->type != MONEY &&
866	curinv->type != FOOD && curinv->type != KEY &&	784	curinv->type != FOOD && curinv->type != KEY &&
867	curinv->type != SPECIAL_KEY && curinv->type != GEM &&	785	curinv->type != SPECIAL_KEY && curinv->type != GEM &&
868	!curinv->invisible && (curinv->type != CONTAINER || op->container != curinv))	786	!curinv->invisible && (curinv->type != CONTAINER || op->container != curinv))
869	{	787	{
870	drop (op, curinv);	788	drop (op, curinv);
		789	if (--cnt <= 0) break;
871	}	790	}
		791
872	curinv = nextinv;	792	curinv = nextinv;
873	}	793	}
874	}	794	}
875
876	else if (strcmp (params, "weapons") == 0)	795	else if (strcmp (params, "weapons") == 0)
877	{	796	{
878	while (curinv != NULL)	797	while (curinv)
879	{	798	{
880	nextinv = curinv->below;	799	nextinv = curinv->below;
		800
881	while (nextinv && nextinv->type == MONEY)	801	while (nextinv && nextinv->type == MONEY)
882	nextinv = nextinv->below;	802	nextinv = nextinv->below;
		803
883	if (!QUERY_FLAG (curinv, FLAG_INV_LOCKED) && ((curinv->type == WEAPON) || (curinv->type == BOW) || (curinv->type == ARROW)))	804	if (!QUERY_FLAG (curinv, FLAG_INV_LOCKED) && ((curinv->type == WEAPON) || (curinv->type == BOW) || (curinv->type == ARROW)))
884	{	805	{
885	drop (op, curinv);	806	drop (op, curinv);
		807	if (--cnt <= 0) break;
886	}	808	}
		809
887	curinv = nextinv;	810	curinv = nextinv;
888	}	811	}
889	}	812	}
890
891	else if (strcmp (params, "armor") == 0 || strcmp (params, "armour") == 0)	813	else if (strcmp (params, "armor") == 0 || strcmp (params, "armour") == 0)
892	{	814	{
893	while (curinv != NULL)	815	while (curinv)
894	{	816	{
895	nextinv = curinv->below;	817	nextinv = curinv->below;
		818
896	while (nextinv && nextinv->type == MONEY)	819	while (nextinv && nextinv->type == MONEY)
897	nextinv = nextinv->below;	820	nextinv = nextinv->below;
		821
898	if (!QUERY_FLAG (curinv, FLAG_INV_LOCKED) && ((curinv->type == ARMOUR) || curinv->type == SHIELD || curinv->type == HELMET))	822	if (!QUERY_FLAG (curinv, FLAG_INV_LOCKED) && ((curinv->type == ARMOUR) || curinv->type == SHIELD || curinv->type == HELMET))
899	{	823	{
900	drop (op, curinv);	824	drop (op, curinv);
		825	if (--cnt <= 0) break;
901	}	826	}
		827
902	curinv = nextinv;	828	curinv = nextinv;
903	}	829	}
904	}	830	}
905
906	else if (strcmp (params, "misc") == 0)	831	else if (strcmp (params, "misc") == 0)
907	{	832	{
908	while (curinv != NULL)	833	while (curinv)
909	{	834	{
910	nextinv = curinv->below;	835	nextinv = curinv->below;
		836
911	while (nextinv && nextinv->type == MONEY)	837	while (nextinv && nextinv->type == MONEY)
912	nextinv = nextinv->below;	838	nextinv = nextinv->below;
		839
913	if (!QUERY_FLAG (curinv, FLAG_INV_LOCKED) && !QUERY_FLAG (curinv, FLAG_APPLIED))	840	if (!QUERY_FLAG (curinv, FLAG_INV_LOCKED) && !QUERY_FLAG (curinv, FLAG_APPLIED))
914	{	841	{
915	switch (curinv->type)	842	switch (curinv->type)
916	{	843	{
917	case HORN:	844	case HORN:
…		…
935	break;	862	break;
936	default:	863	default:
937	curinv = nextinv;	864	curinv = nextinv;
938	break;	865	break;
939	}	866	}
		867
		868	if (--cnt <= 0) break;
940	}	869	}
		870
941	curinv = nextinv;	871	curinv = nextinv;
942	}	872	}
943	}	873	}
944		874
945	op->contr->ns->floorbox_update ();	875	if (cnt <= 0)
		876	op->failmsg ("Only dropped some items, can't drop that many items at once.");
946		877
947	/* draw_look(op);*/	878	/* draw_look(op);*/
948	return 0;	879	return 0;
		880	}
		881
		882
		883	/* This function tries to drop all objects in the <objs> vector.
		884	* <dropper> is the object that wants to drop them.
		885	* <cnt> can be a 0 pointer or a pointer to the maximum number of
		886	* drop operations to perform.
		887	*
		888	* Returns true if at least one item was dropped.
		889	*/
		890	bool
		891	drop_vector (object *dropper, vector<object *> &objs, int *cnt)
		892	{
		893	vector<object *>::iterator i;
		894
		895	bool did_one = false;
		896
		897	for (i = objs.begin (); i != objs.end (); i++)
		898	{
		899	drop (dropper, *i);
		900	if (cnt && --*cnt <= 0) break;
		901	did_one = true;
		902	}
		903
		904	return did_one;
949	}	905	}
950		906
951	/* Object op wants to drop object(s) params. params can be a	907	/* Object op wants to drop object(s) params. params can be a
952	* comma seperated list.	908	* comma seperated list.
953	*/	909	*/
954
955	int	910	int
956	command_drop (object *op, char *params)	911	command_drop (object *op, char *params)
957	{	912	{
958	object *tmp, *next;	913	object *tmp, *next;
959	int did_one = 0;	914	int did_one = 0;
…		…
963	new_draw_info (NDI_UNIQUE, 0, op, "Drop what?");	918	new_draw_info (NDI_UNIQUE, 0, op, "Drop what?");
964	return 0;	919	return 0;
965	}	920	}
966	else	921	else
967	{	922	{
		923	vector<object *> matched_objs;
		924
968	for (tmp = op->inv; tmp; tmp = next)	925	for (tmp = op->inv; tmp; tmp = next)
969	{	926	{
970	next = tmp->below;	927	next = tmp->below;
971	if (QUERY_FLAG (tmp, FLAG_NO_DROP) || tmp->invisible)	928	if (QUERY_FLAG (tmp, FLAG_NO_DROP) || tmp->invisible)
972	continue;	929	continue;
		930
973	if (item_matched_string (op, tmp, params))	931	if (item_matched_string (op, tmp, params))
974	{	932	matched_objs.push_back (tmp);
975	drop (op, tmp);
976	did_one = 1;
977	}	933	}
978	}	934
979	if (!did_one)	935	int cnt = MAX_ITEM_PER_DROP;
		936
		937	if (!drop_vector (op, matched_objs, &cnt))
980	new_draw_info (NDI_UNIQUE, 0, op, "Nothing to drop.");	938	new_draw_info (NDI_UNIQUE, 0, op, "Nothing to drop.");
981	}	939
982	if (op->type == PLAYER)	940	if (cnt <= 0)
983	{	941	op->failmsg ("Only dropped some items, can't drop that many items at once.");
984	op->contr->count = 0;
985	op->contr->ns->floorbox_update ();
986	};	942	}
987		943
988	/* draw_look(op);*/
989	return 0;	944	return 0;
990	}	945	}
991		946
992	int	947	int
993	command_examine (object *op, char *params)	948	command_examine (object *op, char *params)
994	{	949	{
995	if (!params)	950	if (!params)
996	{	951	{
997	object *tmp = op->below;	952	object *tmp = op->below;
998		953
999	while (tmp && !LOOK_OBJ (tmp))	954	while (tmp && !tmp->client_visible ())
1000	tmp = tmp->below;	955	tmp = tmp->below;
		956
1001	if (tmp)	957	if (tmp)
1002	examine (op, tmp);	958	examine (op, tmp);
1003	}	959	}
1004	else	960	else
1005	{	961	{
1006	object *tmp = find_best_object_match (op, params);	962	object *tmp = find_best_object_match (op, params);
1007		963
1008	if (tmp)	964	if (tmp)
1009	examine (op, tmp);	965	examine (op, tmp);
1010	else	966	else
1011	new_draw_info_format (NDI_UNIQUE, 0, op, "Could not find an object that matches %s", params);	967	op->contr->infobox (MSG_CHANNEL ("examine"), format ("Could not find an object that matches %s", params));
1012	}	968	}
		969
1013	return 0;	970	return 0;
1014	}	971	}
1015		972
1016	/* op should be a player.	973	/* op should be a player.
1017	* we return the object the player has marked with the 'mark' command	974	* we return the object the player has marked with the 'mark' command
…		…
1056	}	1013	}
1057		1014
1058	return 0;	1015	return 0;
1059	}	1016	}
1060		1017
1061		1018	std::string
1062	/* op should be a player, params is any params.	1019	object::describe_monster (object *who)
1063	* If no params given, we print out the currently marked object.
1064	* otherwise, try to find a matching object - try best match first.
1065	*/
1066	int
1067	command_mark (object *op, char *params)
1068	{	1020	{
1069	if (!op->contr)	1021	dynbuf_text buf (512, 512);
1070	return 1;
1071		1022
1072	if (!params)	1023	object *mon = head ? head : this;
1073	{
1074	object *mark = find_marked_object (op);
1075		1024
1076	if (!mark)	1025	if (QUERY_FLAG (mon, FLAG_UNDEAD))
1077	new_draw_info (NDI_UNIQUE, 0, op, "You have no marked object.");	1026	buf << "It is an undead force.\r";
1078	else	1027
1079	new_draw_info_format (NDI_UNIQUE, 0, op, "%s is marked.", query_name (mark));	1028	if (mon->level > who->level)
1080	}	1029	buf << "It is likely more powerful than you.\r";
		1030	else if (mon->level < who->level)
		1031	buf << "It is likely less powerful than you.\r";
1081	else	1032	else
1082	{	1033	buf << "It is probably as powerful as you.\r";
1083	object *mark1 = find_best_object_match (op, params);
1084		1034
1085	if (!mark1)
1086	{
1087	new_draw_info_format (NDI_UNIQUE, 0, op, "Could not find an object that matches %s", params);
1088	return 1;
1089	}
1090	else
1091	{
1092	op->contr->mark = mark1;
1093	new_draw_info_format (NDI_UNIQUE, 0, op, "Marked item %s", query_name (mark1));
1094	return 0;
1095	}
1096	}
1097
1098	return 0; /*shouldnt get here */
1099	}
1100
1101
1102	/* op is the player
1103	* tmp is the monster being examined.
1104	*/
1105	void
1106	examine_monster (object *op, object *tmp)
1107	{
1108	object *mon = tmp->head ? tmp->head : tmp;
1109
1110	if (QUERY_FLAG (mon, FLAG_UNDEAD))
1111	new_draw_info (NDI_UNIQUE, 0, op, "It is an undead force.");
1112	if (mon->level > op->level)
1113	new_draw_info (NDI_UNIQUE, 0, op, "It is likely more powerful than you.");
1114	else if (mon->level < op->level)
1115	new_draw_info (NDI_UNIQUE, 0, op, "It is likely less powerful than you.");
1116	else
1117	new_draw_info (NDI_UNIQUE, 0, op, "It is probably as powerful as you.");
1118	if (mon->attacktype & AT_ACID)	1035	if (mon->attacktype & AT_ACID)
1119	new_draw_info (NDI_UNIQUE, 0, op, "You seem to smell an acrid odor.");	1036	buf << "You seem to smell an acrid odor.\r";
1120		1037
1121	/* Anyone know why this used to use the clone value instead of the	1038	/* Anyone know why this used to use the clone value instead of the
1122	* maxhp field? This seems that it should give more accurate results.	1039	* maxhp field? This seems that it should give more accurate results.
1123	*/	1040	*/
1124	switch ((mon->stats.hp + 1) * 4 / (mon->stats.maxhp + 1))	1041	switch ((mon->stats.hp + 1) * 4 / (mon->stats.maxhp + 1))
1125	{ /* From 1-4 */	1042	{ /* From 1-4 */
1126	case 1:	1043	case 1:
1127	new_draw_info (NDI_UNIQUE, 0, op, "It is in a bad shape.");	1044	buf << "It is in a bad shape.\r";
1128	break;	1045	break;
1129	case 2:	1046	case 2:
1130	new_draw_info (NDI_UNIQUE, 0, op, "It is hurt.");	1047	buf << "It is hurt.\r";
1131	break;	1048	break;
1132	case 3:	1049	case 3:
1133	new_draw_info (NDI_UNIQUE, 0, op, "It is somewhat hurt.");	1050	buf << "It is somewhat hurt.\r";
1134	break;	1051	break;
1135	case 4:	1052	case 4:
1136	new_draw_info (NDI_UNIQUE, 0, op, "It is in excellent shape.");	1053	buf << "It is in excellent shape.\r";
1137	break;	1054	break;
1138	}	1055	}
		1056
1139	if (present_in_ob (POISONING, mon) != NULL)	1057	if (present_in_ob (POISONING, mon))
1140	new_draw_info (NDI_UNIQUE, 0, op, "It looks very ill.");	1058	buf << "It looks very ill.\r";
1141	}
1142		1059
		1060	buf << '\n';
		1061
		1062	return buf;
		1063	}
1143		1064
1144	/* tmp is the object being described, pl is who is examing it. */	1065	/* tmp is the object being described, pl is who is examing it. */
1145	char *	1066	const char *
1146	long_desc (object *tmp, object *pl)	1067	long_desc (object *tmp, object *pl)
1147	{	1068	{
1148	static char buf[VERY_BIG_BUF];	1069	static std::string s;
1149	char *cp;
1150		1070
1151	if (tmp == NULL)	1071	return (s = tmp->long_desc (pl)).c_str ();
1152	return "";	1072	}
1153		1073
1154	buf[0] = '\0';	1074	std::string
		1075	object::long_desc (object *who)
		1076	{
		1077	std::string buf (query_name (this));
		1078
1155	switch (tmp->type)	1079	switch (type)
1156	{	1080	{
1157	case RING:	1081	case RING:
1158	case SKILL:	1082	case SKILL:
1159	case WEAPON:	1083	case WEAPON:
1160	case ARMOUR:	1084	case ARMOUR:
…		…
1171	case FOOD:	1095	case FOOD:
1172	case DRINK:	1096	case DRINK:
1173	case FLESH:	1097	case FLESH:
1174	case SKILL_TOOL:	1098	case SKILL_TOOL:
1175	case POWER_CRYSTAL:	1099	case POWER_CRYSTAL:
1176	if (*(cp = describe_item (tmp, pl)) != '\0')	1100	{
		1101	const char *cp = ::describe_item (this, who);
		1102
		1103	if (*cp)
		1104	{
		1105	buf.append (" ");
		1106	buf.append (cp);
		1107	}
		1108	}
		1109	}
		1110
		1111	return buf;
		1112	}
		1113
		1114	/* op is the player
		1115	* tmp is the monster being examined.
		1116	*/
		1117	void
		1118	examine_monster (object *op, object *tmp)
		1119	{
		1120	new_draw_info (NDI_UNIQUE, 0, op, tmp->describe_monster (op).c_str ());
		1121	}
		1122
		1123	std::string
		1124	object::describe (object *who)
		1125	{
		1126	dynbuf_text buf (1024, 1024);
		1127
		1128	buf.printf ("That is: %s.\r", long_desc (who).c_str ());
		1129
		1130	if (custom_name)
		1131	buf.printf ("You call it %s.\r", &custom_name);
		1132
		1133	switch (type)
		1134	{
		1135	case SPELLBOOK:
		1136	if (flag [FLAG_IDENTIFIED] && inv)
		1137	buf.printf ("%s is a level %s %s spell.\r", &inv->name, get_levelnumber (inv->level), &inv->skill);
		1138	break;
		1139
		1140	case BOOK:
		1141	if (msg)
		1142	buf << "Something is written in it.\r";
		1143	break;
		1144
		1145	case CONTAINER:
		1146	if (race)
1177	{	1147	{
		1148	if (weight_limit && stats.Str < 100)
		1149	buf.printf ("It can hold only %s and its weight limit is %.1f kg.\r",
		1150	&race, weight_limit / (10.0 * (100 - stats.Str)));
1178	int len;	1151	else
1179		1152	buf.printf ("It can hold only %s.\r", &race);
1180	assign (buf, query_name (tmp));
1181	len = strlen (buf);
1182	if (len < VERY_BIG_BUF - 5)
1183	{
1184	/* Since we know the length, we save a few cpu cycles by using
1185	* it instead of calling strcat */
1186	strcpy (buf + len, " ");
1187	len++;
1188	assign (buf + len, cp, VERY_BIG_BUF - len - 1);
1189	}
1190	}	1153	}
1191	}
1192
1193	if (buf[0] == '\0')
1194	assign (buf, query_name (tmp));
1195
1196	return buf;
1197	}
1198
1199	void
1200	examine (object *op, object *tmp)
1201	{
1202	char buf[VERY_BIG_BUF];
1203	int i;
1204
1205	if (tmp == NULL || tmp->type == CLOSE_CON)
1206	return;
1207
1208	strcpy (buf, "That is ");
1209	strncat (buf, long_desc (tmp, op), VERY_BIG_BUF - strlen (buf) - 1);
1210	buf[VERY_BIG_BUF - 1] = 0;
1211
1212	new_draw_info (NDI_UNIQUE, 0, op, buf);
1213	buf[0] = '\0';
1214
1215	if (tmp->custom_name)
1216	{
1217	strcpy (buf, "You call it ");
1218	strncat (buf, tmp->custom_name, VERY_BIG_BUF - strlen (buf) - 1);
1219	buf[VERY_BIG_BUF - 1] = 0;
1220	new_draw_info (NDI_UNIQUE, 0, op, buf);
1221	buf[0] = '\0';
1222	}
1223
1224	switch (tmp->type)
1225	{
1226	case SPELLBOOK:
1227	if (QUERY_FLAG (tmp, FLAG_IDENTIFIED) && tmp->inv)
1228	{
1229	sprintf (buf, "%s is a %s level %s spell", &tmp->inv->name, get_levelnumber (tmp->inv->level), &tmp->inv->skill);
1230	}
1231	break;
1232
1233	case BOOK:
1234	if (tmp->msg != NULL)
1235	strcpy (buf, "Something is written in it.");
1236	break;
1237
1238	case CONTAINER:
1239	if (tmp->race != NULL)
1240	{
1241	if (tmp->weight_limit && tmp->stats.Str < 100)
1242	sprintf (buf, "It can hold only %s and its weight limit is %.1f kg.",
1243	&tmp->race, tmp->weight_limit / (10.0 * (100 - tmp->stats.Str)));
1244	else
1245	sprintf (buf, "It can hold only %s.", &tmp->race);
1246	}
1247	else if (tmp->weight_limit && tmp->stats.Str < 100)	1154	else if (weight_limit && stats.Str < 100)
1248	sprintf (buf, "Its weight limit is %.1f kg.", tmp->weight_limit / (10.0 * (100 - tmp->stats.Str)));	1155	buf.printf ("Its weight limit is %.1f kg.\r", weight_limit / (10.0 * (100 - stats.Str)));
1249	break;	1156	break;
1250		1157
1251	case WAND:	1158	case WAND:
1252	if (QUERY_FLAG (tmp, FLAG_IDENTIFIED))	1159	if (flag [FLAG_IDENTIFIED])
1253	sprintf (buf, "It has %d charges left.", tmp->stats.food);	1160	buf.printf ("It has %d charges left.\r", stats.food);
1254	break;	1161	break;
1255	}
1256
1257	if (buf[0] != '\0')
1258	new_draw_info (NDI_UNIQUE, 0, op, buf);
1259
1260	if (tmp->materialname != NULL && !tmp->msg)
1261	{	1162	}
		1163
		1164	if (materialname && !msg)
1262	sprintf (buf, "It is made of: %s.", &tmp->materialname);	1165	buf.printf ("It is made of: %s.\r", &materialname);
1263	new_draw_info (NDI_UNIQUE, 0, op, buf);	1166
1264	}	1167	if (who)
1265	/* Where to wear this item */	1168	/* Where to wear this item */
1266	for (i = 0; i < NUM_BODY_LOCATIONS; i++)	1169	for (int i = 0; i < NUM_BODY_LOCATIONS; i++)
1267	{	1170	if (slot[i].info)
1268	if (tmp->body_info[i] < -1)	1171	{
		1172	buf << (who->slot[i].info ? body_locations[i].use_name : body_locations[i].nonuse_name);
		1173
		1174	if (slot[i].info < -1 && who->slot[i].info)
		1175	buf.printf ("(%d)", -slot[i].info);
		1176
		1177	buf << ".\r";
1269	{	1178	}
1270	if (op->body_info[i])	1179
1271	new_draw_info_format (NDI_UNIQUE, 0, op, "It goes %s (%d)", body_locations[i].use_name, -tmp->body_info[i]);	1180	if (weight)
		1181	buf.printf ("%s %3.3f kg.\r", nrof > 1 ? "They weigh" : "It weighs", weight * (nrof ? nrof : 1) / 1000.0);
		1182
		1183	if (value && !flag [FLAG_STARTEQUIP] && !flag [FLAG_NO_PICK] && who)
		1184	{
		1185	buf.printf ("You reckon %s worth %s.\r", nrof > 1 ? "they are" : "it is", query_cost_string (this, who, F_TRUE | F_APPROX));
		1186
		1187	if (is_in_shop (who))
		1188	{
		1189	if (flag [FLAG_UNPAID])
		1190	buf.printf ("%s would cost you %s.\r", nrof > 1 ? "They" : "It", query_cost_string (this, who, F_BUY | F_SHOP));
1272	else	1191	else
1273	new_draw_info_format (NDI_UNIQUE, 0, op, "It goes %s", body_locations[i].nonuse_name);
1274	}
1275	else if (tmp->body_info[i])
1276	{
1277	if (op->body_info[i])
1278	new_draw_info_format (NDI_UNIQUE, 0, op, "It goes %s", body_locations[i].use_name);
1279	else
1280	new_draw_info_format (NDI_UNIQUE, 0, op, "It goes %s", body_locations[i].nonuse_name);
1281	}
1282	}
1283
1284	if (tmp->weight)
1285	{
1286	sprintf (buf, tmp->nrof > 1 ? "They weigh %3.3f kg." : "It weighs %3.3f kg.", tmp->weight * (tmp->nrof ? tmp->nrof : 1) / 1000.0);
1287	new_draw_info (NDI_UNIQUE, 0, op, buf);
1288	}
1289
1290	if (tmp->value && !QUERY_FLAG (tmp, FLAG_STARTEQUIP) && !QUERY_FLAG (tmp, FLAG_NO_PICK))
1291	{
1292	sprintf (buf, "You reckon %s worth %s.", tmp->nrof > 1 ? "they are" : "it is", query_cost_string (tmp, op, F_TRUE | F_APPROX));
1293	new_draw_info (NDI_UNIQUE, 0, op, buf);
1294	if (is_in_shop (op))
1295	{
1296	if (QUERY_FLAG (tmp, FLAG_UNPAID))
1297	sprintf (buf, "%s would cost you %s.", tmp->nrof > 1 ? "They" : "It", query_cost_string (tmp, op, F_BUY | F_SHOP));
1298	else
1299	sprintf (buf, "You are offered %s for %s.", query_cost_string (tmp, op, F_SELL + F_SHOP), tmp->nrof > 1 ? "them" : "it");	1192	buf.printf ("You are offered %s for %s.\r", query_cost_string (this, who, F_SELL + F_SHOP), nrof > 1 ? "them" : "it");
1300	new_draw_info (NDI_UNIQUE, 0, op, buf);
1301	}	1193	}
1302	}	1194	}
1303		1195
1304	if (QUERY_FLAG (tmp, FLAG_MONSTER))	1196	if (flag [FLAG_MONSTER])
1305	examine_monster (op, tmp);	1197	buf << describe_monster (who);
1306		1198
1307	/* Is this item buildable? */	1199	/* Is this item buildable? */
1308	if (QUERY_FLAG (tmp, FLAG_IS_BUILDABLE))	1200	if (flag [FLAG_IS_BUILDABLE])
1309	new_draw_info (NDI_UNIQUE, 0, op, "This is a buildable item.");	1201	buf << "This is a buildable item.\r";
1310		1202
1311	/* Does the object have a message? Don't show message for all object	1203	/* Does the object have a message? Don't show message for all object
1312	* types - especially if the first entry is a match	1204	* types - especially if the first entry is a match
1313	*/	1205	*/
1314	if (tmp->msg && tmp->type != EXIT && tmp->type != BOOK && tmp->type != CORPSE && !tmp->move_on && strncasecmp (tmp->msg, "@match", 7))	1206	if (msg && type != EXIT && type != BOOK && type != CORPSE && !move_on && !has_dialogue ())
1315	{	1207	{
1316
1317	/* This is just a hack so when identifying the items, we print	1208	/* This is just a hack so when identifying the items, we print
1318	* out the extra message	1209	* out the extra message
1319	*/	1210	*/
1320	if (need_identify (tmp) && QUERY_FLAG (tmp, FLAG_IDENTIFIED))	1211	if (need_identify (this) && flag [FLAG_IDENTIFIED])
1321	new_draw_info (NDI_UNIQUE, 0, op, "The object has a story:");	1212	buf << "The object has a story:\r";
1322		1213
1323	new_draw_info (NDI_UNIQUE, 0, op, tmp->msg);	1214	buf << msg << '\n';
1324	}
1325	new_draw_info (NDI_UNIQUE, 0, op, " "); /* Blank line */
1326	}
1327
1328	/*
1329	* inventory prints object's inventory. If inv==NULL then print player's
1330	* inventory.
1331	* [ Only items which are applied are showed. Tero.Haatanen@lut.fi ]
1332	*/
1333	void
1334	inventory (object *op, object *inv)
1335	{
1336	object *tmp;
1337	char *in;
1338	int items = 0, length;
1339
1340	if (inv == NULL && op == NULL)
1341	{	1215	}
1342	new_draw_info (NDI_UNIQUE, 0, op, "Inventory of what object?");
1343	return;
1344	}
1345	tmp = inv ? inv->inv : op->inv;
1346		1216
1347	while (tmp)	1217	buf << '\n';
1348	{	1218
1349	if ((!tmp->invisible &&	1219	return std::string (buf.linearise (), buf.size ());
1350	(inv == NULL || inv->type == CONTAINER || QUERY_FLAG (tmp, FLAG_APPLIED))) || (!op || QUERY_FLAG (op, FLAG_WIZ)))
1351	items++;
1352	tmp = tmp->below;
1353	}
1354	if (inv == NULL)
1355	{ /* player's inventory */
1356	if (items == 0)
1357	{
1358	new_draw_info (NDI_UNIQUE, 0, op, "You carry nothing.");
1359	return;
1360	}
1361	else
1362	{
1363	length = 28;
1364	in = "";
1365	if (op)
1366	clear_win_info (op);
1367	new_draw_info (NDI_UNIQUE, 0, op, "Inventory:");
1368	}
1369	}
1370	else
1371	{
1372	if (items == 0)
1373	return;
1374	else
1375	{
1376	length = 28;
1377	in = " ";
1378	}
1379	}
1380	for (tmp = inv ? inv->inv : op->inv; tmp; tmp = tmp->below)
1381	{
1382	if ((!op || !QUERY_FLAG (op, FLAG_WIZ)) && (tmp->invisible || (inv && inv->type != CONTAINER && !QUERY_FLAG (tmp, FLAG_APPLIED))))
1383	continue;
1384	if ((!op || QUERY_FLAG (op, FLAG_WIZ)))
1385	new_draw_info_format (NDI_UNIQUE, 0, op, "%s- %-*.*s (%5d) %-8s", in, length, length,
1386	query_name (tmp), tmp->count, query_weight (tmp));
1387	else
1388	new_draw_info_format (NDI_UNIQUE, 0, op, "%s- %-*.*s %-8s", in, length + 8, length + 8, query_name (tmp), query_weight (tmp));
1389	}
1390	if (!inv && op)
1391	{
1392	new_draw_info_format (NDI_UNIQUE, 0, op, "%-*s %-8s", 41, "Total weight :", query_weight (op));
1393	}
1394	}	1220	}
1395		1221
1396	static void	1222	static void
1397	display_new_pickup (object *op)	1223	display_new_pickup (object *op)
1398	{	1224	{
…		…
1559	new_draw_info (NDI_UNIQUE, 0, op, "Example: search magic+1");	1385	new_draw_info (NDI_UNIQUE, 0, op, "Example: search magic+1");
1560	new_draw_info (NDI_UNIQUE, 0, op, "Would automatically pick up all");	1386	new_draw_info (NDI_UNIQUE, 0, op, "Would automatically pick up all");
1561	new_draw_info (NDI_UNIQUE, 0, op, "items containing the word 'magic+1'.");	1387	new_draw_info (NDI_UNIQUE, 0, op, "items containing the word 'magic+1'.");
1562	return 1;	1388	return 1;
1563	}	1389	}
		1390
1564	op->contr->search_str[0] = '\0';	1391	op->contr->search_str[0] = '\0';
1565	new_draw_info (NDI_UNIQUE, 0, op, "Search mode turned off.");	1392	new_draw_info (NDI_UNIQUE, 0, op, "Search mode turned off.");
1566	op->update_stats ();	1393	op->update_stats ();
1567	return 1;	1394	return 1;
1568	}	1395	}
		1396
1569	if ((int) strlen (params) >= MAX_BUF)	1397	if ((int) strlen (params) >= MAX_BUF)
1570	{	1398	{
1571	new_draw_info (NDI_UNIQUE, 0, op, "Search string too long.");	1399	new_draw_info (NDI_UNIQUE, 0, op, "Search string too long.");
1572	return 1;	1400	return 1;
1573	}	1401	}
		1402
1574	strcpy (op->contr->search_str, params);	1403	strcpy (op->contr->search_str, params);
1575	sprintf (buf, "Searching for '%s'.", op->contr->search_str);	1404	sprintf (buf, "Searching for '%s'.", op->contr->search_str);
1576	new_draw_info (NDI_UNIQUE, 0, op, buf);	1405	new_draw_info (NDI_UNIQUE, 0, op, buf);
1577	op->update_stats ();	1406	op->update_stats ();
1578	return 1;	1407	return 1;

Diff Legend

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