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.32 by root, Thu Dec 14 01:12:35 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.
…		…
50	* operations	44	* operations
51	*	45	*
52	* esrv_map_doneredraw finishes the map update, and ships across the	46	* esrv_map_doneredraw finishes the map update, and ships across the
53	* map updates.	47	* map updates.
54	*	48	*
55	* esrv_map_scroll tells the client to scroll the map, and does similarily
56	* for the locally cached copy.
57	*/	49	*/
58		50
59	#include <global.h>	51	#include <global.h>
60	#include <sproto.h>	52	#include <sproto.h>
61		53
…		…
65	#include <commands.h>	57	#include <commands.h>
66		58
67	/* This block is basically taken from socket.c - I assume if it works there,	59	/* This block is basically taken from socket.c - I assume if it works there,
68	* it should work here.	60	* it should work here.
69	*/	61	*/
70	#ifndef WIN32 /* ---win32 exclude unix headers */
71	# include <sys/types.h>	62	#include <sys/types.h>
72	# include <sys/time.h>	63	#include <sys/time.h>
73	# include <sys/socket.h>	64	#include <sys/socket.h>
74	# include <netinet/in.h>	65	#include <netinet/in.h>
75	# include <netdb.h>	66	#include <netdb.h>
76	#endif /* win32 */
77		67
78	#ifdef HAVE_UNISTD_H	68	#ifdef HAVE_UNISTD_H
79	# include <unistd.h>	69	# include <unistd.h>
80	#endif	70	#endif
81		71
…		…
112	{	102	{
113	struct Map newmap;	103	struct Map newmap;
114	int x, y, mx, my;	104	int x, y, mx, my;
115		105
116	{	106	{
117	char buf[MAXSOCKBUF];	107	SockList sl (MAXSOCKBUF);
118		108
119	sprintf (buf, "map_scroll %d %d", dx, dy);	109	sl.printf ("map_scroll %d %d", dx, dy);
120	Write_String_To_Socket (ns, buf, strlen (buf));	110	ns->send_packet (sl);
		111	sl.free ();
121	}	112	}
122		113
123	/* If we are using the Map1aCmd, we may in fact send	114	/* If we are using the Map1aCmd, we may in fact send
124	* head information that is outside the viewable map.	115	* head information that is outside the viewable map.
125	* So set the mx,my to the max value we want to	116	* So set the mx,my to the max value we want to
…		…
145	for (x = 0; x < mx; x++)	136	for (x = 0; x < mx; x++)
146	{	137	{
147	for (y = 0; y < my; y++)	138	for (y = 0; y < my; y++)
148	{	139	{
149	if (x >= ns->mapx || y >= ns->mapy)	140	if (x >= ns->mapx || y >= ns->mapy)
150	{
151	/* clear cells outside the viewable area */	141	/* clear cells outside the viewable area */
152	memset (&newmap.cells[x][y], 0, sizeof (struct MapCell));	142	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)	143	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 */	144	/* clear newly visible tiles within the viewable area */
157	memset (&(newmap.cells[x][y]), 0, sizeof (struct MapCell));	145	memset (&(newmap.cells[x][y]), 0, sizeof (struct MapCell));
158	}
159	else	146	else
160	{
161	memcpy (&(newmap.cells[x][y]), &(ns->lastmap.cells[x + dx][y + dy]), sizeof (struct MapCell));	147	memcpy (&(newmap.cells[x][y]), &(ns->lastmap.cells[x + dx][y + dy]), sizeof (struct MapCell));
162	}
163	}	148	}
164	}	149	}
165		150
166	memcpy (&(ns->lastmap), &newmap, sizeof (struct Map));	151	memcpy (&(ns->lastmap), &newmap, sizeof (struct Map));
167		152
…		…
177	NewSocket & socket = pl->socket;	162	NewSocket & socket = pl->socket;
178		163
179	memset (&socket.lastmap, 0, sizeof (socket.lastmap));	164	memset (&socket.lastmap, 0, sizeof (socket.lastmap));
180		165
181	if (socket.newmapcmd == 1)	166	if (socket.newmapcmd == 1)
182	Write_String_To_Socket (&socket, "newmap", 6);	167	socket.send_packet ("newmap");
183		168
184	socket.update_look = 1;	169	socket.update_look = 1;
185	socket.look_position = 0;	170	socket.look_position = 0;
186	}	171	}
187		172
…		…
218	flags, socket.mapx / 2 - ob->x, socket.mapy / 2 - ob->y, ob->map->width, ob->map->height, ob->map->path);	203	flags, socket.mapx / 2 - ob->x, socket.mapy / 2 - ob->y, ob->map->width, ob->map->height, ob->map->path);
219	}	204	}
220	else	205	else
221	snprintf (buf, MAX_BUF, "mapinfo current");	206	snprintf (buf, MAX_BUF, "mapinfo current");
222		207
223	Write_String_To_Socket (&socket, buf, strlen (buf));	208	socket.send_packet (buf);
224	}	209	}
225	}	210	}
226	else if (socket.current_x != ob->x || socket.current_y != ob->y)	211	else if (socket.current_x != ob->x || socket.current_y != ob->y)
227	{	212	{
228	int dx = ob->x - socket.current_x;	213	int dx = ob->x - socket.current_x;
…		…
266	if (!strncmp (buf, "spatial ", 8))	251	if (!strncmp (buf, "spatial ", 8))
267	{	252	{
268	buf += 8;	253	buf += 8;
269		254
270	// initial map and its origin	255	// initial map and its origin
271	mapstruct *map = pl->ob->map;	256	maptile *map = pl->ob->map;
272	sint16 dx, dy;	257	sint16 dx, dy;
273	int mapx = pl->socket.mapx / 2 - pl->ob->x;	258	int mapx = pl->socket.mapx / 2 - pl->ob->x;
274	int mapy = pl->socket.mapy / 2 - pl->ob->y;	259	int mapy = pl->socket.mapy / 2 - pl->ob->y;
275	int max_distance = 8; // limit maximum path length to something generous	260	int max_distance = 8; // limit maximum path length to something generous
276		261
…		…
330	snprintf (bigbuf, MAX_BUF, "mapinfo %s nomap", token);	315	snprintf (bigbuf, MAX_BUF, "mapinfo %s nomap", token);
331	}	316	}
332	else	317	else
333	snprintf (bigbuf, MAX_BUF, "mapinfo %s unsupported", token);	318	snprintf (bigbuf, MAX_BUF, "mapinfo %s unsupported", token);
334		319
335	Write_String_To_Socket (&pl->socket, bigbuf, strlen (bigbuf));	320	pl->socket.send_packet (bigbuf);
336	}	321	}
337		322
338	/** This is the Setup cmd - easy first implementation */	323	/** This is the Setup cmd - easy first implementation */
339	void	324	void
340	SetUp (char *buf, int len, NewSocket * ns)	325	SetUp (char *buf, int len, NewSocket * ns)
…		…
347	*	332	*
348	* we send the status of the cmd back, or a FALSE is the cmd is the server unknown	333	* 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	334	* The client then must sort this out
350	*/	335	*/
351		336
352	LOG (llevInfo, "Get SetupCmd:: %s\n", buf);	337	//LOG (llevInfo, "Get SetupCmd:: %s\n", buf);
		338
353	strcpy (cmdback, "setup");	339	strcpy (cmdback, "setup");
354	for (s = 0; s < len;)	340	for (s = 0; s < len; )
355	{	341	{
356
357	cmd = &buf[s];	342	cmd = &buf[s];
358		343
359	/* find the next space, and put a null there */	344	/* find the next space, and put a null there */
360	for (; buf[s] && buf[s] != ' '; s++);	345	for (; buf[s] && buf[s] != ' '; s++)
		346	;
		347
361	buf[s++] = 0;	348	buf[s++] = 0;
		349
362	while (buf[s] == ' ')	350	while (buf[s] == ' ')
363	s++;	351	s++;
364		352
365	if (s >= len)	353	if (s >= len)
366	break;	354	break;
367		355
368	param = &buf[s];	356	param = &buf[s];
369		357
370	for (; buf[s] && buf[s] != ' '; s++);	358	for (; buf[s] && buf[s] != ' '; s++)
		359	;
		360
371	buf[s++] = 0;	361	buf[s++] = 0;
		362
372	while (buf[s] == ' ')	363	while (buf[s] == ' ')
373	s++;	364	s++;
374		365
375	slen = strlen (cmdback);	366	slen = strlen (cmdback);
376	safe_strcat (cmdback, " ", &slen, HUGE_BUF);	367	safe_strcat (cmdback, " ", &slen, HUGE_BUF);
…		…
537	* report a failure to the client.	528	* report a failure to the client.
538	*/	529	*/
539	safe_strcat (cmdback, "FALSE", &slen, HUGE_BUF);	530	safe_strcat (cmdback, "FALSE", &slen, HUGE_BUF);
540	}	531	}
541	} /* for processing all the setup commands */	532	} /* for processing all the setup commands */
		533
542	LOG (llevInfo, "SendBack SetupCmd:: %s\n", cmdback);	534	LOG (llevInfo, "SendBack SetupCmd:: %s\n", cmdback);
543	Write_String_To_Socket (ns, cmdback, strlen (cmdback));	535	ns->send_packet (cmdback);
544	}	536	}
545		537
546	/**	538	/**
547	* The client has requested to be added to the game.	539	* 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.	540	* This is what takes care of it. We tell the client how things worked out.
…		…
554	{	546	{
555	Settings oldsettings;	547	Settings oldsettings;
556		548
557	oldsettings = settings;	549	oldsettings = settings;
558	if (ns->status != Ns_Add || add_player (ns))	550	if (ns->status != Ns_Add || add_player (ns))
559	{	551	ns->send_packet ("addme_failed");
560	Write_String_To_Socket (ns, "addme_failed", 12);
561	}
562	else	552	else
563	{	553	{
564	/* Basically, the add_player copies the socket structure into	554	/* Basically, the add_player copies the socket structure into
565	* the player structure, so this one (which is from init_sockets)	555	* the player structure, so this one (which is from init_sockets)
566	* is not needed anymore. The write below should still work, as the	556	* is not needed anymore. The write below should still work, as the
567	* stuff in ns is still relevant.	557	* stuff in ns is still relevant.
568	*/	558	*/
569	Write_String_To_Socket (ns, "addme_success", 13);	559	ns->send_packet ("addme_success");
570	socket_info.nconns--;	560	socket_info.nconns--;
571	ns->status = Ns_Avail;	561	ns->status = Ns_Avail;
572	}	562	}
		563
