[ViewVC] Diff of: cvs/deliantra/server/socket/item.C

Comparing deliantra/server/socket/item.C (file contents):
Revision 1.3 by root, Tue Aug 29 08:01:38 2006 UTC vs.
Revision 1.60 by root, Tue Apr 22 07:01:47 2008 UTC

…		…
1
2	/*	1	/*
3	* static char *rcsid_item_c =	2	* This file is part of Deliantra, the Roguelike Realtime MMORPG.
4	* "$Id: item.C,v 1.3 2006/08/29 08:01:38 root Exp $";	3	*
5	*/	4	* Copyright (©) 2005,2006,2007,2008 Marc Alexander Lehmann / Robin Redeker / the Deliantra team
6
7	/*
8	CrossFire, A Multiplayer game for X-windows
9
10	Copyright (C) 2002 Mark Wedel & Crossfire Development Team	5	* Copyright (©) 2002,2007 Mark Wedel & Crossfire Development Team
11	Copyright (C) 1992 Frank Tore Johansen	6	* Copyright (©) 1992,2007 Frank Tore Johansen
12		7	*
13	This program is free software; you can redistribute it and/or modify	8	* Deliantra is free software: you can redistribute it and/or modify
14	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
15	the Free Software Foundation; either version 2 of the License, or	10	* the Free Software Foundation, either version 3 of the License, or
16	(at your option) any later version.	11	* (at your option) any later version.
17		12	*
18	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,
19	but WITHOUT ANY WARRANTY; without even the implied warranty of	14	* but WITHOUT ANY WARRANTY; without even the implied warranty of
20	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the	15	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
21	GNU General Public License for more details.	16	* GNU General Public License for more details.
22		17	*
23	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
24	along with this program; if not, write to the Free Software	19	* along with this program. If not, see <http://www.gnu.org/licenses/>.
25	Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.	20	*
26		21	* The authors can be reached via e-mail to <support@deliantra.net>
27	The author can be reached via e-mail to crossfire-devel@real-time.com
28	*/	22	*/
29		23
30	/**	24	/**
31	* \file	25	* \file
32	* Client/server logic.	26	* Client/server logic.
33	*	27	*
34	* \date 2003-12-02	28	* \date 2003-12-02
35	*	29	*
36	* This containes item logic for client/server. It doesn't contain	30	* This contains item logic for client/server. It doesn't contain
37	* the actual commands that send the data, but does contain	31	* the actual commands that send the data, but does contain
38	* the logic for what items should be sent.	32	* the logic for what items should be sent.
39	*/	33	*/
40		34
41
42	#include <global.h>	35	#include <global.h>
43	#include <object.h> /* LOOK_OBJ */
44	#include <newclient.h>	36	#include <object.h>
45	#include <newserver.h>
46	#include <sproto.h>	37	#include <sproto.h>
47		38
48	/** This is the maximum number of bytes we expect any one item to take up */	39	/** This is the maximum number of bytes we expect any one item to take up */
49	#define MAXITEMLEN 300	40	#define MAXITEMLEN 300
		41
		42	#if 0
		43	tag_t
		44	client_container::tag () const
		45	{
		46	switch (type)
		47	{
		48	case CC_INVENTORY:
		49	return ns->pl->count;
		50	case CC_MAPSPACE:
		51	return 0;
		52	case CC_CONTAINER:
		53	return env->count;
		54	}
		55
		56	abort ();
		57	}
		58
		59	void
		60	client_container::clear ()
		61	{
		62	switch (type)
		63	{
		64	case CC_INVENTORY:
		65	abort ();
		66
		67	case CC_MAPSPACE:
		68	case CC_CONTAINER:
		69	ns->send_packet_printf ("delinv %d", tag ());
		70	break;
		71	}
		72
		73	for (iterator i = begin (); i != end (); ++i)
		74	i->op->seen_by = 0;
		75
		76	vector< refitem, slice_allocator<refitem> >::clear ();
		77	}
		78
		79	inline iterator
		80	client_container::merge_item (iterator i, object *op)
		81	{
		82	if (i != end () && i->op == op)
		83	return ++i;
		84
		85	if (op->seen_by)
		86	return; // seen by another entity already
		87
		88	op->seen_by = this;
		89
		90	refitem ref;
		91	ref.op = op;
		92
		93	return insert (i, ref);
		94	}
		95
		96	void
		97	client_container::update (int offset)
		98	{
		99	iterator i = begin ();
		100
		101	switch (type)
		102	{
		103	case CC_INVENTORY:
		104	case CC_CONTAINER:
		105	{
		106	object *env = type == CC_INVENTORY
		107	? ns->pl->ob
		108	: this->env;
		109
		110	// pass 1, erase all objects no longer in container
		111	for (iterator j = begin (); j != end (); ++j)
		112	if (j->op->env != env)
		113	{
		114	j->op->seen_by = 0;
		115	erase (j);
		116	}
		117
		118	// pass 2 merge items
		119	for (object *op = env->inv; op; op = op->below)
		120	{
		121	if (--offset < 0)
		122	i = merge_item (i, op);
		123	else if (offset < -FLOORBOX_PAGESIZE)
		124	break;
		125	}
		126	}
		127	break;
		128
		129	case CC_MAPSPACE:
		130	{
		131	// pass 1, erase all objects no longer on space
		132	for (iterator j = begin (); j != end (); ++j)
		133	if (j->op->x != x \|\| j->op->y != y \|\| j->op->map != map)
		134	{
		135	j->op->seen_by = 0;
		136	erase (j);
		137	}
		138
		139	// pass 2 merge items
		140	for (object *op = GET_MAP_OB (map, x, y); op; op = op->above)
		141	{
		142	if (--offset < 0)
		143	i = merge_item (i, op);
		144	else if (offset < -FLOORBOX_PAGESIZE)
		145	break;
		146	}
		147	}
		148	break;
		149	}
		150
		151	// pass 3, erase all extra items
		152	for (iterator j = i; j != end (); ++j)
		153	j->op->seen_by = 0;
		154
		155	if (i != end ())
		156	erase (i, end ());
		157	}
		158
		159	void
		160	client_container::set_mapspace (maptile *map, int x, int y)
		161	{
		162	if (type == CC_MAPSPACE
		163	&& this->map == map
		164	&& this->x == x
		165	&& this->y == y)
		166	return;
		167
		168	clear ();
		169
		170	type = CC_MAPSPACE;
		171	this->map = map;
		172	this->x = x;
		173	this->y = y;
		174	}
		175
		176	void
		177	client_container::set_container (object *env)
		178	{
		179	}
		180	#endif
