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.40 by pippijn, Fri Mar 2 12:14:57 2007 UTC vs.
Revision 1.89 by elmex, Mon Jan 12 00:17:23 2009 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 (©) 2005,2006,2007,2008,2009 Marc Alexander Lehmann / Robin Redeker / the Deliantra team
5	* Copyright (C) 2002 Mark Wedel & Crossfire Development Team	5	* Copyright (©) 2002,2007 Mark Wedel & Crossfire Development Team
6	* Copyright (C) 1992 Frank Tore Johansen	6	* Copyright (©) 1992,2007 Frank Tore Johansen
7	*	7	*
8	* This program is free software; you can redistribute it and/or modify	8	* Deliantra is free software: you can redistribute it and/or modify
9	* 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
10	* the Free Software Foundation; either version 2 of the License, or	10	* the Free Software Foundation, either version 3 of the License, or
11	* (at your option) any later version.	11	* (at your option) any later version.
12	*	12	*
13	* This program is distributed in the hope that it will be useful,	13	* This program is distributed in the hope that it will be useful,
14	* but WITHOUT ANY WARRANTY; without even the implied warranty of	14	* but WITHOUT ANY WARRANTY; without even the implied warranty of
15	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the	15	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16	* GNU General Public License for more details.	16	* GNU General Public License for more details.
17	*	17	*
18	* You should have received a copy of the GNU General Public License	18	* You should have received a copy of the GNU General Public License
19	* along with this program; if not, write to the Free Software	19	* along with this program. If not, see <http://www.gnu.org/licenses/>.
20	* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
21	*	20	*
22	* The author can be reached via e-mail to <crossfire@schmorp.de>	21	* The authors can be reached via e-mail to <support@deliantra.net>
23	*
24	*/	22	*/
25		23
26	/*	24	/*
27	* Object (handling) commands	25	* Object (handling) commands
28	*/	26	*/
…		…
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) && (QUERY_FLAG (tmp, FLAG_APPLIED)))
73	continue;	74	continue;
		75
74	if ((aflag == AP_UNAPPLY) && (!QUERY_FLAG (tmp, FLAG_APPLIED)))	76	if ((aflag == AP_UNAPPLY) && (!QUERY_FLAG (tmp, 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 skill %s", params);
118	return 0;	143	return 0;
119	}	144	}
120	return change_skill (pl, skill, 0);
121	}
122		145
123		146	pl->change_skill (0);
124	/* These functions (command_search, command_disarm) are really just wrappers for	147	apply_special (pl, skill, AP_APPLY);
125	* things like 'use_skill ...'). In fact, they should really be obsoleted	148	return 1;
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	}	149	}
133
134	int
135	command_disarm (object *op, char *params)
136	{
137	return use_skill (op, skill_names[SK_DISARM_TRAPS]);
138	}
139
140		150
141	/* A little special because we do want to pass the full params along	151	/* A little special because we do want to pass the full params along
142	* as it includes the object to throw.	152	* as it includes the object to throw.
143	*/	153	*/
144	int	154	int
145	command_throw (object *op, char *params)	155	command_throw (object *op, char *params)
146	{	156	{
147	object *skop;
148
149	skop = find_skill_by_name (op, skill_names[SK_THROWING]);	157	if (object *skop = find_skill_by_name (op, skill_names[SK_THROWING]))
150	if (skop)
151	return do_skill (op, op, skop, op->facing, params);	158	return do_skill (op, op, skop, op->facing, params);
152	else	159	else
153	{
154	new_draw_info (NDI_UNIQUE, 0, op, "You have no knowledge of the skill throwing.");	160	new_draw_info (NDI_UNIQUE, 0, op, "You have no knowledge of the skill throwing.");
155	}	161
156	return 0;	162	return 0;
157	}	163	}
158
159		164
160	int	165	int
161	command_apply (object *op, char *params)	166	command_apply (object *op, char *params)
162	{	167	{
163	if (!params)	168	if (!params)
…		…
165	player_apply_below (op);	170	player_apply_below (op);
166	return 0;	171	return 0;
167	}	172	}
168	else	173	else
169	{	174	{
170	apply_flag aflag = (apply_flag) 0;	175	apply_flag aflag = (apply_flag)0;
171	object *inv;
172		176
173	while (*params == ' ')	177	while (*params == ' ')
174	params++;	178	params++;
		179
175	if (!strncmp (params, "-a ", 3))	180	if (!strncmp (params, "-a ", 3))
176	{	181	{
177	aflag = AP_APPLY;	182	aflag = AP_APPLY;
178	params += 3;	183	params += 3;
179	}	184	}
		185
180	if (!strncmp (params, "-u ", 3))	186	if (!strncmp (params, "-u ", 3))
181	{	187	{
182	aflag = AP_UNAPPLY;	188	aflag = AP_UNAPPLY;
183	params += 3;	189	params += 3;
184	}	190	}
		191
185	while (*params == ' ')	192	while (*params == ' ')
186	params++;	193	params++;
187		194
188	inv = find_best_apply_object_match (op, params, aflag);	195	if (object *inv = find_best_apply_object_match (op, params, aflag))
189	if (inv)
190	{
191	player_apply (op, inv, aflag, 0);	196	player_apply (op, inv, aflag, 0);
192	}
193	else	197	else
194	new_draw_info_format (NDI_UNIQUE, 0, op, "Could not find any match to the %s.", params);	198	new_draw_info_format (NDI_UNIQUE, 0, op, "Could not find any match to the %s.", params);
195	}	199	}
		200