573	settings = oldsettings;	564	settings = oldsettings;
574	}	565	}
575		566
576	/** Reply to ExtendedInfos command */	567	/** Reply to ExtendedInfos command */
577	void	568	void
…		…
621	{	612	{
622	strcat (cmdback, " ");	613	strcat (cmdback, " ");
623	strcat (cmdback, "smoothing");	614	strcat (cmdback, "smoothing");
624	}	615	}
625		616
626	Write_String_To_Socket (ns, cmdback, strlen (cmdback));	617	ns->send_packet (cmdback);
627	}	618	}
628		619
629	/*	620	/*
630	#define MSG_TYPE_BOOK 1	621	#define MSG_TYPE_BOOK 1
631	#define MSG_TYPE_CARD 2	622	#define MSG_TYPE_CARD 2
…		…
684	strcat (cmdback, " ");	675	strcat (cmdback, " ");
685	snprintf (temp, sizeof (temp), "%d", i);	676	snprintf (temp, sizeof (temp), "%d", i);
686	strcat (cmdback, temp);	677	strcat (cmdback, temp);
687	}	678	}
688		679
689	Write_String_To_Socket (ns, cmdback, strlen (cmdback));	680	ns->send_packet (cmdback);
690	}	681	}
691		682
692	/**	683	/**
693	* A lot like the old AskSmooth (in fact, now called by AskSmooth).	684	* 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	685	* Basically, it makes no sense to wait for the client to request a
…		…
698	*/	689	*/
699	static void	690	static void
700	SendSmooth (NewSocket * ns, uint16 face)	691	SendSmooth (NewSocket * ns, uint16 face)
701	{	692	{
702	uint16 smoothface;	693	uint16 smoothface;
703	unsigned char reply[MAX_BUF];
704	SockList sl;
705		694
706	/* If we can't find a face, return and set it so we won't try to send this	695	/* If we can't find a face, return and set it so we won't try to send this
707	* again.	696	* again.
708	*/	697	*/
709	if ((!FindSmooth (face, &smoothface)) && (!FindSmooth (smooth_face->number, &smoothface)))	698	if ((!FindSmooth (face, &smoothface)) && (!FindSmooth (smooth_face->number, &smoothface)))
…		…
717	if (!(ns->faces_sent[smoothface] & NS_FACESENT_FACE))	706	if (!(ns->faces_sent[smoothface] & NS_FACESENT_FACE))
718	esrv_send_face (ns, smoothface, 0);	707	esrv_send_face (ns, smoothface, 0);
719		708
720	ns->faces_sent[face] |= NS_FACESENT_SMOOTH;	709	ns->faces_sent[face] |= NS_FACESENT_SMOOTH;
721		710
722	sl.buf = reply;	711	SockList sl (MAXSOCKBUF);
723	strcpy ((char *) sl.buf, "smooth ");	712
724	sl.len = strlen ((char *) sl.buf);	713	sl << "smooth "
725	SockList_AddShort (&sl, face);	714	<< uint16 (face)
726	SockList_AddShort (&sl, smoothface);	715	<< uint16 (smoothface);
		716
727	Send_With_Handling (ns, &sl);	717	Send_With_Handling (ns, &sl);
		718	sl.free ();
728	}	719	}
729		720
730	/**	721	/**
731	* Tells client the picture it has to use	722	* Tells client the picture it has to use
732	* to smooth a picture number given as argument.	723	* to smooth a picture number given as argument.
…		…
738		729
739	facenbr = atoi (buf);	730	facenbr = atoi (buf);
740	SendSmooth (ns, facenbr);	731	SendSmooth (ns, facenbr);
741	}	732	}
742		733
743
744
745
746
747	/**	734	/**
748	* This handles the general commands from the client (ie, north, fire, cast,	735	* This handles the general commands from the client (ie, north, fire, cast,
749	* etc.)	736	* etc.)
750	*/	737	*/
751	void	738	void
…		…
804	*/	791	*/
805	void	792	void
806	NewPlayerCmd (uint8 * buf, int len, player *pl)	793	NewPlayerCmd (uint8 * buf, int len, player *pl)
807	{	794	{
808	int time, repeat;	795	int time, repeat;
		796	char command[MAX_BUF];
809	short packet;	797	short packet;
810	unsigned char command[MAX_BUF];
811	SockList sl;
812		798
813	if (len < 7)	799	if (len < 7)
814	{	800	{
815	LOG (llevDebug, "Corrupt ncom command <%s> not long enough - discarding\n", buf);	801	LOG (llevDebug, "Corrupt ncom command <%s> not long enough - discarding\n", buf);
816	return;	802	return;
817	}	803	}
818		804
819	packet = GetShort_String (buf);	805	packet = net_uint16 (buf);
820	repeat = GetInt_String (buf + 2);	806	repeat = net_uint32 (buf + 2);
		807
821	/* -1 is special - no repeat, but don't update */	808	/* -1 is special - no repeat, but don't update */
822	if (repeat != -1)	809	if (repeat != -1)
823	{
824	pl->count = repeat;	810	pl->count = repeat;
825	}	811
826	if ((len - 4) >= MAX_BUF)	812	if ((len - 4) >= MAX_BUF)
827	len = MAX_BUF - 5;	813	len = MAX_BUF - 5;
828		814
829	strncpy ((char *) command, (char *) buf + 6, len - 4);	815	strncpy ((char *) command, (char *) buf + 6, len - 4);
830	command[len - 4] = '\0';	816	command[len - 4] = '\0';
…		…
840	return;	826	return;
841	}	827	}
842		828
843	/* This should not happen anymore. */	829	/* This should not happen anymore. */
844	if (pl->ob->speed_left < -1.0)	830	if (pl->ob->speed_left < -1.0)
845	{
846	LOG (llevError, "Player has negative time - shouldn't do command.\n");	831	LOG (llevError, "Player has negative time - shouldn't do command.\n");
847	}	832
848	/* In c_new.c */	833	/* In c_new.c */
849	execute_newserver_command (pl->ob, (char *) command);	834	execute_newserver_command (pl->ob, (char *) command);
850	/* Perhaps something better should be done with a left over count.	835	/* Perhaps something better should be done with a left over count.
851	* Cleaning up the input should probably be done first - all actions	836	* 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	837	* for the command that issued the count should be done before any other
853	* commands.	838	* commands.
854	*/	839	*/
855	pl->count = 0;	840	pl->count = 0;
856		841
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)	842	if (FABS (pl->ob->speed) < 0.001)
863	time = MAX_TIME * 100;	843	time = MAX_TIME * 100;
864	else	844	else
865	time = (int) (MAX_TIME / FABS (pl->ob->speed));	845	time = (int) (MAX_TIME / FABS (pl->ob->speed));
866	SockList_AddInt (&sl, time);	846
		847	/* Send confirmation of command execution now */
		848
		849	SockList sl (MAXSOCKBUF);
		850	sl << "comc " << uint16 (packet) << uint32 (time);
867	Send_With_Handling (&pl->socket, &sl);	851	Send_With_Handling (&pl->socket, &sl);
		852	sl.free ();
868	}	853	}
869		854
870		855
871	/** This is a reply to a previous query. */	856	/** This is a reply to a previous query. */
872	void	857	void
…		…
984	/* these are old dxclients */	969	/* these are old dxclients */
985	/* Version 1024 added support for singular + plural name values -	970	/* Version 1024 added support for singular + plural name values -
986	* requiing this minimal value reduces complexity of that code, and it	971	* requiing this minimal value reduces complexity of that code, and it
987	* has been around for a long time.	972	* has been around for a long time.
988	*/	973	*/
989	if (!strcmp (" CF DX CLIENT", cp) || ns->sc_version < 1024)	974	if (ns->sc_version < 1026)
990	{	975	{
991	sprintf (version_warning, "drawinfo %d %s", NDI_RED,	976	sprintf (version_warning, "drawinfo %d %s", NDI_RED,
992	"**** VERSION WARNING ****\n**** CLIENT IS TOO OLD!! UPDATE THE CLIENT!! ****");	977	"**** VERSION WARNING ****\n**** CLIENT IS TOO OLD!! UPDATE THE CLIENT!! ****");
993	Write_String_To_Socket (ns, version_warning, strlen (version_warning));	978	ns->send_packet (version_warning);
994	}	979	}
995		980
996	}	981	}
997	}	982	}
998		983
…		…
1070	send_query (NewSocket * ns, uint8 flags, char *text)	1055	send_query (NewSocket * ns, uint8 flags, char *text)
1071	{	1056	{
1072	char buf[MAX_BUF];	1057	char buf[MAX_BUF];
1073		1058
1074	sprintf (buf, "query %d %s", flags, text ? text : "");	1059	sprintf (buf, "query %d %s", flags, text ? text : "");
1075	Write_String_To_Socket (ns, buf, strlen (buf));	1060	ns->send_packet (buf);
1076	}	1061	}
1077		1062
1078	#define AddIfInt64(Old,New,Type) if (Old != New) {\	1063	#define AddIfInt64(Old,New,Type) if (Old != New) {\
1079	Old = New; \	1064	Old = New; \
1080	SockList_AddChar(&sl, Type); \	1065	sl << uint8 (Type) << uint64 (New); \
1081	SockList_AddInt64(&sl, New); \
1082	}	1066	}
1083		1067
1084	#define AddIfInt(Old,New,Type) if (Old != New) {\	1068	#define AddIfInt(Old,New,Type) if (Old != New) {\
1085	Old = New; \	1069	Old = New; \
1086	SockList_AddChar(&sl, Type); \	1070	sl << uint8 (Type) << uint32 (New); \
1087	SockList_AddInt(&sl, New); \
1088	}	1071	}
1089		1072
1090	#define AddIfShort(Old,New,Type) if (Old != New) {\	1073	#define AddIfShort(Old,New,Type) if (Old != New) {\
1091	Old = New; \	1074	Old = New; \
1092	SockList_AddChar(&sl, Type); \	1075	sl << uint8 (Type) << uint16 (New); \
1093	SockList_AddShort(&sl, New); \
1094	}	1076	}
1095		1077
1096	#define AddIfFloat(Old,New,Type) if (Old != New) {\	1078	#define AddIfFloat(Old,New,Type) if (Old != New) {\
1097	Old = New; \	1079	Old = New; \
1098	SockList_AddChar(&sl, Type); \	1080	sl << uint8 (Type) << uint32 (New*FLOAT_MULTI); \
1099	SockList_AddInt(&sl,(long)(New*FLOAT_MULTI));\
1100	}	1081	}
1101		1082
1102	#define AddIfString(Old,New,Type) if (Old == NULL || strcmp(Old,New)) {\	1083	#define AddIfString(Old,New,Type) if (Old == NULL || strcmp(Old,New)) {\
1103	if (Old) free(Old);\
1104	Old = strdup_local(New);\	1084	free(Old); Old = strdup (New);\
1105	SockList_AddChar(&sl, Type); \	1085	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	}	1086	}
1110		1087
1111	/**	1088	/**
1112	* Sends a statistics update. We look at the old values,	1089	* Sends a statistics update. We look at the old values,
1113	* and only send what has changed. Stat mapping values are in newclient.h	1090	* and only send what has changed. Stat mapping values are in newclient.h
…		…
1115	* commands for now.	1092	* commands for now.
1116	*/	1093	*/
1117	void	1094	void
1118	esrv_update_stats (player *pl)	1095	esrv_update_stats (player *pl)
1119	{	1096	{
1120	SockList sl;
1121	char buf[MAX_BUF];	1097	char buf[MAX_BUF];
1122	uint16 flags;	1098	uint16 flags;
1123		1099
1124	sl.buf = (unsigned char *) malloc (MAXSOCKBUF);	1100	SockList sl (MAXSOCKBUF);
1125	strcpy ((char *) sl.buf, "stats ");	1101	sl << "stats ";
1126	sl.len = strlen ((char *) sl.buf);
1127		1102
1128	if (pl->ob != NULL)	1103	if (pl->ob != NULL)
1129	{	1104	{
1130	AddIfShort (pl->last_stats.hp, pl->ob->stats.hp, CS_STAT_HP);	1105	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);	1106	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);	1114	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);	1115	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);	1116	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);	1117	AddIfShort (pl->last_stats.Cha, pl->ob->stats.Cha, CS_STAT_CHA);
1143	}	1118	}
		1119