50		181
51	/*******************************************************************************	182	/*******************************************************************************
52	*	183	*
53	* Functions related to sending object data to the client.	184	* Functions related to sending object data to the client.
54	*	185	*
55	******************************************************************************/	186	******************************************************************************/
56		187
57	/**	188	/**
58	* Adds string to socklist.
59	*
60	* This is a simple function that we use a lot here. It basically
61	* adds the specified buffer into the socklist, but prepends a
62	* single byte in length. If the data is longer than that byte, it is
63	* truncated approprately.
64	*/
65	inline void add_stringlen_to_sockbuf(const char buf, SockList sl)
66	{
67	int len;
68
69	len=strlen(buf);
70	if (len>255) len=255;
71	SockList_AddChar(sl, (char) len);
72	strncpy((char*)sl->buf+sl->len, buf,len);
73	sl->len += len;
74	}
75
76	/**
77	* This is a similar to query_name, but returns flags	189	* This is a similar to query_name, but returns flags
78	* to be sended to client.	190	* to be sent to client.
79	*/	191	*/
		192	unsigned int
80	unsigned int query_flags (object *op)	193	query_flags (object *op)
81	{	194	{
82	unsigned int flags = 0;	195	unsigned int flags = 0;
83		196
84	if(QUERY_FLAG(op,FLAG_APPLIED)) {	197	if (QUERY_FLAG (op, FLAG_APPLIED))
		198	{
85	switch(op->type) {	199	switch (op->type)
		200	{
86	case BOW:	201	case BOW:
87	case WAND:	202	case WAND:
88	case ROD:	203	case ROD:
89	case HORN:	204	case HORN:
90	flags = a_readied;	205	flags = a_readied;
111	default:	226	default:
112	flags = a_applied;	227	flags = a_applied;
113	break;	228	break;
114	}	229	}
115	}	230	}
		231
116	if (op->type == CONTAINER && ((op->env && op->env->container == op) \|\|	232	if (op->type == CONTAINER && ((op->env && op->env->container == op) \|\| (!op->env && QUERY_FLAG (op, FLAG_APPLIED))))
117	(!op->env && QUERY_FLAG(op,FLAG_APPLIED))))
118	flags \|= F_OPEN;	233	flags \|= F_OPEN;
119		234
120	if (QUERY_FLAG(op,FLAG_KNOWN_CURSED)) {	235	if (QUERY_FLAG (op, FLAG_KNOWN_CURSED))
		236	{
121	if(QUERY_FLAG(op,FLAG_DAMNED))	237	if (QUERY_FLAG (op, FLAG_DAMNED))
122	flags \|= F_DAMNED;	238	flags \|= F_DAMNED;
123	else if(QUERY_FLAG(op,FLAG_CURSED))	239	else if (QUERY_FLAG (op, FLAG_CURSED))
124	flags \|= F_CURSED;	240	flags \|= F_CURSED;
125	}	241	}
		242
126	if (QUERY_FLAG(op,FLAG_KNOWN_MAGICAL) && !QUERY_FLAG(op,FLAG_IDENTIFIED))	243	if (QUERY_FLAG (op, FLAG_KNOWN_MAGICAL) && !QUERY_FLAG (op, FLAG_IDENTIFIED))
127	flags \|= F_MAGIC;	244	flags \|= F_MAGIC;
128	if (QUERY_FLAG(op,FLAG_UNPAID))	245	if (QUERY_FLAG (op, FLAG_UNPAID))
129	flags \|= F_UNPAID;	246	flags \|= F_UNPAID;
130	if (QUERY_FLAG(op,FLAG_INV_LOCKED))	247	if (QUERY_FLAG (op, FLAG_INV_LOCKED))
131	flags \|= F_LOCKED;	248	flags \|= F_LOCKED;
132		249
133	return flags;	250	return flags;
134	}	251	}
135		252
136	/* Used in the send_look to put object head into SockList	253	/* Used in the send_look to put object head into packet
137	* sl for socket ns. Need socket to know if we need to send	254	* sl for socket ns. Need socket to know if we need to send
138	* animation of face to the client.	255	* animation of face to the client.
139	*/	256	*/
140	static void add_object_to_socklist(NewSocket ns, SockList sl, object *head)	257	static void
		258	add_object_to_socklist (client &ns, packet &sl, object *head)
