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.27 by root, Wed Dec 13 18:08:02 2006 UTC vs.
Revision 1.39 by root, Fri Dec 15 03:53:44 2006 UTC

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

Diff Legend

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