[ViewVC] Diff of: cvs/deliantra/server/server/c

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

Diff Legend

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

Comparing deliantra/server/server/c_object.C (file contents): Revision 1.43 by root, Mon Apr 23 18:21:54 2007 UTC vs. Revision 1.134 by root, Sat Nov 17 23:40:03 2018 UTC

Diff Legend

Comparing deliantra/server/server/c_object.C (file contents):
Revision 1.43 by root, Mon Apr 23 18:21:54 2007 UTC vs.
Revision 1.134 by root, Sat Nov 17 23:40:03 2018 UTC