[ViewVC] Diff of: cvs/deliantra/server/socket/request.C

Comparing deliantra/server/socket/request.C (file contents):
Revision 1.48 by root, Wed Dec 20 11:36:39 2006 UTC vs.
Revision 1.67 by pippijn, Thu Mar 1 12:28:17 2007 UTC

…		…
1	/*	1	/*
2	CrossFire, A Multiplayer game for X-windows	2	* CrossFire, A Multiplayer game for X-windows
3		3	*
		4	* Copyright (C) 2005, 2006, 2007 Marc Lehmann & Crossfire+ Development Team
4	Copyright (C) 2001 Mark Wedel	5	* Copyright (C) 2001 Mark Wedel
5	Copyright (C) 1992 Frank Tore Johansen	6	* Copyright (C) 1992 Frank Tore Johansen
6		7	*
7	This program is free software; you can redistribute it and/or modify	8	* This program is free software; you can redistribute it and/or modify
8	it under the terms of the GNU General Public License as published by	9	* it under the terms of the GNU General Public License as published by
9	the Free Software Foundation; either version 2 of the License, or	10	* the Free Software Foundation; either version 2 of the License, or
10	(at your option) any later version.	11	* (at your option) any later version.
11		12	*
12	This program is distributed in the hope that it will be useful,	13	* This program is distributed in the hope that it will be useful,
13	but WITHOUT ANY WARRANTY; without even the implied warranty of	14	* but WITHOUT ANY WARRANTY; without even the implied warranty of
14	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the	15	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15	GNU General Public License for more details.	16	* GNU General Public License for more details.
16		17	*
17	You should have received a copy of the GNU General Public License	18	* You should have received a copy of the GNU General Public License
18	along with this program; if not, write to the Free Software	19	* along with this program; if not, write to the Free Software
19	Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.	20	* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
20		21	*
21	The author can be reached via e-mail to <crossfire@schmorp.de>	22	* The author can be reached via e-mail to <crossfire@schmorp.de>
22	*/	23	*/
23		24
24	/**	25	/**
25	* \file	26	* \file
26	* Client handling.	27	* Client handling.
27	*	28	*
35	* have the prototype of (char *data, int datalen, int client_num). This	36	* have the prototype of (char *data, int datalen, int client_num). This
36	* way, we can use one dispatch table.	37	* way, we can use one dispatch table.
37	*	38	*
38	* esrv_map_new starts updating the map	39	* esrv_map_new starts updating the map
39	*	40	*
40	* esrv_map_setbelow allows filling in all of the faces for the map.
41	* if a face has not already been sent to the client, it is sent now.
42	*
43	*/	41	*/
44		42
45	#include <global.h>	43	#include <global.h>
46	#include <sproto.h>	44	#include <sproto.h>
47		45
…		…
138	}	136	}
139		137
140	static void	138	static void
141	clear_map (player *pl)	139	clear_map (player *pl)
142	{	140	{
143	memset (&pl->socket->lastmap, 0, sizeof (pl->socket->lastmap));	141	memset (&pl->ns->lastmap, 0, sizeof (pl->ns->lastmap));
144		142
145	if (pl->socket->newmapcmd == 1)	143	if (pl->ns->newmapcmd == 1)
146	pl->socket->send_packet ("newmap");	144	pl->ns->send_packet ("newmap");
147		145
148	pl->socket->floorbox_reset ();	146	pl->ns->floorbox_reset ();
149	}	147	}
150		148
151	/** check for map change and send new map data */	149	/** check for map/region change and send new map data */
152	static void	150	static void
153	check_map_change (player *pl)	151	check_map_change (player *pl)
154	{	152	{
155	client &socket = *pl->socket;	153	client &socket = *pl->ns;
156	object *ob = pl->ob;	154	object *ob = pl->ob;
157	char buf[MAX_BUF]; /* eauugggh */	155	char buf[MAX_BUF]; /* eauugggh */
158		156
159	if (socket.current_map != ob->map)	157	if (socket.current_map != ob->map)
160	{	158	{
…		…
176	flags \|= 4;	174	flags \|= 4;
177	if (ob->map->tile_path[3])	175	if (ob->map->tile_path[3])
178	flags \|= 8;	176	flags \|= 8;
179		177
180	snprintf (buf, MAX_BUF, "mapinfo - spatial %d %d %d %d %d %s",	178	snprintf (buf, MAX_BUF, "mapinfo - spatial %d %d %d %d %d %s",
181	flags, socket.mapx / 2 - ob->x, socket.mapy / 2 - ob->y, ob->map->width, ob->map->height, ob->map->path);	179	flags, socket.mapx / 2 - ob->x, socket.mapy / 2 - ob->y, ob->map->width, ob->map->height, &ob->map->path);
182	}	180	}
183	else	181	else
184	snprintf (buf, MAX_BUF, "mapinfo current");	182	snprintf (buf, MAX_BUF, "mapinfo current");
185		183
186	socket.send_packet (buf);	184	socket.send_packet (buf);
…		…
200	}	198	}
201	}	199	}
202		200
203	socket.current_x = ob->x;	201	socket.current_x = ob->x;
204	socket.current_y = ob->y;	202	socket.current_y = ob->y;
		203
		204	region *reg = ob->region ();
		205	if (socket.current_region != reg)
		206	{
		207	socket.current_region = reg;
		208	socket.send_packet_printf ("drawinfo 0 You are now %s.\n(use whereami for more details)", &reg->longname);
		209	}