1144	if (pl->socket.exp64)	1120	if (pl->socket.exp64)
1145	{	1121	{
1146	uint8 s;	1122	uint8 s;
1147		1123
1148	for (s = 0; s < NUM_SKILLS; s++)	1124	for (s = 0; s < NUM_SKILLS; s++)
1149	{	1125	{
1150	if (pl->last_skill_ob[s] && pl->last_skill_exp[s] != pl->last_skill_ob[s]->stats.exp)	1126	if (pl->last_skill_ob[s] && pl->last_skill_exp[s] != pl->last_skill_ob[s]->stats.exp)
1151	{	1127	{
1152
1153	/* Always send along the level if exp changes. This is only	1128	/* Always send along the level if exp changes. This is only
1154	* 1 extra byte, but keeps processing simpler.	1129	* 1 extra byte, but keeps processing simpler.
1155	*/	1130	*/
1156	SockList_AddChar (&sl, (char) (s + CS_STAT_SKILLINFO));	1131	sl << uint8 (s + CS_STAT_SKILLINFO)
1157	SockList_AddChar (&sl, (char) pl->last_skill_ob[s]->level);	1132	<< uint8 (pl->last_skill_ob[s]->level)
1158	SockList_AddInt64 (&sl, pl->last_skill_ob[s]->stats.exp);	1133	<< uint64 (pl->last_skill_ob[s]->stats.exp);
		1134
1159	pl->last_skill_exp[s] = pl->last_skill_ob[s]->stats.exp;	1135	pl->last_skill_exp[s] = pl->last_skill_ob[s]->stats.exp;
1160	}	1136	}
1161	}	1137	}
1162	}	1138	}
		1139
1163	if (pl->socket.exp64)	1140	if (pl->socket.exp64)
1164	{
1165	AddIfInt64 (pl->last_stats.exp, pl->ob->stats.exp, CS_STAT_EXP64);	1141	{ AddIfInt64 (pl->last_stats.exp, pl->ob->stats.exp, CS_STAT_EXP64) }
1166	}
1167	else	1142	else
1168	{
1169	AddIfInt (pl->last_stats.exp, (int) pl->ob->stats.exp, CS_STAT_EXP);	1143	{ AddIfInt (pl->last_stats.exp, (int) pl->ob->stats.exp, CS_STAT_EXP) }
1170	}	1144
1171	AddIfShort (pl->last_level, (char) pl->ob->level, CS_STAT_LEVEL);	1145	AddIfShort (pl->last_level, (char) pl->ob->level, CS_STAT_LEVEL);
1172	AddIfShort (pl->last_stats.wc, pl->ob->stats.wc, CS_STAT_WC);	1146	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);	1147	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);	1148	AddIfShort (pl->last_stats.dam, pl->ob->stats.dam, CS_STAT_DAM);
1175	AddIfFloat (pl->last_speed, pl->ob->speed, CS_STAT_SPEED);	1149	AddIfFloat (pl->last_speed, pl->ob->speed, CS_STAT_SPEED);
1176	AddIfShort (pl->last_stats.food, pl->ob->stats.food, CS_STAT_FOOD);	1150	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);	1151	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);	1152	AddIfInt (pl->last_weight_limit, (sint32) weight_limit[pl->ob->stats.Str], CS_STAT_WEIGHT_LIM);
1179	flags = 0;	1153	flags = 0;
		1154
1180	if (pl->fire_on)	1155	if (pl->fire_on)
1181	flags |= SF_FIREON;	1156	flags |= SF_FIREON;
		1157
1182	if (pl->run_on)	1158	if (pl->run_on)
1183	flags |= SF_RUNON;	1159	flags |= SF_RUNON;
1184		1160
1185	AddIfShort (pl->last_flags, flags, CS_STAT_FLAGS);	1161	AddIfShort (pl->last_flags, flags, CS_STAT_FLAGS);
		1162
1186	if (pl->socket.sc_version < 1025)	1163	if (pl->socket.sc_version < 1025)
1187	{
1188	AddIfShort (pl->last_resist[ATNR_PHYSICAL], pl->ob->resist[ATNR_PHYSICAL], CS_STAT_ARMOUR);	1164	{ AddIfShort (pl->last_resist[ATNR_PHYSICAL], pl->ob->resist[ATNR_PHYSICAL], CS_STAT_ARMOUR) }
1189	}
1190	else	1165	else
1191	{	1166	{
1192	int i;	1167	int i;
1193		1168
1194	for (i = 0; i < NROFATTACKS; i++)	1169	for (i = 0; i < NROFATTACKS; i++)
1195	{	1170	{
1196	/* Skip ones we won't send */	1171	/* Skip ones we won't send */
1197	if (atnr_cs_stat[i] == -1)	1172	if (atnr_cs_stat[i] == -1)
1198	continue;	1173	continue;
		1174
1199	AddIfShort (pl->last_resist[i], pl->ob->resist[i], (char) atnr_cs_stat[i]);	1175	AddIfShort (pl->last_resist[i], pl->ob->resist[i], (char) atnr_cs_stat[i]);
1200	}	1176	}
1201	}	1177	}
		1178
1202	if (pl->socket.monitor_spells)	1179	if (pl->socket.monitor_spells)
1203	{	1180	{
1204	AddIfInt (pl->last_path_attuned, pl->ob->path_attuned, CS_STAT_SPELL_ATTUNE);	1181	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);	1182	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);	1183	AddIfInt (pl->last_path_denied, pl->ob->path_denied, CS_STAT_SPELL_DENY);
1207	}	1184	}
		1185
1208	rangetostring (pl->ob, buf); /* we want use the new fire & run system in new client */	1186	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);	1187	AddIfString (pl->socket.stats.range, buf, CS_STAT_RANGE);
1210	set_title (pl->ob, buf);	1188	set_title (pl->ob, buf);
1211	AddIfString (pl->socket.stats.title, buf, CS_STAT_TITLE);	1189	AddIfString (pl->socket.stats.title, buf, CS_STAT_TITLE);
1212		1190
…		…
1216	#ifdef ESRV_DEBUG	1194	#ifdef ESRV_DEBUG
1217	LOG (llevDebug, "Sending stats command, %d bytes long.\n", sl.len);	1195	LOG (llevDebug, "Sending stats command, %d bytes long.\n", sl.len);
1218	#endif	1196	#endif
1219	Send_With_Handling (&pl->socket, &sl);	1197	Send_With_Handling (&pl->socket, &sl);
1220	}	1198	}
1221	free (sl.buf);
1222	}
1223		1199
		1200	sl.free ();
		1201	}