196	return 0;	201	return 0;
197	}	202	}
198		203
199	/*	204	/*
200	* Check if an item op can be put into a sack. If pl exists then tell	205	* 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.	211	* not need to use split_ob and stuff.
207	*/	212	*/
208	int	213	int
209	sack_can_hold (object *pl, object *sack, object *op, uint32 nrof)	214	sack_can_hold (object *pl, object *sack, object *op, uint32 nrof)
210	{	215	{
211
212	if (!QUERY_FLAG (sack, FLAG_APPLIED))	216	if (!QUERY_FLAG (sack, FLAG_APPLIED))
213	{	217	{
214	new_draw_info_format (NDI_UNIQUE, 0, pl, "The %s is not active.", query_name (sack));	218	new_draw_info_format (NDI_UNIQUE, 0, pl, "The %s is not active.", query_name (sack));
215	return 0;	219	return 0;
216	}	220	}
		221
217	if (sack == op)	222	if (sack == op)
218	{	223	{
219	new_draw_info_format (NDI_UNIQUE, 0, pl, "You can't put the %s into itself.", query_name (sack));	224	new_draw_info_format (NDI_UNIQUE, 0, pl, "You can't put the %s into itself.", query_name (sack));
220	return 0;	225	return 0;
221	}	226	}
		227
222	if (sack->race && (sack->race != op->race || op->type == CONTAINER || (sack->stats.food && sack->stats.food != op->type)))	228	if (sack->race && (sack->race != op->race || op->type == CONTAINER || (sack->stats.food && sack->stats.food != op->type)))
223	{	229	{
224	new_draw_info_format (NDI_UNIQUE, 0, pl, "You can put only %s into the %s.", &sack->race, query_name (sack));	230	new_draw_info_format (NDI_UNIQUE, 0, pl, "You can put only %s into the %s.", &sack->race, query_name (sack));
225	return 0;	231	return 0;
226	}	232	}
		233
227	if (op->type == SPECIAL_KEY && sack->slaying && op->slaying)	234	if (op->type == SPECIAL_KEY && sack->slaying && op->slaying)
228	{	235	{
229	new_draw_info_format (NDI_UNIQUE, 0, pl, "You can't put the key into %s.", query_name (sack));	236	new_draw_info_format (NDI_UNIQUE, 0, pl, "You can't put the key into %s.", query_name (sack));
230	return 0;	237	return 0;
231	}	238	}
		239
232	if (sack->weight_limit && (sint32) (sack->carrying + (nrof ? nrof : 1) *	240	if (sack->weight_limit && (sint32) (sack->carrying + (nrof ? nrof : 1) *
233	(op->weight + (op->type == CONTAINER ? (op->carrying * op->stats.Str) : 0))	241	(op->weight + (op->type == CONTAINER ? (op->carrying * op->stats.Str) : 0))
234	* (100 - sack->stats.Str) / 100) > sack->weight_limit)	242	* (100 - sack->stats.Str) / 100) > sack->weight_limit)
235	{	243	{
236	new_draw_info_format (NDI_UNIQUE, 0, pl, "That won't fit in the %s!", query_name (sack));	244	new_draw_info_format (NDI_UNIQUE, 0, pl, "That won't fit in the %s!", query_name (sack));
237	return 0;	245	return 0;
238	}	246	}
		247
239	/* All other checks pass, must be OK */	248	/* All other checks pass, must be OK */
240	return 1;	249	return 1;
241	}	250	}
242		251
243	/* Pick up commands follow */	252	/* Pick up commands follow */
…		…
248	* pick up (0 means all of them)	257	* pick up (0 means all of them)
249	*/	258	*/
250	static void	259	static void
251	pick_up_object (object *pl, object *op, object *tmp, int nrof)	260	pick_up_object (object *pl, object *op, object *tmp, int nrof)
252	{	261	{
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;	262	object *env = tmp->env;
258	uint32 weight, effective_weight_limit;	263	uint32 weight, effective_weight_limit;
259	int tmp_nrof = tmp->nrof ? tmp->nrof : 1;	264	int tmp_nrof = tmp->number_of ();
260		265
261	/* IF the player is flying & trying to take the item out of a container	266	/* 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	267	* 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	268	* (sack, luggage, etc), tmp->env->env then points to the player (nested
264	* containers not allowed as of now)	269	* containers not allowed as of now)
265	*/	270	*/
266	if ((pl->move_type & MOVE_FLYING) && !QUERY_FLAG (pl, FLAG_WIZ) && tmp->in_player () != pl)	271	if ((pl->move_type & MOVE_FLYING) && !QUERY_FLAG (pl, FLAG_WIZ) && tmp->in_player () != pl)
267	{	272	{
268	new_draw_info (NDI_UNIQUE, 0, pl, "You are levitating, you can't reach the ground!");	273	pl->failmsg ("You are levitating, you can't reach the ground! "
		274	"H<You have to stop levitating first, if you can, either by using your levitation skill, "
		275	"or waiting till the levitation effect wears off.>");
269	return;	276	return;
270	}	277	}
271		278
272	if (QUERY_FLAG (tmp, FLAG_NO_DROP))	279	if (QUERY_FLAG (tmp, FLAG_NO_DROP))
273	return;	280	return;
274		281
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)	282	if (nrof > tmp_nrof || nrof <= 0)
288	nrof = tmp_nrof;	283	nrof = tmp_nrof;
289		284
290	/* Figure out how much weight this object will add to the player */	285	/* Figure out how much weight this object will add to the player */
291	weight = tmp->weight * nrof;	286	weight = tmp->weight * nrof;
292	if (tmp->inv)	287	if (tmp->inv)
293	weight += tmp->carrying * (100 - tmp->stats.Str) / 100;	288	weight += tmp->carrying * (100 - tmp->stats.Str) / 100;
294		289
295	if (pl->stats.Str <= MAX_STAT)
296	effective_weight_limit = weight_limit[pl->stats.Str];	290	effective_weight_limit = weight_limit [min (MAX_STAT, pl->stats.Str)];
297	else
298	effective_weight_limit = weight_limit[MAX_STAT];
299		291
300	if ((pl->weight + pl->carrying + weight) > effective_weight_limit)	292	if ((pl->weight + pl->carrying + weight) > effective_weight_limit)
301	{	293	{
302	new_draw_info (0, 0, pl, "That item is too heavy for you to pick up.");	294	new_draw_info (0, 0, pl, "That item is too heavy for you to pick up.");
303	return;	295	return;
304	}	296	}
305		297
306	if (nrof != tmp_nrof)	298	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;	299	return;
315	}
316		300
317	/* Tell the client what happened to the rest of objects */	301	if (QUERY_FLAG (tmp, FLAG_UNPAID))
318	if (pl->contr)	302	{
319	if (tmp2->destroyed ())	303	tmp->flag.reset (FLAG_UNPAID);
320	esrv_del_item (pl->contr, tmp2->count);	304	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	305	tmp->flag.set (FLAG_UNPAID);
322	esrv_update_item (UPD_NROF, pl, tmp2);
323	}	306	}
324	else	307	else
325	{	308	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		309
335	tmp->remove (); /* Unlink it */	310	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	}	311	}
369		312
370	/* modified slightly to allow monsters use this -b.t. 5-31-95 */	313	/* modified slightly to allow monsters use this -b.t. 5-31-95 */
371	void	314	void
372	pick_up (object *op, object *alt)	315	pick_up (object *op, object *alt)
…		…
382	if (!can_pick (op, alt))	325	if (!can_pick (op, alt))
383	{	326	{
384	new_draw_info_format (NDI_UNIQUE, 0, op, "You can't pick up the %s.", &alt->name);	327	new_draw_info_format (NDI_UNIQUE, 0, op, "You can't pick up the %s.", &alt->name);
385	goto leave;	328	goto leave;
386	}	329	}
		330
387	tmp = alt;	331	tmp = alt;
388	}	332	}
389	else	333	else
390	{	334	{
391	if (op->below == NULL || !can_pick (op, op->below))	335	if (op->below == NULL || !can_pick (op, op->below))
…		…
400	/* Try to catch it. */	344	/* Try to catch it. */
401	tmp_map = tmp->map;	345	tmp_map = tmp->map;
402	tmp = stop_item (tmp);	346	tmp = stop_item (tmp);
403	if (tmp == NULL)	347	if (tmp == NULL)
404	goto leave;	348	goto leave;
		349
405	need_fix_tmp = 1;	350	need_fix_tmp = 1;
406	if (!can_pick (op, tmp))	351	if (!can_pick (op, tmp))
407	goto leave;	352	goto leave;
408		353
409	if (op->type == PLAYER)	354	if (op->type == PLAYER)
…		…
414	}	359	}
415	else	360	else
416	count = tmp->nrof;	361	count = tmp->nrof;
417		362
418	/* container is open, so use it */	363	/* container is open, so use it */
		364	if (tmp->flag [FLAG_STARTEQUIP])
		365	alt = op;