205	}	210	}
206		211
207	/**	212	/**
208	* RequestInfo is sort of a meta command. There is some specific	213	* RequestInfo is sort of a meta command. There is some specific
209	* request of information, but we call other functions to provide	214	* request of information, but we call other functions to provide
…		…
280	buf += 8;	285	buf += 8;
281		286
282	// initial map and its origin	287	// initial map and its origin
283	maptile *map = pl->ob->map;	288	maptile *map = pl->ob->map;
284	sint16 dx, dy;	289	sint16 dx, dy;
285	int mapx = pl->socket->mapx / 2 - pl->ob->x;	290	int mapx = pl->ns->mapx / 2 - pl->ob->x;
286	int mapy = pl->socket->mapy / 2 - pl->ob->y;	291	int mapy = pl->ns->mapy / 2 - pl->ob->y;
287	int max_distance = 8; // limit maximum path length to something generous	292	int max_distance = 8; // limit maximum path length to something generous
288		293
289	while (*buf && map && max_distance)	294	while (*buf && map && max_distance)
290	{	295	{
291	int dir = *buf++;	296	int dir = *buf++;
292		297
293	switch (dir)	298	switch (dir)
294	{	299	{
295	case '1':	300	case '1':
296	dx = 0;	301	dx = 0;
297	dy = -1;	302	dy = -1;
298	map = get_map_from_coord (map, &dx, &dy);	303	map = map->xy_find (dx, dy);
299	map && (mapy -= map->height);	304	map && (mapy -= map->height);
300	break;	305	break;
301	case '2':	306	case '2':
302	mapx += map->width;	307	mapx += map->width;
303	dx = map->width;	308	dx = map->width;
304	dy = 0;	309	dy = 0;
305	map = get_map_from_coord (map, &dx, &dy);	310	map = map->xy_find (dx, dy);
306	break;	311	break;
307	case '3':	312	case '3':
308	mapy += map->height;	313	mapy += map->height;
309	dx = 0;	314	dx = 0;
310	dy = map->height;	315	dy = map->height;
311	map = get_map_from_coord (map, &dx, &dy);	316	map = map->xy_find (dx, dy);
312	break;	317	break;
313	case '4':	318	case '4':
314	dx = -1;	319	dx = -1;
315	dy = 0;	320	dy = 0;
316	map = get_map_from_coord (map, &dx, &dy);	321	map = map->xy_find (dx, dy);
317	map && (mapx -= map->width);	322	map && (mapx -= map->width);
318	break;	323	break;
319	}	324	}
320		325
321	--max_distance;	326	--max_distance;
322	}	327	}
323		328
…		…
334	if (map->tile_path[2])	339	if (map->tile_path[2])
335	flags \|= 4;	340	flags \|= 4;
336	if (map->tile_path[3])	341	if (map->tile_path[3])
337	flags \|= 8;	342	flags \|= 8;
338		343
339	snprintf (bigbuf, MAX_BUF, "mapinfo %s spatial %d %d %d %d %d %s", token, flags, mapx, mapy, map->width, map->height, map->path);	344	snprintf (bigbuf, MAX_BUF, "mapinfo %s spatial %d %d %d %d %d %s", token, flags, mapx, mapy, map->width, map->height, &map->path);
340	}	345	}
341	else	346	else
342	snprintf (bigbuf, MAX_BUF, "mapinfo %s nomap", token);	347	snprintf (bigbuf, MAX_BUF, "mapinfo %s nomap", token);
343	}	348	}
344	else	349	else
345	snprintf (bigbuf, MAX_BUF, "mapinfo %s unsupported", token);	350	snprintf (bigbuf, MAX_BUF, "mapinfo %s unsupported", token);
346		351
347	pl->socket->send_packet (bigbuf);	352	pl->ns->send_packet (bigbuf);
348	}	353	}
349		354
350	/** This is the Setup cmd - easy first implementation */	355	/** This is the Setup cmd - easy first implementation */
351	void	356	void
352	SetUp (char buf, int len, client ns)	357	SetUp (char buf, int len, client ns)
…		…
399	{	404	{
400	ns->sound = atoi (param);	405	ns->sound = atoi (param);
401	safe_strcat (cmdback, param, &slen, HUGE_BUF);	406	safe_strcat (cmdback, param, &slen, HUGE_BUF);
402	}	407	}
403	else if (!strcmp (cmd, "exp64"))	408	else if (!strcmp (cmd, "exp64"))
404	{
405	ns->exp64 = atoi (param);
406	safe_strcat (cmdback, param, &slen, HUGE_BUF);	409	safe_strcat (cmdback, param, &slen, HUGE_BUF);
407	}
408	else if (!strcmp (cmd, "spellmon"))	410	else if (!strcmp (cmd, "spellmon"))
409	{	411	{
410	ns->monitor_spells = atoi (param);	412	ns->monitor_spells = atoi (param);
411	safe_strcat (cmdback, param, &slen, HUGE_BUF);	413	safe_strcat (cmdback, param, &slen, HUGE_BUF);
412	}	414	}
…		…
569	* it either has to be here or init_sockets needs to be exported.	571	* it either has to be here or init_sockets needs to be exported.
570	*/	572	*/
571	void	573	void
572	AddMeCmd (char buf, int len, client ns)	574	AddMeCmd (char buf, int len, client ns)
573	{	575	{
574	if (ns->status != Ns_Add \|\| add_player (ns))	576	INVOKE_CLIENT (ADDME, ns, ARG_DATA (buf, len));
575	ns->send_packet ("addme_failed");
576	else
577	ns->send_packet ("addme_success");
578	}	577	}
579		578
580	/** Reply to ExtendedInfos command */	579	/** Reply to ExtendedInfos command */
581	void	580	void
582	ToggleExtendedInfos (char buf, int len, client ns)	581	ToggleExtendedInfos (char buf, int len, client ns)
…		…
803	* commands.	802	* commands.
804	*/	803	*/
805	pl->count = 0;	804	pl->count = 0;
806		805
807	//TODO: schmorp thinks whatever this calculates, it makes no sense at all	806	//TODO: schmorp thinks whatever this calculates, it makes no sense at all
808	int time = FABS (pl->ob->speed) < 0.001	807	int time = fabs (pl->ob->speed) < 0.001
809	? time = MAX_TIME * 100	808	? time = MAX_TIME * 100
810	: time = (int) (MAX_TIME / FABS (pl->ob->speed));	809	: time = (int) (MAX_TIME / fabs (pl->ob->speed));
811		810
812	/* Send confirmation of command execution now */	811	/* Send confirmation of command execution now */
813	packet sl ("comc");	812	packet sl ("comc");
814	sl << uint16 (cmdid) << uint32 (time);	813	sl << uint16 (cmdid) << uint32 (time);
815	pl->socket->send_packet (sl);	814	pl->ns->send_packet (sl);
816	}	815	}
817
818		816
819	/** This is a reply to a previous query. */	817	/** This is a reply to a previous query. */
820	void	818	void
821	ReplyCmd (char buf, int len, player pl)	819	ReplyCmd (char buf, int len, client ns)
822	{	820	{
		821	if (ns->state == ST_CUSTOM)
		822	{
		823	INVOKE_CLIENT (REPLY, ns, ARG_DATA (buf, len));
		824	return;
		825	}
		826
		827	if (!ns->pl)
		828	return; //TODO: depends on the exact reply we are after
		829	//TODO: but right now, we always have a ns->pl
		830
		831	player *pl = ns->pl;
		832
823	/* This is to synthesize how the data would be stored if it	833	/* This is to synthesize how the data would be stored if it
824	* was normally entered. A bit of a hack, and should be cleaned up	834	* was normally entered. A bit of a hack, and should be cleaned up
825	* once all the X11 code is removed from the server.	835	* once all the X11 code is removed from the server.
826	*	836	*
827	* We pass 13 to many of the functions because this way they	837	* We pass 13 to many of the functions because this way they
…		…
830	*/	840	*/
831	snprintf (pl->write_buf, sizeof (pl->write_buf), ":%s", buf);	841	snprintf (pl->write_buf, sizeof (pl->write_buf), ":%s", buf);
832		842
833	/* this avoids any hacking here */	843	/* this avoids any hacking here */
834		844
835	switch (pl->state)	845	switch (ns->state)
836	{	846	{
837	case ST_PLAYING:	847	case ST_PLAYING:
838	LOG (llevError, "Got reply message with ST_PLAYING input state\n");	848	LOG (llevError, "Got reply message with ST_PLAYING input state\n");
839	break;	849	break;
840		850
841	case ST_PLAY_AGAIN:
842	/* We can check this for return value (2==quit). Maybe we
843	* should, and do something appropriate?
844	*/
845	receive_play_again (pl->ob, buf[0]);
846	break;
847
848	case ST_ROLL_STAT:
849	key_roll_stat (pl->ob, buf[0]);
850	break;
851
852	case ST_CHANGE_CLASS:	851	case ST_CHANGE_CLASS:
853
854	key_change_class (pl->ob, buf[0]);	852	key_change_class (pl->ob, buf[0]);
855	break;
856
857	case ST_CONFIRM_QUIT:
858	key_confirm_quit (pl->ob, buf[0]);
859	break;
860
861	case ST_CONFIGURE:
862	LOG (llevError, "In client input handling, but into configure state\n");
863	pl->state = ST_PLAYING;
864	break;
865
866	case ST_GET_NAME:
867	receive_player_name (pl->ob, 13);
868	break;
869
870	case ST_GET_PASSWORD:
871	case ST_CONFIRM_PASSWORD:
872	receive_player_password (pl->ob, 13);
873	break;	853	break;
874		854
875	case ST_GET_PARTY_PASSWORD: /* Get password for party */	855	case ST_GET_PARTY_PASSWORD: /* Get password for party */
876	receive_party_password (pl->ob, 13);	856	receive_party_password (pl->ob, 13);
877	break;	857	break;
878		858
879	default:	859	default:
880	LOG (llevError, "Unknown input state: %d\n", pl->state);	860	LOG (llevError, "Unknown input state: %d\n", ns->state);
881	}	861	}
882	}	862	}
883		863
884	/**	864	/**
885	* Client tells its version. If there is a mismatch, we close the	865	* Client tells its version. If there is a mismatch, we close the
…		…
935	{	915	{
936	ns->sound = atoi (buf);	916	ns->sound = atoi (buf);
937	}	917	}
938		918
939	/** client wants the map resent */	919	/** client wants the map resent */
940
941	void	920	void
942	MapRedrawCmd (char buf, int len, player pl)	921	MapRedrawCmd (char buf, int len, player pl)
943	{	922	{
944	/* This function is currently disabled; just clearing the map state results in	923	/* This function is currently disabled; just clearing the map state results in
945	* display errors. It should clear the cache and send a newmap command.	924	* display errors. It should clear the cache and send a newmap command.
…		…
1032	esrv_update_stats (player *pl)	1011	esrv_update_stats (player *pl)
1033	{	1012	{
1034	char buf[MAX_BUF];	1013	char buf[MAX_BUF];
1035	uint16 flags;	1014	uint16 flags;
1036		1015
		1016	client *ns = pl->ns;
		1017	if (!ns)
		1018	return;
		1019
		1020	object *ob = pl->ob;
		1021	if (!ob)
		1022	return;
		1023
1037	packet sl ("stats");	1024	packet sl ("stats");
1038		1025
1039	if (pl->ob)
1040	{
1041	AddIfShort (pl->last_stats.hp, pl->ob->stats.hp, CS_STAT_HP);	1026	AddIfShort (ns->last_stats.hp, ob->stats.hp, CS_STAT_HP);
1042	AddIfShort (pl->last_stats.maxhp, pl->ob->stats.maxhp, CS_STAT_MAXHP);	1027	AddIfShort (ns->last_stats.maxhp, ob->stats.maxhp, CS_STAT_MAXHP);
1043	AddIfShort (pl->last_stats.sp, pl->ob->stats.sp, CS_STAT_SP);	1028	AddIfShort (ns->last_stats.sp, ob->stats.sp, CS_STAT_SP);
1044	AddIfShort (pl->last_stats.maxsp, pl->ob->stats.maxsp, CS_STAT_MAXSP);	1029	AddIfShort (ns->last_stats.maxsp, ob->stats.maxsp, CS_STAT_MAXSP);
1045	AddIfShort (pl->last_stats.grace, pl->ob->stats.grace, CS_STAT_GRACE);	1030	AddIfShort (ns->last_stats.grace, ob->stats.grace, CS_STAT_GRACE);
1046	AddIfShort (pl->last_stats.maxgrace, pl->ob->stats.maxgrace, CS_STAT_MAXGRACE);	1031	AddIfShort (ns->last_stats.maxgrace, ob->stats.maxgrace, CS_STAT_MAXGRACE);
1047	AddIfShort (pl->last_stats.Str, pl->ob->stats.Str, CS_STAT_STR);	1032	AddIfShort (ns->last_stats.Str, ob->stats.Str, CS_STAT_STR);
1048	AddIfShort (pl->last_stats.Int, pl->ob->stats.Int, CS_STAT_INT);
1049	AddIfShort (pl->last_stats.Pow, pl->ob->stats.Pow, CS_STAT_POW);
1050	AddIfShort (pl->last_stats.Wis, pl->ob->stats.Wis, CS_STAT_WIS);
1051	AddIfShort (pl->last_stats.Dex, pl->ob->stats.Dex, CS_STAT_DEX);	1033	AddIfShort (ns->last_stats.Dex, ob->stats.Dex, CS_STAT_DEX);
1052	AddIfShort (pl->last_stats.Con, pl->ob->stats.Con, CS_STAT_CON);	1034	AddIfShort (ns->last_stats.Con, ob->stats.Con, CS_STAT_CON);
		1035	AddIfShort (ns->last_stats.Int, ob->stats.Int, CS_STAT_INT);
		1036	AddIfShort (ns->last_stats.Wis, ob->stats.Wis, CS_STAT_WIS);
		1037	AddIfShort (ns->last_stats.Pow, ob->stats.Pow, CS_STAT_POW);
1053	AddIfShort (pl->last_stats.Cha, pl->ob->stats.Cha, CS_STAT_CHA);	1038	AddIfShort (ns->last_stats.Cha, ob->stats.Cha, CS_STAT_CHA);
1054	}
1055		1039
1056	if (pl->socket->exp64)
1057	for (int s = 0; s < NUM_SKILLS; s++)	1040	for (int s = 0; s < NUM_SKILLS; s++)
1058	if (pl->last_skill_ob[s] && pl->last_skill_exp[s] != pl->last_skill_ob[s]->stats.exp)	1041	if (object *skill = pl->last_skill_ob[s])
		1042	if (skill->stats.exp != ns->last_skill_exp [s])
1059	{	1043	{
		1044	ns->last_skill_exp [s] = skill->stats.exp;
		1045
1060	/* Always send along the level if exp changes. This is only	1046	/* Always send along the level if exp changes. This is only
1061	* 1 extra byte, but keeps processing simpler.	1047	* 1 extra byte, but keeps processing simpler.
1062	*/	1048	*/
1063	sl << uint8 (s + CS_STAT_SKILLINFO)	1049	sl << uint8 (s + CS_STAT_SKILLINFO)
1064	<< uint8 (pl->last_skill_ob[s]->level)	1050	<< uint8 (skill->level)
1065	<< uint64 (pl->last_skill_ob[s]->stats.exp);	1051	<< uint64 (skill->stats.exp);
1066
1067	pl->last_skill_exp[s] = pl->last_skill_ob[s]->stats.exp;
1068	}	1052	}
1069		1053
1070	if (pl->socket->exp64)
1071	{ AddIfInt64 (pl->last_stats.exp, pl->ob->stats.exp, CS_STAT_EXP64) }	1054	AddIfInt64 (ns->last_stats.exp, ob->stats.exp, CS_STAT_EXP64);
1072	else
1073	{ AddIfInt (pl->last_stats.exp, (int) pl->ob->stats.exp, CS_STAT_EXP) }
1074
1075	AddIfShort (pl->last_level, (char) pl->ob->level, CS_STAT_LEVEL);	1055	AddIfShort (ns->last_level, ob->level, CS_STAT_LEVEL);
1076	AddIfShort (pl->last_stats.wc, pl->ob->stats.wc, CS_STAT_WC);	1056	AddIfShort (ns->last_stats.wc, ob->stats.wc, CS_STAT_WC);
1077	AddIfShort (pl->last_stats.ac, pl->ob->stats.ac, CS_STAT_AC);	1057	AddIfShort (ns->last_stats.ac, ob->stats.ac, CS_STAT_AC);
1078	AddIfShort (pl->last_stats.dam, pl->ob->stats.dam, CS_STAT_DAM);	1058	AddIfShort (ns->last_stats.dam, ob->stats.dam, CS_STAT_DAM);
1079	AddIfFloat (pl->last_speed, pl->ob->speed, CS_STAT_SPEED);	1059	AddIfFloat (ns->last_speed, ob->speed, CS_STAT_SPEED);
1080	AddIfShort (pl->last_stats.food, pl->ob->stats.food, CS_STAT_FOOD);	1060	AddIfShort (ns->last_stats.food, ob->stats.food, CS_STAT_FOOD);
1081	AddIfFloat (pl->last_weapon_sp, pl->weapon_sp, CS_STAT_WEAP_SP);	1061	AddIfFloat (ns->last_weapon_sp, pl->weapon_sp, CS_STAT_WEAP_SP);
1082	AddIfInt (pl->last_weight_limit, (sint32) weight_limit[pl->ob->stats.Str], CS_STAT_WEIGHT_LIM);	1062	AddIfInt (ns->last_weight_limit, weight_limit[ob->stats.Str], CS_STAT_WEIGHT_LIM);
		1063