1224		1202
1225	/**	1203	/**
1226	* Tells the client that here is a player it should start using.	1204	* Tells the client that here is a player it should start using.
1227	*/	1205	*/
1228	void	1206	void
1229	esrv_new_player (player *pl, uint32 weight)	1207	esrv_new_player (player *pl, uint32 weight)
1230	{	1208	{
1231	SockList sl;
1232
1233	pl->last_weight = weight;	1209	pl->last_weight = weight;
1234		1210
1235	sl.buf = (unsigned char *) malloc (MAXSOCKBUF);	1211	SockList sl (MAXSOCKBUF);
		1212	sl << "player ";
1236		1213
1237	strcpy ((char *) sl.buf, "player ");	1214	sl << uint32 (pl->ob->count)
1238	sl.len = strlen ((char *) sl.buf);	1215	<< uint32 (weight)
1239	SockList_AddInt (&sl, pl->ob->count);	1216	<< uint32 (pl->ob->face->number)
1240	SockList_AddInt (&sl, weight);	1217	<< data8 (pl->ob->name);
1241	SockList_AddInt (&sl, pl->ob->face->number);
1242
1243	SockList_AddChar (&sl, (char) strlen (pl->ob->name));
1244	strcpy ((char *) sl.buf + sl.len, pl->ob->name);
1245	sl.len += strlen (pl->ob->name);
1246		1218
1247	Send_With_Handling (&pl->socket, &sl);	1219	Send_With_Handling (&pl->socket, &sl);
1248	free (sl.buf);	1220	sl.free ();
1249	SET_FLAG (pl->ob, FLAG_CLIENT_SENT);	1221	SET_FLAG (pl->ob, FLAG_CLIENT_SENT);
1250	}	1222	}
1251
1252		1223
1253	/**	1224	/**
1254	* Need to send an animation sequence to the client.	1225	* Need to send an animation sequence to the client.
1255	* We will send appropriate face commands to the client if we haven't	1226	* 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	1227	* sent them the face yet (this can become quite costly in terms of
…		…
1258	* when the player logs in and picks stuff up.	1229	* when the player logs in and picks stuff up.
1259	*/	1230	*/
1260	void	1231	void
1261	esrv_send_animation (NewSocket * ns, short anim_num)	1232	esrv_send_animation (NewSocket * ns, short anim_num)
1262	{	1233	{
1263	SockList sl;
1264	int i;	1234	int i;
1265		1235
1266	/* Do some checking on the anim_num we got. Note that the animations	1236	/* 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	1237	* are added in contigous order, so if the number is in the valid
1268	* range, it must be a valid animation.	1238	* range, it must be a valid animation.
…		…
1271	{	1241	{
1272	LOG (llevError, "esrv_send_anim (%d) out of bounds??\n", anim_num);	1242	LOG (llevError, "esrv_send_anim (%d) out of bounds??\n", anim_num);
1273	return;	1243	return;
1274	}	1244	}
1275		1245
1276	sl.buf = (unsigned char *) malloc (MAXSOCKBUF);	1246	SockList sl (MAXSOCKBUF);
1277	strcpy ((char *) sl.buf, "anim ");	1247
1278	sl.len = 5;	1248	sl << "anim "
1279	SockList_AddShort (&sl, anim_num);	1249	<< uint16 (anim_num)
1280	SockList_AddShort (&sl, 0); /* flags - not used right now */	1250	<< uint16 (0); /* flags - not used right now */
		1251
1281	/* Build up the list of faces. Also, send any information (ie, the	1252	/* Build up the list of faces. Also, send any information (ie, the
1282	* the face itself) down to the client.	1253	* the face itself) down to the client.
1283	*/	1254	*/
1284	for (i = 0; i < animations[anim_num].num_animations; i++)	1255	for (i = 0; i < animations[anim_num].num_animations; i++)
1285	{	1256	{
1286	if (!(ns->faces_sent[animations[anim_num].faces[i]] & NS_FACESENT_FACE))	1257	if (!(ns->faces_sent[animations[anim_num].faces[i]] & NS_FACESENT_FACE))
1287	esrv_send_face (ns, animations[anim_num].faces[i], 0);	1258	esrv_send_face (ns, animations[anim_num].faces[i], 0);
1288	SockList_AddShort (&sl, animations[anim_num].faces[i]); /* flags - not used right now */	1259	sl << uint16 (animations[anim_num].faces[i]); /* flags - not used right now */
1289	}	1260	}
		1261
1290	Send_With_Handling (ns, &sl);	1262	Send_With_Handling (ns, &sl);
1291	free (sl.buf);	1263	sl.free ();
		1264
1292	ns->anims_sent[anim_num] = 1;	1265	ns->anims_sent[anim_num] = 1;
1293	}	1266	}
1294		1267
1295		1268
1296	/******************************************************************************	1269	/******************************************************************************
…		…
1310	{	1283	{
1311	LOG (llevError, "Too many faces in map cell %d %d\n", x, y);	1284	LOG (llevError, "Too many faces in map cell %d %d\n", x, y);
1312	return;	1285	return;
1313	abort ();	1286	abort ();
1314	}	1287	}
		1288
1315	newmap->cells[x][y].faces[newmap->cells[x][y].count] = face_num;	1289	newmap->cells[x][y].faces[newmap->cells[x][y].count] = face_num;
1316	newmap->cells[x][y].count++;	1290	newmap->cells[x][y].count++;
		1291
1317	if (!(ns->faces_sent[face_num] & NS_FACESENT_FACE))	1292	if (!(ns->faces_sent[face_num] & NS_FACESENT_FACE))
1318	esrv_send_face (ns, face_num, 0);	1293	esrv_send_face (ns, face_num, 0);
1319	}	1294	}
1320		1295
1321	struct LayerCell	1296	struct LayerCell
…		…
1428	static void	1403	static void
1429	esrv_map_doneredraw (NewSocket * ns, struct Map *newmap)	1404	esrv_map_doneredraw (NewSocket * ns, struct Map *newmap)
1430	{	1405	{
1431	static long frames, bytes, tbytes, tframes;	1406	static long frames, bytes, tbytes, tframes;
1432	char *cur;	1407	char *cur;
1433	SockList sl;
1434		1408
1435		1409	SockList sl (MAXSOCKBUF);
1436	sl.buf = (unsigned char *) malloc (MAXSOCKBUF);	1410	sl << "map ";
1437	strcpy ((char *) sl.buf, "map ");
1438	sl.len = strlen ((char *) sl.buf);
1439		1411
1440	cur = (char *) compactlayer (ns, (unsigned char *) sl.buf + sl.len, MAP_LAYERS, newmap);	1412	cur = (char *) compactlayer (ns, (unsigned char *) sl.buf + sl.len, MAP_LAYERS, newmap);
1441	sl.len = cur - (char *) sl.buf;	1413	sl.len = cur - (char *) sl.buf;
1442		1414
1443	/* LOG(llevDebug, "Sending map command.\n");*/	1415	/* LOG(llevDebug, "Sending map command.\n");*/
1444		1416
1445	if (sl.len > (int) strlen ("map ") || ns->sent_scroll)	1417	if (sl.len > (int) strlen ("map ") || ns->sent_scroll)
1446	{	1418	{
1447	/* All of this is just accounting stuff */	1419	/* All of this is just accounting stuff */
1448	if (tframes > 100)	1420	if (tframes > 100)
1449	{
1450	tframes = tbytes = 0;	1421	tframes = tbytes = 0;
1451	}	1422
1452	tframes++;	1423	tframes++;
1453	frames++;	1424	frames++;
1454	tbytes += sl.len;	1425	tbytes += sl.len;
1455	bytes += sl.len;	1426	bytes += sl.len;
1456	memcpy (&ns->lastmap, newmap, sizeof (struct Map));	1427	memcpy (&ns->lastmap, newmap, sizeof (struct Map));
1457	Send_With_Handling (ns, &sl);	1428	Send_With_Handling (ns, &sl);
1458	ns->sent_scroll = 0;	1429	ns->sent_scroll = 0;
1459	}	1430	}
1460	free (sl.buf);	1431
		1432	sl.free ();