419	if (op->container)	366	else if (op->container)
420	{	367	{
421	alt = op->container;	368	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	}
…		…
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: */
…		…
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;
506		454
		455	int cnt = MAX_ITEM_PER_DROP;
		456
507	while (tmp)	457	while (tmp)
508	{	458	{
509	next = tmp->below;	459	next = tmp->below;
510		460
511	if (tmp->invisible)	461	if (tmp->invisible)
…		…
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)
…		…
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;	537	sack2 = tmp;
…		…
584	for (tmp2 = tmp->inv; tmp2; tmp2 = tmp)	540	for (tmp2 = tmp->inv; tmp2; tmp2 = tmp)
585	{	541	{
586	tmp = tmp2->below;	542	tmp = tmp2->below;
587		543
588	if ((sack->type == CONTAINER && sack_can_hold (op, op->container, tmp2, tmp2->nrof)))	544	if ((sack->type == CONTAINER && sack_can_hold (op, op->container, tmp2, tmp2->nrof)))
589	{
590	put_object_in_sack (op, sack, tmp2, 0);	545	put_object_in_sack (op, sack, tmp2, 0);
591	}
592	else	546	else
593	{	547	{
594	sprintf (buf, "Your %s fills up.", query_name (sack));	548	sprintf (buf, "Your %s fills up.", query_name (sack));
595	new_draw_info (NDI_UNIQUE, 0, op, buf);	549	new_draw_info (NDI_UNIQUE, 0, op, buf);
596	break;	550	break;
597	}	551	}
598	}	552	}
599		553
600	esrv_update_item (UPD_WEIGHT, op, sack2);
601	return;	554	return;
602	}	555	}
603		556
604	/* Don't worry about this for containers - our caller should have	557	/* Don't worry about this for containers - our caller should have
605	* already checked this.	558	* already checked this.
…		…
610	if (QUERY_FLAG (tmp, FLAG_APPLIED))	563	if (QUERY_FLAG (tmp, FLAG_APPLIED))
611	if (apply_special (op, tmp, AP_UNAPPLY | AP_NO_MERGE))	564	if (apply_special (op, tmp, AP_UNAPPLY | AP_NO_MERGE))
612	return;	565	return;
613		566
614	/* we want to put some portion of the item into the container */	567	/* we want to put some portion of the item into the container */
615	if (nrof && tmp->nrof != nrof)	568	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;	569	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		570
635	new_draw_info_format (NDI_UNIQUE, 0, op, "You put the %s in %s.", query_name (tmp), query_name (sack));	571	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);	572	sack->insert (tmp);
637	op->update_stats (); /* This is overkill, fix_player() is called somewhere */
638	/* in object.c */
639
640	/* If an object merged (and thus, different object), we need to
641	* delete the original.
642	*/
643	if (tmp2 != tmp)
644	esrv_del_item (op->contr, tmp->count);
645
646	esrv_send_item (op, tmp2);
647
648	/* update the sacks weight */
649	esrv_update_item (UPD_WEIGHT, op, sack);
650	}	573	}
651		574
652	/*	575	/*
653	* This function was part of drop, now is own function.	576	* This function was part of drop, now is own function.
654	* Player 'op' tries to drop object 'tmp', if tmp is non zero, then	577	* Player 'op' tries to drop object 'tmp', if tmp is non zero, then
…		…
656	* This is used when dropping objects onto the floor.	579	* This is used when dropping objects onto the floor.
657	*/	580	*/
658	void	581	void
659	drop_object (object *op, object *tmp, uint32 nrof)	582	drop_object (object *op, object *tmp, uint32 nrof)
660	{	583	{
661	char buf[MAX_BUF];
662	object *floor;
663
664	if (QUERY_FLAG (tmp, FLAG_NO_DROP))	584	if (QUERY_FLAG (tmp, FLAG_NO_DROP))
665	return;	585	return;
666		586
667	if (QUERY_FLAG (tmp, FLAG_APPLIED))	587	if (QUERY_FLAG (tmp, FLAG_APPLIED))
668	if (apply_special (op, tmp, AP_UNAPPLY | AP_NO_MERGE))	588	if (apply_special (op, tmp, AP_UNAPPLY | AP_NO_MERGE))
…		…
671	//fprintf (stderr, "ui, on space is %ld\n", op->ms ().volume ());//D	591	//fprintf (stderr, "ui, on space is %ld\n", op->ms ().volume ());//D
672		592
673	/* We are only dropping some of the items. We split the current object	593	/* We are only dropping some of the items. We split the current object
674	* off	594	* off
675	*/	595	*/
676	if (nrof && tmp->nrof != nrof)	596	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;	597	return;
702		598
		599	drop_object (op, tmp);
		600
		601	if (!tmp->destroyed () && !tmp->is_inserted ())
		602	{
		603	// if nothing happened with the object we give it back
		604	op->insert (tmp);
		605	}
		606	}
		607
		608	/* In contrast to drop_object (op, tmp, nrof) above this function takes the
		609	* already split off object, and feeds it to the event handlers and does
		610	* other magic with it.
		611	*
		612	* <droppper> is the object that dropped this object and <obj> is the
		613	* object that was dropped.
		614	*
		615	* Make sure to check what happened with <obj> after this function returns!
		616	* Otherwise you may leak this object.
		617	*/
		618
		619	void
		620	drop_object (object *dropper, object *obj)
		621	{
		622	if (INVOKE_OBJECT (DROP, obj, ARG_OBJECT (dropper)))
		623	return;
		624
		625	if (obj->destroyed () || obj->is_inserted ())
		626	return;
		627
703	if (QUERY_FLAG (tmp, FLAG_STARTEQUIP))	628	if (QUERY_FLAG (obj, FLAG_STARTEQUIP))
704	{	629	{
705	sprintf (buf, "You drop the %s.", query_name (tmp));	630	dropper->statusmsg (format ("You drop the %s.", query_name (obj)));
706	new_draw_info (NDI_UNIQUE, 0, op, buf);	631	dropper->statusmsg ("The god who lent it to you retrieves it.");
707	new_draw_info (NDI_UNIQUE, 0, op, "The gods who lent it to you retrieves it.");
708		632
709	if (op->type == PLAYER)
710	esrv_del_item (op->contr, tmp->count);
711
712	tmp->destroy ();	633	obj->destroy ();
713	op->update_stats ();	634	dropper->update_stats ();
714	return;	635	return;
715	}	636	}
716		637
717	if (op->type == PLAYER)	638	for (object *floor = GET_MAP_OB (dropper->map, dropper->x, dropper->y);
718	esrv_del_item (op->contr, tmp->count);	639	floor;
		640	floor = floor->above)
		641	if (INVOKE_OBJECT (DROP_ON, floor, ARG_OBJECT (obj), ARG_OBJECT (dropper)))
		642	return;
719		643
720	/* Call this before we update the various windows/players. At least	644	if (obj->destroyed () || obj->is_inserted ())
721	* that we, we know the weight is correct.	645	return;
		646
		647	if (is_in_shop (dropper) && !QUERY_FLAG (obj, FLAG_UNPAID) && obj->type != MONEY)
		648	if (!sell_item (obj, dropper))
		649	return;
		650
		651	/* If nothing special happened with this object, the default action is to
		652	* insert it below the dropper:
722	*/	653	*/
723	op->update_stats (); /* This is overkill, fix_player() is called somewhere */
724	/* in object.c */
725		654
726	if (op->type == PLAYER)	655	obj->x = dropper->x;
727	{	656	obj->y = dropper->y;
728	/* Need to update the weight for the player */
729	esrv_send_item (op, op);
730	op->contr->ns->floorbox_update ();
731	}
732		657
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);	658	insert_ob_in_map (obj, dropper->map, dropper, INS_BELOW_ORIGINATOR);
744	}	659	}
745		660
746	void	661	void
747	drop (object *op, object *tmp)	662	drop (object *op, object *tmp)
748	{	663	{
…		…
757	if (tmp->env && tmp->env->type != PLAYER)	672	if (tmp->env && tmp->env->type != PLAYER)
758	{	673	{
759	/* Just toss the object - probably shouldn't be hanging	674	/* Just toss the object - probably shouldn't be hanging
760	* around anyways	675	* around anyways
761	*/	676	*/
762	tmp->remove ();
763	tmp->destroy ();	677	tmp->destroy ();
764	return;	678	return;
765	}	679	}
766	else	680	else
767	{	681	{
768	while (tmp != NULL && tmp->invisible)	682	while (tmp && tmp->invisible)
769	tmp = tmp->below;	683	tmp = tmp->below;
770	}	684	}
771	}	685	}
772		686
773	if (tmp == NULL)	687	if (tmp == NULL)
774	{	688	{
775	new_draw_info (NDI_UNIQUE, 0, op, "You don't have anything to drop.");	689	new_draw_info (NDI_UNIQUE, 0, op, "You don't have anything to drop.");
776	return;	690	return;
777	}	691	}
		692
