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

Diff Legend

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