1461	}	1433	}
1462		1434
1463		1435
1464	/** Clears a map cell */	1436	/** Clears a map cell */
1465	static void	1437	static void
1466	map_clearcell (struct MapCell *cell, int face0, int face1, int face2, int count)	1438	map_clearcell (struct MapCell *cell, int face0, int face1, int face2, int count)
1467	{	1439	{
1468	cell->faces[0] = face0;	1440	cell->faces[0] = face0;
1469	cell->faces[1] = face1;	1441	cell->faces[1] = face1;
1470	cell->faces[2] = face2;	1442	cell->faces[2] = face2;
1471	cell->count = count;	1443	cell->count = count;
1472	cell->stat_hp = 0;	1444	cell->stat_hp = 0;
		1445	cell->flags = 0;
1473	cell->player = 0;	1446	cell->player = 0;
1474	}	1447	}
1475		1448
1476	#define MAX_HEAD_POS MAX(MAX_CLIENT_X, MAX_CLIENT_Y)	1449	#define MAX_HEAD_POS MAX(MAX_CLIENT_X, MAX_CLIENT_Y)
1477	#define MAX_LAYERS 3	1450	#define MAX_LAYERS 3
1478		1451
…		…
1506	* needs to get sent - if so, it adds the data, sending the head	1479	* 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	1480	* if needed, and returning 1. If this no data needs to get
1508	* sent, it returns zero.	1481	* sent, it returns zero.
1509	*/	1482	*/
1510	static int	1483	static int
1511	check_head (SockList & sl, NewSocket & ns, int ax, int ay, int layer)	1484	check_head (SockList &sl, NewSocket &ns, int ax, int ay, int layer)
1512	{	1485	{
1513	short face_num;	1486	short face_num;
1514		1487
1515	if (heads[(ay * MAX_HEAD_POS + ax) * MAX_LAYERS + layer])	1488	if (heads[(ay * MAX_HEAD_POS + ax) * MAX_LAYERS + layer])
1516	face_num = heads[(ay * MAX_HEAD_POS + ax) * MAX_LAYERS + layer]->face->number;	1489	face_num = heads[(ay * MAX_HEAD_POS + ax) * MAX_LAYERS + layer]->face->number;
1517	else	1490	else
1518	face_num = 0;	1491	face_num = 0;
1519		1492
1520	if (face_num != ns.lastmap.cells[ax][ay].faces[layer])	1493	if (face_num != ns.lastmap.cells[ax][ay].faces[layer])
1521	{	1494	{
1522	SockList_AddShort (&sl, face_num);	1495	sl << uint16 (face_num);
1523	if (face_num && !(ns.faces_sent[face_num] & NS_FACESENT_FACE))	1496	if (face_num && !(ns.faces_sent[face_num] & NS_FACESENT_FACE))
1524	esrv_send_face (&ns, face_num, 0);	1497	esrv_send_face (&ns, face_num, 0);
		1498
1525	heads[(ay * MAX_HEAD_POS + ax) * MAX_LAYERS + layer] = NULL;	1499	heads[(ay * MAX_HEAD_POS + ax) * MAX_LAYERS + layer] = NULL;
1526	ns.lastmap.cells[ax][ay].faces[layer] = face_num;	1500	ns.lastmap.cells[ax][ay].faces[layer] = face_num;
1527	return 1;	1501	return 1;
1528	}	1502	}
1529		1503
…		…
1549	* the case, it seems to make more sense to have these layer values	1523	* the case, it seems to make more sense to have these layer values
1550	* actually match.	1524	* actually match.
1551	*/	1525	*/
1552		1526
1553	static int	1527	static int
1554	update_space (SockList * sl, NewSocket * ns, mapstruct *mp, int mx, int my, int sx, int sy, int layer)	1528	update_space (SockList &sl, NewSocket &ns, maptile *mp, int mx, int my, int sx, int sy, int layer)
1555	{	1529	{
1556	object *ob, *head;	1530	object *ob, *head;
1557	uint16 face_num;	1531	uint16 face_num;
1558	int bx, by, i;	1532	int bx, by, i;
1559		1533
1560	/* If there is a multipart object stored away, treat that as more important.	1534	/* If there is a multipart object stored away, treat that as more important.
1561	* If not, then do the normal processing.	1535	* If not, then do the normal processing.
1562	*/	1536	*/
1563
1564	head = heads[(sy * MAX_HEAD_POS + sx) * MAX_LAYERS + layer];	1537	head = heads[(sy * MAX_HEAD_POS + sx) * MAX_LAYERS + layer];
1565		1538
1566	/* Check to see if this head is part of the set of objects	1539	/* Check to see if this head is part of the set of objects
1567	* we would normally send for this space. If so, then	1540	* we would normally send for this space. If so, then
1568	* don't use the head value. We need to do the check	1541	* don't use the head value. We need to do the check
…		…
1733		1706
1734	/* Another hack - because of heads and whatnot, this face may match one	1707	/* 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	1708	* we already sent for a lower layer. In that case, don't send
1736	* this one.	1709	* this one.
1737	*/	1710	*/
1738	if (face_num && layer + 1 < MAP_LAYERS && ns->lastmap.cells[sx][sy].faces[layer + 1] == face_num)	1711	if (face_num && layer + 1 < MAP_LAYERS && ns.lastmap.cells[sx][sy].faces[layer + 1] == face_num)
1739	{
1740	face_num = 0;	1712	face_num = 0;
1741	}
1742		1713
1743	/* We've gotten what face we want to use for the object. Now see if	1714	/* 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.	1715	* if it has changed since we last sent it to the client.
1745	*/	1716	*/
1746	if (ns->lastmap.cells[sx][sy].faces[layer] != face_num)	1717	if (ns.lastmap.cells[sx][sy].faces[layer] != face_num)
1747	{	1718	{
1748	ns->lastmap.cells[sx][sy].faces[layer] = face_num;	1719	ns.lastmap.cells[sx][sy].faces[layer] = face_num;
1749	if (!(ns->faces_sent[face_num] & NS_FACESENT_FACE))	1720	if (!(ns.faces_sent[face_num] & NS_FACESENT_FACE))
1750	esrv_send_face (ns, face_num, 0);	1721	esrv_send_face (&ns, face_num, 0);
1751	SockList_AddShort (sl, face_num);	1722
		1723	sl << uint16 (face_num);
1752	return 1;	1724	return 1;
1753	}	1725	}
		1726
1754	/* Nothing changed */	1727	/* Nothing changed */
1755	return 0;	1728	return 0;
1756	}	1729	}
1757		1730
1758	/**	1731	/**
…		…
1773	* top layer (this matches what the GET_MAP_FACE and GET_MAP_FACE_OBJ	1746	* top layer (this matches what the GET_MAP_FACE and GET_MAP_FACE_OBJ
1774	* take.	1747	* take.
1775	*/	1748	*/
1776		1749
1777	static inline int	1750	static inline int
1778	update_smooth (SockList * sl, NewSocket * ns, mapstruct *mp, int mx, int my, int sx, int sy, int layer)	1751	update_smooth (SockList &sl, NewSocket &ns, maptile *mp, int mx, int my, int sx, int sy, int layer)
1779	{	1752	{
1780	object *ob;	1753	object *ob;
1781	int smoothlevel; /* old face_num; */	1754	int smoothlevel; /* old face_num; */
1782		1755
1783	ob = GET_MAP_FACE_OBJ (mp, mx, my, layer);	1756	ob = GET_MAP_FACE_OBJ (mp, mx, my, layer);
…		…
1788	if (!ob || ob->face == blank_face || MAP_NOSMOOTH (mp))	1761	if (!ob || ob->face == blank_face || MAP_NOSMOOTH (mp))
1789	smoothlevel = 0;	1762	smoothlevel = 0;
1790	else	1763	else
1791	{	1764	{
1792	smoothlevel = ob->smoothlevel;	1765	smoothlevel = ob->smoothlevel;
1793	if (smoothlevel && !(ns->faces_sent[ob->face->number] & NS_FACESENT_SMOOTH))	1766	if (smoothlevel && !(ns.faces_sent[ob->face->number] & NS_FACESENT_SMOOTH))
1794	SendSmooth (ns, ob->face->number);	1767	SendSmooth (&ns, ob->face->number);
1795	} /* else not already head object or blank face */	1768	} /* else not already head object or blank face */
1796		1769
1797	/* We've gotten what face we want to use for the object. Now see if	1770	/* 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.	1771	* if it has changed since we last sent it to the client.
1799	*/	1772	*/
1800	if (smoothlevel > 255)	1773	if (smoothlevel > 255)
1801	smoothlevel = 255;	1774	smoothlevel = 255;
1802	else if (smoothlevel < 0)	1775	else if (smoothlevel < 0)
1803	smoothlevel = 0;	1776	smoothlevel = 0;
		1777
1804	if (ns->lastmap.cells[sx][sy].smooth[layer] != smoothlevel)	1778	if (ns.lastmap.cells[sx][sy].smooth[layer] != smoothlevel)
1805	{	1779	{
1806	ns->lastmap.cells[sx][sy].smooth[layer] = smoothlevel;	1780	ns.lastmap.cells[sx][sy].smooth[layer] = smoothlevel;
1807	SockList_AddChar (sl, (uint8) (smoothlevel & 0xFF));	1781	sl << uint8 (smoothlevel);
1808	return 1;	1782	return 1;
1809	}	1783	}
		1784
1810	/* Nothing changed */	1785	/* Nothing changed */
1811	return 0;	1786	return 0;
1812	}	1787	}
1813		1788
1814	/**	1789	/**
…		…
1855	draw_client_map1 (object *pl)	1830	draw_client_map1 (object *pl)
1856	{	1831	{
1857	int x, y, ax, ay, d, startlen, max_x, max_y, oldlen;	1832	int x, y, ax, ay, d, startlen, max_x, max_y, oldlen;
1858	sint16 nx, ny;	1833	sint16 nx, ny;
1859	int estartlen, eoldlen;	1834	int estartlen, eoldlen;
1860	SockList sl;
1861	SockList esl; /*For extended Map info */
1862	uint16 mask, emask;	1835	uint16 mask, emask;
1863	uint8 eentrysize;	1836	uint8 eentrysize;
1864	uint16 ewhatstart, ewhatflag;	1837	uint16 ewhatstart, ewhatflag;
1865	uint8 extendedinfos;	1838	uint8 extendedinfos;
1866	mapstruct *m;	1839	maptile *m;
1867		1840
1868	NewSocket & socket = pl->contr->socket;	1841	NewSocket &socket = pl->contr->socket;
1869		1842
1870	check_map_change (pl->contr);	1843	check_map_change (pl->contr);
1871		1844
1872	sl.buf = (unsigned char *) malloc (MAXSOCKBUF);	1845	SockList sl (MAXSOCKBUF);
1873	if (socket.mapmode == Map1Cmd)	1846	SockList esl (MAXSOCKBUF);
1874	strcpy ((char *) sl.buf, "map1 ");	1847
1875	else	1848	sl << (socket.mapmode == Map1Cmd ? "map1 " : "map1a ");
1876	strcpy ((char *) sl.buf, "map1a ");
1877	sl.len = strlen ((char *) sl.buf);
1878	startlen = sl.len;	1849	startlen = sl.len;
		1850
1879	/*Extendedmapinfo structure initialisation */	1851	/*Extendedmapinfo structure initialisation */
1880	if (socket.ext_mapinfos)	1852	if (socket.ext_mapinfos)
1881	{	1853	{
1882	esl.buf = (unsigned char *) malloc (MAXSOCKBUF);
1883	strcpy ((char *) esl.buf, "mapextended ");
1884	esl.len = strlen ((char *) esl.buf);
1885	extendedinfos = EMI_NOREDRAW;	1854	extendedinfos = EMI_NOREDRAW;
		1855
1886	if (socket.EMI_smooth)	1856	if (socket.EMI_smooth)
1887	extendedinfos |= EMI_SMOOTH;	1857	extendedinfos |= EMI_SMOOTH;
		1858
1888	ewhatstart = esl.len;	1859	ewhatstart = esl.len;
1889	ewhatflag = extendedinfos; /*The EMI_NOREDRAW bit	1860	ewhatflag = extendedinfos; /*The EMI_NOREDRAW bit
1890	could need to be taken away */	1861	could need to be taken away */
1891	SockList_AddChar (&esl, extendedinfos);
1892	eentrysize = getExtendedMapInfoSize (&socket);	1862	eentrysize = getExtendedMapInfoSize (&socket);
1893	SockList_AddChar (&esl, eentrysize);	1863	esl << "mapextended "
		1864	<< uint8 (extendedinfos)
		1865	<< uint8 (eentrysize);
1894	estartlen = esl.len;	1866	estartlen = esl.len;
1895	}	1867	}
1896	else	1868	else
1897	{	1869	{
1898	/* suppress compiler warnings */	1870	/* suppress compiler warnings */
1899	ewhatstart = 0;	1871	ewhatstart = 0;
1900	ewhatflag = 0;	1872	ewhatflag = 0;
1901	estartlen = 0;	1873	estartlen = 0;
1902	}	1874	}
		1875
1903	/* Init data to zero */	1876	/* Init data to zero */
1904	memset (heads, 0, sizeof (object *) * MAX_HEAD_POS * MAX_HEAD_POS * MAX_LAYERS);	1877	memset (heads, 0, sizeof (object *) * MAX_HEAD_POS * MAX_HEAD_POS * MAX_LAYERS);
1905		1878
1906	/* x,y are the real map locations. ax, ay are viewport relative	1879	/* x,y are the real map locations. ax, ay are viewport relative
1907	* locations.	1880	* locations.
…		…
1911	/* We could do this logic as conditionals in the if statement,	1884	/* We could do this logic as conditionals in the if statement,
1912	* but that started to get a bit messy to look at.	1885	* but that started to get a bit messy to look at.
1913	*/	1886	*/
1914	max_x = pl->x + (socket.mapx + 1) / 2;	1887	max_x = pl->x + (socket.mapx + 1) / 2;
1915	max_y = pl->y + (socket.mapy + 1) / 2;	1888	max_y = pl->y + (socket.mapy + 1) / 2;
		1889
1916	if (socket.mapmode == Map1aCmd)	1890	if (socket.mapmode == Map1aCmd)
1917	{	1891	{
1918	max_x += MAX_HEAD_OFFSET;	1892	max_x += MAX_HEAD_OFFSET;
1919	max_y += MAX_HEAD_OFFSET;	1893	max_y += MAX_HEAD_OFFSET;
1920	}	1894	}
…		…
1937	{	1911	{
1938	int i, got_one;	1912	int i, got_one;
1939		1913
1940	oldlen = sl.len;	1914	oldlen = sl.len;
1941		1915
1942	SockList_AddShort (&sl, mask);	1916	sl << uint16 (mask);
1943		1917
1944	if (check_head (sl, socket, ax, ay, 2))	1918	if (check_head (sl, socket, ax, ay, 2)) mask |= 0x4;
1945	mask |= 0x4;
1946	if (check_head (sl, socket, ax, ay, 1))	1919	if (check_head (sl, socket, ax, ay, 1)) mask |= 0x2;
1947	mask |= 0x2;
1948	if (check_head (sl, socket, ax, ay, 0))	1920	if (check_head (sl, socket, ax, ay, 0)) mask |= 0x1;
1949	mask |= 0x1;
1950		1921
1951	/* If all we are doing is sending 0 (blank) faces, we don't	1922	/* If all we are doing is sending 0 (blank) faces, we don't
1952	* actually need to send that - just the coordinates	1923	* actually need to send that - just the coordinates
1953	* with no faces tells the client to blank out the	1924	* with no faces tells the client to blank out the
1954	* space.	1925	* space.
1955	*/	1926	*/
1956	got_one = 0;	1927	got_one = 0;
1957	for (i = oldlen + 2; i < sl.len; i++)	1928	for (i = oldlen + 2; i < sl.len; i++)
1958	{
1959	if (sl.buf[i])	1929	if (sl.buf[i])
1960	got_one = 1;	1930	got_one = 1;
1961	}
1962		1931
1963	if (got_one && (mask & 0xf))	1932	if (got_one && (mask & 0xf))
1964	{
1965	sl.buf[oldlen + 1] = mask & 0xff;	1933	sl.buf[oldlen + 1] = mask & 0xff;
1966	}
1967	else	1934	else
1968	{ /*either all faces blank, either no face at all */	1935	{ /*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 */	1936	if (mask & 0xf) /*at least 1 face, we know it's blank, only send coordinates */
1970	sl.len = oldlen + 2;	1937	sl.len = oldlen + 2;
1971	else	1938	else
1972	sl.len = oldlen;	1939	sl.len = oldlen;
1973	}	1940	}
		1941
1974	/*What concerns extendinfos, nothing to be done for now	1942	/*What concerns extendinfos, nothing to be done for now
1975	* (perhaps effects layer later)	1943	* (perhaps effects layer later)
1976	*/	1944	*/
1977	continue; /* don't do processing below */	1945	continue; /* don't do processing below */
1978	}	1946	}
1979		1947
1980	MapCell & lastcell = socket.lastmap.cells[ax][ay];	1948	MapCell &lastcell = socket.lastmap.cells[ax][ay];
1981		1949
1982	d = pl->contr->blocked_los[ax][ay];	1950	d = pl->contr->blocked_los[ax][ay];
1983		1951
1984	/* If the coordinates are not valid, or it is too dark to see,	1952	/* If the coordinates are not valid, or it is too dark to see,
1985	* we tell the client as such	1953	* we tell the client as such
1986	*/	1954	*/
1987	nx = x;	1955	nx = x;
1988	ny = y;	1956	ny = y;
1989	m = get_map_from_coord (pl->map, &nx, &ny);	1957	m = get_map_from_coord (pl->map, &nx, &ny);
		1958
1990	if (!m)	1959	if (!m)
1991	{	1960	{
1992	/* space is out of map. Update space and clear values	1961	/* space is out of map. Update space and clear values
1993	* if this hasn't already been done. If the space is out	1962	* if this hasn't already been done. If the space is out
1994	* of the map, it shouldn't have a head	1963	* of the map, it shouldn't have a head
1995	*/	1964	*/
1996	if (lastcell.count != -1)	1965	if (lastcell.count != -1)
1997	{	1966	{
1998	SockList_AddShort (&sl, mask);	1967	sl << uint16 (mask);
1999	map_clearcell (&lastcell, 0, 0, 0, -1);	1968	map_clearcell (&lastcell, 0, 0, 0, -1);
2000	}	1969	}
2001	}	1970	}
2002	else if (d > 3)	1971	else if (d > 3)
2003	{	1972	{
…		…
2007	* reason. Still may need to send the head for this space.	1976	* reason. Still may need to send the head for this space.
2008	*/	1977	*/
2009		1978
2010	oldlen = sl.len;	1979	oldlen = sl.len;
2011		1980
2012	SockList_AddShort (&sl, mask);	1981	sl << uint16 (mask);
		1982
2013	if (lastcell.count != -1)	1983	if (lastcell.count != -1)
2014	need_send = 1;	1984	need_send = 1;
		1985
2015	count = -1;	1986	count = -1;
2016		1987
2017	if (socket.mapmode == Map1aCmd && have_head (ax, ay))	1988	if (socket.mapmode == Map1aCmd && have_head (ax, ay))
2018	{	1989	{
2019	/* Now check to see if any heads need to be sent */	1990	/* Now check to see if any heads need to be sent */
2020		1991
2021	if (check_head (sl, socket, ax, ay, 2))	1992	if (check_head (sl, socket, ax, ay, 2)) mask |= 0x4;
2022	mask |= 0x4;
2023	if (check_head (sl, socket, ax, ay, 1))	1993	if (check_head (sl, socket, ax, ay, 1)) mask |= 0x2;
2024	mask |= 0x2;
2025	if (check_head (sl, socket, ax, ay, 0))	1994	if (check_head (sl, socket, ax, ay, 0)) mask |= 0x1;
2026	mask |= 0x1;
2027		1995
2028	lastcell.count = count;	1996	lastcell.count = count;
2029
2030	}	1997	}
2031	else	1998	else
2032	{	1999	{
2033	struct MapCell *cell = &lastcell;
2034
2035	/* properly clear a previously sent big face */	2000	/* properly clear a previously sent big face */
2036	if (cell->faces[0] != 0 || cell->faces[1] != 0 || cell->faces[2] != 0)	2001	if (lastcell.faces[0] != 0 || lastcell.faces[1] != 0 || lastcell.faces[2] != 0
		2002	|| lastcell.stat_hp || lastcell.flags || lastcell.player)
2037	need_send = 1;	2003	need_send = 1;
		2004
2038	map_clearcell (&lastcell, 0, 0, 0, count);	2005	map_clearcell (&lastcell, 0, 0, 0, count);
2039	}	2006	}
2040		2007
2041	if ((mask & 0xf) || need_send)	2008	if ((mask & 0xf) || need_send)
2042	{
2043	sl.buf[oldlen + 1] = mask & 0xff;	2009	sl.buf[oldlen + 1] = mask & 0xff;
2044	}
2045	else	2010	else
2046	{
2047	sl.len = oldlen;	2011	sl.len = oldlen;
2048	}
2049	}	2012	}
2050	else	2013	else
2051	{	2014	{
2052	/* In this block, the space is visible or there are head objects	2015	/* In this block, the space is visible or there are head objects
2053	* we need to send.	2016	* we need to send.
…		…
2065	*/	2028	*/
2066	oldlen = sl.len;	2029	oldlen = sl.len;
2067	mask = (ax & 0x3f) << 10 | (ay & 0x3f) << 4;	2030	mask = (ax & 0x3f) << 10 | (ay & 0x3f) << 4;
2068	eoldlen = esl.len;	2031	eoldlen = esl.len;
2069	emask = (ax & 0x3f) << 10 | (ay & 0x3f) << 4;	2032	emask = (ax & 0x3f) << 10 | (ay & 0x3f) << 4;
2070	SockList_AddShort (&sl, mask);	2033	sl << uint16 (mask);
2071		2034
2072	if (socket.ext_mapinfos)	2035	if (socket.ext_mapinfos)
2073	SockList_AddShort (&esl, emask);	2036	esl << uint16 (emask);
2074		2037
2075	unsigned char dummy;	2038	unsigned char dummy;
2076	unsigned char *last_ext = &dummy;	2039	unsigned char *last_ext = &dummy;
2077		2040
2078	/* Darkness changed */	2041	/* Darkness changed */
…		…
2082		2045
2083	if (socket.extmap)	2046	if (socket.extmap)
2084	{	2047	{
2085	*last_ext |= 0x80;	2048	*last_ext |= 0x80;
2086	last_ext = sl.buf + sl.len;	2049	last_ext = sl.buf + sl.len;
2087	SockList_AddChar (&sl, d);	2050	sl << uint8 (d);
2088	}	2051	}
2089	else	2052	else
2090	SockList_AddChar (&sl, 255 - 64 * d);	2053	sl << uint8 (255 - 64 * d);
2091	}	2054	}
2092		2055
2093	lastcell.count = d;	2056	lastcell.count = d;
2094		2057
2095	if (socket.extmap)	2058	if (socket.extmap)
2096	{	2059	{
2097	uint8 stat_hp = 0;	2060	uint8 stat_hp = 0;
2098	uint8 stat_width = 0;	2061	uint8 stat_width = 0;
		2062	uint8 flags = 0;
2099	tag_t player = 0;	2063	UUID player = 0;
2100		2064
2101	// send hp information, if applicable	2065	// send hp information, if applicable
2102	if (object *op = GET_MAP_FACE_OBJ (m, nx, ny, 0))	2066	if (object *op = GET_MAP_FACE_OBJ (m, nx, ny, 0))
2103	{	2067	{
2104	if (op->head || op->invisible)	2068	if (op->head || op->invisible)
…		…
2111	stat_hp = 255 - (op->stats.hp * 255 + 254) / op->stats.maxhp;	2075	stat_hp = 255 - (op->stats.hp * 255 + 254) / op->stats.maxhp;
2112	stat_width = op->arch->tail_x;	2076	stat_width = op->arch->tail_x;
2113	}	2077	}
2114	}	2078	}
2115		2079
		2080	if (op->msg && op->msg[0] == '@')
		2081	flags |= 1;
		2082
2116	if (op->type == PLAYER && op != pl)	2083	if (op->type == PLAYER && op != pl)
2117	player = op->count;	2084	player = op->count;
2118	}	2085	}
2119		2086
2120	if (lastcell.stat_hp != stat_hp)	2087	if (lastcell.stat_hp != stat_hp)
…		…
2122	lastcell.stat_hp = stat_hp;	2089	lastcell.stat_hp = stat_hp;
2123		2090
2124	mask |= 0x8;	2091	mask |= 0x8;
2125	*last_ext |= 0x80;	2092	*last_ext |= 0x80;
2126	last_ext = sl.buf + sl.len;	2093	last_ext = sl.buf + sl.len;
2127	SockList_AddChar (&sl, 5);	2094
2128	SockList_AddChar (&sl, stat_hp);	2095	sl << uint8 (5) << uint8 (stat_hp);
2129		2096
2130	if (stat_width > 1)	2097	if (stat_width > 1)
2131	{	2098	{
2132	*last_ext |= 0x80;	2099	*last_ext |= 0x80;
2133	last_ext = sl.buf + sl.len;	2100	last_ext = sl.buf + sl.len;
2134	SockList_AddChar (&sl, 6);	2101
2135	SockList_AddChar (&sl, stat_width);	2102	sl << uint8 (6) << uint8 (stat_width);
2136	}	2103	}
2137	}	2104	}
2138		2105
2139	if (lastcell.player !=player)	2106	if (lastcell.player != player)
2140	{	2107	{
2141	lastcell.player = player;	2108	lastcell.player = player;
2142		2109
2143	mask |= 0x8;	2110	mask |= 0x8;
2144	*last_ext |= 0x80;	2111	*last_ext |= 0x80;
2145	last_ext = sl.buf + sl.len;	2112	last_ext = sl.buf + sl.len;
2146	SockList_AddChar (&sl, 0x47);	2113
2147	SockList_AddChar (&sl, 4);	2114	sl << uint8 (0x47) << uint8 (8) << (uint64)player;
2148	SockList_AddInt (&sl, player);	2115	}
		2116
		2117	if (lastcell.flags != flags)
		2118	{
		2119	lastcell.flags = flags;
		2120
		2121	mask |= 0x8;
		2122	*last_ext |= 0x80;
		2123	last_ext = sl.buf + sl.len;
		2124
		2125	sl << uint8 (8) << uint8 (flags);
2149	}	2126	}
2150	}	2127	}
2151		2128
2152	/* Floor face */	2129	/* Floor face */
2153	if (update_space (&sl, &socket, m, nx, ny, ax, ay, 2))	2130	if (update_space (sl, socket, m, nx, ny, ax, ay, 2))
2154	mask |= 0x4;	2131	mask |= 0x4;
2155		2132
2156	if (socket.EMI_smooth)	2133	if (socket.EMI_smooth)
2157	if (update_smooth (&esl, &socket, m, nx, ny, ax, ay, 2))	2134	if (update_smooth (esl, socket, m, nx, ny, ax, ay, 2))
2158	emask |= 0x4;	2135	emask |= 0x4;
2159		2136
2160	/* Middle face */	2137	/* Middle face */
2161	if (update_space (&sl, &socket, m, nx, ny, ax, ay, 1))	2138	if (update_space (sl, socket, m, nx, ny, ax, ay, 1))
2162	mask |= 0x2;	2139	mask |= 0x2;
2163		2140
2164	if (socket.EMI_smooth)	2141	if (socket.EMI_smooth)
2165	if (update_smooth (&esl, &socket, m, nx, ny, ax, ay, 1))	2142	if (update_smooth (esl, socket, m, nx, ny, ax, ay, 1))
2166	emask |= 0x2;	2143	emask |= 0x2;
2167		2144
2168	if (nx == pl->x && ny == pl->y && pl->invisible & (pl->invisible < 50 ? 4 : 1))	2145	if (nx == pl->x && ny == pl->y && pl->invisible & (pl->invisible < 50 ? 4 : 1))
2169	{	2146	{
2170	if (lastcell.faces[0] != pl->face->number)	2147	if (lastcell.faces[0] != pl->face->number)
2171	{	2148	{
2172	lastcell.faces[0] = pl->face->number;	2149	lastcell.faces[0] = pl->face->number;
2173	mask |= 0x1;	2150	mask |= 0x1;
		2151
2174	if (!(socket.faces_sent[pl->face->number] & NS_FACESENT_FACE))	2152	if (!(socket.faces_sent[pl->face->number] & NS_FACESENT_FACE))
2175	esrv_send_face (&socket, pl->face->number, 0);	2153	esrv_send_face (&socket, pl->face->number, 0);
2176	SockList_AddShort (&sl, pl->face->number);	2154
		2155	sl << uint16 (pl->face->number);
2177	}	2156	}
2178	}	2157	}
2179	/* Top face */
2180	else	2158	else
2181	{	2159	{
		2160	/* Top face */
2182	if (update_space (&sl, &socket, m, nx, ny, ax, ay, 0))	2161	if (update_space (sl, socket, m, nx, ny, ax, ay, 0))
2183	mask |= 0x1;	2162	mask |= 0x1;
		2163
2184	if (socket.EMI_smooth)	2164	if (socket.EMI_smooth)
2185	if (update_smooth (&esl, &socket, m, nx, ny, ax, ay, 0))	2165	if (update_smooth (esl, socket, m, nx, ny, ax, ay, 0))
2186	{
2187	emask |= 0x1;	2166	emask |= 0x1;
2188	}
2189	}	2167	}
		2168