141	{	259	{
142	int flags, len, anim_speed;	260	int flags, len, anim_speed;
143	char item_n[MAX_BUF];	261	char item_n[MAX_BUF];
144	const char *item_p;	262	const char *item_p;
145		263
146	flags = query_flags (head);	264	flags = query_flags (head);
147	if (QUERY_FLAG(head, FLAG_NO_PICK))	265	if (QUERY_FLAG (head, FLAG_NO_PICK))
148	flags \|= F_NOPICK;	266	flags \|= F_NOPICK;
149		267
150	if (!(ns->faces_sent[head->face->number] & NS_FACESENT_FACE))	268	ns.send_face (head->face, -50);
151	esrv_send_face(ns, head->face->number,0);	269	ns.flush_fx ();
152		270
153	if (QUERY_FLAG(head,FLAG_ANIMATE) && !ns->anims_sent[head->animation_id])	271	if (QUERY_FLAG (head, FLAG_ANIMATE) && !ns.anims_sent[head->animation_id])
154	esrv_send_animation(ns, head->animation_id);	272	ns.send_animation (head->animation_id);
155		273
156	SockList_AddInt(sl, head->count);	274	sl << uint32 (head->count)
157	SockList_AddInt(sl, flags);	275	<< uint32 (flags)
158	SockList_AddInt(sl, QUERY_FLAG(head, FLAG_NO_PICK) ? -1 : WEIGHT(head));	276	<< uint32 (QUERY_FLAG (head, FLAG_NO_PICK) ? -1 : head->client_weight ())
159	SockList_AddInt(sl, head->face->number);	277	<< uint32 (head->face);
160		278
161	if (!head->custom_name) {	279	if (!head->custom_name)
		280	{
162	strncpy(item_n,query_base_name(head, 0),127);	281	strncpy (item_n, query_base_name (head, 0), 127);
163	item_n[127]=0;	282	item_n[127] = 0;
164	len=strlen(item_n);	283	len = strlen (item_n);
165	item_p=query_base_name(head, 1);	284	item_p = query_base_name (head, 1);
166	} else {	285	}
		286	else
		287	{
167	strncpy(item_n,head->custom_name,127);	288	strncpy (item_n, head->custom_name, 127);
168	item_n[127]=0;	289	item_n[127] = 0;
169	len=strlen(item_n);	290	len = strlen (item_n);
170	item_p=head->custom_name;	291	item_p = head->custom_name;
171	}	292	}
		293
172	strncpy(item_n+len+1, item_p, 127);	294	strncpy (item_n + len + 1, item_p, 127);
173	item_n[254]=0;	295	item_n[254] = 0;
174	len += strlen(item_n+1+len) + 1;	296	len += strlen (item_n + 1 + len) + 1;
175	SockList_AddChar(sl, (char ) len);
176	memcpy(sl->buf+sl->len, item_n, len);
177	sl->len += len;
178		297
179	SockList_AddShort(sl,head->animation_id);	298	sl << data8 (item_n, len)
		299	<< uint16 (head->animation_id);
		300
180	anim_speed=0;	301	anim_speed = 0;
181	if (QUERY_FLAG(head,FLAG_ANIMATE)) {	302	if (QUERY_FLAG (head, FLAG_ANIMATE))
		303	{
		304	if (head->anim_speed)
182	if (head->anim_speed) anim_speed=head->anim_speed;	305	anim_speed = head->anim_speed;
183	else {	306	else
184	if (FABS(head->speed)<0.001) anim_speed=255;
185	else if (FABS(head->speed)>=1.0) anim_speed=1;
186	else anim_speed = (int) (1.0/FABS(head->speed));
187	}	307	{
188	if (anim_speed>255) anim_speed=255;	308	if (fabs (head->speed) < 0.001)
189	}	309	anim_speed = 255;
190	SockList_AddChar(sl, (char) anim_speed);	310	else if (fabs (head->speed) >= 1.0)
191	SockList_AddInt(sl, head->nrof);	311	anim_speed = 1;
		312	else
		313	anim_speed = (int) (1.0 / fabs (head->speed));
		314	}
192		315
		316	if (anim_speed > 255)
		317	anim_speed = 255;
		318	}
		319
		320	sl << uint8 (anim_speed)
		321	<< uint32 (head->nrof);
		322
193	if (ns->itemcmd == 2)	323	if (ns.itemcmd == 2)
194	SockList_AddShort(sl, head->client_type);	324	sl << uint16 (head->client_type);
195		325
196	SET_FLAG(head, FLAG_CLIENT_SENT);	326	SET_FLAG (head, FLAG_CLIENT_SENT);
197	}	327	}
198
199		328
200	/**	329	/**
201	* Send the look window. Don't need to do animations here	330	* Send the look window. Don't need to do animations here
202	* This sends all the faces to the client, not just updates. This is	331	* This sends all the faces to the client, not just updates. This is
203	* because object ordering would otherwise be inconsistent	332	* because object ordering would otherwise be inconsistent.
204	*/	333	*/
205		334	void
206	void esrv_draw_look(object *pl)	335	esrv_draw_look (player *pl)
207	{	336	{
208	object tmp, last;
209	int got_one=0,start_look=0, end_look=0;	337	int got_one = 0, start_look = 0, end_look = 0;
210	SockList sl;
211	char buf[MAX_BUF];
212		338
		339	object *ob = pl->ob;
		340
213	if (!pl->contr->socket.update_look) {	341	if (!pl->ns->update_look)
		342	{
214	LOG(llevDebug,"esrv_draw_look called when update_look was not set\n");	343	LOG (llevDebug, "esrv_draw_look called when update_look was not set (player %s)\n", &ob->name);
215	return;	344	return;
216	} else {	345	}
217	pl->contr->socket.update_look=0;	346	else
		347	pl->ns->update_look = 0;
		348
		349	if (QUERY_FLAG (ob, FLAG_REMOVED)
		350	\|\| !ob->map
		351	\|\| ob->map->in_memory != MAP_ACTIVE
		352	\|\| out_of_map (ob->map, ob->x, ob->y))
		353	return;
		354
		355	pl->ns->send_packet ("delinv 0");
		356
		357	packet sl;
		358	sl.printf ("item%d ", pl->ns->itemcmd);
		359
		360	sl << uint32 (0);
		361
		362	pl->ns->send_face (empty_face, -50);
		363	pl->ns->flush_fx ();
		364
		365	if (pl->ns->look_position)
218	}	366	{
		367	char buf[80];
		368	snprintf (buf, 80, "Apply this to see %d previous items", FLOORBOX_PAGESIZE);
219		369
220	if(QUERY_FLAG(pl, FLAG_REMOVED) \|\| pl->map == NULL \|\|	370	sl << uint32 (0x80000000 \| (pl->ns->look_position - FLOORBOX_PAGESIZE))
221	pl->map->in_memory != MAP_IN_MEMORY \|\| out_of_map(pl->map,pl->x,pl->y))	371	<< uint32 (0)
222	return;	372	<< sint32 (-1)
		373	<< uint32 (empty_face)
		374	<< data8 (buf)
		375	<< uint16 (0)
		376	<< uint8 (0)
		377	<< uint32 (0);
223		378
224	for (tmp=get_map_ob(pl->map,pl->x,pl->y); tmp && tmp->above;tmp=tmp->above) ;
225
226	sl.buf= (unsigned char *) malloc(MAXSOCKBUF);
227
228	Write_String_To_Socket(&pl->contr->socket, "delinv 0", strlen("delinv 0"));
229	sprintf((char*)sl.buf,"item%d ", pl->contr->socket.itemcmd);
230	sl.len=strlen((char*)sl.buf);
231
232	SockList_AddInt(&sl, 0);
233
234	if (!(pl->contr->socket.faces_sent[empty_face->number]&NS_FACESENT_FACE))
235	esrv_send_face(&pl->contr->socket, empty_face->number,0);
236
237	if (pl->contr->socket.look_position) {
238	SockList_AddInt(&sl, 0x80000000 \| (pl->contr->socket.look_position- NUM_LOOK_OBJECTS));
239	SockList_AddInt(&sl, 0);
240	SockList_AddInt(&sl, (uint32) -1);
241	SockList_AddInt(&sl, empty_face->number);
242	sprintf(buf,"Click here to see %d previous items", NUM_LOOK_OBJECTS);
243	add_stringlen_to_sockbuf(buf, &sl);
244	SockList_AddShort(&sl,0);
245	SockList_AddChar(&sl, 0);
246	SockList_AddInt(&sl, 0);
247	if (pl->contr->socket.itemcmd == 2)	379	if (pl->ns->itemcmd == 2)
248	SockList_AddShort(&sl, 0);	380	sl << uint16 (0);
		381	}
		382
		383	object *tmp = ob->ms ().top;
		384	for (object *last = 0; tmp != last; tmp = tmp->below)
249	}	385	{
250
251	for (last=NULL; tmp!=last; tmp=tmp->below) {
252	object *head;	386	object *head;
253		387
254	if (QUERY_FLAG(tmp, FLAG_IS_FLOOR) && !last) {	388	if (QUERY_FLAG (tmp, FLAG_IS_FLOOR) && !last)
		389	{
255	last = tmp->below; /* assumes double floor mode */	390	last = tmp->below; /* assumes double floor mode */
256	if (last && QUERY_FLAG(last, FLAG_IS_FLOOR))	391	if (last && QUERY_FLAG (last, FLAG_IS_FLOOR))
257	last = last->below;	392	last = last->below;
		393	}
		394
		395	if (tmp->client_visible ())
258	}	396	{
259	if (LOOK_OBJ(tmp)) {
260	if (++start_look < pl->contr->socket.look_position) continue;	397	if (++start_look < pl->ns->look_position)
		398	continue;
		399
261	end_look++;	400	end_look++;
262	if (end_look > NUM_LOOK_OBJECTS) {	401
		402	if (end_look > FLOORBOX_PAGESIZE)
		403	{
263	/* What we basically do is make a 'fake' object - when the user applies it,	404	/* What we basically do is make a 'fake' object - when the user applies it,
264	* we notice the special tag the object has, and act accordingly.	405	* we notice the special tag the object has, and act accordingly.
265	*/	406	*/
266	SockList_AddInt(&sl, 0x80000000 \| (pl->contr->socket.look_position+ NUM_LOOK_OBJECTS));	407	sl << uint32 (0x80000000 \| (pl->ns->look_position + FLOORBOX_PAGESIZE))
267	SockList_AddInt(&sl, 0);	408	<< uint32 (0)
268	SockList_AddInt(&sl, (uint32) -1);	409	<< uint32 ((uint32) - 1)
269	SockList_AddInt(&sl, empty_face->number);	410	<< uint32 (empty_face)
270	sprintf(buf,"Click here to see next group of items");	411	<< data8 ("Apply this to see next group of items")
271	add_stringlen_to_sockbuf(buf, &sl);	412	<< uint16 (0)
272	SockList_AddShort(&sl,0);	413	<< uint8 (0)
273	SockList_AddChar(&sl, 0);	414	<< uint32 (0);
274	SockList_AddInt(&sl, 0);	415
275	if (pl->contr->socket.itemcmd == 2)	416	if (pl->ns->itemcmd == 2)
276	SockList_AddShort(&sl, 0);	417	sl << uint16 (0);
		418
277	break;	419	break;
278	}	420	}
		421
		422	if (tmp->head)
279	if (tmp->head) head = tmp->head;	423	head = tmp->head;
		424	else
280	else head = tmp;	425	head = tmp;
281		426
282	add_object_to_socklist(&pl->contr->socket, &sl, head);	427	add_object_to_socklist (*pl->ns, sl, head);
283	got_one++;	428	got_one++;
284		429
285	if (sl.len >= (MAXSOCKBUF-MAXITEMLEN)) {	430	if (sl.length () > MAXSOCKBUF - MAXITEMLEN)
286	Send_With_Handling(&pl->contr->socket, &sl);	431	{
		432	pl->ns->send_packet (sl);
		433
		434	sl.reset ();
287	sprintf((char*)sl.buf,"item%d ", pl->contr->socket.itemcmd);	435	sl.printf ("item%d ", pl->ns->itemcmd);
288	sl.len=strlen((char*)sl.buf);	436	sl << uint32 (0);
289	SockList_AddInt(&sl, 0);
290	got_one=0;	437	got_one = 0;
291	}	438	}
292	} /* If LOOK_OBJ() */	439	}
293	}	440	}
		441
294	if (got_one)	442	if (got_one)
295	Send_With_Handling(&pl->contr->socket, &sl);	443	pl->ns->send_packet (sl);
296		444
297	free(sl.buf);
298	}	445	}
299		446
300	/**	447	/**
301	* Sends whole inventory.	448	* Sends whole inventory.
302	*/	449	*/
		450	void
