ViewVC Help

View File | Revision Log | Show Annotations | Download File

/cvs/deliantra/server/socket/request.C

Comparing deliantra/server/socket/request.C (file contents):
Revision 1.17 by root, Tue Sep 12 19:20:09 2006 UTC vs.
Revision 1.39 by root, Fri Dec 15 03:53:44 2006 UTC

1
2	/*
3	* static char *rcsid_init_c =
4	* "$Id: request.C,v 1.17 2006/09/12 19:20:09 root Exp $";
5	*/
6
7	/*	1	/*
8	CrossFire, A Multiplayer game for X-windows	2	CrossFire, A Multiplayer game for X-windows
9		3
10	Copyright (C) 2001 Mark Wedel	4	Copyright (C) 2001 Mark Wedel
11	Copyright (C) 1992 Frank Tore Johansen	5	Copyright (C) 1992 Frank Tore Johansen
…		…
22		16
23	You should have received a copy of the GNU General Public License	17	You should have received a copy of the GNU General Public License
24	along with this program; if not, write to the Free Software	18	along with this program; if not, write to the Free Software
25	Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.	19	Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
26		20
27	The author can be reached via e-mail to crossfire-devel@real-time.com	21	The author can be reached via e-mail to <crossfire@schmorp.de>
28	*/	22	*/
29		23
30	/**	24	/**
31	* \file	25	* \file
32	* Client handling.	26	* Client handling.
…		…
47	* if a face has not already been sent to the client, it is sent now.	41	* if a face has not already been sent to the client, it is sent now.
48	*	42	*
49	* mapcellchanged, compactlayer, compactstack, perform the map compressing	43	* mapcellchanged, compactlayer, compactstack, perform the map compressing
50	* operations	44	* operations
51	*	45	*
52	* esrv_map_doneredraw finishes the map update, and ships across the
53	* map updates.
54	*
55	* esrv_map_scroll tells the client to scroll the map, and does similarily
56	* for the locally cached copy.
57	*/	46	*/
58		47
59	#include <global.h>	48	#include <global.h>
60	#include <sproto.h>	49	#include <sproto.h>
61		50
…		…
65	#include <commands.h>	54	#include <commands.h>
66		55
67	/* This block is basically taken from socket.c - I assume if it works there,	56	/* This block is basically taken from socket.c - I assume if it works there,
68	* it should work here.	57	* it should work here.
69	*/	58	*/
70	#ifndef WIN32 /* ---win32 exclude unix headers */
71	# include <sys/types.h>	59	#include <sys/types.h>
72	# include <sys/time.h>	60	#include <sys/time.h>
73	# include <sys/socket.h>	61	#include <sys/socket.h>
74	# include <netinet/in.h>	62	#include <netinet/in.h>
75	# include <netdb.h>	63	#include <netdb.h>
76	#endif /* win32 */
77		64
78	#ifdef HAVE_UNISTD_H
79	# include <unistd.h>	65	#include <unistd.h>
80	#endif
81
82	#ifdef HAVE_SYS_TIME_H
83	# include <sys/time.h>	66	#include <sys/time.h>
84	#endif
85		67
86	#include "sounds.h"	68	#include "sounds.h"
87		69
88	/**	70	/**
89	* This table translates the attack numbers as used within the	71	* This table translates the attack numbers as used within the
…		…
106	-1, /* life stealing */	88	-1, /* life stealing */
107	-1 /* Disease - not fully done yet */	89	-1 /* Disease - not fully done yet */
108	};	90	};
109		91
110	static void	92	static void
111	socket_map_scroll (NewSocket * ns, int dx, int dy)	93	socket_map_scroll (client_socket * ns, int dx, int dy)
112	{	94	{
113	struct Map newmap;	95	struct Map newmap;
114	int x, y, mx, my;	96	int x, y, mx, my;
115		97
116	{	98	{
117	char buf[MAXSOCKBUF];	99	packet sl;
118		100
119	sprintf (buf, "map_scroll %d %d", dx, dy);	101	sl.printf ("map_scroll %d %d", dx, dy);
120	Write_String_To_Socket (ns, buf, strlen (buf));	102	ns->send_packet (sl);
121	}	103	}
122		104
123	/* If we are using the Map1aCmd, we may in fact send	105	/* If we are using the Map1aCmd, we may in fact send
124	* head information that is outside the viewable map.	106	* head information that is outside the viewable map.
125	* So set the mx,my to the max value we want to	107	* So set the mx,my to the max value we want to
…		…
145	for (x = 0; x < mx; x++)	127	for (x = 0; x < mx; x++)
146	{	128	{
147	for (y = 0; y < my; y++)	129	for (y = 0; y < my; y++)
148	{	130	{
149	if (x >= ns->mapx || y >= ns->mapy)	131	if (x >= ns->mapx || y >= ns->mapy)
150	{
151	/* clear cells outside the viewable area */	132	/* clear cells outside the viewable area */
152	memset (&newmap.cells[x][y], 0, sizeof (struct MapCell));	133	memset (&newmap.cells[x][y], 0, sizeof (struct MapCell));
153	}
154	else if ((x + dx) < 0 || (x + dx) >= ns->mapx || (y + dy) < 0 || (y + dy) >= ns->mapy)	134	else if ((x + dx) < 0 || (x + dx) >= ns->mapx || (y + dy) < 0 || (y + dy) >= ns->mapy)
155	{
156	/* clear newly visible tiles within the viewable area */	135	/* clear newly visible tiles within the viewable area */
157	memset (&(newmap.cells[x][y]), 0, sizeof (struct MapCell));	136	memset (&(newmap.cells[x][y]), 0, sizeof (struct MapCell));
158	}
159	else	137	else
160	{
161	memcpy (&(newmap.cells[x][y]), &(ns->lastmap.cells[x + dx][y + dy]), sizeof (struct MapCell));	138	memcpy (&(newmap.cells[x][y]), &(ns->lastmap.cells[x + dx][y + dy]), sizeof (struct MapCell));
162	}
163	}	139	}
164	}	140	}
165		141
166	memcpy (&(ns->lastmap), &newmap, sizeof (struct Map));	142	memcpy (&(ns->lastmap), &newmap, sizeof (struct Map));
167		143
…		…
172	}	148	}
173		149
174	static void	150	static void
175	clear_map (player *pl)	151	clear_map (player *pl)
176	{	152	{
177	NewSocket & socket = pl->socket;	153	client_socket &socket = *pl->socket;
178		154
179	memset (&socket.lastmap, 0, sizeof (socket.lastmap));	155	memset (&socket.lastmap, 0, sizeof (socket.lastmap));
180		156
181	if (socket.newmapcmd == 1)	157	if (socket.newmapcmd == 1)
182	Write_String_To_Socket (&socket, "newmap", 6);	158	socket.send_packet ("newmap");
183		159
184	socket.update_look = 1;	160	socket.update_look = 1;
185	socket.look_position = 0;	161	socket.look_position = 0;
186	}	162	}
187		163
188	/** check for map change and send new map data */	164	/** check for map change and send new map data */
189	static void	165	static void
190	check_map_change (player *pl)	166	check_map_change (player *pl)
191	{	167	{
192	NewSocket & socket = pl->socket;	168	client_socket &socket = *pl->socket;
193	object *ob = pl->ob;	169	object *ob = pl->ob;
194	char buf[MAX_BUF]; /* eauugggh */	170	char buf[MAX_BUF]; /* eauugggh */
195		171
196	if (socket.current_map != ob->map)	172	if (socket.current_map != ob->map)
197	{	173	{
…		…
218	flags, socket.mapx / 2 - ob->x, socket.mapy / 2 - ob->y, ob->map->width, ob->map->height, ob->map->path);	194	flags, socket.mapx / 2 - ob->x, socket.mapy / 2 - ob->y, ob->map->width, ob->map->height, ob->map->path);
219	}	195	}
220	else	196	else
221	snprintf (buf, MAX_BUF, "mapinfo current");	197	snprintf (buf, MAX_BUF, "mapinfo current");
222		198
223	Write_String_To_Socket (&socket, buf, strlen (buf));	199	socket.send_packet (buf);
224	}	200	}
225	}	201	}
226	else if (socket.current_x != ob->x || socket.current_y != ob->y)	202	else if (socket.current_x != ob->x || socket.current_y != ob->y)
227	{	203	{
228	int dx = ob->x - socket.current_x;	204	int dx = ob->x - socket.current_x;
…		…
266	if (!strncmp (buf, "spatial ", 8))	242	if (!strncmp (buf, "spatial ", 8))
267	{	243	{
268	buf += 8;	244	buf += 8;
269		245
270	// initial map and its origin	246	// initial map and its origin
271	mapstruct *map = pl->ob->map;	247	maptile *map = pl->ob->map;
272	sint16 dx, dy;	248	sint16 dx, dy;
273	int mapx = pl->socket.mapx / 2 - pl->ob->x;	249	int mapx = pl->socket->mapx / 2 - pl->ob->x;
274	int mapy = pl->socket.mapy / 2 - pl->ob->y;	250	int mapy = pl->socket->mapy / 2 - pl->ob->y;
275	int max_distance = 8; // limit maximum path length to something generous	251	int max_distance = 8; // limit maximum path length to something generous
276		252
277	while (*buf && map && max_distance)	253	while (*buf && map && max_distance)
278	{	254	{
279	int dir = *buf++;	255	int dir = *buf++;
…		…
330	snprintf (bigbuf, MAX_BUF, "mapinfo %s nomap", token);	306	snprintf (bigbuf, MAX_BUF, "mapinfo %s nomap", token);
331	}	307	}
332	else	308	else
333	snprintf (bigbuf, MAX_BUF, "mapinfo %s unsupported", token);	309	snprintf (bigbuf, MAX_BUF, "mapinfo %s unsupported", token);
334		310
335	Write_String_To_Socket (&pl->socket, bigbuf, strlen (bigbuf));	311	pl->socket->send_packet (bigbuf);
336	}	312	}
337		313
338	/** This is the Setup cmd - easy first implementation */	314	/** This is the Setup cmd - easy first implementation */
339	void	315	void
340	SetUp (char *buf, int len, NewSocket * ns)	316	SetUp (char *buf, int len, client_socket * ns)
341	{	317	{
342	int s, slen;	318	int s, slen;
343	char *cmd, *param, cmdback[HUGE_BUF];	319	char *cmd, *param, cmdback[HUGE_BUF];
344		320
345	/* run through the cmds of setup	321	/* run through the cmds of setup
…		…
347	*	323	*
348	* we send the status of the cmd back, or a FALSE is the cmd is the server unknown	324	* we send the status of the cmd back, or a FALSE is the cmd is the server unknown
349	* The client then must sort this out	325	* The client then must sort this out
350	*/	326	*/
351		327
352	LOG (llevInfo, "Get SetupCmd:: %s\n", buf);	328	//LOG (llevInfo, "Get SetupCmd:: %s\n", buf);
		329
353	strcpy (cmdback, "setup");	330	strcpy (cmdback, "setup");
354	for (s = 0; s < len;)	331	for (s = 0; s < len; )
355	{	332	{
356
357	cmd = &buf[s];	333	cmd = &buf[s];
358		334
359	/* find the next space, and put a null there */	335	/* find the next space, and put a null there */
360	for (; buf[s] && buf[s] != ' '; s++);	336	for (; buf[s] && buf[s] != ' '; s++)
		337	;
		338
361	buf[s++] = 0;	339	buf[s++] = 0;
		340
362	while (buf[s] == ' ')	341	while (buf[s] == ' ')
363	s++;	342	s++;
364		343
365	if (s >= len)	344	if (s >= len)
366	break;	345	break;
367		346
368	param = &buf[s];	347	param = &buf[s];
369		348
370	for (; buf[s] && buf[s] != ' '; s++);	349	for (; buf[s] && buf[s] != ' '; s++)
		350	;
		351
371	buf[s++] = 0;	352	buf[s++] = 0;
		353
372	while (buf[s] == ' ')	354	while (buf[s] == ' ')
373	s++;	355	s++;
374		356
375	slen = strlen (cmdback);	357	slen = strlen (cmdback);
376	safe_strcat (cmdback, " ", &slen, HUGE_BUF);	358	safe_strcat (cmdback, " ", &slen, HUGE_BUF);
…		…
537	* report a failure to the client.	519	* report a failure to the client.
538	*/	520	*/
539	safe_strcat (cmdback, "FALSE", &slen, HUGE_BUF);	521	safe_strcat (cmdback, "FALSE", &slen, HUGE_BUF);
540	}	522	}
541	} /* for processing all the setup commands */	523	} /* for processing all the setup commands */
		524
542	LOG (llevInfo, "SendBack SetupCmd:: %s\n", cmdback);	525	LOG (llevInfo, "SendBack SetupCmd:: %s\n", cmdback);
543	Write_String_To_Socket (ns, cmdback, strlen (cmdback));	526	ns->send_packet (cmdback);
544	}	527	}
545		528
546	/**	529	/**
547	* The client has requested to be added to the game.	530	* The client has requested to be added to the game.
548	* This is what takes care of it. We tell the client how things worked out.	531	* This is what takes care of it. We tell the client how things worked out.
549	* I am not sure if this file is the best place for this function. however,	532	* I am not sure if this file is the best place for this function. however,
550	* it either has to be here or init_sockets needs to be exported.	533	* it either has to be here or init_sockets needs to be exported.
551	*/	534	*/
552	void	535	void
553	AddMeCmd (char *buf, int len, NewSocket * ns)	536	AddMeCmd (char *buf, int len, client_socket * ns)
554	{	537	{
555	Settings oldsettings;	538	Settings oldsettings;
556		539
557	oldsettings = settings;	540	oldsettings = settings;
558	if (ns->status != Ns_Add || add_player (ns))	541	if (ns->status != Ns_Add || add_player (ns))
559	{	542	ns->send_packet ("addme_failed");
560	Write_String_To_Socket (ns, "addme_failed", 12);
561	}
562	else	543	else
563	{	544	ns->send_packet ("addme_success");
564	/* Basically, the add_player copies the socket structure into	545
565	* the player structure, so this one (which is from init_sockets)
566	* is not needed anymore. The write below should still work, as the
567	* stuff in ns is still relevant.
568	*/
569	Write_String_To_Socket (ns, "addme_success", 13);
570	socket_info.nconns--;
571	ns->status = Ns_Avail;
572	}
573	settings = oldsettings;	546	settings = oldsettings;
574	}	547	}
575		548
576	/** Reply to ExtendedInfos command */	549	/** Reply to ExtendedInfos command */
577	void	550	void
578	ToggleExtendedInfos (char *buf, int len, NewSocket * ns)	551	ToggleExtendedInfos (char *buf, int len, client_socket * ns)
579	{	552	{
580	char cmdback[MAX_BUF];	553	char cmdback[MAX_BUF];
581	char command[50];	554	char command[50];
582	int info, nextinfo;	555	int info, nextinfo;
583		556
…		…
621	{	594	{
622	strcat (cmdback, " ");	595	strcat (cmdback, " ");
623	strcat (cmdback, "smoothing");	596	strcat (cmdback, "smoothing");
624	}	597	}
625		598
626	Write_String_To_Socket (ns, cmdback, strlen (cmdback));	599	ns->send_packet (cmdback);
627	}	600	}
628		601
629	/*	602	/*
630	#define MSG_TYPE_BOOK 1	603	#define MSG_TYPE_BOOK 1
631	#define MSG_TYPE_CARD 2	604	#define MSG_TYPE_CARD 2
…		…
634	#define MSG_TYPE_MONUMENT 5	607	#define MSG_TYPE_MONUMENT 5
635	#define MSG_TYPE_SCRIPTED_DIALOG 6*/	608	#define MSG_TYPE_SCRIPTED_DIALOG 6*/
636		609
637	/** Reply to ExtendedInfos command */	610	/** Reply to ExtendedInfos command */
638	void	611	void
639	ToggleExtendedText (char *buf, int len, NewSocket * ns)	612	ToggleExtendedText (char *buf, int len, client_socket * ns)
640	{	613	{
641	char cmdback[MAX_BUF];	614	char cmdback[MAX_BUF];
642	char temp[10];	615	char temp[10];
643	char command[50];	616	char command[50];
644	int info, nextinfo, i, flag;	617	int info, nextinfo, i, flag;
…		…
684	strcat (cmdback, " ");	657	strcat (cmdback, " ");
685	snprintf (temp, sizeof (temp), "%d", i);	658	snprintf (temp, sizeof (temp), "%d", i);
686	strcat (cmdback, temp);	659	strcat (cmdback, temp);
687	}	660	}
688		661
689	Write_String_To_Socket (ns, cmdback, strlen (cmdback));	662	ns->send_packet (cmdback);
690	}	663	}
691		664
692	/**	665	/**
693	* A lot like the old AskSmooth (in fact, now called by AskSmooth).	666	* A lot like the old AskSmooth (in fact, now called by AskSmooth).
694	* Basically, it makes no sense to wait for the client to request a	667	* Basically, it makes no sense to wait for the client to request a
695	* a piece of data from us that we know the client wants. So	668	* a piece of data from us that we know the client wants. So
696	* if we know the client wants it, might as well push it to the	669	* if we know the client wants it, might as well push it to the
697	* client.	670	* client.
698	*/	671	*/
699	static void	672	static void
700	SendSmooth (NewSocket * ns, uint16 face)	673	SendSmooth (client_socket * ns, uint16 face)
701	{	674	{
702	uint16 smoothface;	675	uint16 smoothface;
703	unsigned char reply[MAX_BUF];
704	SockList sl;
705		676
706	/* If we can't find a face, return and set it so we won't try to send this	677	/* If we can't find a face, return and set it so we won't try to send this
707	* again.	678	* again.
708	*/	679	*/
709	if ((!FindSmooth (face, &smoothface)) && (!FindSmooth (smooth_face->number, &smoothface)))	680	if ((!FindSmooth (face, &smoothface)) && (!FindSmooth (smooth_face->number, &smoothface)))
…		…
717	if (!(ns->faces_sent[smoothface] & NS_FACESENT_FACE))	688	if (!(ns->faces_sent[smoothface] & NS_FACESENT_FACE))
718	esrv_send_face (ns, smoothface, 0);	689	esrv_send_face (ns, smoothface, 0);
719		690
720	ns->faces_sent[face] |= NS_FACESENT_SMOOTH;	691	ns->faces_sent[face] |= NS_FACESENT_SMOOTH;
721		692
722	sl.buf = reply;	693	packet sl;
723	strcpy ((char *) sl.buf, "smooth ");	694
724	sl.len = strlen ((char *) sl.buf);	695	sl << "smooth "
725	SockList_AddShort (&sl, face);	696	<< uint16 (face)
726	SockList_AddShort (&sl, smoothface);	697	<< uint16 (smoothface);
727	Send_With_Handling (ns, &sl);	698
		699	ns->send_packet (sl);
728	}	700	}
729		701
730	/**	702	/**
731	* Tells client the picture it has to use	703	* Tells client the picture it has to use
732	* to smooth a picture number given as argument.	704	* to smooth a picture number given as argument.
733	*/	705	*/
734	void	706	void
735	AskSmooth (char *buf, int len, NewSocket * ns)	707	AskSmooth (char *buf, int len, client_socket * ns)
736	{	708	{
737	uint16 facenbr;	709	uint16 facenbr;
738		710
739	facenbr = atoi (buf);	711	facenbr = atoi (buf);
740	SendSmooth (ns, facenbr);	712	SendSmooth (ns, facenbr);
741	}	713	}
742
743
744
745
746		714
747	/**	715	/**
748	* This handles the general commands from the client (ie, north, fire, cast,	716	* This handles the general commands from the client (ie, north, fire, cast,
749	* etc.)	717	* etc.)
750	*/	718	*/
…		…
801	* etc.). It is a lot like PlayerCmd above, but is called with the	769	* etc.). It is a lot like PlayerCmd above, but is called with the
802	* 'ncom' method which gives more information back to the client so it	770	* 'ncom' method which gives more information back to the client so it
803	* can throttle.	771	* can throttle.
804	*/	772	*/
805	void	773	void
806	NewPlayerCmd (uint8 * buf, int len, player *pl)	774	NewPlayerCmd (char *buf, int len, player *pl)
807	{	775	{
808	int time, repeat;	776	int time, repeat;
809	short packet;
810	unsigned char command[MAX_BUF];	777	char command[MAX_BUF];
811	SockList sl;	778	int pktlen;
812		779
813	if (len < 7)	780	if (len < 7)
814	{	781	{
815	LOG (llevDebug, "Corrupt ncom command <%s> not long enough - discarding\n", buf);	782	LOG (llevDebug, "Corrupt ncom command <%s> not long enough - discarding\n", buf);
816	return;	783	return;
817	}	784	}
818		785
819	packet = GetShort_String (buf);	786	pktlen = net_uint16 ((uint8 *)buf);
820	repeat = GetInt_String (buf + 2);	787	repeat = net_uint32 ((uint8 *)buf + 2);
		788
821	/* -1 is special - no repeat, but don't update */	789	/* -1 is special - no repeat, but don't update */
822	if (repeat != -1)	790	if (repeat != -1)
823	{
824	pl->count = repeat;	791	pl->count = repeat;
825	}	792
826	if ((len - 4) >= MAX_BUF)	793	if ((len - 4) >= MAX_BUF)
827	len = MAX_BUF - 5;	794	len = MAX_BUF - 5;
828		795
829	strncpy ((char *) command, (char *) buf + 6, len - 4);	796	strncpy ((char *) command, (char *) buf + 6, len - 4);
830	command[len - 4] = '\0';	797	command[len - 4] = 0;
831
832	/* The following should never happen with a proper or honest client.
833	* Therefore, the error message doesn't have to be too clear - if
834	* someone is playing with a hacked/non working client, this gives them
835	* an idea of the problem, but they deserve what they get
836	*/
837	if (pl->state != ST_PLAYING)
838	{
839	new_draw_info_format (NDI_UNIQUE, 0, pl->ob, "You can not issue commands - state is not ST_PLAYING (%s)", buf);
840	return;
841	}
842		798
843	/* This should not happen anymore. */	799	/* This should not happen anymore. */
844	if (pl->ob->speed_left < -1.0)	800	if (pl->ob->speed_left < -1.0)
845	{
846	LOG (llevError, "Player has negative time - shouldn't do command.\n");	801	LOG (llevError, "Player has negative time - shouldn't do command.\n");
847	}	802
848	/* In c_new.c */	803	/* In c_new.c */
849	execute_newserver_command (pl->ob, (char *) command);	804	execute_newserver_command (pl->ob, (char *) command);
850	/* Perhaps something better should be done with a left over count.	805	/* Perhaps something better should be done with a left over count.
851	* Cleaning up the input should probably be done first - all actions	806	* Cleaning up the input should probably be done first - all actions
852	* for the command that issued the count should be done before any other	807	* for the command that issued the count should be done before any other
853	* commands.	808	* commands.
854	*/	809	*/
855	pl->count = 0;	810	pl->count = 0;
856		811
857	/* Send confirmation of command execution now */
858	sl.buf = command;
859	strcpy ((char *) sl.buf, "comc ");
860	sl.len = 5;
861	SockList_AddShort (&sl, packet);
862	if (FABS (pl->ob->speed) < 0.001)	812	if (FABS (pl->ob->speed) < 0.001)
863	time = MAX_TIME * 100;	813	time = MAX_TIME * 100;
864	else	814	else
865	time = (int) (MAX_TIME / FABS (pl->ob->speed));	815	time = (int) (MAX_TIME / FABS (pl->ob->speed));
866	SockList_AddInt (&sl, time);	816
867	Send_With_Handling (&pl->socket, &sl);	817	/* Send confirmation of command execution now */
		818
		819	packet sl;
		820	sl << "comc " << uint16 (pktlen) << uint32 (time);
		821	pl->socket->send_packet (sl);
868	}	822	}
869		823
870		824
871	/** This is a reply to a previous query. */	825	/** This is a reply to a previous query. */
872	void	826	void
…		…
939	* something older than the server. If we assume the client will be	893	* something older than the server. If we assume the client will be
940	* backwards compatible, having it be a later version should not be a	894	* backwards compatible, having it be a later version should not be a
941	* problem.	895	* problem.
942	*/	896	*/
943	void	897	void
944	VersionCmd (char *buf, int len, NewSocket * ns)	898	VersionCmd (char *buf, int len, client_socket * ns)
945	{	899	{
946	char *cp;	900	char *cp;
947	char version_warning[256];	901	char version_warning[256];
948		902
949	if (!buf)	903	if (!buf)
…		…
984	/* these are old dxclients */	938	/* these are old dxclients */
985	/* Version 1024 added support for singular + plural name values -	939	/* Version 1024 added support for singular + plural name values -
986	* requiing this minimal value reduces complexity of that code, and it	940	* requiing this minimal value reduces complexity of that code, and it
987	* has been around for a long time.	941	* has been around for a long time.
988	*/	942	*/
989	if (!strcmp (" CF DX CLIENT", cp) || ns->sc_version < 1024)	943	if (ns->sc_version < 1026)
990	{	944	{
991	sprintf (version_warning, "drawinfo %d %s", NDI_RED,	945	sprintf (version_warning, "drawinfo %d %s", NDI_RED,
992	"**** VERSION WARNING ****\n**** CLIENT IS TOO OLD!! UPDATE THE CLIENT!! ****");	946	"**** VERSION WARNING ****\n**** CLIENT IS TOO OLD!! UPDATE THE CLIENT!! ****");
993	Write_String_To_Socket (ns, version_warning, strlen (version_warning));	947	ns->send_packet (version_warning);
994	}	948	}
995		949
996	}	950	}
997	}	951	}
998		952
999	/** sound related functions. */	953	/** sound related functions. */
1000		954
1001	void	955	void
1002	SetSound (char *buf, int len, NewSocket * ns)	956	SetSound (char *buf, int len, client_socket * ns)
1003	{	957	{
1004	ns->sound = atoi (buf);	958	ns->sound = atoi (buf);
1005	}	959	}
1006		960
1007	/** client wants the map resent */	961	/** client wants the map resent */
…		…
1017	*/	971	*/
1018	#if 0	972	#if 0
1019	/* Okay, this is MAJOR UGLY. but the only way I know how to	973	/* Okay, this is MAJOR UGLY. but the only way I know how to
1020	* clear the "cache"	974	* clear the "cache"
1021	*/	975	*/
1022	memset (&pl->socket.lastmap, 0, sizeof (struct Map));	976	memset (&pl->socket->lastmap, 0, sizeof (struct Map));
1023	draw_client_map (pl->ob);	977	draw_client_map (pl->ob);
1024	#endif	978	#endif
1025	}	979	}
1026		980
1027	/**	981	/**
…		…
1065	/**	1019	/**
1066	* Asks the client to query the user. This way, the client knows	1020	* Asks the client to query the user. This way, the client knows
1067	* it needs to send something back (vs just printing out a message)	1021	* it needs to send something back (vs just printing out a message)
1068	*/	1022	*/
1069	void	1023	void
1070	send_query (NewSocket * ns, uint8 flags, char *text)	1024	send_query (client_socket * ns, uint8 flags, char *text)
1071	{	1025	{
1072	char buf[MAX_BUF];	1026	char buf[MAX_BUF];
1073		1027
1074	sprintf (buf, "query %d %s", flags, text ? text : "");	1028	sprintf (buf, "query %d %s", flags, text ? text : "");
1075	Write_String_To_Socket (ns, buf, strlen (buf));	1029	ns->send_packet (buf);
1076	}	1030	}
1077		1031
1078	#define AddIfInt64(Old,New,Type) if (Old != New) {\	1032	#define AddIfInt64(Old,New,Type) if (Old != New) {\
1079	Old = New; \	1033	Old = New; \
1080	SockList_AddChar(&sl, Type); \	1034	sl << uint8 (Type) << uint64 (New); \
1081	SockList_AddInt64(&sl, New); \
1082	}	1035	}
1083		1036
1084	#define AddIfInt(Old,New,Type) if (Old != New) {\	1037	#define AddIfInt(Old,New,Type) if (Old != New) {\
1085	Old = New; \	1038	Old = New; \
1086	SockList_AddChar(&sl, Type); \	1039	sl << uint8 (Type) << uint32 (New); \
1087	SockList_AddInt(&sl, New); \
1088	}	1040	}
1089		1041
1090	#define AddIfShort(Old,New,Type) if (Old != New) {\	1042	#define AddIfShort(Old,New,Type) if (Old != New) {\
1091	Old = New; \	1043	Old = New; \
1092	SockList_AddChar(&sl, Type); \	1044	sl << uint8 (Type) << uint16 (New); \
1093	SockList_AddShort(&sl, New); \
1094	}	1045	}
1095		1046
1096	#define AddIfFloat(Old,New,Type) if (Old != New) {\	1047	#define AddIfFloat(Old,New,Type) if (Old != New) {\
1097	Old = New; \	1048	Old = New; \
1098	SockList_AddChar(&sl, Type); \	1049	sl << uint8 (Type) << uint32 (New*FLOAT_MULTI); \
1099	SockList_AddInt(&sl,(long)(New*FLOAT_MULTI));\
1100	}	1050	}
1101		1051
1102	#define AddIfString(Old,New,Type) if (Old == NULL || strcmp(Old,New)) {\	1052	#define AddIfString(Old,New,Type) if (Old == NULL || strcmp(Old,New)) {\
1103	if (Old) free(Old);\
1104	Old = strdup_local(New);\	1053	free(Old); Old = strdup (New);\
1105	SockList_AddChar(&sl, Type); \	1054	sl << uint8 (Type) << data8 (New); \
1106	SockList_AddChar(&sl, ( char )strlen(New)); \
1107	strcpy((char*)sl.buf + sl.len, New); \
1108	sl.len += strlen(New); \
1109	}	1055	}
1110		1056
1111	/**	1057	/**
1112	* Sends a statistics update. We look at the old values,	1058	* Sends a statistics update. We look at the old values,
1113	* and only send what has changed. Stat mapping values are in newclient.h	1059	* and only send what has changed. Stat mapping values are in newclient.h
…		…
1115	* commands for now.	1061	* commands for now.
1116	*/	1062	*/
1117	void	1063	void
1118	esrv_update_stats (player *pl)	1064	esrv_update_stats (player *pl)
1119	{	1065	{
1120	SockList sl;
1121	char buf[MAX_BUF];	1066	char buf[MAX_BUF];
1122	uint16 flags;	1067	uint16 flags;
1123		1068
1124	sl.buf = (unsigned char *) malloc (MAXSOCKBUF);	1069	packet sl;
1125	strcpy ((char *) sl.buf, "stats ");	1070	sl << "stats ";
1126	sl.len = strlen ((char *) sl.buf);
1127		1071
1128	if (pl->ob != NULL)	1072	if (pl->ob != NULL)
1129	{	1073	{
1130	AddIfShort (pl->last_stats.hp, pl->ob->stats.hp, CS_STAT_HP);	1074	AddIfShort (pl->last_stats.hp, pl->ob->stats.hp, CS_STAT_HP);
1131	AddIfShort (pl->last_stats.maxhp, pl->ob->stats.maxhp, CS_STAT_MAXHP);	1075	AddIfShort (pl->last_stats.maxhp, pl->ob->stats.maxhp, CS_STAT_MAXHP);
…		…
1139	AddIfShort (pl->last_stats.Wis, pl->ob->stats.Wis, CS_STAT_WIS);	1083	AddIfShort (pl->last_stats.Wis, pl->ob->stats.Wis, CS_STAT_WIS);
1140	AddIfShort (pl->last_stats.Dex, pl->ob->stats.Dex, CS_STAT_DEX);	1084	AddIfShort (pl->last_stats.Dex, pl->ob->stats.Dex, CS_STAT_DEX);
1141	AddIfShort (pl->last_stats.Con, pl->ob->stats.Con, CS_STAT_CON);	1085	AddIfShort (pl->last_stats.Con, pl->ob->stats.Con, CS_STAT_CON);
1142	AddIfShort (pl->last_stats.Cha, pl->ob->stats.Cha, CS_STAT_CHA);	1086	AddIfShort (pl->last_stats.Cha, pl->ob->stats.Cha, CS_STAT_CHA);
1143	}	1087	}
		1088
1144	if (pl->socket.exp64)	1089	if (pl->socket->exp64)
1145	{	1090	{
1146	uint8 s;	1091	uint8 s;
1147		1092
1148	for (s = 0; s < NUM_SKILLS; s++)	1093	for (s = 0; s < NUM_SKILLS; s++)
1149	{	1094	{
1150	if (pl->last_skill_ob[s] && pl->last_skill_exp[s] != pl->last_skill_ob[s]->stats.exp)	1095	if (pl->last_skill_ob[s] && pl->last_skill_exp[s] != pl->last_skill_ob[s]->stats.exp)
1151	{	1096	{
1152
1153	/* Always send along the level if exp changes. This is only	1097	/* Always send along the level if exp changes. This is only
1154	* 1 extra byte, but keeps processing simpler.	1098	* 1 extra byte, but keeps processing simpler.
1155	*/	1099	*/
1156	SockList_AddChar (&sl, (char) (s + CS_STAT_SKILLINFO));	1100	sl << uint8 (s + CS_STAT_SKILLINFO)
1157	SockList_AddChar (&sl, (char) pl->last_skill_ob[s]->level);	1101	<< uint8 (pl->last_skill_ob[s]->level)
1158	SockList_AddInt64 (&sl, pl->last_skill_ob[s]->stats.exp);	1102	<< uint64 (pl->last_skill_ob[s]->stats.exp);
		1103
1159	pl->last_skill_exp[s] = pl->last_skill_ob[s]->stats.exp;	1104	pl->last_skill_exp[s] = pl->last_skill_ob[s]->stats.exp;
1160	}	1105	}
1161	}	1106	}
1162	}	1107	}
		1108
1163	if (pl->socket.exp64)	1109	if (pl->socket->exp64)
1164	{
1165	AddIfInt64 (pl->last_stats.exp, pl->ob->stats.exp, CS_STAT_EXP64);	1110	{ AddIfInt64 (pl->last_stats.exp, pl->ob->stats.exp, CS_STAT_EXP64) }
1166	}
1167	else	1111	else
1168	{
1169	AddIfInt (pl->last_stats.exp, (int) pl->ob->stats.exp, CS_STAT_EXP);	1112	{ AddIfInt (pl->last_stats.exp, (int) pl->ob->stats.exp, CS_STAT_EXP) }
1170	}	1113
1171	AddIfShort (pl->last_level, (char) pl->ob->level, CS_STAT_LEVEL);	1114	AddIfShort (pl->last_level, (char) pl->ob->level, CS_STAT_LEVEL);
1172	AddIfShort (pl->last_stats.wc, pl->ob->stats.wc, CS_STAT_WC);	1115	AddIfShort (pl->last_stats.wc, pl->ob->stats.wc, CS_STAT_WC);
1173	AddIfShort (pl->last_stats.ac, pl->ob->stats.ac, CS_STAT_AC);	1116	AddIfShort (pl->last_stats.ac, pl->ob->stats.ac, CS_STAT_AC);
1174	AddIfShort (pl->last_stats.dam, pl->ob->stats.dam, CS_STAT_DAM);	1117	AddIfShort (pl->last_stats.dam, pl->ob->stats.dam, CS_STAT_DAM);
1175	AddIfFloat (pl->last_speed, pl->ob->speed, CS_STAT_SPEED);	1118	AddIfFloat (pl->last_speed, pl->ob->speed, CS_STAT_SPEED);
1176	AddIfShort (pl->last_stats.food, pl->ob->stats.food, CS_STAT_FOOD);	1119	AddIfShort (pl->last_stats.food, pl->ob->stats.food, CS_STAT_FOOD);
1177	AddIfFloat (pl->last_weapon_sp, pl->weapon_sp, CS_STAT_WEAP_SP);	1120	AddIfFloat (pl->last_weapon_sp, pl->weapon_sp, CS_STAT_WEAP_SP);
1178	AddIfInt (pl->last_weight_limit, (sint32) weight_limit[pl->ob->stats.Str], CS_STAT_WEIGHT_LIM);	1121	AddIfInt (pl->last_weight_limit, (sint32) weight_limit[pl->ob->stats.Str], CS_STAT_WEIGHT_LIM);
1179	flags = 0;	1122	flags = 0;
		1123
1180	if (pl->fire_on)	1124	if (pl->fire_on)
1181	flags |= SF_FIREON;	1125	flags |= SF_FIREON;
		1126
1182	if (pl->run_on)	1127	if (pl->run_on)
1183	flags |= SF_RUNON;	1128	flags |= SF_RUNON;
1184		1129
1185	AddIfShort (pl->last_flags, flags, CS_STAT_FLAGS);	1130	AddIfShort (pl->last_flags, flags, CS_STAT_FLAGS);
		1131
1186	if (pl->socket.sc_version < 1025)	1132	if (pl->socket->sc_version < 1025)
1187	{
1188	AddIfShort (pl->last_resist[ATNR_PHYSICAL], pl->ob->resist[ATNR_PHYSICAL], CS_STAT_ARMOUR);	1133	{ AddIfShort (pl->last_resist[ATNR_PHYSICAL], pl->ob->resist[ATNR_PHYSICAL], CS_STAT_ARMOUR) }
1189	}
1190	else	1134	else
1191	{	1135	{
1192	int i;	1136	int i;
1193		1137
1194	for (i = 0; i < NROFATTACKS; i++)	1138	for (i = 0; i < NROFATTACKS; i++)
1195	{	1139	{
1196	/* Skip ones we won't send */	1140	/* Skip ones we won't send */
1197	if (atnr_cs_stat[i] == -1)	1141	if (atnr_cs_stat[i] == -1)
1198	continue;	1142	continue;
		1143
1199	AddIfShort (pl->last_resist[i], pl->ob->resist[i], (char) atnr_cs_stat[i]);	1144	AddIfShort (pl->last_resist[i], pl->ob->resist[i], (char) atnr_cs_stat[i]);
1200	}	1145	}
1201	}	1146	}
		1147
1202	if (pl->socket.monitor_spells)	1148	if (pl->socket->monitor_spells)
1203	{	1149	{
1204	AddIfInt (pl->last_path_attuned, pl->ob->path_attuned, CS_STAT_SPELL_ATTUNE);	1150	AddIfInt (pl->last_path_attuned, pl->ob->path_attuned, CS_STAT_SPELL_ATTUNE);
1205	AddIfInt (pl->last_path_repelled, pl->ob->path_repelled, CS_STAT_SPELL_REPEL);	1151	AddIfInt (pl->last_path_repelled, pl->ob->path_repelled, CS_STAT_SPELL_REPEL);
1206	AddIfInt (pl->last_path_denied, pl->ob->path_denied, CS_STAT_SPELL_DENY);	1152	AddIfInt (pl->last_path_denied, pl->ob->path_denied, CS_STAT_SPELL_DENY);
1207	}	1153	}
		1154
1208	rangetostring (pl->ob, buf); /* we want use the new fire & run system in new client */	1155	rangetostring (pl->ob, buf); /* we want use the new fire & run system in new client */
1209	AddIfString (pl->socket.stats.range, buf, CS_STAT_RANGE);	1156	AddIfString (pl->socket->stats.range, buf, CS_STAT_RANGE);
1210	set_title (pl->ob, buf);	1157	set_title (pl->ob, buf);
1211	AddIfString (pl->socket.stats.title, buf, CS_STAT_TITLE);	1158	AddIfString (pl->socket->stats.title, buf, CS_STAT_TITLE);
1212		1159
1213	/* Only send it away if we have some actual data */	1160	/* Only send it away if we have some actual data */
1214	if (sl.len > 6)	1161	if (sl.length () > 6)
1215	{	1162	pl->socket->send_packet (sl);
1216	#ifdef ESRV_DEBUG
1217	LOG (llevDebug, "Sending stats command, %d bytes long.\n", sl.len);
1218	#endif
1219	Send_With_Handling (&pl->socket, &sl);
1220	}
1221	free (sl.buf);
1222	}	1163	}
1223
1224		1164
1225	/**	1165	/**
1226	* Tells the client that here is a player it should start using.	1166	* Tells the client that here is a player it should start using.
1227	*/	1167	*/
1228	void	1168	void
1229	esrv_new_player (player *pl, uint32 weight)	1169	esrv_new_player (player *pl, uint32 weight)
1230	{	1170	{
1231	SockList sl;
1232
1233	pl->last_weight = weight;	1171	pl->last_weight = weight;
1234		1172
1235	sl.buf = (unsigned char *) malloc (MAXSOCKBUF);	1173	packet sl;
		1174	sl << "player ";
1236		1175
1237	strcpy ((char *) sl.buf, "player ");	1176	sl << uint32 (pl->ob->count)
1238	sl.len = strlen ((char *) sl.buf);	1177	<< uint32 (weight)
1239	SockList_AddInt (&sl, pl->ob->count);	1178	<< uint32 (pl->ob->face->number)
1240	SockList_AddInt (&sl, weight);	1179	<< data8 (pl->ob->name);
1241	SockList_AddInt (&sl, pl->ob->face->number);
1242		1180
1243	SockList_AddChar (&sl, (char) strlen (pl->ob->name));	1181	pl->socket->send_packet (sl);
1244	strcpy ((char *) sl.buf + sl.len, pl->ob->name);
1245	sl.len += strlen (pl->ob->name);
1246
1247	Send_With_Handling (&pl->socket, &sl);
1248	free (sl.buf);
1249	SET_FLAG (pl->ob, FLAG_CLIENT_SENT);	1182	SET_FLAG (pl->ob, FLAG_CLIENT_SENT);
1250	}	1183	}
1251
1252		1184
1253	/**	1185	/**
1254	* Need to send an animation sequence to the client.	1186	* Need to send an animation sequence to the client.
1255	* We will send appropriate face commands to the client if we haven't	1187	* We will send appropriate face commands to the client if we haven't
1256	* sent them the face yet (this can become quite costly in terms of	1188	* sent them the face yet (this can become quite costly in terms of
1257	* how much we are sending - on the other hand, this should only happen	1189	* how much we are sending - on the other hand, this should only happen
1258	* when the player logs in and picks stuff up.	1190	* when the player logs in and picks stuff up.
1259	*/	1191	*/
1260	void	1192	void
1261	esrv_send_animation (NewSocket * ns, short anim_num)	1193	esrv_send_animation (client_socket * ns, short anim_num)
1262	{	1194	{
1263	SockList sl;
1264	int i;	1195	int i;
1265		1196
1266	/* Do some checking on the anim_num we got. Note that the animations	1197	/* Do some checking on the anim_num we got. Note that the animations
1267	* are added in contigous order, so if the number is in the valid	1198	* are added in contigous order, so if the number is in the valid
1268	* range, it must be a valid animation.	1199	* range, it must be a valid animation.
…		…
1271	{	1202	{
1272	LOG (llevError, "esrv_send_anim (%d) out of bounds??\n", anim_num);	1203	LOG (llevError, "esrv_send_anim (%d) out of bounds??\n", anim_num);
1273	return;	1204	return;
1274	}	1205	}
1275		1206
1276	sl.buf = (unsigned char *) malloc (MAXSOCKBUF);	1207	packet sl;
1277	strcpy ((char *) sl.buf, "anim ");	1208
1278	sl.len = 5;	1209	sl << "anim "
1279	SockList_AddShort (&sl, anim_num);	1210	<< uint16 (anim_num)
1280	SockList_AddShort (&sl, 0); /* flags - not used right now */	1211	<< uint16 (0); /* flags - not used right now */
		1212
1281	/* Build up the list of faces. Also, send any information (ie, the	1213	/* Build up the list of faces. Also, send any information (ie, the
1282	* the face itself) down to the client.	1214	* the face itself) down to the client.
1283	*/	1215	*/
1284	for (i = 0; i < animations[anim_num].num_animations; i++)	1216	for (i = 0; i < animations[anim_num].num_animations; i++)
1285	{	1217	{
1286	if (!(ns->faces_sent[animations[anim_num].faces[i]] & NS_FACESENT_FACE))	1218	if (!(ns->faces_sent[animations[anim_num].faces[i]] & NS_FACESENT_FACE))
1287	esrv_send_face (ns, animations[anim_num].faces[i], 0);	1219	esrv_send_face (ns, animations[anim_num].faces[i], 0);
1288	SockList_AddShort (&sl, animations[anim_num].faces[i]); /* flags - not used right now */	1220	sl << uint16 (animations[anim_num].faces[i]); /* flags - not used right now */
1289	}	1221	}
1290	Send_With_Handling (ns, &sl);	1222
1291	free (sl.buf);	1223	ns->send_packet (sl);
		1224
1292	ns->anims_sent[anim_num] = 1;	1225	ns->anims_sent[anim_num] = 1;
1293	}	1226	}
1294		1227
1295		1228
1296	/******************************************************************************	1229	/******************************************************************************
…		…
1302	/**	1235	/**
1303	* This adds face_num to a map cell at x,y. If the client doesn't have	1236	* This adds face_num to a map cell at x,y. If the client doesn't have
1304	* the face yet, we will also send it.	1237	* the face yet, we will also send it.
1305	*/	1238	*/
1306	static void	1239	static void
1307	esrv_map_setbelow (NewSocket * ns, int x, int y, short face_num, struct Map *newmap)	1240	esrv_map_setbelow (client_socket * ns, int x, int y, short face_num, struct Map *newmap)
1308	{	1241	{
1309	if (newmap->cells[x][y].count >= MAP_LAYERS)	1242	if (newmap->cells[x][y].count >= MAP_LAYERS)
1310	{	1243	{
1311	LOG (llevError, "Too many faces in map cell %d %d\n", x, y);	1244	LOG (llevError, "Too many faces in map cell %d %d\n", x, y);
1312	return;	1245	return;
1313	abort ();	1246	abort ();
1314	}	1247	}
		1248
1315	newmap->cells[x][y].faces[newmap->cells[x][y].count] = face_num;	1249	newmap->cells[x][y].faces[newmap->cells[x][y].count] = face_num;
1316	newmap->cells[x][y].count++;	1250	newmap->cells[x][y].count++;
		1251
1317	if (!(ns->faces_sent[face_num] & NS_FACESENT_FACE))	1252	if (!(ns->faces_sent[face_num] & NS_FACESENT_FACE))
1318	esrv_send_face (ns, face_num, 0);	1253	esrv_send_face (ns, face_num, 0);
1319	}	1254	}
1320		1255
1321	struct LayerCell	1256	struct LayerCell
…		…
1330	struct LayerCell lcells[MAP_CLIENT_X * MAP_CLIENT_Y];	1265	struct LayerCell lcells[MAP_CLIENT_X * MAP_CLIENT_Y];
1331	};	1266	};
1332		1267
1333	/** Checkes if map cells have changed */	1268	/** Checkes if map cells have changed */
1334	static int	1269	static int
1335	mapcellchanged (NewSocket * ns, int i, int j, struct Map *newmap)	1270	mapcellchanged (client_socket * ns, int i, int j, struct Map *newmap)
1336	{	1271	{
1337	int k;	1272	int k;
1338		1273
1339	if (ns->lastmap.cells[i][j].count != newmap->cells[i][j].count)	1274	if (ns->lastmap.cells[i][j].count != newmap->cells[i][j].count)
1340	return 1;	1275	return 1;
…		…
1353	* cnum is the client number, cur is the the buffer we put all of	1288	* cnum is the client number, cur is the the buffer we put all of
1354	* this data into. we return the end of the data. layers is	1289	* this data into. we return the end of the data. layers is
1355	* how many layers of data we should back.	1290	* how many layers of data we should back.
1356	*/	1291	*/
1357	static uint8 *	1292	static uint8 *
1358	compactlayer (NewSocket * ns, unsigned char *cur, int numlayers, struct Map *newmap)	1293	compactlayer (client_socket * ns, unsigned char *cur, int numlayers, struct Map *newmap)
1359	{	1294	{
1360	int x, y, k;	1295	int x, y, k;
1361	int face;	1296	int face;
1362	unsigned char *fcur;	1297	unsigned char *fcur;
1363	struct MapLayer layers[MAP_LAYERS];	1298	struct MapLayer layers[MAP_LAYERS];
…		…
1423	*fcur = *fcur | 128; /* mark for end of faces at this layer */	1358	*fcur = *fcur | 128; /* mark for end of faces at this layer */
1424	}	1359	}
1425	return cur;	1360	return cur;
1426	}	1361	}
1427		1362
1428	static void
1429	esrv_map_doneredraw (NewSocket * ns, struct Map *newmap)
1430	{
1431	static long frames, bytes, tbytes, tframes;
1432	char *cur;
1433	SockList sl;
1434
1435
1436	sl.buf = (unsigned char *) malloc (MAXSOCKBUF);
1437	strcpy ((char *) sl.buf, "map ");
1438	sl.len = strlen ((char *) sl.buf);
1439
1440	cur = (char *) compactlayer (ns, (unsigned char *) sl.buf + sl.len, MAP_LAYERS, newmap);
1441	sl.len = cur - (char *) sl.buf;
1442
1443	/* LOG(llevDebug, "Sending map command.\n");*/
1444
1445	if (sl.len > (int) strlen ("map ") || ns->sent_scroll)
1446	{
1447	/* All of this is just accounting stuff */
1448	if (tframes > 100)
1449	{
1450	tframes = tbytes = 0;
1451	}
1452	tframes++;
1453	frames++;
1454	tbytes += sl.len;
1455	bytes += sl.len;
1456	memcpy (&ns->lastmap, newmap, sizeof (struct Map));
1457	Send_With_Handling (ns, &sl);
1458	ns->sent_scroll = 0;
1459	}
1460	free (sl.buf);
1461	}
1462
1463
1464	/** Clears a map cell */	1363	/** Clears a map cell */
1465	static void	1364	static void
1466	map_clearcell (struct MapCell *cell, int face0, int face1, int face2, int count)	1365	map_clearcell (struct MapCell *cell, int face0, int face1, int face2, int count)
1467	{	1366	{
1468	cell->faces[0] = face0;	1367	cell->faces[0] = face0;
1469	cell->faces[1] = face1;	1368	cell->faces[1] = face1;
1470	cell->faces[2] = face2;	1369	cell->faces[2] = face2;
1471	cell->count = count;	1370	cell->count = count;
1472	cell->stat_hp = 0;	1371	cell->stat_hp = 0;
		1372	cell->flags = 0;
1473	cell->player = 0;	1373	cell->player = 0;
1474	}	1374	}
1475		1375
1476	#define MAX_HEAD_POS MAX(MAX_CLIENT_X, MAX_CLIENT_Y)	1376	#define MAX_HEAD_POS MAX(MAX_CLIENT_X, MAX_CLIENT_Y)
1477	#define MAX_LAYERS 3	1377	#define MAX_LAYERS 3
1478		1378
…		…
1506	* needs to get sent - if so, it adds the data, sending the head	1406	* needs to get sent - if so, it adds the data, sending the head
1507	* if needed, and returning 1. If this no data needs to get	1407	* if needed, and returning 1. If this no data needs to get
1508	* sent, it returns zero.	1408	* sent, it returns zero.
1509	*/	1409	*/
1510	static int	1410	static int
1511	check_head (SockList & sl, NewSocket & ns, int ax, int ay, int layer)	1411	check_head (packet &sl, client_socket &ns, int ax, int ay, int layer)
1512	{	1412	{
1513	short face_num;	1413	short face_num;
1514		1414
1515	if (heads[(ay * MAX_HEAD_POS + ax) * MAX_LAYERS + layer])	1415	if (heads[(ay * MAX_HEAD_POS + ax) * MAX_LAYERS + layer])
1516	face_num = heads[(ay * MAX_HEAD_POS + ax) * MAX_LAYERS + layer]->face->number;	1416	face_num = heads[(ay * MAX_HEAD_POS + ax) * MAX_LAYERS + layer]->face->number;
1517	else	1417	else
1518	face_num = 0;	1418	face_num = 0;
1519		1419
1520	if (face_num != ns.lastmap.cells[ax][ay].faces[layer])	1420	if (face_num != ns.lastmap.cells[ax][ay].faces[layer])
1521	{	1421	{
1522	SockList_AddShort (&sl, face_num);	1422	sl << uint16 (face_num);
1523	if (face_num && !(ns.faces_sent[face_num] & NS_FACESENT_FACE))	1423	if (face_num && !(ns.faces_sent[face_num] & NS_FACESENT_FACE))
1524	esrv_send_face (&ns, face_num, 0);	1424	esrv_send_face (&ns, face_num, 0);
		1425
1525	heads[(ay * MAX_HEAD_POS + ax) * MAX_LAYERS + layer] = NULL;	1426	heads[(ay * MAX_HEAD_POS + ax) * MAX_LAYERS + layer] = NULL;
1526	ns.lastmap.cells[ax][ay].faces[layer] = face_num;	1427	ns.lastmap.cells[ax][ay].faces[layer] = face_num;
1527	return 1;	1428	return 1;
1528	}	1429	}
1529		1430
…		…
1549	* the case, it seems to make more sense to have these layer values	1450	* the case, it seems to make more sense to have these layer values
1550	* actually match.	1451	* actually match.
1551	*/	1452	*/
1552		1453
1553	static int	1454	static int
1554	update_space (SockList * sl, NewSocket * ns, mapstruct *mp, int mx, int my, int sx, int sy, int layer)	1455	update_space (packet &sl, client_socket &ns, maptile *mp, int mx, int my, int sx, int sy, int layer)
1555	{	1456	{
1556	object *ob, *head;	1457	object *ob, *head;
1557	uint16 face_num;	1458	uint16 face_num;
1558	int bx, by, i;	1459	int bx, by, i;
1559		1460
1560	/* If there is a multipart object stored away, treat that as more important.	1461	/* If there is a multipart object stored away, treat that as more important.
1561	* If not, then do the normal processing.	1462	* If not, then do the normal processing.
1562	*/	1463	*/
1563
1564	head = heads[(sy * MAX_HEAD_POS + sx) * MAX_LAYERS + layer];	1464	head = heads[(sy * MAX_HEAD_POS + sx) * MAX_LAYERS + layer];
1565		1465
1566	/* Check to see if this head is part of the set of objects	1466	/* Check to see if this head is part of the set of objects
1567	* we would normally send for this space. If so, then	1467	* we would normally send for this space. If so, then
1568	* don't use the head value. We need to do the check	1468	* don't use the head value. We need to do the check
…		…
1733		1633
1734	/* Another hack - because of heads and whatnot, this face may match one	1634	/* Another hack - because of heads and whatnot, this face may match one
1735	* we already sent for a lower layer. In that case, don't send	1635	* we already sent for a lower layer. In that case, don't send
1736	* this one.	1636	* this one.
1737	*/	1637	*/
1738	if (face_num && layer + 1 < MAP_LAYERS && ns->lastmap.cells[sx][sy].faces[layer + 1] == face_num)	1638	if (face_num && layer + 1 < MAP_LAYERS && ns.lastmap.cells[sx][sy].faces[layer + 1] == face_num)
1739	{
1740	face_num = 0;	1639	face_num = 0;
1741	}
1742		1640
1743	/* We've gotten what face we want to use for the object. Now see if	1641	/* We've gotten what face we want to use for the object. Now see if
1744	* if it has changed since we last sent it to the client.	1642	* if it has changed since we last sent it to the client.
1745	*/	1643	*/
1746	if (ns->lastmap.cells[sx][sy].faces[layer] != face_num)	1644	if (ns.lastmap.cells[sx][sy].faces[layer] != face_num)
1747	{	1645	{
1748	ns->lastmap.cells[sx][sy].faces[layer] = face_num;	1646	ns.lastmap.cells[sx][sy].faces[layer] = face_num;
1749	if (!(ns->faces_sent[face_num] & NS_FACESENT_FACE))	1647	if (!(ns.faces_sent[face_num] & NS_FACESENT_FACE))
1750	esrv_send_face (ns, face_num, 0);	1648	esrv_send_face (&ns, face_num, 0);
1751	SockList_AddShort (sl, face_num);	1649
		1650	sl << uint16 (face_num);
1752	return 1;	1651	return 1;
1753	}	1652	}
		1653
1754	/* Nothing changed */	1654	/* Nothing changed */
1755	return 0;	1655	return 0;
1756	}	1656	}
1757		1657
1758	/**	1658	/**
…		…
1773	* top layer (this matches what the GET_MAP_FACE and GET_MAP_FACE_OBJ	1673	* top layer (this matches what the GET_MAP_FACE and GET_MAP_FACE_OBJ
1774	* take.	1674	* take.
1775	*/	1675	*/
1776		1676
1777	static inline int	1677	static inline int
1778	update_smooth (SockList * sl, NewSocket * ns, mapstruct *mp, int mx, int my, int sx, int sy, int layer)	1678	update_smooth (packet &sl, client_socket &ns, maptile *mp, int mx, int my, int sx, int sy, int layer)
1779	{	1679	{
1780	object *ob;	1680	object *ob;
1781	int smoothlevel; /* old face_num; */	1681	int smoothlevel; /* old face_num; */
1782		1682
1783	ob = GET_MAP_FACE_OBJ (mp, mx, my, layer);	1683	ob = GET_MAP_FACE_OBJ (mp, mx, my, layer);
…		…
1788	if (!ob || ob->face == blank_face || MAP_NOSMOOTH (mp))	1688	if (!ob || ob->face == blank_face || MAP_NOSMOOTH (mp))
1789	smoothlevel = 0;	1689	smoothlevel = 0;
1790	else	1690	else
1791	{	1691	{
1792	smoothlevel = ob->smoothlevel;	1692	smoothlevel = ob->smoothlevel;
1793	if (smoothlevel && !(ns->faces_sent[ob->face->number] & NS_FACESENT_SMOOTH))	1693	if (smoothlevel && !(ns.faces_sent[ob->face->number] & NS_FACESENT_SMOOTH))
1794	SendSmooth (ns, ob->face->number);	1694	SendSmooth (&ns, ob->face->number);
1795	} /* else not already head object or blank face */	1695	} /* else not already head object or blank face */
1796		1696
1797	/* We've gotten what face we want to use for the object. Now see if	1697	/* We've gotten what face we want to use for the object. Now see if
1798	* if it has changed since we last sent it to the client.	1698	* if it has changed since we last sent it to the client.
1799	*/	1699	*/
1800	if (smoothlevel > 255)	1700	if (smoothlevel > 255)
1801	smoothlevel = 255;	1701	smoothlevel = 255;
1802	else if (smoothlevel < 0)	1702	else if (smoothlevel < 0)
1803	smoothlevel = 0;	1703	smoothlevel = 0;
		1704
1804	if (ns->lastmap.cells[sx][sy].smooth[layer] != smoothlevel)	1705	if (ns.lastmap.cells[sx][sy].smooth[layer] != smoothlevel)
1805	{	1706	{
1806	ns->lastmap.cells[sx][sy].smooth[layer] = smoothlevel;	1707	ns.lastmap.cells[sx][sy].smooth[layer] = smoothlevel;
1807	SockList_AddChar (sl, (uint8) (smoothlevel & 0xFF));	1708	sl << uint8 (smoothlevel);
1808	return 1;	1709	return 1;
1809	}	1710	}
		1711
1810	/* Nothing changed */	1712	/* Nothing changed */
1811	return 0;	1713	return 0;
1812	}	1714	}
1813		1715
1814	/**	1716	/**
1815	* Returns the size of a data for a map square as returned by	1717	* Returns the size of a data for a map square as returned by
1816	* mapextended. There are CLIENTMAPX*CLIENTMAPY*LAYERS entries	1718	* mapextended. There are CLIENTMAPX*CLIENTMAPY*LAYERS entries
1817	* available.	1719	* available.
1818	*/	1720	*/
1819	int	1721	int
1820	getExtendedMapInfoSize (NewSocket * ns)	1722	getExtendedMapInfoSize (client_socket * ns)
1821	{	1723	{
1822	int result = 0;	1724	int result = 0;
1823		1725
1824	if (ns->ext_mapinfos)	1726	if (ns->ext_mapinfos)
1825	{	1727	{
…		…
1855	draw_client_map1 (object *pl)	1757	draw_client_map1 (object *pl)
1856	{	1758	{
1857	int x, y, ax, ay, d, startlen, max_x, max_y, oldlen;	1759	int x, y, ax, ay, d, startlen, max_x, max_y, oldlen;
1858	sint16 nx, ny;	1760	sint16 nx, ny;
1859	int estartlen, eoldlen;	1761	int estartlen, eoldlen;
1860	SockList sl;
1861	SockList esl; /*For extended Map info */
1862	uint16 mask, emask;	1762	uint16 mask, emask;
1863	uint8 eentrysize;	1763	uint8 eentrysize;
1864	uint16 ewhatstart, ewhatflag;	1764	uint16 ewhatstart, ewhatflag;
1865	uint8 extendedinfos;	1765	uint8 extendedinfos;
1866	mapstruct *m;	1766	maptile *m;
1867		1767
1868	NewSocket & socket = pl->contr->socket;	1768	client_socket &socket = *pl->contr->socket;
1869		1769
1870	check_map_change (pl->contr);	1770	check_map_change (pl->contr);
1871		1771
1872	sl.buf = (unsigned char *) malloc (MAXSOCKBUF);	1772	packet sl;
1873	if (socket.mapmode == Map1Cmd)	1773	packet esl;
1874	strcpy ((char *) sl.buf, "map1 ");	1774
1875	else	1775	sl << (socket.mapmode == Map1Cmd ? "map1 " : "map1a ");
1876	strcpy ((char *) sl.buf, "map1a ");
1877	sl.len = strlen ((char *) sl.buf);
1878	startlen = sl.len;	1776	startlen = sl.length ();
		1777
1879	/*Extendedmapinfo structure initialisation */	1778	/*Extendedmapinfo structure initialisation */
1880	if (socket.ext_mapinfos)	1779	if (socket.ext_mapinfos)
1881	{	1780	{
1882	esl.buf = (unsigned char *) malloc (MAXSOCKBUF);
1883	strcpy ((char *) esl.buf, "mapextended ");
1884	esl.len = strlen ((char *) esl.buf);
1885	extendedinfos = EMI_NOREDRAW;	1781	extendedinfos = EMI_NOREDRAW;
		1782
1886	if (socket.EMI_smooth)	1783	if (socket.EMI_smooth)
1887	extendedinfos |= EMI_SMOOTH;	1784	extendedinfos |= EMI_SMOOTH;
		1785
1888	ewhatstart = esl.len;	1786	ewhatstart = esl.length ();
1889	ewhatflag = extendedinfos; /*The EMI_NOREDRAW bit	1787	ewhatflag = extendedinfos; /*The EMI_NOREDRAW bit
1890	could need to be taken away */	1788	could need to be taken away */
1891	SockList_AddChar (&esl, extendedinfos);
1892	eentrysize = getExtendedMapInfoSize (&socket);	1789	eentrysize = getExtendedMapInfoSize (&socket);
1893	SockList_AddChar (&esl, eentrysize);	1790	esl << "mapextended "
		1791	<< uint8 (extendedinfos)
		1792	<< uint8 (eentrysize);
		1793
1894	estartlen = esl.len;	1794	estartlen = esl.length ();
1895	}	1795	}
1896	else	1796	else
1897	{	1797	{
1898	/* suppress compiler warnings */	1798	/* suppress compiler warnings */
1899	ewhatstart = 0;	1799	ewhatstart = 0;
1900	ewhatflag = 0;	1800	ewhatflag = 0;
1901	estartlen = 0;	1801	estartlen = 0;
1902	}	1802	}
		1803
1903	/* Init data to zero */	1804	/* Init data to zero */
1904	memset (heads, 0, sizeof (object *) * MAX_HEAD_POS * MAX_HEAD_POS * MAX_LAYERS);	1805	memset (heads, 0, sizeof (object *) * MAX_HEAD_POS * MAX_HEAD_POS * MAX_LAYERS);
1905		1806
1906	/* x,y are the real map locations. ax, ay are viewport relative	1807	/* x,y are the real map locations. ax, ay are viewport relative
1907	* locations.	1808	* locations.
…		…
1911	/* We could do this logic as conditionals in the if statement,	1812	/* We could do this logic as conditionals in the if statement,
1912	* but that started to get a bit messy to look at.	1813	* but that started to get a bit messy to look at.
1913	*/	1814	*/
1914	max_x = pl->x + (socket.mapx + 1) / 2;	1815	max_x = pl->x + (socket.mapx + 1) / 2;
1915	max_y = pl->y + (socket.mapy + 1) / 2;	1816	max_y = pl->y + (socket.mapy + 1) / 2;
		1817
1916	if (socket.mapmode == Map1aCmd)	1818	if (socket.mapmode == Map1aCmd)
1917	{	1819	{
1918	max_x += MAX_HEAD_OFFSET;	1820	max_x += MAX_HEAD_OFFSET;
1919	max_y += MAX_HEAD_OFFSET;	1821	max_y += MAX_HEAD_OFFSET;
1920	}	1822	}
…		…
1935	*/	1837	*/
1936	if (ax >= socket.mapx || ay >= socket.mapy)	1838	if (ax >= socket.mapx || ay >= socket.mapy)
1937	{	1839	{
1938	int i, got_one;	1840	int i, got_one;
1939		1841
1940	oldlen = sl.len;	1842	oldlen = sl.length ();
1941		1843
1942	SockList_AddShort (&sl, mask);	1844	sl << uint16 (mask);
1943		1845
1944	if (check_head (sl, socket, ax, ay, 2))	1846	if (check_head (sl, socket, ax, ay, 2)) mask |= 0x4;
1945	mask |= 0x4;
1946	if (check_head (sl, socket, ax, ay, 1))	1847	if (check_head (sl, socket, ax, ay, 1)) mask |= 0x2;
1947	mask |= 0x2;
1948	if (check_head (sl, socket, ax, ay, 0))	1848	if (check_head (sl, socket, ax, ay, 0)) mask |= 0x1;
1949	mask |= 0x1;
1950		1849
1951	/* If all we are doing is sending 0 (blank) faces, we don't	1850	/* If all we are doing is sending 0 (blank) faces, we don't
1952	* actually need to send that - just the coordinates	1851	* actually need to send that - just the coordinates
1953	* with no faces tells the client to blank out the	1852	* with no faces tells the client to blank out the
1954	* space.	1853	* space.
1955	*/	1854	*/
1956	got_one = 0;	1855	got_one = 0;
1957	for (i = oldlen + 2; i < sl.len; i++)	1856	for (i = oldlen + 2; i < sl.length (); i++)
1958	{
1959	if (sl.buf[i])	1857	if (sl[i])
1960	got_one = 1;	1858	got_one = 1;
1961	}
1962		1859
1963	if (got_one && (mask & 0xf))	1860	if (got_one && (mask & 0xf))
1964	{
1965	sl.buf[oldlen + 1] = mask & 0xff;	1861	sl[oldlen + 1] = mask & 0xff;
1966	}
1967	else	1862	else
1968	{ /*either all faces blank, either no face at all */	1863	{ /*either all faces blank, either no face at all */
1969	if (mask & 0xf) /*at least 1 face, we know it's blank, only send coordinates */	1864	if (mask & 0xf) /*at least 1 face, we know it's blank, only send coordinates */
1970	sl.len = oldlen + 2;	1865	sl.reset (oldlen + 2);
1971	else	1866	else
1972	sl.len = oldlen;	1867	sl.reset (oldlen);
1973	}	1868	}
		1869
1974	/*What concerns extendinfos, nothing to be done for now	1870	/*What concerns extendinfos, nothing to be done for now
1975	* (perhaps effects layer later)	1871	* (perhaps effects layer later)
1976	*/	1872	*/
1977	continue; /* don't do processing below */	1873	continue; /* don't do processing below */
1978	}	1874	}
1979		1875
1980	MapCell & lastcell = socket.lastmap.cells[ax][ay];	1876	MapCell &lastcell = socket.lastmap.cells[ax][ay];
1981		1877
1982	d = pl->contr->blocked_los[ax][ay];	1878	d = pl->contr->blocked_los[ax][ay];
1983		1879
1984	/* If the coordinates are not valid, or it is too dark to see,	1880	/* If the coordinates are not valid, or it is too dark to see,
1985	* we tell the client as such	1881	* we tell the client as such
1986	*/	1882	*/
1987	nx = x;	1883	nx = x;
1988	ny = y;	1884	ny = y;
1989	m = get_map_from_coord (pl->map, &nx, &ny);	1885	m = get_map_from_coord (pl->map, &nx, &ny);
		1886
1990	if (!m)	1887	if (!m)
1991	{	1888	{
1992	/* space is out of map. Update space and clear values	1889	/* space is out of map. Update space and clear values
1993	* if this hasn't already been done. If the space is out	1890	* if this hasn't already been done. If the space is out
1994	* of the map, it shouldn't have a head	1891	* of the map, it shouldn't have a head
1995	*/	1892	*/
1996	if (lastcell.count != -1)	1893	if (lastcell.count != -1)
1997	{	1894	{
1998	SockList_AddShort (&sl, mask);	1895	sl << uint16 (mask);
1999	map_clearcell (&lastcell, 0, 0, 0, -1);	1896	map_clearcell (&lastcell, 0, 0, 0, -1);
2000	}	1897	}
2001	}	1898	}
2002	else if (d > 3)	1899	else if (d > 3)
2003	{	1900	{
…		…
2005		1902
2006	/* This block deals with spaces that are not visible for whatever	1903	/* This block deals with spaces that are not visible for whatever
2007	* reason. Still may need to send the head for this space.	1904	* reason. Still may need to send the head for this space.
2008	*/	1905	*/
2009		1906
2010	oldlen = sl.len;	1907	oldlen = sl.length ();
2011		1908
2012	SockList_AddShort (&sl, mask);	1909	sl << uint16 (mask);
		1910
2013	if (lastcell.count != -1)	1911	if (lastcell.count != -1)
2014	need_send = 1;	1912	need_send = 1;
		1913
2015	count = -1;	1914	count = -1;
2016		1915
2017	if (socket.mapmode == Map1aCmd && have_head (ax, ay))	1916	if (socket.mapmode == Map1aCmd && have_head (ax, ay))
2018	{	1917	{
2019	/* Now check to see if any heads need to be sent */	1918	/* Now check to see if any heads need to be sent */
2020		1919
2021	if (check_head (sl, socket, ax, ay, 2))	1920	if (check_head (sl, socket, ax, ay, 2)) mask |= 0x4;
2022	mask |= 0x4;
2023	if (check_head (sl, socket, ax, ay, 1))	1921	if (check_head (sl, socket, ax, ay, 1)) mask |= 0x2;
2024	mask |= 0x2;
2025	if (check_head (sl, socket, ax, ay, 0))	1922	if (check_head (sl, socket, ax, ay, 0)) mask |= 0x1;
2026	mask |= 0x1;
2027		1923
2028	lastcell.count = count;	1924	lastcell.count = count;
2029
2030	}	1925	}
2031	else	1926	else
2032	{	1927	{
2033	struct MapCell *cell = &lastcell;
2034
2035	/* properly clear a previously sent big face */	1928	/* properly clear a previously sent big face */
2036	if (cell->faces[0] != 0 || cell->faces[1] != 0 || cell->faces[2] != 0)	1929	if (lastcell.faces[0] != 0 || lastcell.faces[1] != 0 || lastcell.faces[2] != 0
		1930	|| lastcell.stat_hp || lastcell.flags || lastcell.player)
2037	need_send = 1;	1931	need_send = 1;
		1932
2038	map_clearcell (&lastcell, 0, 0, 0, count);	1933	map_clearcell (&lastcell, 0, 0, 0, count);
2039	}	1934	}
2040		1935
2041	if ((mask & 0xf) || need_send)	1936	if ((mask & 0xf) || need_send)
2042	{
2043	sl.buf[oldlen + 1] = mask & 0xff;	1937	sl[oldlen + 1] = mask & 0xff;
2044	}
2045	else	1938	else
2046	{
2047	sl.len = oldlen;	1939	sl.reset (oldlen);
2048	}
2049	}	1940	}
2050	else	1941	else
2051	{	1942	{
2052	/* In this block, the space is visible or there are head objects	1943	/* In this block, the space is visible or there are head objects
2053	* we need to send.	1944	* we need to send.
…		…
2055		1946
2056	/* Rather than try to figure out what everything that we might	1947	/* Rather than try to figure out what everything that we might
2057	* need to send is, then form the packet after that,	1948	* need to send is, then form the packet after that,
2058	* we presume that we will in fact form a packet, and update	1949	* we presume that we will in fact form a packet, and update
2059	* the bits by what we do actually send. If we send nothing,	1950	* the bits by what we do actually send. If we send nothing,
2060	* we just back out sl.len to the old value, and no harm	1951	* we just back out sl.length () to the old value, and no harm
2061	* is done.	1952	* is done.
2062	* I think this is simpler than doing a bunch of checks to see	1953	* I think this is simpler than doing a bunch of checks to see
2063	* what if anything we need to send, setting the bits, then	1954	* what if anything we need to send, setting the bits, then
2064	* doing those checks again to add the real data.	1955	* doing those checks again to add the real data.
2065	*/	1956	*/
2066	oldlen = sl.len;	1957	oldlen = sl.length ();
2067	mask = (ax & 0x3f) << 10 | (ay & 0x3f) << 4;	1958	mask = (ax & 0x3f) << 10 | (ay & 0x3f) << 4;
2068	eoldlen = esl.len;	1959	eoldlen = esl.length ();
2069	emask = (ax & 0x3f) << 10 | (ay & 0x3f) << 4;	1960	emask = (ax & 0x3f) << 10 | (ay & 0x3f) << 4;
2070	SockList_AddShort (&sl, mask);	1961	sl << uint16 (mask);
2071		1962
2072	if (socket.ext_mapinfos)	1963	if (socket.ext_mapinfos)
2073	SockList_AddShort (&esl, emask);	1964	esl << uint16 (emask);
2074		1965
2075	unsigned char dummy;	1966	unsigned char dummy;
2076	unsigned char *last_ext = &dummy;	1967	unsigned char *last_ext = &dummy;
2077		1968
2078	/* Darkness changed */	1969	/* Darkness changed */
…		…
2081	mask |= 0x8;	1972	mask |= 0x8;
2082		1973
2083	if (socket.extmap)	1974	if (socket.extmap)
2084	{	1975	{
2085	*last_ext |= 0x80;	1976	*last_ext |= 0x80;
2086	last_ext = sl.buf + sl.len;	1977	last_ext = &sl[sl.length ()];
2087	SockList_AddChar (&sl, d);	1978	sl << uint8 (d);
2088	}	1979	}
2089	else	1980	else
2090	SockList_AddChar (&sl, 255 - 64 * d);	1981	sl << uint8 (255 - 64 * d);
2091	}	1982	}
2092		1983
2093	lastcell.count = d;	1984	lastcell.count = d;
2094		1985
2095	if (socket.extmap)	1986	if (socket.extmap)
2096	{	1987	{
2097	uint8 stat_hp = 0;	1988	uint8 stat_hp = 0;
2098	uint8 stat_width = 0;	1989	uint8 stat_width = 0;
		1990	uint8 flags = 0;
2099	tag_t player = 0;	1991	UUID player = 0;
2100		1992
2101	// send hp information, if applicable	1993	// send hp information, if applicable
2102	if (object *op = GET_MAP_FACE_OBJ (m, nx, ny, 0))	1994	if (object *op = GET_MAP_FACE_OBJ (m, nx, ny, 0))
2103	{	1995	{
2104	if (op->head || op->invisible)	1996	if (op->head || op->invisible)
…		…
2111	stat_hp = 255 - (op->stats.hp * 255 + 254) / op->stats.maxhp;	2003	stat_hp = 255 - (op->stats.hp * 255 + 254) / op->stats.maxhp;
2112	stat_width = op->arch->tail_x;	2004	stat_width = op->arch->tail_x;
2113	}	2005	}
2114	}	2006	}
2115		2007
		2008	if (op->msg && op->msg[0] == '@')
		2009	flags |= 1;
		2010
2116	if (op->type == PLAYER && op != pl)	2011	if (op->type == PLAYER && op != pl)
2117	player = op->count;	2012	player = op->count;
2118	}	2013	}
2119		2014
2120	if (lastcell.stat_hp != stat_hp)	2015	if (lastcell.stat_hp != stat_hp)
2121	{	2016	{
2122	lastcell.stat_hp = stat_hp;	2017	lastcell.stat_hp = stat_hp;
2123		2018
2124	mask |= 0x8;	2019	mask |= 0x8;
2125	*last_ext |= 0x80;	2020	*last_ext |= 0x80;
2126	last_ext = sl.buf + sl.len;	2021	last_ext = &sl[sl.length ()];
2127	SockList_AddChar (&sl, 5);	2022
2128	SockList_AddChar (&sl, stat_hp);	2023	sl << uint8 (5) << uint8 (stat_hp);
2129		2024
2130	if (stat_width > 1)	2025	if (stat_width > 1)
2131	{	2026	{
2132	*last_ext |= 0x80;	2027	*last_ext |= 0x80;
2133	last_ext = sl.buf + sl.len;	2028	last_ext = &sl[sl.length ()];
2134	SockList_AddChar (&sl, 6);	2029
2135	SockList_AddChar (&sl, stat_width);	2030	sl << uint8 (6) << uint8 (stat_width);
2136	}	2031	}
2137	}	2032	}
2138		2033
2139	if (lastcell.player !=player)	2034	if (lastcell.player != player)
2140	{	2035	{
2141	lastcell.player = player;	2036	lastcell.player = player;
2142		2037
2143	mask |= 0x8;	2038	mask |= 0x8;
2144	*last_ext |= 0x80;	2039	*last_ext |= 0x80;
2145	last_ext = sl.buf + sl.len;	2040	last_ext = &sl[sl.length ()];
2146	SockList_AddChar (&sl, 0x47);	2041
2147	SockList_AddChar (&sl, 4);	2042	sl << uint8 (0x47) << uint8 (8) << (uint64)player;
2148	SockList_AddInt (&sl, player);	2043	}
		2044
		2045	if (lastcell.flags != flags)
		2046	{
		2047	lastcell.flags = flags;
		2048
		2049	mask |= 0x8;
		2050	*last_ext |= 0x80;
		2051	last_ext = &sl[sl.length ()];
		2052
		2053	sl << uint8 (8) << uint8 (flags);
2149	}	2054	}
2150	}	2055	}
2151		2056
2152	/* Floor face */	2057	/* Floor face */
2153	if (update_space (&sl, &socket, m, nx, ny, ax, ay, 2))	2058	if (update_space (sl, socket, m, nx, ny, ax, ay, 2))
2154	mask |= 0x4;	2059	mask |= 0x4;
2155		2060
2156	if (socket.EMI_smooth)	2061	if (socket.EMI_smooth)
2157	if (update_smooth (&esl, &socket, m, nx, ny, ax, ay, 2))	2062	if (update_smooth (esl, socket, m, nx, ny, ax, ay, 2))
2158	emask |= 0x4;	2063	emask |= 0x4;
2159		2064
2160	/* Middle face */	2065	/* Middle face */
2161	if (update_space (&sl, &socket, m, nx, ny, ax, ay, 1))	2066	if (update_space (sl, socket, m, nx, ny, ax, ay, 1))
2162	mask |= 0x2;	2067	mask |= 0x2;
2163		2068
2164	if (socket.EMI_smooth)	2069	if (socket.EMI_smooth)
2165	if (update_smooth (&esl, &socket, m, nx, ny, ax, ay, 1))	2070	if (update_smooth (esl, socket, m, nx, ny, ax, ay, 1))
2166	emask |= 0x2;	2071	emask |= 0x2;
2167		2072
2168	if (nx == pl->x && ny == pl->y && pl->invisible & (pl->invisible < 50 ? 4 : 1))	2073	if (nx == pl->x && ny == pl->y && pl->invisible & (pl->invisible < 50 ? 4 : 1))
2169	{	2074	{
2170	if (lastcell.faces[0] != pl->face->number)	2075	if (lastcell.faces[0] != pl->face->number)
2171	{	2076	{
2172	lastcell.faces[0] = pl->face->number;	2077	lastcell.faces[0] = pl->face->number;
2173	mask |= 0x1;	2078	mask |= 0x1;
		2079
2174	if (!(socket.faces_sent[pl->face->number] & NS_FACESENT_FACE))	2080	if (!(socket.faces_sent[pl->face->number] & NS_FACESENT_FACE))
2175	esrv_send_face (&socket, pl->face->number, 0);	2081	esrv_send_face (&socket, pl->face->number, 0);
2176	SockList_AddShort (&sl, pl->face->number);	2082
		2083	sl << uint16 (pl->face->number);
2177	}	2084	}
2178	}	2085	}
2179	/* Top face */
2180	else	2086	else
2181	{	2087	{
		2088	/* Top face */
2182	if (update_space (&sl, &socket, m, nx, ny, ax, ay, 0))	2089	if (update_space (sl, socket, m, nx, ny, ax, ay, 0))
2183	mask |= 0x1;	2090	mask |= 0x1;
		2091
2184	if (socket.EMI_smooth)	2092	if (socket.EMI_smooth)
2185	if (update_smooth (&esl, &socket, m, nx, ny, ax, ay, 0))	2093	if (update_smooth (esl, socket, m, nx, ny, ax, ay, 0))
2186	{
2187	emask |= 0x1;	2094	emask |= 0x1;
2188	}
2189	}	2095	}
		2096
2190	/* Check to see if we are in fact sending anything for this	2097	/* Check to see if we are in fact sending anything for this
2191	* space by checking the mask. If so, update the mask.	2098	* space by checking the mask. If so, update the mask.
2192	* if not, reset the len to that from before adding the mask	2099	* if not, reset the len to that from before adding the mask
2193	* value, so we don't send those bits.	2100	* value, so we don't send those bits.
2194	*/	2101	*/
2195	if (mask & 0xf)	2102	if (mask & 0xf)
2196	{
2197	sl.buf[oldlen + 1] = mask & 0xff;	2103	sl[oldlen + 1] = mask & 0xff;
2198	}
2199	else	2104	else
2200	{
2201	sl.len = oldlen;	2105	sl.reset (oldlen);
2202	}	2106
2203	if (emask & 0xf)	2107	if (emask & 0xf)
2204	{
2205	esl.buf[eoldlen + 1] = emask & 0xff;	2108	esl[eoldlen + 1] = emask & 0xff;
2206	}
2207	else	2109	else
2208	{
2209	esl.len = eoldlen;	2110	esl.reset (eoldlen);
2210	}
2211	} /* else this is a viewable space */	2111	} /* else this is a viewable space */
2212	} /* for x loop */	2112	} /* for x loop */
2213	} /* for y loop */	2113	} /* for y loop */
2214		2114
2215	/* Verify that we in fact do need to send this */	2115	/* Verify that we in fact do need to send this */
2216	if (socket.ext_mapinfos)	2116	if (socket.ext_mapinfos)
2217	{	2117	{
2218	if (!(sl.len > startlen || socket.sent_scroll))	2118	if (!(sl.length () > startlen || socket.sent_scroll))
2219	{	2119	{
2220	/* No map data will follow, so don't say the client	2120	/* No map data will follow, so don't say the client
2221	* it doesn't need draw!	2121	* it doesn't need draw!
2222	*/	2122	*/
2223	ewhatflag &= (~EMI_NOREDRAW);	2123	ewhatflag &= (~EMI_NOREDRAW);
2224	esl.buf[ewhatstart + 1] = ewhatflag & 0xff;	2124	esl[ewhatstart + 1] = ewhatflag & 0xff;
2225	}	2125	}
		2126
2226	if (esl.len > estartlen)	2127	if (esl.length () > estartlen)
2227	{	2128	socket.send_packet (esl);
2228	Send_With_Handling (&socket, &esl);
2229	}
2230	free (esl.buf);
2231	}	2129	}
		2130