2190	/* Check to see if we are in fact sending anything for this	2169	/* Check to see if we are in fact sending anything for this
2191	* space by checking the mask. If so, update the mask.	2170	* space by checking the mask. If so, update the mask.
2192	* if not, reset the len to that from before adding the mask	2171	* if not, reset the len to that from before adding the mask
2193	* value, so we don't send those bits.	2172	* value, so we don't send those bits.
2194	*/	2173	*/
2195	if (mask & 0xf)	2174	if (mask & 0xf)
2196	{
2197	sl.buf[oldlen + 1] = mask & 0xff;	2175	sl.buf[oldlen + 1] = mask & 0xff;
2198	}
2199	else	2176	else
2200	{
2201	sl.len = oldlen;	2177	sl.len = oldlen;
2202	}	2178
2203	if (emask & 0xf)	2179	if (emask & 0xf)
2204	{
2205	esl.buf[eoldlen + 1] = emask & 0xff;	2180	esl.buf[eoldlen + 1] = emask & 0xff;
2206	}
2207	else	2181	else
2208	{
2209	esl.len = eoldlen;	2182	esl.len = eoldlen;
2210	}
2211	} /* else this is a viewable space */	2183	} /* else this is a viewable space */
2212	} /* for x loop */	2184	} /* for x loop */
2213	} /* for y loop */	2185	} /* for y loop */
2214		2186
2215	/* Verify that we in fact do need to send this */	2187	/* Verify that we in fact do need to send this */
…		…
2221	* it doesn't need draw!	2193	* it doesn't need draw!
2222	*/	2194	*/
2223	ewhatflag &= (~EMI_NOREDRAW);	2195	ewhatflag &= (~EMI_NOREDRAW);
2224	esl.buf[ewhatstart + 1] = ewhatflag & 0xff;	2196	esl.buf[ewhatstart + 1] = ewhatflag & 0xff;
2225	}	2197	}
		2198