778	if (QUERY_FLAG (tmp, FLAG_INV_LOCKED))	693	if (QUERY_FLAG (tmp, FLAG_INV_LOCKED))
779	{	694	{
780	new_draw_info (NDI_UNIQUE, 0, op, "This item is locked");	695	new_draw_info (NDI_UNIQUE, 0, op, "This item is locked");
781	return;	696	return;
782	}	697	}
		698
783	if (QUERY_FLAG (tmp, FLAG_NO_DROP))	699	if (QUERY_FLAG (tmp, FLAG_NO_DROP))
784	{	700	{
785	#if 0	701	#if 0
786	/* Eneq(@csd.uu.se): Objects with NO_DROP defined can't be dropped. */	702	/* 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.");	703	new_draw_info (NDI_UNIQUE, 0, op, "This item can't be dropped.");
…		…
811		727
812	if (op->type == PLAYER)	728	if (op->type == PLAYER)
813	op->contr->count = 0;	729	op->contr->count = 0;
814	}	730	}
815		731
816
817
818	/* Command will drop all items that have not been locked */	732	/* Command will drop all items that have not been locked */
819	int	733	int
820	command_dropall (object *op, char *params)	734	command_dropall (object *op, char *params)
821	{	735	{
822		736
823	object *curinv, *nextinv;
824
825	if (op->inv == NULL)	737	if (op->inv == NULL)
826	{	738	{
827	new_draw_info (NDI_UNIQUE, 0, op, "Nothing to drop!");	739	new_draw_info (NDI_UNIQUE, 0, op, "Nothing to drop!");
828	return 0;	740	return 0;
829	}	741	}
830		742
831	curinv = op->inv;	743	object *curinv = op->inv;
		744	object *nextinv;
832		745
833	/*	746	/*
834	This is the default. Drops everything not locked or considered	747	This is the default. Drops everything not locked or considered
835	not something that should be dropped.	748	not something that should be dropped.
836	*/	749	*/
…		…
838	Care must be taken that the next item pointer is not to money as	751	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	752	the drop() routine will do unknown things to it when dropping
840	in a shop. --Tero.Pelander@utu.fi	753	in a shop. --Tero.Pelander@utu.fi
841	*/	754	*/
842		755
843	if (params == NULL)	756	int cnt = MAX_ITEM_PER_DROP;
		757
		758	if (!params)
844	{	759	{
845	while (curinv != NULL)	760	while (curinv)
846	{	761	{
847	nextinv = curinv->below;	762	nextinv = curinv->below;
		763
848	while (nextinv && nextinv->type == MONEY)	764	while (nextinv && nextinv->type == MONEY)
849	nextinv = nextinv->below;	765	nextinv = nextinv->below;
		766
850	if (!QUERY_FLAG (curinv, FLAG_INV_LOCKED) && curinv->type != MONEY &&	767	if (!QUERY_FLAG (curinv, FLAG_INV_LOCKED) && curinv->type != MONEY &&
851	curinv->type != FOOD && curinv->type != KEY &&	768	curinv->type != FOOD && curinv->type != KEY &&
852	curinv->type != SPECIAL_KEY && curinv->type != GEM &&	769	curinv->type != SPECIAL_KEY && curinv->type != GEM &&
853	!curinv->invisible && (curinv->type != CONTAINER || op->container != curinv))	770	!curinv->invisible && (curinv->type != CONTAINER || op->container != curinv))
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 (!QUERY_FLAG (curinv, 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 (!QUERY_FLAG (curinv, 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;
		823
898	if (!QUERY_FLAG (curinv, FLAG_INV_LOCKED) && !QUERY_FLAG (curinv, FLAG_APPLIED))	824	if (!QUERY_FLAG (curinv, FLAG_INV_LOCKED) && !QUERY_FLAG (curinv, FLAG_APPLIED))
899	{	825	{
900	switch (curinv->type)	826	switch (curinv->type)
901	{	827	{
902	case HORN:	828	case HORN:
…		…
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;
		864	}
		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	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;
934	}	889	}
935		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;	898	int did_one = 0;
…		…
948	new_draw_info (NDI_UNIQUE, 0, op, "Drop what?");	902	new_draw_info (NDI_UNIQUE, 0, op, "Drop what?");
949	return 0;	903	return 0;
950	}	904	}
951	else	905	else
952	{	906	{
		907	vector<object *> matched_objs;
		908
953	for (tmp = op->inv; tmp; tmp = next)	909	for (tmp = op->inv; tmp; tmp = next)
954	{	910	{
955	next = tmp->below;	911	next = tmp->below;
956	if (QUERY_FLAG (tmp, FLAG_NO_DROP) || tmp->invisible)	912	if (QUERY_FLAG (tmp, FLAG_NO_DROP) || tmp->invisible)
957	continue;	913	continue;
		914
958	if (item_matched_string (op, tmp, params))	915	if (item_matched_string (op, tmp, params))
959	{	916	matched_objs.push_back (tmp);
960	drop (op, tmp);
961	did_one = 1;
962	}	917	}
963	}	918
964	if (!did_one)	919	int cnt = MAX_ITEM_PER_DROP;
		920
		921	if (!drop_vector (op, matched_objs, &cnt))
965	new_draw_info (NDI_UNIQUE, 0, op, "Nothing to drop.");	922	new_draw_info (NDI_UNIQUE, 0, op, "Nothing to drop.");
966	}	923
967	if (op->type == PLAYER)	924	if (cnt <= 0)
968	{	925	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	};	926	}
972		927
973	/* draw_look(op);*/
974	return 0;	928	return 0;
975	}	929	}
976		930
977	int	931	int
978	command_examine (object *op, char *params)	932	command_examine (object *op, char *params)
…		…
981	{	935	{
982	object *tmp = op->below;	936	object *tmp = op->below;
983		937
984	while (tmp && !tmp->client_visible ())	938	while (tmp && !tmp->client_visible ())
985	tmp = tmp->below;	939	tmp = tmp->below;
		940
986	if (tmp)	941	if (tmp)
987	examine (op, tmp);	942	examine (op, tmp);
988	}	943	}
989	else	944	else
990	{	945	{
991	object *tmp = find_best_object_match (op, params);	946	object *tmp = find_best_object_match (op, params);
992		947
993	if (tmp)	948	if (tmp)
994	examine (op, tmp);	949	examine (op, tmp);
995	else	950	else
996	new_draw_info_format (NDI_UNIQUE, 0, op, "Could not find an object that matches %s", params);	951	op->contr->infobox (MSG_CHANNEL ("examine"), format ("Could not find an object that matches %s", params));
997	}	952	}
		953
998	return 0;	954	return 0;
999	}	955	}
1000		956
1001	/* op should be a player.	957	/* op should be a player.
1002	* we return the object the player has marked with the 'mark' command	958	* we return the object the player has marked with the 'mark' command
…		…
1041	}	997	}
1042		998
1043	return 0;	999	return 0;
1044	}	1000	}
1045		1001
1046	/* op is the player	1002	std::string
1047	* tmp is the monster being examined.	1003	object::describe_monster (object *who)
1048	*/
1049	void
1050	examine_monster (object *op, object *tmp)
1051	{	1004	{
		1005	dynbuf_text buf (512, 512);
		1006
1052	object *mon = tmp->head ? tmp->head : tmp;	1007	object *mon = head ? head : this;
1053		1008
1054	if (QUERY_FLAG (mon, FLAG_UNDEAD))	1009	if (QUERY_FLAG (mon, FLAG_UNDEAD))
1055	new_draw_info (NDI_UNIQUE, 0, op, "It is an undead force.");	1010	buf << "It is an undead force.\r";
		1011
1056	if (mon->level > op->level)	1012	if (mon->level > who->level)
1057	new_draw_info (NDI_UNIQUE, 0, op, "It is likely more powerful than you.");	1013	buf << "It is likely more powerful than you.\r";
1058	else if (mon->level < op->level)	1014	else if (mon->level < who->level)
1059	new_draw_info (NDI_UNIQUE, 0, op, "It is likely less powerful than you.");	1015	buf << "It is likely less powerful than you.\r";
1060	else	1016	else
1061	new_draw_info (NDI_UNIQUE, 0, op, "It is probably as powerful as you.");	1017	buf << "It is probably as powerful as you.\r";
		1018
1062	if (mon->attacktype & AT_ACID)	1019	if (mon->attacktype & AT_ACID)
1063	new_draw_info (NDI_UNIQUE, 0, op, "You seem to smell an acrid odor.");	1020	buf << "You seem to smell an acrid odor.\r";
1064		1021
1065	/* Anyone know why this used to use the clone value instead of the	1022	/* Anyone know why this used to use the clone value instead of the
1066	* maxhp field? This seems that it should give more accurate results.	1023	* maxhp field? This seems that it should give more accurate results.
1067	*/	1024	*/
1068	switch ((mon->stats.hp + 1) * 4 / (mon->stats.maxhp + 1))	1025	switch ((mon->stats.hp + 1) * 4 / (mon->stats.maxhp + 1))
1069	{ /* From 1-4 */	1026	{ /* From 1-4 */
1070	case 1:	1027	case 1:
1071	new_draw_info (NDI_UNIQUE, 0, op, "It is in a bad shape.");	1028	buf << "It is in a bad shape.\r";
1072	break;	1029	break;
1073	case 2:	1030	case 2:
1074	new_draw_info (NDI_UNIQUE, 0, op, "It is hurt.");	1031	buf << "It is hurt.\r";
1075	break;	1032	break;
1076	case 3:	1033	case 3:
1077	new_draw_info (NDI_UNIQUE, 0, op, "It is somewhat hurt.");	1034	buf << "It is somewhat hurt.\r";
1078	break;	1035	break;
1079	case 4:	1036	case 4:
1080	new_draw_info (NDI_UNIQUE, 0, op, "It is in excellent shape.");	1037	buf << "It is in excellent shape.\r";
1081	break;	1038	break;
1082	}	1039	}
		1040
1083	if (present_in_ob (POISONING, mon) != NULL)	1041	if (present_in_ob (POISONING, mon))
1084	new_draw_info (NDI_UNIQUE, 0, op, "It looks very ill.");	1042	buf << "It looks very ill.\r";
1085	}
1086		1043
		1044	buf << '\n';
		1045
		1046	return buf;
		1047	}
1087		1048
1088	/* tmp is the object being described, pl is who is examing it. */	1049	/* tmp is the object being described, pl is who is examing it. */
1089	char *	1050	const char *
1090	long_desc (object *tmp, object *pl)	1051	long_desc (object *tmp, object *pl)
1091	{	1052	{
1092	static char buf[VERY_BIG_BUF];	1053	static std::string s;
1093	char *cp;
1094		1054
1095	if (tmp == NULL)	1055	return (s = tmp->long_desc (pl)).c_str ();
1096	return "";	1056	}
1097		1057
1098	buf[0] = '\0';	1058	std::string
		1059	object::long_desc (object *who)
		1060	{
		1061	std::string buf (query_name ());
		1062
1099	switch (tmp->type)	1063	switch (type)
1100	{	1064	{
1101	case RING:	1065	case RING:
1102	case SKILL:	1066	case SKILL:
1103	case WEAPON:	1067	case WEAPON:
1104	case ARMOUR:	1068	case ARMOUR:
…		…
1114	case CLOAK:	1078	case CLOAK:
1115	case FOOD:	1079	case FOOD:
1116	case DRINK:	1080	case DRINK:
1117	case FLESH:	1081	case FLESH:
1118	case SKILL_TOOL:	1082	case SKILL_TOOL:
		1083	case LAMP:
1119	case POWER_CRYSTAL:	1084	case POWER_CRYSTAL:
1120	if (*(cp = describe_item (tmp, pl)) != '\0')	1085	{
		1086	const char *cp = ::describe_item (this, who);
		1087
		1088	if (*cp)
		1089	{
		1090	buf.append (" ");
		1091	buf.append (cp);
		1092	}
		1093	}
		1094	}
		1095
		1096	return buf;
		1097	}
		1098
		1099	/* op is the player
		1100	* tmp is the monster being examined.
		1101	*/
		1102	void
		1103	examine_monster (object *op, object *tmp)
		1104	{
		1105	new_draw_info (NDI_UNIQUE, 0, op, tmp->describe_monster (op).c_str ());
		1106	}
		1107
		1108	std::string
		1109	object::describe (object *who)
		1110	{
		1111	dynbuf_text buf (1024, 1024);
		1112
		1113	buf.printf ("That is: %s.\r", long_desc (who).c_str ());
		1114
		1115	if (custom_name)
		1116	buf.printf ("You call it %s.\r", &custom_name);
		1117
		1118	switch (type)
		1119	{
		1120	case SPELLBOOK:
		1121	if (flag [FLAG_IDENTIFIED] && inv)
		1122	buf.printf ("%s is a level %s %s spell.\r", &inv->name, get_levelnumber (inv->level), &inv->skill);
		1123	break;
		1124
		1125	case BOOK:
		1126	if (msg)
		1127	buf << "Something is written in it.\r";
		1128	break;
		1129
		1130	case CONTAINER:
		1131	if (race)
1121	{	1132	{
		1133	if (weight_limit && stats.Str < 100)
		1134	buf.printf ("It can hold only %s and its weight limit is %.1f kg.\r",
		1135	&race, weight_limit / (10.0 * (100 - stats.Str)));
1122	int len;	1136	else
1123		1137	buf.printf ("It can hold only %s.\r", &race);
1124	assign (buf, query_name (tmp));
1125	len = strlen (buf);
1126	if (len < VERY_BIG_BUF - 5)
1127	{
1128	/* Since we know the length, we save a few cpu cycles by using
1129	* it instead of calling strcat */
1130	strcpy (buf + len, " ");
1131	len++;
1132	assign (buf + len, cp, VERY_BIG_BUF - len - 1);
1133	}
1134	}	1138	}
1135	}	1139	else if (weight_limit && stats.Str < 100)
1136		1140	buf.printf ("Its weight limit is %.1f kg.\r", weight_limit / (10.0 * (100 - stats.Str)));
1137	if (buf[0] == '\0')
1138	assign (buf, query_name (tmp));
1139
1140	return buf;
1141	}
1142
1143	void
1144	examine (object *op, object *tmp)
1145	{
1146	char buf[VERY_BIG_BUF];
1147	int i;
1148
1149	if (tmp == NULL || tmp->type == CLOSE_CON)
1150	return;
1151
1152	strcpy (buf, "That is ");
1153	strncat (buf, long_desc (tmp, op), VERY_BIG_BUF - strlen (buf) - 1);
1154	buf[VERY_BIG_BUF - 1] = 0;
1155
1156	new_draw_info (NDI_UNIQUE, 0, op, buf);
1157	buf[0] = '\0';
1158
1159	if (tmp->custom_name)
1160	{
1161	strcpy (buf, "You call it ");
1162	strncat (buf, tmp->custom_name, VERY_BIG_BUF - strlen (buf) - 1);
1163	buf[VERY_BIG_BUF - 1] = 0;
1164	new_draw_info (NDI_UNIQUE, 0, op, buf);
1165	buf[0] = '\0';
1166	}
1167
1168	switch (tmp->type)
1169	{
1170	case SPELLBOOK:
1171	if (QUERY_FLAG (tmp, FLAG_IDENTIFIED) && tmp->inv)
1172	{
1173	sprintf (buf, "%s is a %s level %s spell", &tmp->inv->name, get_levelnumber (tmp->inv->level), &tmp->inv->skill);
1174	}
1175	break;	1141	break;
1176		1142
1177	case BOOK:	1143	case WAND:
1178	if (tmp->msg != NULL)	1144	if (flag [FLAG_IDENTIFIED])
1179	strcpy (buf, "Something is written in it.");	1145	buf.printf ("It has %d charges left.\r", stats.food);
1180	break;	1146	break;
1181
1182	case CONTAINER:
1183	if (tmp->race != NULL)
1184	{
1185	if (tmp->weight_limit && tmp->stats.Str < 100)
1186	sprintf (buf, "It can hold only %s and its weight limit is %.1f kg.",
1187	&tmp->race, tmp->weight_limit / (10.0 * (100 - tmp->stats.Str)));
1188	else
1189	sprintf (buf, "It can hold only %s.", &tmp->race);
1190	}
1191	else if (tmp->weight_limit && tmp->stats.Str < 100)
1192	sprintf (buf, "Its weight limit is %.1f kg.", tmp->weight_limit / (10.0 * (100 - tmp->stats.Str)));
1193	break;
1194
1195	case WAND:
1196	if (QUERY_FLAG (tmp, FLAG_IDENTIFIED))
1197	sprintf (buf, "It has %d charges left.", tmp->stats.food);
1198	break;
1199	}
1200
1201	if (buf[0] != '\0')
1202	new_draw_info (NDI_UNIQUE, 0, op, buf);
1203
1204	if (tmp->materialname != NULL && !tmp->msg)
1205	{	1147	}
		1148
		1149	if (materialname && !msg)
1206	sprintf (buf, "It is made of: %s.", &tmp->materialname);	1150	buf.printf ("It is made of: %s.\r", &materialname);
1207	new_draw_info (NDI_UNIQUE, 0, op, buf);	1151
1208	}	1152	if (who)
1209	/* Where to wear this item */	1153	/* Where to wear this item */
1210	for (i = 0; i < NUM_BODY_LOCATIONS; i++)	1154	for (int i = 0; i < NUM_BODY_LOCATIONS; i++)
1211	{	1155	if (slot[i].info)
1212	if (tmp->body_info[i] < -1)	1156	{
		1157	buf << (who->slot[i].info ? body_locations[i].use_name : body_locations[i].nonuse_name);
		1158
		1159	if (slot[i].info < -1 && who->slot[i].info)
		1160	buf.printf ("(%d)", -slot[i].info);
		1161
		1162	buf << ".\r";
1213	{	1163	}
1214	if (op->body_info[i])	1164
1215	new_draw_info_format (NDI_UNIQUE, 0, op, "It goes %s (%d)", body_locations[i].use_name, -tmp->body_info[i]);	1165	if (weight)
		1166	buf.printf ("%s %3.3f kg.\r", nrof > 1 ? "They weigh" : "It weighs", weight * (nrof ? nrof : 1) / 1000.0);
		1167
		1168	if (value && !flag [FLAG_STARTEQUIP] && !flag [FLAG_NO_PICK] && who)
		1169	{
		1170	buf.printf ("You reckon %s worth %s.\r", nrof > 1 ? "they are" : "it is", query_cost_string (this, who, F_TRUE | F_APPROX));
		1171
		1172	if (is_in_shop (who))
		1173	{
		1174	if (flag [FLAG_UNPAID])
		1175	buf.printf ("%s would cost you %s.\r", nrof > 1 ? "They" : "It", query_cost_string (this, who, F_BUY | F_SHOP));
1216	else	1176	else
1217	new_draw_info_format (NDI_UNIQUE, 0, op, "It goes %s", body_locations[i].nonuse_name);
1218	}
1219	else if (tmp->body_info[i])
1220	{
1221	if (op->body_info[i])
1222	new_draw_info_format (NDI_UNIQUE, 0, op, "It goes %s", body_locations[i].use_name);
1223	else
1224	new_draw_info_format (NDI_UNIQUE, 0, op, "It goes %s", body_locations[i].nonuse_name);
1225	}
1226	}
1227
1228	if (tmp->weight)
1229	{
1230	sprintf (buf, tmp->nrof > 1 ? "They weigh %3.3f kg." : "It weighs %3.3f kg.", tmp->weight * (tmp->nrof ? tmp->nrof : 1) / 1000.0);
1231	new_draw_info (NDI_UNIQUE, 0, op, buf);
1232	}
1233
1234	if (tmp->value && !QUERY_FLAG (tmp, FLAG_STARTEQUIP) && !QUERY_FLAG (tmp, FLAG_NO_PICK))
1235	{
1236	sprintf (buf, "You reckon %s worth %s.", tmp->nrof > 1 ? "they are" : "it is", query_cost_string (tmp, op, F_TRUE | F_APPROX));
1237	new_draw_info (NDI_UNIQUE, 0, op, buf);
1238	if (is_in_shop (op))
1239	{
1240	if (QUERY_FLAG (tmp, FLAG_UNPAID))
1241	sprintf (buf, "%s would cost you %s.", tmp->nrof > 1 ? "They" : "It", query_cost_string (tmp, op, F_BUY | F_SHOP));
1242	else
1243	sprintf (buf, "You are offered %s for %s.", query_cost_string (tmp, op, F_SELL + F_SHOP), tmp->nrof > 1 ? "them" : "it");	1177	buf.printf ("You are offered %s for %s.\r", query_cost_string (this, who, F_SELL + F_SHOP), nrof > 1 ? "them" : "it");
1244	new_draw_info (NDI_UNIQUE, 0, op, buf);
1245	}	1178	}
1246	}	1179	}
1247		1180
1248	if (QUERY_FLAG (tmp, FLAG_MONSTER))	1181	if (flag [FLAG_MONSTER])
1249	examine_monster (op, tmp);	1182	buf << describe_monster (who);
1250		1183
1251	/* Is this item buildable? */	1184	/* Is this item buildable? */
1252	if (QUERY_FLAG (tmp, FLAG_IS_BUILDABLE))	1185	if (flag [FLAG_IS_BUILDABLE])
1253	new_draw_info (NDI_UNIQUE, 0, op, "This is a buildable item.");	1186	buf << "This is a buildable item.\r";
1254		1187
1255	/* Does the object have a message? Don't show message for all object	1188	/* Does the object have a message? Don't show message for all object
1256	* types - especially if the first entry is a match	1189	* types - especially if the first entry is a match
1257	*/	1190	*/
1258	if (tmp->msg && tmp->type != EXIT && tmp->type != BOOK && tmp->type != CORPSE && !tmp->move_on && strncasecmp (tmp->msg, "@match", 7))	1191	if (msg && type != EXIT && type != BOOK && type != CORPSE && !move_on && !has_dialogue ())
1259	{	1192	{
1260
1261	/* This is just a hack so when identifying the items, we print	1193	/* This is just a hack so when identifying the items, we print
1262	* out the extra message	1194	* out the extra message
1263	*/	1195	*/
1264	if (need_identify (tmp) && QUERY_FLAG (tmp, FLAG_IDENTIFIED))	1196	if (need_identify (this) && flag [FLAG_IDENTIFIED])
1265	new_draw_info (NDI_UNIQUE, 0, op, "The object has a story:");	1197	buf << "The object has a story:\r";
1266		1198
1267	new_draw_info (NDI_UNIQUE, 0, op, tmp->msg);	1199	buf << msg << '\n';
1268	}
1269	new_draw_info (NDI_UNIQUE, 0, op, " "); /* Blank line */
1270	}
1271
1272	/*
1273	* inventory prints object's inventory. If inv==NULL then print player's
1274	* inventory.
1275	* [ Only items which are applied are showed. Tero.Haatanen@lut.fi ]
1276	*/
1277	void
1278	inventory (object *op, object *inv)
1279	{
1280	object *tmp;
1281	char *in;
1282	int items = 0, length;
1283
1284	if (inv == NULL && op == NULL)
1285	{	1200	}
1286	new_draw_info (NDI_UNIQUE, 0, op, "Inventory of what object?");
1287	return;
1288	}
1289	tmp = inv ? inv->inv : op->inv;
1290		1201
1291	while (tmp)	1202	buf << '\n';
1292	{	1203
1293	if ((!tmp->invisible &&	1204	return std::string (buf.linearise (), buf.size ());
1294	(inv == NULL || inv->type == CONTAINER || QUERY_FLAG (tmp, FLAG_APPLIED))) || (!op || QUERY_FLAG (op, FLAG_WIZ)))
1295	items++;
1296	tmp = tmp->below;
1297	}
1298	if (inv == NULL)
1299	{ /* player's inventory */
1300	if (items == 0)
1301	{
1302	new_draw_info (NDI_UNIQUE, 0, op, "You carry nothing.");
1303	return;
1304	}
1305	else
1306	{
1307	length = 28;
1308	in = "";
1309	if (op)
1310	clear_win_info (op);
1311	new_draw_info (NDI_UNIQUE, 0, op, "Inventory:");
1312	}
1313	}
1314	else
1315	{
1316	if (items == 0)
1317	return;
1318	else
1319	{
1320	length = 28;
1321	in = " ";
1322	}
1323	}
1324	for (tmp = inv ? inv->inv : op->inv; tmp; tmp = tmp->below)
1325	{
1326	if ((!op || !QUERY_FLAG (op, FLAG_WIZ)) && (tmp->invisible || (inv && inv->type != CONTAINER && !QUERY_FLAG (tmp, FLAG_APPLIED))))
1327	continue;
1328	if ((!op || QUERY_FLAG (op, FLAG_WIZ)))
1329	new_draw_info_format (NDI_UNIQUE, 0, op, "%s- %-*.*s (%5d) %-8s", in, length, length,
1330	query_name (tmp), tmp->count, query_weight (tmp));
1331	else
1332	new_draw_info_format (NDI_UNIQUE, 0, op, "%s- %-*.*s %-8s", in, length + 8, length + 8, query_name (tmp), query_weight (tmp));
1333	}
1334	if (!inv && op)
1335	{
1336	new_draw_info_format (NDI_UNIQUE, 0, op, "%-*s %-8s", 41, "Total weight :", query_weight (op));
1337	}
1338	}	1205	}
1339		1206
1340	static void	1207	static void
1341	display_new_pickup (object *op)	1208	display_new_pickup (object *op)
1342	{	1209	{
1343	int i = op->contr->mode;	1210	int i = op->contr->mode;
1344		1211
1345	if (!(i & PU_NEWMODE))
1346	return;
1347
1348	new_draw_info_format (NDI_UNIQUE, 0, op, "%d NEWMODE", i & PU_NEWMODE ? 1 : 0);
1349	new_draw_info_format (NDI_UNIQUE, 0, op, "%d DEBUG", i & PU_DEBUG ? 1 : 0);	1212	new_draw_info_format (NDI_UNIQUE, 0, op, "%d DEBUG", i & PU_DEBUG ? 1 : 0);
1350	new_draw_info_format (NDI_UNIQUE, 0, op, "%d INHIBIT", i & PU_INHIBIT ? 1 : 0);	1213	new_draw_info_format (NDI_UNIQUE, 0, op, "%d INHIBIT", i & PU_INHIBIT ? 1 : 0);
1351	new_draw_info_format (NDI_UNIQUE, 0, op, "%d STOP", i & PU_STOP ? 1 : 0);	1214	new_draw_info_format (NDI_UNIQUE, 0, op, "%d STOP", i & PU_STOP ? 1 : 0);
1352		1215
1353	new_draw_info_format (NDI_UNIQUE, 0, op, "%d <= x pickup weight/value RATIO (0==off)", (i & PU_RATIO) * 5);	1216	new_draw_info_format (NDI_UNIQUE, 0, op, "%d <= x pickup weight/value RATIO (0==off)", (i & PU_RATIO) * 5);
…		…
1404	};	1267	};
1405		1268
1406	if (!params)	1269	if (!params)
1407	{	1270	{
1408	/* if the new mode is used, just print the settings */	1271	/* if the new mode is used, just print the settings */
1409	if (op->contr->mode & PU_NEWMODE)
1410	{
1411	display_new_pickup (op);	1272	display_new_pickup (op);
1412	return 1;
1413	}
1414	if (1)
1415	LOG (llevDebug, "command_pickup: !params\n");
1416	set_pickup_mode (op, (op->contr->mode > 6) ? 0 : op->contr->mode + 1);
1417	return 0;	1273	return 0;
1418	}	1274	}
1419		1275
1420	while (*params == ' ' && *params)	1276	while (*params == ' ' && *params)
1421	params++;	1277	params++;
…		…
1427	for (mode = 0; names[mode]; mode++)	1283	for (mode = 0; names[mode]; mode++)
1428	{	1284	{
1429	if (!strcmp (names[mode], params + 1))	1285	if (!strcmp (names[mode], params + 1))
1430	{	1286	{
1431	i = op->contr->mode;	1287	i = op->contr->mode;
1432	if (!(i & PU_NEWMODE))	1288
1433	i = PU_NEWMODE;
1434	if (*params == '+')	1289	if (*params == '+')
1435	i = i | modes[mode];	1290	i = i | modes[mode];
1436	else	1291	else
1437	i = i & ~modes[mode];	1292	i = i & ~modes[mode];
		1293
1438	op->contr->mode = i;	1294	op->contr->mode = i;
1439	display_new_pickup (op);	1295	display_new_pickup (op);
1440	return 1;	1296	return 1;
1441	}	1297	}
1442	}	1298	}
…		…
1444	return 1;	1300	return 1;
1445	}	1301	}
1446		1302
1447	if (sscanf (params, "%u", &i) != 1)	1303	if (sscanf (params, "%u", &i) != 1)
1448	{	1304	{
1449	if (1)
1450	LOG (llevDebug, "command_pickup: params==NULL\n");
1451	new_draw_info (NDI_UNIQUE, 0, op, "Usage: pickup <0-7> or <value_density> .");	1305	new_draw_info (NDI_UNIQUE, 0, op, "Usage: pickup <value_density> or [+-]type.");
1452	return 1;	1306	return 1;
1453	}	1307	}
1454	set_pickup_mode (op, i);	1308
		1309	if (i <= PU_RATIO)
		1310	i |= op->contr->mode & ~PU_RATIO;
		1311
		1312	op->contr->mode = i;
1455		1313
1456	return 1;	1314	return 1;
1457	}
1458
1459	void
1460	set_pickup_mode (object *op, int i)
1461	{
1462	switch (op->contr->mode = i)
1463	{
1464	case 0:
1465	new_draw_info (NDI_UNIQUE, 0, op, "Mode: Don't pick up.");
1466	break;
1467	case 1:
1468	new_draw_info (NDI_UNIQUE, 0, op, "Mode: Pick up one item.");
1469	break;
1470	case 2:
1471	new_draw_info (NDI_UNIQUE, 0, op, "Mode: Pick up one item and stop.");
1472	break;
1473	case 3:
1474	new_draw_info (NDI_UNIQUE, 0, op, "Mode: Stop before picking up.");
1475	break;
1476	case 4:
1477	new_draw_info (NDI_UNIQUE, 0, op, "Mode: Pick up all items.");
1478	break;
1479	case 5:
1480	new_draw_info (NDI_UNIQUE, 0, op, "Mode: Pick up all items and stop.");
1481	break;
1482	case 6:
1483	new_draw_info (NDI_UNIQUE, 0, op, "Mode: Pick up all magic items.");
1484	break;
1485	case 7:
1486	new_draw_info (NDI_UNIQUE, 0, op, "Mode: Pick up all coins and gems");
1487	break;
1488	}
1489	}	1315	}
1490		1316
1491	int	1317	int
1492	command_search_items (object *op, char *params)	1318	command_search_items (object *op, char *params)
1493	{	1319	{
1494	char buf[MAX_BUF];	1320	char buf[MAX_BUF];
1495		1321
1496	if (settings.search_items == FALSE)
1497	return 1;
1498
1499	if (params == NULL)	1322	if (params == NULL)
1500	{	1323	{
1501	if (op->contr->search_str[0] == '\0')	1324	if (op->contr->search_str[0] == '\0')
1502	{	1325	{
1503	new_draw_info (NDI_UNIQUE, 0, op, "Example: search magic+1");	1326	new_draw_info (NDI_UNIQUE, 0, op, "Example: search-items magic+1");
1504	new_draw_info (NDI_UNIQUE, 0, op, "Would automatically pick up all");	1327	new_draw_info (NDI_UNIQUE, 0, op, "Would automatically pick up all");
1505	new_draw_info (NDI_UNIQUE, 0, op, "items containing the word 'magic+1'.");	1328	new_draw_info (NDI_UNIQUE, 0, op, "items containing the word 'magic+1'.");
1506	return 1;	1329	return 1;
1507	}	1330	}
		1331
1508	op->contr->search_str[0] = '\0';	1332	op->contr->search_str[0] = '\0';
1509	new_draw_info (NDI_UNIQUE, 0, op, "Search mode turned off.");	1333	new_draw_info (NDI_UNIQUE, 0, op, "Search mode turned off.");
1510	op->update_stats ();	1334	op->update_stats ();
1511	return 1;	1335	return 1;
1512	}	1336	}
		1337
1513	if ((int) strlen (params) >= MAX_BUF)	1338	if (strlen (params) >= MAX_BUF)
1514	{	1339	{
1515	new_draw_info (NDI_UNIQUE, 0, op, "Search string too long.");	1340	new_draw_info (NDI_UNIQUE, 0, op, "Search string too long.");
1516	return 1;	1341	return 1;
1517	}	1342	}
		1343
1518	strcpy (op->contr->search_str, params);	1344	strcpy (op->contr->search_str, params);
1519	sprintf (buf, "Searching for '%s'.", op->contr->search_str);	1345	sprintf (buf, "Now searching for '%s'.", op->contr->search_str);
1520	new_draw_info (NDI_UNIQUE, 0, op, buf);	1346	new_draw_info (NDI_UNIQUE, 0, op, buf);
1521	op->update_stats ();	1347	op->update_stats ();
		1348
1522	return 1;	1349	return 1;
1523	}	1350	}
1524		1351

Diff Legend

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