303	void esrv_send_inventory(object pl, object op)	451	esrv_send_inventory (object pl, object op)
304	{	452	{
305	object *tmp;	453	if (!pl->contr->ns)//D
		454	return;
		455
306	int got_one=0;	456	int got_one = 0;
307	SockList sl;	457
		458	pl->contr->ns->send_packet_printf ("delinv %d", op->count);
		459
		460	packet sl;
		461	sl.printf ("item%d ", pl->contr->ns->itemcmd);
		462
		463	sl << uint32 (op->count);
		464
		465	for (object *tmp = op->inv; tmp; tmp = tmp->below)
308		466	{
309	sl.buf= (unsigned char *) malloc(MAXSOCKBUF);
310
311	sprintf((char*)sl.buf,"delinv %d", op->count);
312	sl.len=strlen((char*)sl.buf);
313	Send_With_Handling(&pl->contr->socket, &sl);
314
315	sprintf((char*)sl.buf,"item%d ", pl->contr->socket.itemcmd);
316	sl.len=strlen((char*)sl.buf);
317
318	SockList_AddInt(&sl, op->count);
319
320	for (tmp=op->inv; tmp; tmp=tmp->below) {
321	object *head;	467	object *head;
322		468
		469	if (tmp->head)
323	if (tmp->head) head = tmp->head;	470	head = tmp->head;
		471	else
324	else head = tmp;	472	head = tmp;
325		473
326	if (LOOK_OBJ(head)) {	474	if (head->client_visible ())
327	add_object_to_socklist(&pl->contr->socket, &sl, head);
328		475	{
		476	add_object_to_socklist (*pl->contr->ns, sl, head);
		477
329	got_one++;	478	got_one++;
330		479
331	/* IT is possible for players to accumulate a huge amount of	480	/* IT is possible for players to accumulate a huge amount of
332	* items (especially with some of the bags out there) to	481	* items (especially with some of the bags out there) to
333	* overflow the buffer. IF so, send multiple item commands.	482	* overflow the buffer. IF so, send multiple item commands.
334	*/	483	*/
335	if (sl.len >= (MAXSOCKBUF-MAXITEMLEN)) {	484	if (sl.length () > MAXSOCKBUF - MAXITEMLEN)
336	Send_With_Handling(&pl->contr->socket, &sl);	485	{
		486	pl->contr->ns->send_packet (sl);
		487
		488	sl.reset ();
337	sprintf((char*)sl.buf,"item%d ", pl->contr->socket.itemcmd);	489	sl.printf ("item%d ", pl->contr->ns->itemcmd);
338	sl.len=strlen((char*)sl.buf);	490	sl << uint32 (op->count);
339	SockList_AddInt(&sl, op->count);
340	got_one=0;	491	got_one = 0;
341	}	492	}
342	} /* If LOOK_OBJ() */	493	}
343	}	494	}
		495
344	if (got_one)	496	if (got_one)
345	Send_With_Handling(&pl->contr->socket, &sl);	497	pl->contr->ns->send_packet (sl);
346	free(sl.buf);
347	}	498	}
348		499
349	/**	500	/**
350	* Updates object op for player pl.	501	* Updates object op for player pl.
351	*	502	*
352	* flags is a list of values to update	503	* flags is a list of values to update
353	* to the client (as defined in newclient.h - might as well use the	504	* to the client (as defined in newclient.h - might as well use the
354	* same value both places.	505	* same value both places.
355	*/	506	*/
356		507	void
357	void esrv_update_item(int flags, object pl, object op)	508	esrv_update_item (int flags, object pl, object op)
358	{	509	{
359	SockList sl;
360
361	/* If we have a request to send the player item, skip a few checks. */	510	/* If we have a request to send the player item, skip a few checks. */
362	if (op!=pl) {	511	if (op != pl)
363	if (! LOOK_OBJ(op))	512	{
		513	if (!op->client_visible ())
364	return;	514	return;
365	/* we remove the check for op->env, because in theory, the object	515	/* we remove the check for op->env, because in theory, the object
366	* is hopefully in the same place, so the client should preserve	516	* is hopefully in the same place, so the client should preserve
367	* order.	517	* order.
368	*/	518	*/
369	}	519	}
		520
		521	client *ns = pl->contr->ns;
		522	if (!ns)
		523	return;
		524
370	if (!QUERY_FLAG(op, FLAG_CLIENT_SENT)) {	525	if (!QUERY_FLAG (op, FLAG_CLIENT_SENT))
		526	{
371	/* FLAG_CLIENT_SENT is debug only. We are using it to see where	527	/* FLAG_CLIENT_SENT is debug only. We are using it to see where
372	* this is happening - we can set a breakpoint here in the debugger	528	* this is happening - we can set a breakpoint here in the debugger
373	* and track back the call.	529	* and track back the call.
374	*/	530	*/
375	LOG(llevDebug,"We have not sent item %s (%d)\n", op->name, op->count);	531	LOG (llevDebug, "We have not sent item %s (%d)\n", &op->name, op->count);
376	}	532	}
377	sl.buf= (unsigned char *) malloc(MAXSOCKBUF);
378		533
379	strcpy((char*)sl.buf,"upditem ");	534	packet sl ("upditem");
380	sl.len=strlen((char*)sl.buf);
381		535
382	SockList_AddChar(&sl, (char) flags);	536	sl << uint8 (flags);
383		537
384	if (op->head) op=op->head;	538	if (op->head)
		539	op = op->head;
385		540
386	SockList_AddInt(&sl, op->count);	541	sl << uint32 (op->count);
387		542
388	if (flags & UPD_LOCATION)	543	if (flags & UPD_LOCATION)
389	SockList_AddInt(&sl, op->env? op->env->count:0);	544	sl << uint32 (op->env ? op->env->count : 0);
390		545
391	if (flags & UPD_FLAGS)	546	if (flags & UPD_FLAGS)
392	SockList_AddInt(&sl, query_flags(op));	547	sl << uint32 (query_flags (op));
393		548
394	if (flags & UPD_WEIGHT) {	549	if (flags & UPD_WEIGHT)
395	sint32 weight = WEIGHT(op);	550	{
		551	sint32 weight = op->client_weight ();
396		552
397	SockList_AddInt(&sl, QUERY_FLAG(op, FLAG_NO_PICK) ? -1 : weight);	553	sl << uint32 (QUERY_FLAG (op, FLAG_NO_PICK) ? -1 : weight);
		554
		555	#if 0
398	if (pl == op) {	556	if (pl == op)
399	op->contr->last_weight = weight;	557	ns->last_weight = weight;
400	}	558	#endif
401	}	559	}
402		560
403	if (flags & UPD_FACE) {	561	if (flags & UPD_FACE)
404	if (!(pl->contr->socket.faces_sent[op->face->number] & NS_FACESENT_FACE))
405	esrv_send_face(&pl->contr->socket, op->face->number,0);
406	SockList_AddInt(&sl, op->face->number);
407	}	562	{
		563	ns->send_face (op->face, -50);
		564	ns->flush_fx ();
		565	sl << uint32 (op->face);
		566	}
		567
408	if (flags & UPD_NAME) {	568	if (flags & UPD_NAME)
		569	{
409	int len;	570	int len;
410	const char *item_p;	571	const char *item_p;
411	char item_n[MAX_BUF];	572	char item_n[MAX_BUF];
412		573
413	if (!op->custom_name) {	574	if (!op->custom_name)
		575	{
414	strncpy(item_n,query_base_name(op, 0),127);	576	strncpy (item_n, query_base_name (op, 0), 127);
415	item_n[127]=0;	577	item_n[127] = 0;
416	len=strlen(item_n);	578	len = strlen (item_n);
417	item_p=query_base_name(op, 1);	579	item_p = query_base_name (op, 1);
		580	}
		581	else
418	}	582	{
419	else {
420	strncpy(item_n,op->custom_name,127);	583	strncpy (item_n, op->custom_name, 127);
421	item_n[127]=0;	584	item_n[127] = 0;
422	len=strlen(item_n);	585	len = strlen (item_n);
423	item_p=op->custom_name;	586	item_p = op->custom_name;
424	}	587	}
425		588
426	strncpy(item_n+len+1, item_p, 127);	589	strncpy (item_n + len + 1, item_p, 127);
427	item_n[254]=0;	590	item_n[254] = 0;
428	len += strlen(item_n+1+len) + 1;	591	len += strlen (item_n + 1 + len) + 1;
429	SockList_AddChar(&sl, (char)len);	592
430	memcpy(sl.buf+sl.len, item_n, len);	593	sl << data8 (item_n, len);
431	sl.len += len;
432	}	594	}
		595
433	if (flags & UPD_ANIM)	596	if (flags & UPD_ANIM)
434	SockList_AddShort(&sl,op->animation_id);	597	sl << uint16 (op->animation_id);
435		598
436	if (flags & UPD_ANIMSPEED) {	599	if (flags & UPD_ANIMSPEED)
		600	{
437	int anim_speed=0;	601	int anim_speed = 0;
		602
438	if (QUERY_FLAG(op,FLAG_ANIMATE)) {	603	if (QUERY_FLAG (op, FLAG_ANIMATE))
		604	{
		605	if (op->anim_speed)
439	if (op->anim_speed) anim_speed=op->anim_speed;	606	anim_speed = op->anim_speed;
		607	else
		608	{
		609	if (fabs (op->speed) < 0.001)
		610	anim_speed = 255;
		611	else if (fabs (op->speed) >= 1.0)
		612	anim_speed = 1;
440	else {	613	else
441	if (FABS(op->speed)<0.001) anim_speed=255;
442	else if (FABS(op->speed)>=1.0) anim_speed=1;
443	else anim_speed = (int) (1.0/FABS(op->speed));	614	anim_speed = (int) (1.0 / fabs (op->speed));
444	}	615	}
445	if (anim_speed>255) anim_speed=255;	616
		617	if (anim_speed > 255)
		618	anim_speed = 255;
446	}	619	}
447	SockList_AddChar(&sl, (char)anim_speed);	620
		621	sl << uint8 (anim_speed);
448	}	622	}
		623
449	if (flags & UPD_NROF)	624	if (flags & UPD_NROF)
450	SockList_AddInt(&sl, op->nrof);	625	sl << uint32 (op->nrof);
451		626
452	Send_With_Handling(&pl->contr->socket, &sl);	627	pl->contr->ns->send_packet (sl);
453	free(sl.buf);
454	}	628	}
455		629
456	/**	630	/**
457	* Sends item's info to player.	631	* Sends item's info to player.
458	*/	632	*/
		633	void