2226	if (esl.len > estartlen)	2199	if (esl.len > estartlen)
2227	{
2228	Send_With_Handling (&socket, &esl);	2200	Send_With_Handling (&socket, &esl);
2229	}
2230	free (esl.buf);
2231	}	2201	}
		2202
2232	if (sl.len > startlen || socket.sent_scroll)	2203	if (sl.len > startlen || socket.sent_scroll)
2233	{	2204	{
2234	Send_With_Handling (&socket, &sl);	2205	Send_With_Handling (&socket, &sl);
2235	socket.sent_scroll = 0;	2206	socket.sent_scroll = 0;
2236	}	2207	}
2237	free (sl.buf);	2208
		2209	sl.free ();
		2210	esl.free ();
2238	}	2211	}
2239		2212
2240	/**	2213	/**
2241	* Draws client map.	2214	* Draws client map.
2242	*/	2215	*/
…		…
2247	sint16 ax, ay, nx, ny; /* ax and ay goes from 0 to max-size of arrays */	2220	sint16 ax, ay, nx, ny; /* ax and ay goes from 0 to max-size of arrays */
2248	New_Face *face, *floor;	2221	New_Face *face, *floor;
2249	New_Face *floor2;	2222	New_Face *floor2;
2250	int d, mflags;	2223	int d, mflags;
2251	struct Map newmap;	2224	struct Map newmap;
2252	mapstruct *m, *pm;	2225	maptile *m, *pm;
2253		2226
2254	if (pl->type != PLAYER)	2227	if (pl->type != PLAYER)
2255	{	2228	{
2256	LOG (llevError, "draw_client_map called with non player/non eric-server\n");	2229	LOG (llevError, "draw_client_map called with non player/non eric-server\n");
2257	return;	2230	return;
…		…
2356	esrv_map_setbelow (&pl->contr->socket, ax, ay, floor->number, &newmap);	2329	esrv_map_setbelow (&pl->contr->socket, ax, ay, floor->number, &newmap);
2357	}	2330	}
2358	} /* Is a valid space */	2331	} /* Is a valid space */
2359	}	2332	}
2360	}	2333	}
		2334
2361	esrv_map_doneredraw (&pl->contr->socket, &newmap);	2335	esrv_map_doneredraw (&pl->contr->socket, &newmap);
2362		2336
2363	check_map_change (pl->contr);	2337	check_map_change (pl->contr);
2364	}	2338	}
2365		2339
…		…
2374		2348
2375	/*****************************************************************************/	2349	/*****************************************************************************/
2376	void	2350	void
2377	send_plugin_custom_message (object *pl, char *buf)	2351	send_plugin_custom_message (object *pl, char *buf)
2378	{	2352	{
2379	cs_write_string (&pl->contr->socket, buf, strlen (buf));	2353	pl->contr->socket.send_packet (buf);
2380	}	2354	}
2381		2355
2382	/**	2356	/**
2383	* This sends the skill number to name mapping. We ignore	2357	* This sends the skill number to name mapping. We ignore
2384	* the params - we always send the same info no matter what.	2358	* the params - we always send the same info no matter what.
2385	*/	2359	*/
2386	void	2360	void
2387	send_skill_info (NewSocket * ns, char *params)	2361	send_skill_info (NewSocket *ns, char *params)
2388	{	2362	{
2389	SockList sl;	2363	SockList sl (MAXSOCKBUF);
2390	int i;	2364	sl << "replyinfo skill_info\n";
2391		2365
2392	sl.buf = (unsigned char *) malloc (MAXSOCKBUF);
2393	strcpy ((char *) sl.buf, "replyinfo skill_info\n");
2394	for (i = 1; i < NUM_SKILLS; i++)	2366	for (int i = 1; i < NUM_SKILLS; i++)
2395	{	2367	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]);	2368
2397	}
2398	sl.len = strlen ((char *) sl.buf);
2399	if (sl.len >= MAXSOCKBUF)	2369	if (sl.len >= MAXSOCKBUF)
2400	{	2370	{
2401	LOG (llevError, "Buffer overflow in send_skill_info!\n");	2371	LOG (llevError, "Buffer overflow in send_skill_info!\n");
2402	fatal (0);	2372	fatal (0);
2403	}	2373	}
		2374
