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

Comparing deliantra/server/socket/item.C (file contents):
Revision 1.4 by root, Sun Sep 3 00:18:43 2006 UTC vs.
Revision 1.48 by root, Fri Jun 8 09:18:31 2007 UTC

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

Diff Legend

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

Comparing deliantra/server/socket/item.C (file contents): Revision 1.4 by root, Sun Sep 3 00:18:43 2006 UTC vs. Revision 1.48 by root, Fri Jun 8 09:18:31 2007 UTC

Diff Legend

Comparing deliantra/server/socket/item.C (file contents):
Revision 1.4 by root, Sun Sep 3 00:18:43 2006 UTC vs.
Revision 1.48 by root, Fri Jun 8 09:18:31 2007 UTC