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

Diff Legend

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