459	void esrv_send_item(object pl, objectop)	634	esrv_send_item (object pl, object op)
460	{	635	{
461	SockList sl;	636	if (!pl->contr->ns)
462		637	return;
		638
463	/* If this is not the player object, do some more checks */	639	/* If this is not the player object, do some more checks */
464	if (op!=pl) {	640	if (op != pl)
		641	{
465	/* We only send 'visibile' objects to the client */	642	/* We only send 'visible' objects to the client */
466	if (! LOOK_OBJ(op))	643	if (!op->client_visible ())
467	return;	644	return;
		645
468	/* if the item is on the ground, mark that the look needs to	646	/* if the item is on the ground, mark that the look needs to
469	* be updated.	647	* be updated.
470	*/	648	*/
471	if (!op->env) {	649	if (!op->env)
472	pl->contr->socket.update_look=1;	650	{
		651	pl->contr->ns->floorbox_update ();
473	return;	652	return;
474	}	653	}
475	}	654	}
476		655
477	sl.buf= (unsigned char *) malloc(MAXSOCKBUF);	656	packet sl;
478		657
479	sprintf((char*)sl.buf,"item%d ", pl->contr->socket.itemcmd);	658	sl.printf ("item%d ", pl->contr->ns->itemcmd);
480	sl.len=strlen((char*)sl.buf);
481		659
482	if (op->head) op=op->head;	660	if (op->head)
		661	op = op->head;
483		662
484	SockList_AddInt(&sl, op->env? op->env->count:0);	663	sl << uint32 (op->env ? op->env->count : 0);
485		664
486	add_object_to_socklist(&pl->contr->socket, &sl, op);	665	add_object_to_socklist (*pl->contr->ns, sl, op);
487		666
488	Send_With_Handling(&pl->contr->socket, &sl);	667	pl->contr->ns->send_packet (sl);
489	SET_FLAG(op, FLAG_CLIENT_SENT);	668	SET_FLAG (op, FLAG_CLIENT_SENT);
490	free(sl.buf);
491	}	669	}
492		670
493	/**	671	/**
494	* Tells the client to delete an item. Uses the item	672	* Tells the client to delete an item.
495	* command with a -1 location.
496	*/	673	*/
497		674	void
498	void esrv_del_item(player *pl, int tag)	675	esrv_del_item (player *pl, int tag)
499	{	676	{
500	SockList sl;	677	if (!pl->ns)
		678	return;
501		679
502	sl.buf= (unsigned char *) malloc(MAXSOCKBUF);	680	packet sl ("delitem");
503		681
504	strcpy((char*)sl.buf,"delitem ");	682	sl << uint32 (tag);
505	sl.len=strlen((char*)sl.buf);
506	SockList_AddInt(&sl, tag);
507		683
508	Send_With_Handling(&pl->socket, &sl);	684	pl->ns->send_packet (sl);
509	free(sl.buf);
510	}	685	}
511		686
512		687
513	/*******************************************************************************	688	/*******************************************************************************
514	*	689	*
…		…
518		693
519	/**	694	/**
520	* Takes a player and object count (tag) and returns the actual object	695	* Takes a player and object count (tag) and returns the actual object
521	* pointer, or null if it can't be found.	696	* pointer, or null if it can't be found.
522	*/	697	*/
523		698	object *
524	object esrv_get_ob_from_count(object pl, tag_t count)	699	esrv_get_ob_from_count (object *pl, tag_t count)
525	{	700	{
526	object op, tmp;	701	if (pl->count == count)
		702	return pl;
527		703
		704	for (object *op = pl->inv; op; op = op->below)
528	if (pl->count == count)	705	if (op->count == count)
529	return pl;	706	return op;
530
531	for(op = pl->inv; op; op = op->below)
532	if (op->count == count)
533	return op;
534	else if (op->type == CONTAINER && pl->container == op)	707	else if (op->type == CONTAINER && pl->container == op)
535	for(tmp = op->inv; tmp; tmp = tmp->below)	708	for (object *tmp = op->inv; tmp; tmp = tmp->below)
536	if (tmp->count == count)	709	if (tmp->count == count)
537	return tmp;
538
539	for(op = get_map_ob (pl->map, pl->x, pl->y); op; op = op->above)
540	if (op->head != NULL && op->head->count == count)
541	return op;	710	return tmp;
		711
		712	for (object *op = GET_MAP_OB (pl->map, pl->x, pl->y); op; op = op->above)
		713	if (op->head && op->head->count == count)
		714	return op;
542	else if (op->count == count)	715	else if (op->count == count)
543	return op;	716	return op;
544	else if (op->type == CONTAINER && pl->container == op)	717	else if (op->type == CONTAINER && pl->container == op)
545	for(tmp = op->inv; tmp; tmp = tmp->below)	718	for (object *tmp = op->inv; tmp; tmp = tmp->below)
546	if (tmp->count == count)	719	if (tmp->count == count)
547	return tmp;	720	return tmp;
548		721
		722	#if 0
		723	/* If the high bit is set, player examined a pseudo object. */
		724	if (count & 0x80000000)
549	return NULL;	725	return 0;
550	}	726	#endif
551		727
		728	return 0;
		729	}