2232	if (sl.len > startlen || socket.sent_scroll)	2131	if (sl.length () > startlen || socket.sent_scroll)
2233	{	2132	{
2234	Send_With_Handling (&socket, &sl);	2133	socket.send_packet (sl);
2235	socket.sent_scroll = 0;	2134	socket.sent_scroll = 0;
2236	}	2135	}
2237	free (sl.buf);
2238	}	2136	}
2239		2137
2240	/**	2138	/**
2241	* Draws client map.	2139	* Draws client map.
2242	*/	2140	*/
…		…
2247	sint16 ax, ay, nx, ny; /* ax and ay goes from 0 to max-size of arrays */	2145	sint16 ax, ay, nx, ny; /* ax and ay goes from 0 to max-size of arrays */
2248	New_Face *face, *floor;	2146	New_Face *face, *floor;
2249	New_Face *floor2;	2147	New_Face *floor2;
2250	int d, mflags;	2148	int d, mflags;
2251	struct Map newmap;	2149	struct Map newmap;
2252	mapstruct *m, *pm;	2150	maptile *m, *pm;
2253		2151
2254	if (pl->type != PLAYER)	2152	if (pl->type != PLAYER)
2255	{	2153	{
2256	LOG (llevError, "draw_client_map called with non player/non eric-server\n");	2154	LOG (llevError, "draw_client_map called with non player/non eric-server\n");
2257	return;	2155	return;
…		…
2266	if (pm == NULL || pm->in_memory != MAP_IN_MEMORY)	2164	if (pm == NULL || pm->in_memory != MAP_IN_MEMORY)
2267	return;	2165	return;
2268		2166
2269	memset (&newmap, 0, sizeof (struct Map));	2167	memset (&newmap, 0, sizeof (struct Map));
2270		2168
2271	for (j = (pl->y - pl->contr->socket.mapy / 2); j < (pl->y + (pl->contr->socket.mapy + 1) / 2); j++)	2169	for (j = (pl->y - pl->contr->socket->mapy / 2); j < (pl->y + (pl->contr->socket->mapy + 1) / 2); j++)
2272	{	2170	{
2273	for (i = (pl->x - pl->contr->socket.mapx / 2); i < (pl->x + (pl->contr->socket.mapx + 1) / 2); i++)	2171	for (i = (pl->x - pl->contr->socket->mapx / 2); i < (pl->x + (pl->contr->socket->mapx + 1) / 2); i++)
2274	{	2172	{
2275	ax = i;	2173	ax = i;
2276	ay = j;	2174	ay = j;
2277	m = pm;	2175	m = pm;
2278	mflags = get_map_flags (m, &m, ax, ay, &ax, &ay);	2176	mflags = get_map_flags (m, &m, ax, ay, &ax, &ay);
…		…
2293	{	2191	{
2294	update_los (pl);	2192	update_los (pl);
2295	pl->contr->do_los = 0;	2193	pl->contr->do_los = 0;
2296	}	2194	}
2297		2195
2298	if (pl->contr->socket.mapmode == Map1Cmd || pl->contr->socket.mapmode == Map1aCmd)
2299	{
2300	/* Big maps need a different drawing mechanism to work */	2196	/* Big maps need a different drawing mechanism to work */
2301	draw_client_map1 (pl);	2197	draw_client_map1 (pl);
2302	return;
2303	}
2304
2305	if (pl->invisible & (pl->invisible < 50 ? 4 : 1))
2306	{
2307	esrv_map_setbelow (&pl->contr->socket, pl->contr->socket.mapx / 2, pl->contr->socket.mapy / 2, pl->face->number, &newmap);
2308	}
2309
2310	/* j and i are the y and x coordinates of the real map (which is
2311	* basically some number of spaces around the player)
2312	* ax and ay are values from within the viewport (ie, 0, 0 is upper
2313	* left corner) and are thus disconnected from the map values.
2314	* Subtract 1 from the max values so that we properly handle cases where
2315	* player has specified an even map. Otherwise, we try to send them too
2316	* much, ie, if mapx is 10, we would try to send from -5 to 5, which is actually
2317	* 11 spaces. Now, we would send from -5 to 4, which is properly. If mapx is
2318	* odd, this still works fine.
2319	*/
2320	ay = 0;
2321	for (j = pl->y - pl->contr->socket.mapy / 2; j <= pl->y + (pl->contr->socket.mapy - 1) / 2; j++, ay++)
2322	{
2323	ax = 0;
2324	for (i = pl->x - pl->contr->socket.mapx / 2; i <= pl->x + (pl->contr->socket.mapx - 1) / 2; i++, ax++)
2325	{
2326
2327	d = pl->contr->blocked_los[ax][ay];
2328	/* note the out_of_map and d>3 checks are both within the same
2329	* negation check.
2330	*/
2331	nx = i;
2332	ny = j;
2333	m = get_map_from_coord (pm, &nx, &ny);
2334	if (m && d < 4)
2335	{
2336	face = GET_MAP_FACE (m, nx, ny, 0);
2337	floor2 = GET_MAP_FACE (m, nx, ny, 1);
2338	floor = GET_MAP_FACE (m, nx, ny, 2);
2339
2340	/* If all is blank, send a blank face. */
2341	if ((!face || face == blank_face) && (!floor2 || floor2 == blank_face) && (!floor || floor == blank_face))
2342	{
2343	esrv_map_setbelow (&pl->contr->socket, ax, ay, blank_face->number, &newmap);
2344	}
2345	else
2346	{ /* actually have something interesting */
2347	/* send the darkness mask, if any. */
2348	if (d && pl->contr->socket.darkness)
2349	esrv_map_setbelow (&pl->contr->socket, ax, ay, dark_faces[d - 1]->number, &newmap);
2350
2351	if (face && face != blank_face)
2352	esrv_map_setbelow (&pl->contr->socket, ax, ay, face->number, &newmap);
2353	if (floor2 && floor2 != blank_face)
2354	esrv_map_setbelow (&pl->contr->socket, ax, ay, floor2->number, &newmap);
2355	if (floor && floor != blank_face)
2356	esrv_map_setbelow (&pl->contr->socket, ax, ay, floor->number, &newmap);
2357	}
2358	} /* Is a valid space */
2359	}
2360	}
2361	esrv_map_doneredraw (&pl->contr->socket, &newmap);
2362
2363	check_map_change (pl->contr);
2364	}	2198	}
2365		2199
2366		2200
2367	/*****************************************************************************/	2201	/*****************************************************************************/
2368		2202
…		…
2374		2208
2375	/*****************************************************************************/	2209	/*****************************************************************************/
2376	void	2210	void
2377	send_plugin_custom_message (object *pl, char *buf)	2211	send_plugin_custom_message (object *pl, char *buf)
2378	{	2212	{
2379	cs_write_string (&pl->contr->socket, buf, strlen (buf));	2213	pl->contr->socket->send_packet (buf);
2380	}	2214	}
2381		2215
2382	/**	2216	/**
2383	* This sends the skill number to name mapping. We ignore	2217	* This sends the skill number to name mapping. We ignore
2384	* the params - we always send the same info no matter what.	2218	* the params - we always send the same info no matter what.
2385	*/	2219	*/
2386	void	2220	void
2387	send_skill_info (NewSocket * ns, char *params)	2221	send_skill_info (client_socket *ns, char *params)
2388	{	2222	{
2389	SockList sl;	2223	packet sl;
2390	int i;	2224	sl << "replyinfo skill_info\n";
2391		2225
2392	sl.buf = (unsigned char *) malloc (MAXSOCKBUF);
2393	strcpy ((char *) sl.buf, "replyinfo skill_info\n");
2394	for (i = 1; i < NUM_SKILLS; i++)	2226	for (int i = 1; i < NUM_SKILLS; i++)
2395	{	2227	sl.printf ("%d:%s\n", i + CS_STAT_SKILLINFO, &skill_names[i]);
2396	sprintf ((char *) sl.buf + strlen ((char *) sl.buf), "%d:%s\n", i + CS_STAT_SKILLINFO, &skill_names[i]);	2228
2397	}
2398	sl.len = strlen ((char *) sl.buf);
2399	if (sl.len >= MAXSOCKBUF)	2229	if (sl.length () >= MAXSOCKBUF)
2400	{	2230	{
2401	LOG (llevError, "Buffer overflow in send_skill_info!\n");	2231	LOG (llevError, "Buffer overflow in send_skill_info!\n");
2402	fatal (0);	2232	fatal (0);
2403	}	2233	}
2404	Send_With_Handling (ns, &sl);	2234
2405	free (sl.buf);	2235	ns->send_packet (sl);
2406	}	2236	}
2407		2237
2408	/**	2238	/**
2409	* This sends the spell path to name mapping. We ignore	2239	* This sends the spell path to name mapping. We ignore
2410	* the params - we always send the same info no matter what.	2240	* the params - we always send the same info no matter what.
2411	*/	2241	*/
2412	void	2242	void
2413	send_spell_paths (NewSocket * ns, char *params)	2243	send_spell_paths (client_socket * ns, char *params)
2414	{	2244	{
2415	SockList sl;	2245	packet sl;
2416	int i;
2417		2246
2418	sl.buf = (unsigned char *) malloc (MAXSOCKBUF);	2247	sl << "replyinfo spell_paths\n";
2419	strcpy ((char *) sl.buf, "replyinfo spell_paths\n");	2248
2420	for (i = 0; i < NRSPELLPATHS; i++)	2249	for (int i = 0; i < NRSPELLPATHS; i++)
2421	sprintf ((char *) sl.buf + strlen ((char *) sl.buf), "%d:%s\n", 1 << i, spellpathnames[i]);	2250	sl.printf ("%d:%s\n", 1 << i, spellpathnames[i]);
2422	sl.len = strlen ((char *) sl.buf);	2251
2423	if (sl.len >= MAXSOCKBUF)	2252	if (sl.length () >= MAXSOCKBUF)
2424	{	2253	{
2425	LOG (llevError, "Buffer overflow in send_spell_paths!\n");	2254	LOG (llevError, "Buffer overflow in send_spell_paths!\n");
2426	fatal (0);	2255	fatal (0);
2427	}	2256	}
2428	Send_With_Handling (ns, &sl);	2257
2429	free (sl.buf);	2258	ns->send_packet (sl);
2430	}	2259	}
2431		2260
2432	/**	2261	/**
2433	* This looks for any spells the player may have that have changed their stats.	2262	* This looks for any spells the player may have that have changed their stats.
2434	* it then sends an updspell packet for each spell that has changed in this way	2263	* it then sends an updspell packet for each spell that has changed in this way
2435	*/	2264	*/
2436	void	2265	void
2437	esrv_update_spells (player *pl)	2266	esrv_update_spells (player *pl)
2438	{	2267	{
2439	SockList sl;
2440	int flags = 0;
2441	object *spell;
2442
2443	if (!pl->socket.monitor_spells)	2268	if (!pl->socket->monitor_spells)
2444	return;	2269	return;
		2270
2445	for (spell = pl->ob->inv; spell != NULL; spell = spell->below)	2271	for (object *spell = pl->ob->inv; spell; spell = spell->below)
2446	{	2272	{
2447	if (spell->type == SPELL)	2273	if (spell->type == SPELL)
2448	{	2274	{
		2275	int flags = 0;
		2276
2449	/* check if we need to update it */	2277	/* check if we need to update it */
2450	if (spell->last_sp != SP_level_spellpoint_cost (pl->ob, spell, SPELL_MANA))	2278	if (spell->last_sp != SP_level_spellpoint_cost (pl->ob, spell, SPELL_MANA))
2451	{	2279	{
2452	spell->last_sp = SP_level_spellpoint_cost (pl->ob, spell, SPELL_MANA);	2280	spell->last_sp = SP_level_spellpoint_cost (pl->ob, spell, SPELL_MANA);
2453	flags |= UPD_SP_MANA;	2281	flags |= UPD_SP_MANA;
2454	}	2282	}
		2283
2455	if (spell->last_grace != SP_level_spellpoint_cost (pl->ob, spell, SPELL_GRACE))	2284	if (spell->last_grace != SP_level_spellpoint_cost (pl->ob, spell, SPELL_GRACE))
2456	{	2285	{
2457	spell->last_grace = SP_level_spellpoint_cost (pl->ob, spell, SPELL_GRACE);	2286	spell->last_grace = SP_level_spellpoint_cost (pl->ob, spell, SPELL_GRACE);
2458	flags |= UPD_SP_GRACE;	2287	flags |= UPD_SP_GRACE;
2459	}	2288	}
		2289
2460	if (spell->last_eat != spell->stats.dam + SP_level_dam_adjust (pl->ob, spell))	2290	if (spell->last_eat != spell->stats.dam + SP_level_dam_adjust (pl->ob, spell))
2461	{	2291	{
2462	spell->last_eat = spell->stats.dam + SP_level_dam_adjust (pl->ob, spell);	2292	spell->last_eat = spell->stats.dam + SP_level_dam_adjust (pl->ob, spell);
2463	flags |= UPD_SP_DAMAGE;	2293	flags |= UPD_SP_DAMAGE;
2464	}	2294	}
		2295
2465	if (flags != 0)	2296	if (flags)
2466	{	2297	{
2467	sl.buf = (unsigned char *) malloc (MAXSOCKBUF);	2298	packet sl;
2468	strcpy ((char *) sl.buf, "updspell ");	2299
2469	sl.len = strlen ((char *) sl.buf);	2300	sl << "updspell "
2470	SockList_AddChar (&sl, flags);	2301	<< uint8 (flags)
2471	SockList_AddInt (&sl, spell->count);	2302	<< uint32 (spell->count);
2472	if (flags & UPD_SP_MANA)	2303
2473	SockList_AddShort (&sl, spell->last_sp);	2304	if (flags & UPD_SP_MANA ) sl << uint16 (spell->last_sp);
2474	if (flags & UPD_SP_GRACE)	2305	if (flags & UPD_SP_GRACE ) sl << uint16 (spell->last_grace);
2475	SockList_AddShort (&sl, spell->last_grace);	2306	if (flags & UPD_SP_DAMAGE) sl << uint16 (spell->last_eat);
2476	if (flags & UPD_SP_DAMAGE)	2307
2477	SockList_AddShort (&sl, spell->last_eat);	2308	pl->socket->send_packet (sl);
2478	flags = 0;
2479	Send_With_Handling (&pl->socket, &sl);
2480	free (sl.buf);
2481	}	2309	}
2482	}	2310	}
2483	}	2311	}
2484	}	2312	}
2485		2313
2486	void	2314	void
2487	esrv_remove_spell (player *pl, object *spell)	2315	esrv_remove_spell (player *pl, object *spell)
2488	{	2316	{
2489	SockList sl;
2490
2491	if (!pl->socket.monitor_spells)	2317	if (!pl->socket->monitor_spells)
2492	return;	2318	return;
		2319
2493	if (!pl || !spell || spell->env != pl->ob)	2320	if (!pl || !spell || spell->env != pl->ob)
2494	{	2321	{
2495	LOG (llevError, "Invalid call to esrv_remove_spell");	2322	LOG (llevError, "Invalid call to esrv_remove_spell");
2496	return;	2323	return;
2497	}	2324	}
2498	sl.buf = (unsigned char *) malloc (MAXSOCKBUF);	2325
2499	strcpy ((char *) sl.buf, "delspell ");	2326	packet sl;
2500	sl.len = strlen ((char *) sl.buf);	2327
2501	SockList_AddInt (&sl, spell->count);	2328	sl << "delspell "
2502	Send_With_Handling (&pl->socket, &sl);	2329	<< uint32 (spell->count);
2503	free (sl.buf);	2330
		2331	pl->socket->send_packet (sl);
2504	}	2332	}
2505		2333
2506	/* appends the spell *spell to the Socklist we will send the data to. */	2334	/* appends the spell *spell to the Socklist we will send the data to. */
2507	static void	2335	static void
2508	append_spell (player *pl, SockList * sl, object *spell)	2336	append_spell (player *pl, packet &sl, object *spell)
2509	{	2337	{
2510	int len, i, skill = 0;	2338	int len, i, skill = 0;
2511		2339
2512	if (!(spell->name))	2340	if (!(spell->name))
2513	{	2341	{
2514	LOG (llevError, "item number %d is a spell with no name.\n", spell->count);	2342	LOG (llevError, "item number %d is a spell with no name.\n", spell->count);
2515	return;	2343	return;
2516	}	2344	}
2517	SockList_AddInt (sl, spell->count);	2345
2518	SockList_AddShort (sl, spell->level);
2519	SockList_AddShort (sl, spell->casting_time);
2520	/* store costs and damage in the object struct, to compare to later */	2346	/* store costs and damage in the object struct, to compare to later */
2521	spell->last_sp = SP_level_spellpoint_cost (pl->ob, spell, SPELL_MANA);	2347	spell->last_sp = SP_level_spellpoint_cost (pl->ob, spell, SPELL_MANA);
2522	spell->last_grace = SP_level_spellpoint_cost (pl->ob, spell, SPELL_GRACE);	2348	spell->last_grace = SP_level_spellpoint_cost (pl->ob, spell, SPELL_GRACE);
2523	spell->last_eat = spell->stats.dam + SP_level_dam_adjust (pl->ob, spell);	2349	spell->last_eat = spell->stats.dam + SP_level_dam_adjust (pl->ob, spell);
2524	/* send the current values */
2525	SockList_AddShort (sl, spell->last_sp);
2526	SockList_AddShort (sl, spell->last_grace);
2527	SockList_AddShort (sl, spell->last_eat);
2528		2350
2529	/* figure out which skill it uses, if it uses one */	2351	/* figure out which skill it uses, if it uses one */
2530	if (spell->skill)	2352	if (spell->skill)
2531	{	2353	{
2532	for (i = 1; i < NUM_SKILLS; i++)	2354	for (i = 1; i < NUM_SKILLS; i++)
…		…
2534	{	2356	{
2535	skill = i + CS_STAT_SKILLINFO;	2357	skill = i + CS_STAT_SKILLINFO;
2536	break;	2358	break;
2537	}	2359	}
2538	}	2360	}
2539	SockList_AddChar (sl, skill);
2540		2361
2541	SockList_AddInt (sl, spell->path_attuned);	2362	/* send the current values */
		2363	sl << uint32 (spell->count)
		2364	<< uint16 (spell->level)
		2365	<< uint16 (spell->casting_time)
		2366	<< uint16 (spell->last_sp)
		2367	<< uint16 (spell->last_grace)
		2368	<< uint16 (spell->last_eat)
		2369	<< uint8 (skill)
		2370	<< uint32 (spell->path_attuned)
2542	SockList_AddInt (sl, (spell->face) ? spell->face->number : 0);	2371	<< uint32 (spell->face ? spell->face->number : 0)
2543		2372	<< data8 (spell->name)
2544	len = strlen (spell->name);	2373	<< data16 (spell->msg);
2545	SockList_AddChar (sl, (char) len);
2546	memcpy (sl->buf + sl->len, spell->name, len);
2547	sl->len += len;
2548
2549	if (!spell->msg)
2550	{
2551	SockList_AddShort (sl, 0);
2552	}
2553	else
2554	{
2555	len = strlen (spell->msg);
2556	SockList_AddShort (sl, len);
2557	memcpy (sl->buf + sl->len, spell->msg, len);
2558	sl->len += len;
2559	}
2560	}	2374	}
2561		2375
2562	/**	2376	/**
2563	* This tells the client to add the spell *ob, if *ob is NULL, then add	2377	* This tells the client to add the spell *ob, if *ob is NULL, then add
2564	* all spells in the player's inventory.	2378	* all spells in the player's inventory.
2565	*/	2379	*/
2566	void	2380	void
2567	esrv_add_spells (player *pl, object *spell)	2381	esrv_add_spells (player *pl, object *spell)
2568	{	2382	{
2569	SockList sl;
2570
2571	if (!pl)	2383	if (!pl)
2572	{	2384	{
2573	LOG (llevError, "esrv_add_spells, tried to add a spell to a NULL player");	2385	LOG (llevError, "esrv_add_spells, tried to add a spell to a NULL player");
2574	return;	2386	return;
2575	}	2387	}
		2388
2576	if (!pl->socket.monitor_spells)	2389	if (!pl->socket->monitor_spells)
2577	return;	2390	return;
2578	sl.buf = (unsigned char *) malloc (MAXSOCKBUF);	2391
2579	strcpy ((char *) sl.buf, "addspell ");	2392	packet sl;
2580	sl.len = strlen ((char *) sl.buf);	2393
		2394	sl << "addspell ";
		2395
2581	if (!spell)	2396	if (!spell)
2582	{	2397	{
2583	for (spell = pl->ob->inv; spell != NULL; spell = spell->below)	2398	for (spell = pl->ob->inv; spell != NULL; spell = spell->below)
2584	{	2399	{
2585	/* were we to simply keep appending data here, we could exceed	2400	/* were we to simply keep appending data here, we could exceed
…		…
2595	* is hundreds of bytes off, so correcting 22 vs 26 doesn't seem	2410	* is hundreds of bytes off, so correcting 22 vs 26 doesn't seem
2596	* like it will fix this	2411	* like it will fix this
2597	*/	2412	*/
2598	if (spell->type != SPELL)	2413	if (spell->type != SPELL)
2599	continue;	2414	continue;
		2415
2600	if (sl.len >= (MAXSOCKBUF - (26 + strlen (spell->name) + (spell->msg ? strlen (spell->msg) : 0))))	2416	if (sl.length () >= (MAXSOCKBUF - (26 + strlen (spell->name) + (spell->msg ? strlen (spell->msg) : 0))))
2601	{	2417	{
2602	Send_With_Handling (&pl->socket, &sl);	2418	pl->socket->send_packet (sl);
2603	strcpy ((char *) sl.buf, "addspell ");	2419
2604	sl.len = strlen ((char *) sl.buf);	2420	sl.reset ();
		2421	sl << "addspell ";
2605	}	2422	}
		2423
2606	append_spell (pl, &sl, spell);	2424	append_spell (pl, sl, spell);
2607	}	2425	}
2608	}	2426	}
2609	else if (spell->type != SPELL)	2427	else if (spell->type != SPELL)
2610	{	2428	{
2611	LOG (llevError, "Asked to send a non-spell object as a spell");	2429	LOG (llevError, "Asked to send a non-spell object as a spell");
2612	return;	2430	return;
2613	}	2431	}
2614	else	2432	else
2615	append_spell (pl, &sl, spell);	2433	append_spell (pl, sl, spell);
		2434
2616	if (sl.len >= MAXSOCKBUF)	2435	if (sl.length () >= MAXSOCKBUF)
2617	{	2436	{
2618	LOG (llevError, "Buffer overflow in esrv_add_spells!\n");	2437	LOG (llevError, "Buffer overflow in esrv_add_spells!\n");
2619	fatal (0);	2438	fatal (0);
2620	}	2439	}
		2440
2621	/* finally, we can send the packet */	2441	/* finally, we can send the packet */
2622	Send_With_Handling (&pl->socket, &sl);	2442	pl->socket->send_packet (sl);
2623	free (sl.buf);
2624	}	2443	}
		2444

Diff Legend

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