2404	Send_With_Handling (ns, &sl);	2375	Send_With_Handling (ns, &sl);
2405	free (sl.buf);	2376	sl.free ();
2406	}	2377	}
2407		2378
2408	/**	2379	/**
2409	* This sends the spell path to name mapping. We ignore	2380	* This sends the spell path to name mapping. We ignore
2410	* the params - we always send the same info no matter what.	2381	* the params - we always send the same info no matter what.
2411	*/	2382	*/
2412	void	2383	void
2413	send_spell_paths (NewSocket * ns, char *params)	2384	send_spell_paths (NewSocket * ns, char *params)
2414	{	2385	{
2415	SockList sl;	2386	SockList sl (MAXSOCKBUF);
2416	int i;
2417		2387
2418	sl.buf = (unsigned char *) malloc (MAXSOCKBUF);	2388	sl << "replyinfo spell_paths\n";
2419	strcpy ((char *) sl.buf, "replyinfo spell_paths\n");	2389
2420	for (i = 0; i < NRSPELLPATHS; i++)	2390	for (int i = 0; i < NRSPELLPATHS; i++)
2421	sprintf ((char *) sl.buf + strlen ((char *) sl.buf), "%d:%s\n", 1 << i, spellpathnames[i]);	2391	sl.printf ("%d:%s\n", 1 << i, spellpathnames[i]);
2422	sl.len = strlen ((char *) sl.buf);	2392
2423	if (sl.len >= MAXSOCKBUF)	2393	if (sl.len >= MAXSOCKBUF)
2424	{	2394	{
2425	LOG (llevError, "Buffer overflow in send_spell_paths!\n");	2395	LOG (llevError, "Buffer overflow in send_spell_paths!\n");
2426	fatal (0);	2396	fatal (0);
2427	}	2397	}
		2398
2428	Send_With_Handling (ns, &sl);	2399	Send_With_Handling (ns, &sl);
2429	free (sl.buf);	2400	sl.free ();
2430	}	2401	}
2431		2402
2432	/**	2403	/**
2433	* This looks for any spells the player may have that have changed their stats.	2404	* 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	2405	* it then sends an updspell packet for each spell that has changed in this way
2435	*/	2406	*/
2436	void	2407	void
2437	esrv_update_spells (player *pl)	2408	esrv_update_spells (player *pl)
2438	{	2409	{
2439	SockList sl;
2440	int flags = 0;
2441	object *spell;
2442
2443	if (!pl->socket.monitor_spells)	2410	if (!pl->socket.monitor_spells)
2444	return;	2411	return;
		2412
2445	for (spell = pl->ob->inv; spell != NULL; spell = spell->below)	2413	for (object *spell = pl->ob->inv; spell; spell = spell->below)
2446	{	2414	{
2447	if (spell->type == SPELL)	2415	if (spell->type == SPELL)
2448	{	2416	{
		2417	int flags = 0;
		2418
2449	/* check if we need to update it */	2419	/* check if we need to update it */
2450	if (spell->last_sp != SP_level_spellpoint_cost (pl->ob, spell, SPELL_MANA))	2420	if (spell->last_sp != SP_level_spellpoint_cost (pl->ob, spell, SPELL_MANA))
2451	{	2421	{
2452	spell->last_sp = SP_level_spellpoint_cost (pl->ob, spell, SPELL_MANA);	2422	spell->last_sp = SP_level_spellpoint_cost (pl->ob, spell, SPELL_MANA);
2453	flags |= UPD_SP_MANA;	2423	flags |= UPD_SP_MANA;
2454	}	2424	}
		2425
2455	if (spell->last_grace != SP_level_spellpoint_cost (pl->ob, spell, SPELL_GRACE))	2426	if (spell->last_grace != SP_level_spellpoint_cost (pl->ob, spell, SPELL_GRACE))
2456	{	2427	{
2457	spell->last_grace = SP_level_spellpoint_cost (pl->ob, spell, SPELL_GRACE);	2428	spell->last_grace = SP_level_spellpoint_cost (pl->ob, spell, SPELL_GRACE);
2458	flags |= UPD_SP_GRACE;	2429	flags |= UPD_SP_GRACE;
2459	}	2430	}
		2431
2460	if (spell->last_eat != spell->stats.dam + SP_level_dam_adjust (pl->ob, spell))	2432	if (spell->last_eat != spell->stats.dam + SP_level_dam_adjust (pl->ob, spell))
2461	{	2433	{
2462	spell->last_eat = spell->stats.dam + SP_level_dam_adjust (pl->ob, spell);	2434	spell->last_eat = spell->stats.dam + SP_level_dam_adjust (pl->ob, spell);
2463	flags |= UPD_SP_DAMAGE;	2435	flags |= UPD_SP_DAMAGE;
2464	}	2436	}
		2437
2465	if (flags != 0)	2438	if (flags)
2466	{	2439	{
2467	sl.buf = (unsigned char *) malloc (MAXSOCKBUF);	2440	SockList sl (MAXSOCKBUF);
2468	strcpy ((char *) sl.buf, "updspell ");	2441
2469	sl.len = strlen ((char *) sl.buf);	2442	sl << "updspell "
2470	SockList_AddChar (&sl, flags);	2443	<< uint8 (flags)
2471	SockList_AddInt (&sl, spell->count);	2444	<< uint32 (spell->count);
2472	if (flags & UPD_SP_MANA)	2445
2473	SockList_AddShort (&sl, spell->last_sp);	2446	if (flags & UPD_SP_MANA ) sl << uint16 (spell->last_sp);
2474	if (flags & UPD_SP_GRACE)	2447	if (flags & UPD_SP_GRACE ) sl << uint16 (spell->last_grace);
2475	SockList_AddShort (&sl, spell->last_grace);	2448	if (flags & UPD_SP_DAMAGE) sl << uint16 (spell->last_eat);
2476	if (flags & UPD_SP_DAMAGE)	2449
2477	SockList_AddShort (&sl, spell->last_eat);
2478	flags = 0;
2479	Send_With_Handling (&pl->socket, &sl);	2450	Send_With_Handling (&pl->socket, &sl);
2480	free (sl.buf);	2451	sl.free ();
2481	}	2452	}
2482	}	2453	}
2483	}	2454	}
2484	}	2455	}
2485		2456
2486	void	2457	void
2487	esrv_remove_spell (player *pl, object *spell)	2458	esrv_remove_spell (player *pl, object *spell)
2488	{	2459	{
2489	SockList sl;
2490
2491	if (!pl->socket.monitor_spells)	2460	if (!pl->socket.monitor_spells)
2492	return;	2461	return;
		2462
2493	if (!pl || !spell || spell->env != pl->ob)	2463	if (!pl || !spell || spell->env != pl->ob)
2494	{	2464	{
2495	LOG (llevError, "Invalid call to esrv_remove_spell");	2465	LOG (llevError, "Invalid call to esrv_remove_spell");
2496	return;	2466	return;
2497	}	2467	}
2498	sl.buf = (unsigned char *) malloc (MAXSOCKBUF);	2468
2499	strcpy ((char *) sl.buf, "delspell ");	2469	SockList sl (MAXSOCKBUF);
2500	sl.len = strlen ((char *) sl.buf);	2470
2501	SockList_AddInt (&sl, spell->count);	2471	sl << "delspell "
		2472	<< uint32 (spell->count);
		2473
2502	Send_With_Handling (&pl->socket, &sl);	2474	Send_With_Handling (&pl->socket, &sl);
2503	free (sl.buf);	2475	sl.free ();
2504	}	2476	}
2505		2477
2506	/* appends the spell *spell to the Socklist we will send the data to. */	2478	/* appends the spell *spell to the Socklist we will send the data to. */
2507	static void	2479	static void
2508	append_spell (player *pl, SockList * sl, object *spell)	2480	append_spell (player *pl, SockList &sl, object *spell)
2509	{	2481	{
2510	int len, i, skill = 0;	2482	int len, i, skill = 0;
2511		2483
2512	if (!(spell->name))	2484	if (!(spell->name))
2513	{	2485	{
2514	LOG (llevError, "item number %d is a spell with no name.\n", spell->count);	2486	LOG (llevError, "item number %d is a spell with no name.\n", spell->count);
2515	return;	2487	return;
2516	}	2488	}
2517	SockList_AddInt (sl, spell->count);	2489
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 */	2490	/* 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);	2491	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);	2492	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);	2493	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		2494
2529	/* figure out which skill it uses, if it uses one */	2495	/* figure out which skill it uses, if it uses one */
2530	if (spell->skill)	2496	if (spell->skill)
2531	{	2497	{
2532	for (i = 1; i < NUM_SKILLS; i++)	2498	for (i = 1; i < NUM_SKILLS; i++)
…		…
2534	{	2500	{
2535	skill = i + CS_STAT_SKILLINFO;	2501	skill = i + CS_STAT_SKILLINFO;
2536	break;	2502	break;
2537	}	2503	}
2538	}	2504	}
2539	SockList_AddChar (sl, skill);
2540		2505
2541	SockList_AddInt (sl, spell->path_attuned);	2506	/* send the current values */
		2507	sl << uint32 (spell->count)
		2508	<< uint16 (spell->level)
		2509	<< uint16 (spell->casting_time)
		2510	<< uint16 (spell->last_sp)
		2511	<< uint16 (spell->last_grace)
		2512	<< uint16 (spell->last_eat)
		2513	<< uint8 (skill)
		2514	<< uint32 (spell->path_attuned)
2542	SockList_AddInt (sl, (spell->face) ? spell->face->number : 0);	2515	<< uint32 (spell->face ? spell->face->number : 0)
2543		2516	<< data8 (spell->name)
2544	len = strlen (spell->name);	2517	<< 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	}	2518	}
2561		2519
2562	/**	2520	/**
2563	* This tells the client to add the spell *ob, if *ob is NULL, then add	2521	* This tells the client to add the spell *ob, if *ob is NULL, then add
2564	* all spells in the player's inventory.	2522	* all spells in the player's inventory.
2565	*/	2523	*/
2566	void	2524	void
2567	esrv_add_spells (player *pl, object *spell)	2525	esrv_add_spells (player *pl, object *spell)
2568	{	2526	{
2569	SockList sl;
2570
2571	if (!pl)	2527	if (!pl)
2572	{	2528	{
2573	LOG (llevError, "esrv_add_spells, tried to add a spell to a NULL player");	2529	LOG (llevError, "esrv_add_spells, tried to add a spell to a NULL player");
2574	return;	2530	return;
2575	}	2531	}
		2532
2576	if (!pl->socket.monitor_spells)	2533	if (!pl->socket.monitor_spells)
2577	return;	2534	return;
2578	sl.buf = (unsigned char *) malloc (MAXSOCKBUF);	2535
2579	strcpy ((char *) sl.buf, "addspell ");	2536	SockList sl (MAXSOCKBUF);
2580	sl.len = strlen ((char *) sl.buf);	2537
		2538	sl << "addspell ";
		2539
2581	if (!spell)	2540	if (!spell)
2582	{	2541	{
2583	for (spell = pl->ob->inv; spell != NULL; spell = spell->below)	2542	for (spell = pl->ob->inv; spell != NULL; spell = spell->below)
2584	{	2543	{
2585	/* were we to simply keep appending data here, we could exceed	2544	/* 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	2554	* is hundreds of bytes off, so correcting 22 vs 26 doesn't seem
2596	* like it will fix this	2555	* like it will fix this
2597	*/	2556	*/
2598	if (spell->type != SPELL)	2557	if (spell->type != SPELL)
2599	continue;	2558	continue;
		2559
2600	if (sl.len >= (MAXSOCKBUF - (26 + strlen (spell->name) + (spell->msg ? strlen (spell->msg) : 0))))	2560	if (sl.len >= (MAXSOCKBUF - (26 + strlen (spell->name) + (spell->msg ? strlen (spell->msg) : 0))))
2601	{	2561	{
2602	Send_With_Handling (&pl->socket, &sl);	2562	Send_With_Handling (&pl->socket, &sl);
2603	strcpy ((char *) sl.buf, "addspell ");	2563	strcpy ((char *) sl.buf, "addspell ");
2604	sl.len = strlen ((char *) sl.buf);	2564	sl.len = strlen ((char *) sl.buf);
2605	}	2565	}
		2566
2606	append_spell (pl, &sl, spell);	2567	append_spell (pl, sl, spell);
2607	}	2568	}
2608	}	2569	}
2609	else if (spell->type != SPELL)	2570	else if (spell->type != SPELL)
2610	{	2571	{
2611	LOG (llevError, "Asked to send a non-spell object as a spell");	2572	LOG (llevError, "Asked to send a non-spell object as a spell");
2612	return;	2573	return;
2613	}	2574	}
2614	else	2575	else
2615	append_spell (pl, &sl, spell);	2576	append_spell (pl, sl, spell);
		2577
2616	if (sl.len >= MAXSOCKBUF)	2578	if (sl.length () >= MAXSOCKBUF)
2617	{	2579	{
2618	LOG (llevError, "Buffer overflow in esrv_add_spells!\n");	2580	LOG (llevError, "Buffer overflow in esrv_add_spells!\n");
2619	fatal (0);	2581	fatal (0);
2620	}	2582	}
		2583
2621	/* finally, we can send the packet */	2584	/* finally, we can send the packet */
2622	Send_With_Handling (&pl->socket, &sl);	2585	Send_With_Handling (&pl->socket, &sl);
2623	free (sl.buf);	2586
		2587	sl.free ();
2624	}	2588	}
		2589

Diff Legend

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