552		730
553	/** Client wants to examine some object. So lets do so. */	731	/** Client wants to examine some object. So lets do so. */
		732	void
554	void ExamineCmd(char buf, int len,player pl)	733	ExamineCmd (char buf, int len, player pl)
555	{	734	{
556	long tag = atoi(buf);	735	tag_t tag = atoi (buf);
		736
557	object *op = esrv_get_ob_from_count(pl->ob, tag);	737	object *op = esrv_get_ob_from_count (pl->ob, tag);
558		738
559	if (!op) {	739	if (!op)
		740	{
560	LOG(llevDebug, "Player '%s' tried to examine the unknown object (%ld)\n",	741	LOG (llevDebug, "Player '%s' tried to examine the unknown object (%ld)\n", &pl->ob->name, tag);
561	pl->ob->name, tag);
562	return;	742	return;
563	}	743	}
		744
564	examine (pl->ob, op);	745	examine (pl->ob, op);
565	}	746	}
566		747
		748	/** Client wants to examine some object. So lets do so. */
		749	void
		750	ExCmd (char buf, int len, player pl)
		751	{
		752	tag_t tag = atoi (buf);
		753
		754	if (object *op = esrv_get_ob_from_count (pl->ob, tag))
		755	{
		756	std::string s = op->describe (pl->ob);
		757
		758	packet sl ("ex");
		759	sl << ber32 (tag) << s.c_str ();
		760
		761	pl->ns->send_packet (sl);
		762	}
		763	}
		764
567	/** Client wants to apply some object. Lets do so. */	765	/** Client wants to apply some object. Lets do so. */
		766	void