1083	flags = 0;	1064	flags = 0;
1084		1065
1085	if (pl->fire_on)	1066	if (pl->fire_on)
1086	flags \|= SF_FIREON;	1067	flags \|= SF_FIREON;
1087		1068
1088	if (pl->run_on)	1069	if (pl->run_on)
1089	flags \|= SF_RUNON;	1070	flags \|= SF_RUNON;
1090		1071
1091	AddIfShort (pl->last_flags, flags, CS_STAT_FLAGS);	1072	AddIfShort (ns->last_flags, flags, CS_STAT_FLAGS);
1092		1073
1093	if (pl->socket->sc_version < 1025)	1074	if (ns->sc_version < 1025)
1094	{ AddIfShort (pl->last_resist[ATNR_PHYSICAL], pl->ob->resist[ATNR_PHYSICAL], CS_STAT_ARMOUR) }	1075	{ AddIfShort (ns->last_resist[ATNR_PHYSICAL], ob->resist[ATNR_PHYSICAL], CS_STAT_ARMOUR) }
1095	else	1076	else
1096	for (int i = 0; i < NROFATTACKS; i++)	1077	for (int i = 0; i < NROFATTACKS; i++)
1097	{	1078	{
1098	/* Skip ones we won't send */	1079	/* Skip ones we won't send */
1099	if (atnr_cs_stat[i] == -1)	1080	if (atnr_cs_stat[i] == -1)
1100	continue;	1081	continue;
1101		1082
1102	AddIfShort (pl->last_resist[i], pl->ob->resist[i], (char) atnr_cs_stat[i]);	1083	AddIfShort (ns->last_resist[i], ob->resist[i], atnr_cs_stat[i]);
1103	}	1084	}
1104		1085
1105	if (pl->socket->monitor_spells)	1086	if (pl->ns->monitor_spells)
1106	{	1087	{
1107	AddIfInt (pl->last_path_attuned, pl->ob->path_attuned, CS_STAT_SPELL_ATTUNE);	1088	AddIfInt (ns->last_path_attuned, ob->path_attuned, CS_STAT_SPELL_ATTUNE);
1108	AddIfInt (pl->last_path_repelled, pl->ob->path_repelled, CS_STAT_SPELL_REPEL);	1089	AddIfInt (ns->last_path_repelled, ob->path_repelled, CS_STAT_SPELL_REPEL);
1109	AddIfInt (pl->last_path_denied, pl->ob->path_denied, CS_STAT_SPELL_DENY);	1090	AddIfInt (ns->last_path_denied, ob->path_denied, CS_STAT_SPELL_DENY);
1110	}	1091	}
1111		1092
1112	rangetostring (pl->ob, buf); /* we want use the new fire & run system in new client */	1093	rangetostring (ob, buf); /* we want use the new fire & run system in new client */
1113	AddIfString (pl->socket->stats.range, buf, CS_STAT_RANGE);	1094	AddIfString (ns->stats.range, buf, CS_STAT_RANGE);
1114	set_title (pl->ob, buf);	1095	set_title (ob, buf);
1115	AddIfString (pl->socket->stats.title, buf, CS_STAT_TITLE);	1096	AddIfString (ns->stats.title, buf, CS_STAT_TITLE);
1116		1097
1117	/* Only send it away if we have some actual data */	1098	/* Only send it away if we have some actual data */
1118	if (sl.length () > 6)	1099	if (sl.length () > 6)
1119	pl->socket->send_packet (sl);	1100	ns->send_packet (sl);
1120	}	1101	}
1121		1102
1122	/**	1103	/**
1123	* Tells the client that here is a player it should start using.	1104	* Tells the client that here is a player it should start using.
1124	*/	1105	*/
1125	void	1106	void
1126	esrv_new_player (player *pl, uint32 weight)	1107	esrv_new_player (player *pl, uint32 weight)
1127	{	1108	{
1128	pl->last_weight = weight;
1129
1130	packet sl ("player");	1109	packet sl ("player");
1131		1110
1132	sl << uint32 (pl->ob->count)	1111	sl << uint32 (pl->ob->count)
1133	<< uint32 (weight)	1112	<< uint32 (weight)
1134	<< uint32 (pl->ob->face->number)	1113	<< uint32 (pl->ob->face->number)
1135	<< data8 (pl->ob->name);	1114	<< data8 (pl->ob->name);
1136		1115
		1116	pl->ns->last_weight = weight;
1137	pl->socket->send_packet (sl);	1117	pl->ns->send_packet (sl);
1138	SET_FLAG (pl->ob, FLAG_CLIENT_SENT);	1118	SET_FLAG (pl->ob, FLAG_CLIENT_SENT);
1139	}	1119	}
1140		1120
1141	/**	1121	/**
1142	* Need to send an animation sequence to the client.	1122	* Need to send an animation sequence to the client.
…		…
1183	/******************************************************************************	1163	/******************************************************************************
1184	*	1164	*
1185	* Start of map related commands.	1165	* Start of map related commands.
1186	*	1166	*
1187	******************************************************************************/	1167	******************************************************************************/
1188
1189	/**
1190	* This adds face_num to a map cell at x,y. If the client doesn't have
1191	* the face yet, we will also send it.
1192	*/
1193	static void
1194	esrv_map_setbelow (client * ns, int x, int y, short face_num, struct Map *newmap)
1195	{
1196	if (newmap->cells[x][y].count >= MAP_LAYERS)
1197	{
1198	//TODO: one or the other, can't both have abort and return, verify and act
1199	LOG (llevError, "Too many faces in map cell %d %d\n", x, y);
1200	return;
1201	abort ();
1202	}
1203
1204	newmap->cells[x][y].faces[newmap->cells[x][y].count] = face_num;
1205	newmap->cells[x][y].count++;
1206
1207	if (!(ns->faces_sent[face_num] & NS_FACESENT_FACE))
1208	esrv_send_face (ns, face_num, 0);
1209	}
1210		1168
1211	/** Clears a map cell */	1169	/** Clears a map cell */
1212	static void	1170	static void
1213	map_clearcell (struct MapCell *cell, int face0, int face1, int face2, int count)	1171	map_clearcell (struct MapCell *cell, int face0, int face1, int face2, int count)
1214	{	1172	{
…		…
1529	ob = GET_MAP_FACE_OBJ (mp, mx, my, layer);	1487	ob = GET_MAP_FACE_OBJ (mp, mx, my, layer);
1530		1488
1531	/* If there is no object for this space, or if the face for the object	1489	/* If there is no object for this space, or if the face for the object
1532	* is the blank face, set the smoothlevel to zero.	1490	* is the blank face, set the smoothlevel to zero.
1533	*/	1491	*/
1534	if (!ob \|\| ob->face == blank_face \|\| MAP_NOSMOOTH (mp))	1492	if (!ob \|\| ob->face == blank_face)
1535	smoothlevel = 0;	1493	smoothlevel = 0;
1536	else	1494	else
1537	{	1495	{
1538	smoothlevel = ob->smoothlevel;	1496	smoothlevel = ob->smoothlevel;
1539	if (smoothlevel && !(ns.faces_sent[ob->face->number] & NS_FACESENT_SMOOTH))	1497	if (smoothlevel && !(ns.faces_sent[ob->face->number] & NS_FACESENT_SMOOTH))
…		…
1574	if (ns->EMI_smooth)	1532	if (ns->EMI_smooth)
1575	result += 1; /One byte for smoothlevel /	1533	result += 1; /One byte for smoothlevel /
1576	}	1534	}
1577		1535
1578	return result;	1536	return result;
		1537	}
		1538
		1539	// prefetch (and touch) all maps within a specific distancd
		1540	static void
		1541	prefetch_surrounding_maps (maptile *map, int distance)
		1542	{
		1543	map->last_access = runtime;
		1544
		1545	if (--distance)
		1546	for (int dir = 4; --dir; )
		1547	if (const shstr &path = map->tile_path [dir])
		1548	if (maptile *&neigh = map->tile_map [dir])
		1549	prefetch_surrounding_maps (neigh, distance);
		1550	else
		1551	neigh = maptile::find_async (path, map);
		1552	}
		1553
		1554	// prefetch a generous area around the player
		1555	static void
		1556	prefetch_surrounding_maps (object *op)
		1557	{
		1558	prefetch_surrounding_maps (op->map, 3);
1579	}	1559	}
1580		1560
1581	/**	1561	/**
1582	* This function uses the new map1 protocol command to send the map	1562	* This function uses the new map1 protocol command to send the map
1583	* to the client. It is necessary because the old map command supports	1563	* to the client. It is necessary because the old map command supports
…		…
1589	* we need 2 bytes for coordinates and 2 bytes for faces, such a trade off	1569	* we need 2 bytes for coordinates and 2 bytes for faces, such a trade off
1590	* maps no sense. Instead, we actually really only use 12 bits for coordinates,	1570	* maps no sense. Instead, we actually really only use 12 bits for coordinates,
1591	* and use the other 4 bits for other informatiion. For full documentation	1571	* and use the other 4 bits for other informatiion. For full documentation
1592	* of what we send, see the doc/Protocol file.	1572	* of what we send, see the doc/Protocol file.
1593	* I will describe internally what we do:	1573	* I will describe internally what we do:
1594	* the socket->lastmap shows how the map last looked when sent to the client.	1574	* the ns->lastmap shows how the map last looked when sent to the client.
1595	* in the lastmap structure, there is a cells array, which is set to the	1575	* in the lastmap structure, there is a cells array, which is set to the
1596	* maximum viewable size (As set in config.h).	1576	* maximum viewable size (As set in config.h).
1597	* in the cells, there are faces and a count value.	1577	* in the cells, there are faces and a count value.
1598	* we use the count value to hold the darkness value. If -1, then this space	1578	* we use the count value to hold the darkness value. If -1, then this space
1599	* is not viewable.	1579	* is not viewable.
…		…
1610	uint8 eentrysize;	1590	uint8 eentrysize;
1611	uint16 ewhatstart, ewhatflag;	1591	uint16 ewhatstart, ewhatflag;
1612	uint8 extendedinfos;	1592	uint8 extendedinfos;
1613	maptile *m;	1593	maptile *m;
1614		1594
1615	client &socket = *pl->contr->socket;	1595	client &socket = *pl->contr->ns;
		1596
		1597	if (!pl->active)
		1598	return;
1616		1599
1617	check_map_change (pl->contr);	1600	check_map_change (pl->contr);
		1601	prefetch_surrounding_maps (pl);
1618		1602
1619	packet sl (socket.mapmode == Map1Cmd ? "map1" : "map1a");	1603	packet sl (socket.mapmode == Map1Cmd ? "map1" : "map1a");
1620	packet esl;	1604	packet esl;
1621		1605
1622	startlen = sl.length ();	1606	startlen = sl.length ();
…		…
1741	map_clearcell (&lastcell, 0, 0, 0, -1);	1725	map_clearcell (&lastcell, 0, 0, 0, -1);
1742	}	1726	}
1743	}	1727	}
1744	else if (d > 3)	1728	else if (d > 3)
1745	{	1729	{
		1730	m->touch ();
		1731
1746	int need_send = 0, count;	1732	int need_send = 0, count;
1747		1733
1748	/* This block deals with spaces that are not visible for whatever	1734	/* This block deals with spaces that are not visible for whatever
1749	* reason. Still may need to send the head for this space.	1735	* reason. Still may need to send the head for this space.
1750	*/	1736	*/
…		…
1783	else	1769	else
1784	sl.reset (oldlen);	1770	sl.reset (oldlen);
1785	}	1771	}
1786	else	1772	else
1787	{	1773	{
		1774	m->touch ();
		1775
1788	/* In this block, the space is visible or there are head objects	1776	/* In this block, the space is visible or there are head objects
1789	* we need to send.	1777	* we need to send.
1790	*/	1778	*/
1791		1779
1792	/* Rather than try to figure out what everything that we might	1780	/* Rather than try to figure out what everything that we might
…		…
1985	*/	1973	*/
1986	void	1974	void
1987	draw_client_map (object *pl)	1975	draw_client_map (object *pl)
1988	{	1976	{
1989	int i, j;	1977	int i, j;
1990	sint16 ax, ay, nx, ny; /* ax and ay goes from 0 to max-size of arrays */	1978	sint16 ax, ay; /* ax and ay goes from 0 to max-size of arrays */
1991	New_Face face, floor;
1992	New_Face *floor2;
1993	int d, mflags;	1979	int mflags;
1994	struct Map newmap;	1980	struct Map newmap;
1995	maptile m, pm;	1981	maptile m, pm;
1996		1982
1997	if (pl->type != PLAYER)	1983	if (pl->type != PLAYER)
1998	{	1984	{
…		…
2009	if (pm == NULL \|\| pm->in_memory != MAP_IN_MEMORY)	1995	if (pm == NULL \|\| pm->in_memory != MAP_IN_MEMORY)
2010	return;	1996	return;
2011		1997
2012	memset (&newmap, 0, sizeof (struct Map));	1998	memset (&newmap, 0, sizeof (struct Map));
2013		1999
2014	for (j = (pl->y - pl->contr->socket->mapy / 2); j < (pl->y + (pl->contr->socket->mapy + 1) / 2); j++)	2000	for (j = (pl->y - pl->contr->ns->mapy / 2); j < (pl->y + (pl->contr->ns->mapy + 1) / 2); j++)
2015	for (i = (pl->x - pl->contr->socket->mapx / 2); i < (pl->x + (pl->contr->socket->mapx + 1) / 2); i++)	2001	for (i = (pl->x - pl->contr->ns->mapx / 2); i < (pl->x + (pl->contr->ns->mapx + 1) / 2); i++)
2016	{	2002	{
2017	ax = i;	2003	ax = i;
2018	ay = j;	2004	ay = j;
2019	m = pm;	2005	m = pm;
2020	mflags = get_map_flags (m, &m, ax, ay, &ax, &ay);	2006	mflags = get_map_flags (m, &m, ax, ay, &ax, &ay);
…		…
2052		2038
2053	/*****************************************************************************/	2039	/*****************************************************************************/
2054	void	2040	void
2055	send_plugin_custom_message (object pl, char buf)	2041	send_plugin_custom_message (object pl, char buf)
2056	{	2042	{
2057	pl->contr->socket->send_packet (buf);	2043	pl->contr->ns->send_packet (buf);
2058	}	2044	}
2059		2045
2060	/**	2046	/**
2061	* This sends the skill number to name mapping. We ignore	2047	* This sends the skill number to name mapping. We ignore
2062	* the params - we always send the same info no matter what.	2048	* the params - we always send the same info no matter what.
…		…
2107	* it then sends an updspell packet for each spell that has changed in this way	2093	* it then sends an updspell packet for each spell that has changed in this way
2108	*/	2094	*/
2109	void	2095	void
2110	esrv_update_spells (player *pl)	2096	esrv_update_spells (player *pl)
2111	{	2097	{
		2098	if (!pl->ns)
		2099	return;
		2100
2112	if (!pl->socket->monitor_spells)	2101	if (!pl->ns->monitor_spells)
2113	return;	2102	return;
2114		2103
2115	for (object *spell = pl->ob->inv; spell; spell = spell->below)	2104	for (object *spell = pl->ob->inv; spell; spell = spell->below)
2116	{	2105	{
2117	if (spell->type == SPELL)	2106	if (spell->type == SPELL)
…		…
2147		2136
2148	if (flags & UPD_SP_MANA ) sl << uint16 (spell->last_sp);	2137	if (flags & UPD_SP_MANA ) sl << uint16 (spell->last_sp);
2149	if (flags & UPD_SP_GRACE ) sl << uint16 (spell->last_grace);	2138	if (flags & UPD_SP_GRACE ) sl << uint16 (spell->last_grace);
2150	if (flags & UPD_SP_DAMAGE) sl << uint16 (spell->last_eat);	2139	if (flags & UPD_SP_DAMAGE) sl << uint16 (spell->last_eat);
2151		2140
2152	pl->socket->send_packet (sl);	2141	pl->ns->send_packet (sl);
2153	}	2142	}
2154	}	2143	}
2155	}	2144	}
2156	}	2145	}
2157		2146
2158	void	2147	void
2159	esrv_remove_spell (player pl, object spell)	2148	esrv_remove_spell (player pl, object spell)
2160	{	2149	{
2161	if (!pl->socket->monitor_spells)	2150	if (!pl->ns->monitor_spells)
2162	return;	2151	return;
2163		2152
2164	if (!pl \|\| !spell \|\| spell->env != pl->ob)	2153	if (!pl \|\| !spell \|\| spell->env != pl->ob)
2165	{	2154	{
2166	LOG (llevError, "Invalid call to esrv_remove_spell");	2155	LOG (llevError, "Invalid call to esrv_remove_spell");
…		…
2169		2158
2170	packet sl ("delspell");	2159	packet sl ("delspell");
2171		2160
2172	sl << uint32 (spell->count);	2161	sl << uint32 (spell->count);
2173		2162
2174	pl->socket->send_packet (sl);	2163	pl->ns->send_packet (sl);
2175	}	2164	}
2176		2165
2177	/* appends the spell spell to the Socklist we will send the data to. /	2166	/* appends the spell spell to the Socklist we will send the data to. /
2178	static void	2167	static void
2179	append_spell (player pl, packet &sl, object spell)	2168	append_spell (player pl, packet &sl, object spell)
2180	{	2169	{
2181	int len, i, skill = 0;	2170	int i, skill = 0;
2182		2171
2183	if (!(spell->name))	2172	if (!(spell->name))
2184	{	2173	{
2185	LOG (llevError, "item number %d is a spell with no name.\n", spell->count);	2174	LOG (llevError, "item number %d is a spell with no name.\n", spell->count);
2186	return;	2175	return;
…		…
2227	{	2216	{
2228	LOG (llevError, "esrv_add_spells, tried to add a spell to a NULL player");	2217	LOG (llevError, "esrv_add_spells, tried to add a spell to a NULL player");
2229	return;	2218	return;
2230	}	2219	}
2231		2220
2232	if (!pl->socket->monitor_spells)	2221	if (!pl->ns->monitor_spells)
2233	return;	2222	return;
2234		2223
2235	packet sl ("addspell");	2224	packet sl ("addspell");
2236		2225
2237	if (!spell)	2226	if (!spell)
…		…
2254	if (spell->type != SPELL)	2243	if (spell->type != SPELL)
2255	continue;	2244	continue;
2256		2245
2257	if (sl.length () >= (MAXSOCKBUF - (26 + strlen (spell->name) + (spell->msg ? strlen (spell->msg) : 0))))	2246	if (sl.length () >= (MAXSOCKBUF - (26 + strlen (spell->name) + (spell->msg ? strlen (spell->msg) : 0))))
2258	{	2247	{
2259	pl->socket->send_packet (sl);	2248	pl->ns->send_packet (sl);
2260		2249
2261	sl.reset ();	2250	sl.reset ();
2262	sl << "addspell ";	2251	sl << "addspell ";
2263	}	2252	}
2264		2253
…		…
2278	LOG (llevError, "Buffer overflow in esrv_add_spells!\n");	2267	LOG (llevError, "Buffer overflow in esrv_add_spells!\n");
2279	fatal (0);	2268	fatal (0);
2280	}	2269	}
2281		2270
2282	/* finally, we can send the packet */	2271	/* finally, we can send the packet */
2283	pl->socket->send_packet (sl);	2272	pl->ns->send_packet (sl);
2284	}	2273	}
2285		2274

Diff Legend

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

Comparing deliantra/server/socket/request.C (file contents): Revision 1.48 by root, Wed Dec 20 11:36:39 2006 UTC vs. Revision 1.67 by pippijn, Thu Mar 1 12:28:17 2007 UTC

Diff Legend

Comparing deliantra/server/socket/request.C (file contents):
Revision 1.48 by root, Wed Dec 20 11:36:39 2006 UTC vs.
Revision 1.67 by pippijn, Thu Mar 1 12:28:17 2007 UTC