568	void ApplyCmd(char buf, int len,player pl)	767	ApplyCmd (char buf, int len, player pl)
569	{	768	{
570	uint32 tag = atoi(buf);	769	tag_t tag = atoi (buf);
571	object *op = esrv_get_ob_from_count(pl->ob, tag);
572		770
573	/* sort of a hack, but if the player saves and the player then manually	771	/* sort of a hack, but if the player saves and the player then manually
574	* applies a savebed (or otherwise tries to do stuff), we run into trouble.	772	* applies a savebed (or otherwise tries to do stuff), we run into trouble.
575	*/	773	*/
576	if (QUERY_FLAG(pl->ob, FLAG_REMOVED)) return;	774	if (QUERY_FLAG (pl->ob, FLAG_REMOVED))
		775	return;
577		776
578	/* If the high bit is set, player applied a pseudo object. */	777	/* If the high bit is set, player applied a pseudo object. */
579	if (tag & 0x80000000) {	778	if (tag & 0x80000000)
		779	{
580	pl->socket.look_position = tag & 0x7fffffff;	780	pl->ns->look_position = tag & 0x7fffffff;
581	pl->socket.update_look = 1;	781	pl->ns->floorbox_update ();
582	return;	782	return;
583	}	783	}
584		784
		785	object *op = esrv_get_ob_from_count (pl->ob, tag);
		786
585	if (!op) {	787	if (!op)
		788	{
586	LOG(llevDebug, "Player '%s' tried to apply the unknown object (%d)\n",	789	LOG (llevDebug, "Player '%s' tried to apply the unknown object (%d)\n", &pl->ob->name, tag);
587	pl->ob->name, tag);
588	return;	790	return;
589	}	791	}
		792
590	player_apply (pl->ob, op, 0, 0);	793	player_apply (pl->ob, op, 0, 0);
591	}	794	}
592		795
593	/** Client wants to apply some object. Lets do so. */	796	/** Client wants to lock some object. Lets do so. */
		797	void
594	void LockItem(uint8 data, int len,player pl)	798	LockItem (char data, int len, player pl)
595	{	799	{
596	int flag, tag;
597	object *op;
598
599	flag = data[0];	800	int flag = data[0];
600	tag = GetInt_String(data+1);	801	tag_t tag = net_uint32 ((uint8 *)data + 1);
601	op = esrv_get_ob_from_count(pl->ob, tag);	802	object *op = esrv_get_ob_from_count (pl->ob, tag);
602		803
603	if (!op) {	804	if (!op)
604	new_draw_info(NDI_UNIQUE, 0, pl->ob,"Could not find object to lock/unlock");	805	{
		806	pl->failmsg ("Could not find object to lock/unlock");
605	return;	807	return;
606	}	808	}
		809
607	if (!flag)	810	if (!flag)
608	CLEAR_FLAG(op,FLAG_INV_LOCKED);	811	CLEAR_FLAG (op, FLAG_INV_LOCKED);
609	else	812	else
610	SET_FLAG(op,FLAG_INV_LOCKED);	813	SET_FLAG (op, FLAG_INV_LOCKED);
		814
611	esrv_update_item(UPD_FLAGS, pl->ob, op);	815	esrv_update_item (UPD_FLAGS, pl->ob, op);
612	}	816	}
613		817
614	/** Client wants to apply some object. Lets do so. */	818	/** Client wants to mark some object. Lets do so. */
		819	void
615	void MarkItem(uint8 data, int len,player pl)	820	MarkItem (char data, int len, player pl)
616	{	821	{
617	int tag;	822	tag_t tag = net_uint32 ((uint8 *)data);
618	object *op;
619
620	tag = GetInt_String(data);
621	op = esrv_get_ob_from_count(pl->ob, tag);	823	object *op = esrv_get_ob_from_count (pl->ob, tag);
		824
622	if (!op) {	825	if (!op)
623	new_draw_info(NDI_UNIQUE, 0, pl->ob,"Could not find object to mark");	826	{
		827	pl->failmsg ("Could not find object to mark");
624	return;	828	return;
625	}	829	}
		830
626	pl->mark = op;	831	pl->mark = op;
627	pl->mark_count = op->count;	832	pl->ob->statusmsg (format ("Marked item %s", query_name (op)));
628	new_draw_info_format(NDI_UNIQUE, 0, pl->ob, "Marked item %s", query_name(op));
629	}	833	}
630
631		834
632	/**	835	/**
633	* look_at prints items on the specified square.	836	* look_at prints items on the specified square.
634	*	837	*
635	* [ removed EARTHWALL check and added check for containers inventory.	838	* [ removed EARTHWALL check and added check for containers inventory.
636	* Tero.Haatanen@lut.fi ]	839	* Tero.Haatanen@lut.fi ]
637	*/	840	*/
638	void look_at(object *op,int dx,int dy) {	841	static void
639	object *tmp;	842	look_at (player *pl, int dx, int dy)
640	int flag=0;	843	{
641	sint16 x,y;	844	dynbuf_text buf;
642	mapstruct *m;	845	object *ob = pl->ob;
643		846
644	x = op->x + dx;	847	if (!pl->observe->map)
645	y = op->y + dy;	848	return;
646		849
647	if (out_of_map(op->map, x, y)) return;	850	mapxy pos (pl->observe);
		851	pos.move (dx, dy);
648		852
649	m = get_map_from_coord(op->map, &x, &y);	853	if (pos.normalise ())
650	if (!m) return;	854	for (object *tmp = pos->top; tmp; tmp = tmp->below)
651		855	{
652	for(tmp=get_map_ob(m, x ,y);tmp!=NULL&&tmp->above!=NULL;
653	tmp=tmp->above);
654
655	for ( ; tmp != NULL; tmp=tmp->below ) {
656	if (tmp->invisible && !QUERY_FLAG(op, FLAG_WIZ)) continue;	856	if (tmp->invisible && !QUERY_FLAG (ob, FLAG_WIZ))
		857	continue;
657		858
658	if(!flag) {	859	if (QUERY_FLAG (ob, FLAG_WIZ))
659	if(dx\|\|dy)	860	buf.printf ("- %s (%d).\n", query_name (tmp), tmp->count);
660	new_draw_info(NDI_UNIQUE, 0,op,"There you see:");	861	else
		862	buf.printf ("- %s.\n", query_name (tmp));
		863
		864	object *head = tmp->head_ ();
		865
		866	if (head->inv)
		867	if ((head->type != CONTAINER && head->type != FLESH)
		868	\|\| QUERY_FLAG (ob, FLAG_WIZ))
		869	buf << head->query_inventory (ob, " ");
		870
		871	if (QUERY_FLAG (tmp, FLAG_IS_FLOOR) && !QUERY_FLAG (ob, FLAG_WIZ)) /* don't continue under the floor */
		872	break;
		873	}
		874
		875	if (buf.empty ())
		876	pl->failmsg ("You see nothing there.");
		877	else
		878	pl->infobox (MSG_CHANNEL ("lookat"), buf);
		879	}
		880
		881	/** Client wants to look at some object. Lets do so. */
		882	void
		883	LookAt (char buf, int len, player pl)
		884	{
		885	char *cp;
		886
		887	int dx = atoi (buf);
		888	if (!(cp = strchr (buf, ' ')))
		889	return;
		890
		891	int dy = atoi (cp);
		892
		893	if (player *opl = pl->observe->contr)
		894	if (client *ns = opl->ns)
		895	{
		896	if (fabs (dx) > ns->mapx / 2 \|\| fabs (dy) > ns->mapy / 2)
		897	return;
		898
		899	if (opl->blocked_los[dx + ns->mapx / 2][dy + ns->mapy / 2])
		900	return;
		901	}
		902
		903	look_at (pl, dx, dy);
		904	}
		905
		906	/** Move an object to a new location */
		907	void
		908	esrv_move_object (object *pl, tag_t to, tag_t tag, long nrof)
		909	{
		910	object op, env;
		911
		912	op = esrv_get_ob_from_count (pl, tag);
		913	if (!op)
		914	{
		915	LOG (llevDebug, "Player '%s' tried to move an unknown object (%ld)\n", &pl->name, tag);
		916	return;
		917	}
		918
		919	if (!to)
		920	{ /* drop it to the ground */
		921	if (op->map && !op->env)
		922	return;
		923
		924	/* If it is an active container, then we should drop all objects
		925	* in the container and not the container itself.
		926	*/
		927	if (op->inv && QUERY_FLAG (op, FLAG_APPLIED))
		928	{
		929	int cnt = MAX_ITEM_PER_DROP;
		930
		931	for (object *current = op->inv; current; )
661	else {	932	{
662	clear_win_info(op);	933	object *next = current->below;
663	new_draw_info(NDI_UNIQUE, 0,op,"You see:");	934
		935	drop_object (pl, current, 0);
		936
		937	if (--cnt <= 0) break;
		938
		939	current = next;
664	}	940	}
665	flag=1;	941
		942	if (cnt <= 0)
		943	op->failmsg ("Only dropped some items, can't drop that many items at once.");
666	}	944	}
667
668	if (QUERY_FLAG(op, FLAG_WIZ))
669	new_draw_info_format(NDI_UNIQUE,0, op, "- %s (%d).",query_name(tmp),tmp->count);
670	else
671	new_draw_info_format(NDI_UNIQUE,0, op, "- %s.",query_name(tmp));
672
673	if (((tmp->inv!=NULL \|\| (tmp->head && tmp->head->inv)) &&
674	(tmp->type != CONTAINER && tmp->type!=FLESH)) \|\| QUERY_FLAG(op, FLAG_WIZ))
675	inventory(op,tmp->head==NULL?tmp:tmp->head);
676
677	if(QUERY_FLAG(tmp, FLAG_IS_FLOOR)&&!QUERY_FLAG(op, FLAG_WIZ)) /* don't continue under the floor */
678	break;
679	}
680
681	if(!flag) {
682	if(dx\|\|dy)
683	new_draw_info(NDI_UNIQUE, 0,op,"You see nothing there.");
684	else	945	else
685	new_draw_info(NDI_UNIQUE, 0,op,"You see nothing.");	946	drop_object (pl, op, nrof);
686	}
687	}
688		947
		948	update_after_inventory_change (pl);
689		949
690		950	return;
691	/** Client wants to look at some object. Lets do so. */	951	}
692	void LookAt(char buf, int len,player pl)	952	else if (to == pl->count)
693	{	953	{ /* pick it up to the inventory */
694	int dx, dy;	954	/* return if player has already picked it up */
695	char *cp;	955	if (op->env == pl)
696
697	dx=atoi(buf);
698	if (!(cp=strchr(buf,' '))) {
699	return;	956	return;
700	}
701	dy=atoi(cp);
702		957
703	if (FABS(dx) > pl->socket.mapx / 2 \|\| FABS(dy) > pl->socket.mapy / 2)
704	return;
705
706	if(pl->blocked_los[dx + pl->socket.mapx / 2][dy + pl->socket.mapy / 2])
707	return;
708
709	look_at(pl->ob, dx, dy);
710	}
711
712	/** Move an object to a new location */
713	void esrv_move_object (object *pl, tag_t to, tag_t tag, long nrof)
714	{
715	object op, env;
716
717	op = esrv_get_ob_from_count(pl, tag);
718	if (!op) {
719	LOG(llevDebug, "Player '%s' tried to move an unknown object (%ld)\n",
720	pl->name, tag);
721	return;
722	}
723
724	if (!to) { /* drop it to the ground */
725	/* LOG(llevDebug, "Drop it on the ground.\n");*/
726
727	if (op->map && !op->env) {
728	/* LOG(llevDebug,"Dropping object to ground that is already on ground\n");*/
729	return;
730	}
731	/* If it is an active container, then we should drop all objects
732	* in the container and not the container itself.
733	*/
734	if (op->inv && QUERY_FLAG(op, FLAG_APPLIED)) {
735	object current, next;
736	for (current=op->inv; current!=NULL; current=next) {
737	next=current->below;
738	drop_object(pl, current, 0);
739	}
740	esrv_update_item(UPD_WEIGHT, pl, op);
741	}
742	else {
743	drop_object (pl, op, nrof);
744	}
745	return;
746	} else if (to == pl->count) { /* pick it up to the inventory */
747	/* return if player has already picked it up */
748	if (op->env == pl) return;
749
750	pl->contr->count = nrof;	958	pl->contr->count = nrof;
751	pick_up(pl, op);	959	pick_up (pl, op);
752	return ;	960	return;
753	}	961	}
		962
754	env = esrv_get_ob_from_count(pl, to);	963	env = esrv_get_ob_from_count (pl, to);
755	if (!env) {	964	if (!env)
756	LOG(llevDebug,	965	{
757	"Player '%s' tried to move object to the unknown location (%d)\n",	966	LOG (llevDebug, "Player '%s' tried to move object to the unknown location (%d)\n", &pl->name, to);
758	pl->name, to);
759	return;	967	return;
760	}	968	}
		969
761	/* put_object_in_sack presumes that necessary sanity checking	970	/* put_object_in_sack presumes that necessary sanity checking
762	* has already been done (eg, it can be picked up and fits in	971	* has already been done (eg, it can be picked up and fits in
763	* in a sack, so check for those things. We should also check	972	* in a sack, so check for those things. We should also check
764	* an make sure env is in fact a container for that matter.	973	* an make sure env is in fact a container for that matter.
765	*/	974	*/
766	if (env->type == CONTAINER
767	&& can_pick(pl, op) && sack_can_hold(pl, env, op, nrof)) {	975	if (env->type == CONTAINER && can_pick (pl, op) && sack_can_hold (pl, env, op, nrof))
		976	{
768	put_object_in_sack (pl, env, op, nrof);	977	put_object_in_sack (pl, env, op, nrof);
		978	update_after_inventory_change (pl);
769	}	979	}
770	}	980	}
771		981
772

Diff Legend

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

Comparing deliantra/server/socket/item.C (file contents): Revision 1.3 by root, Tue Aug 29 08:01:38 2006 UTC vs. Revision 1.60 by root, Tue Apr 22 07:01:47 2008 UTC

Diff Legend

Comparing deliantra/server/socket/item.C (file contents):
Revision 1.3 by root, Tue Aug 29 08:01:38 2006 UTC vs.
Revision 1.60 by root, Tue Apr 22 07:01:47 2008 UTC