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

Comparing deliantra/server/socket/request.C (file contents):
Revision 1.44 by root, Sat Dec 16 21:40:26 2006 UTC vs.
Revision 1.59 by pippijn, Sat Jan 6 14:42:31 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
138	}	139	}
139		140
140	static void	141	static void
141	clear_map (player *pl)	142	clear_map (player *pl)
142	{	143	{
143	client &socket = *pl->socket;
144
145	memset (&socket.lastmap, 0, sizeof (socket.lastmap));	144	memset (&pl->ns->lastmap, 0, sizeof (pl->ns->lastmap));
146		145
147	if (socket.newmapcmd == 1)	146	if (pl->ns->newmapcmd == 1)
148	socket.send_packet ("newmap");	147	pl->ns->send_packet ("newmap");
149		148
150	socket.update_look = 1;	149	pl->ns->floorbox_reset ();
151	socket.look_position = 0;
152	}	150	}
153		151
154	/** check for map change and send new map data */	152	/** check for map change and send new map data */
155	static void	153	static void
156	check_map_change (player *pl)	154	check_map_change (player *pl)
157	{	155	{
158	client &socket = *pl->socket;	156	client &socket = *pl->ns;
159	object *ob = pl->ob;	157	object *ob = pl->ob;
160	char buf[MAX_BUF]; /* eauugggh */	158	char buf[MAX_BUF]; /* eauugggh */
161		159
162	if (socket.current_map != ob->map)	160	if (socket.current_map != ob->map)
163	{	161	{
…		…
179	flags \|= 4;	177	flags \|= 4;
180	if (ob->map->tile_path[3])	178	if (ob->map->tile_path[3])
181	flags \|= 8;	179	flags \|= 8;
182		180
183	snprintf (buf, MAX_BUF, "mapinfo - spatial %d %d %d %d %d %s",	181	snprintf (buf, MAX_BUF, "mapinfo - spatial %d %d %d %d %d %s",
184	flags, socket.mapx / 2 - ob->x, socket.mapy / 2 - ob->y, ob->map->width, ob->map->height, ob->map->path);	182	flags, socket.mapx / 2 - ob->x, socket.mapy / 2 - ob->y, ob->map->width, ob->map->height, &ob->map->path);
185	}	183	}
186	else	184	else
187	snprintf (buf, MAX_BUF, "mapinfo current");	185	snprintf (buf, MAX_BUF, "mapinfo current");
188		186
189	socket.send_packet (buf);	187	socket.send_packet (buf);
…		…
197	if (socket.buggy_mapscroll && (abs (dx) > 8 \|\| abs (dy) > 8))	195	if (socket.buggy_mapscroll && (abs (dx) > 8 \|\| abs (dy) > 8))
198	clear_map (pl); // current (<= 1.9.1) clients have unchecked buffer overflows	196	clear_map (pl); // current (<= 1.9.1) clients have unchecked buffer overflows
199	else	197	else
200	{	198	{
201	socket_map_scroll (&socket, ob->x - socket.current_x, ob->y - socket.current_y);	199	socket_map_scroll (&socket, ob->x - socket.current_x, ob->y - socket.current_y);
202	socket.update_look = 1;	200	socket.floorbox_reset ();
203	socket.look_position = 0;
204	}	201	}
205	}	202	}
206		203
207	socket.current_x = ob->x;	204	socket.current_x = ob->x;
208	socket.current_y = ob->y;	205	socket.current_y = ob->y;
…		…
257	{	254	{
258	INVOKE_PLAYER (EXTCMD, pl, ARG_DATA (buf, len));	255	INVOKE_PLAYER (EXTCMD, pl, ARG_DATA (buf, len));
259	}	256	}
260		257
261	void	258	void
		259	ExtiCmd (char buf, int len, client ns)
		260	{
		261	INVOKE_CLIENT (EXTICMD, ns, ARG_DATA (buf, len));
		262	}
		263
		264	void
262	MapInfoCmd (char buf, int len, player pl)	265	MapInfoCmd (char buf, int len, player pl)
263	{	266	{
264	// <mapinfo tag spatial tile-path	267	// <mapinfo tag spatial tile-path
265	// >mapinfo tag spatial flags x y w h hash	268	// >mapinfo tag spatial flags x y w h hash
266		269
…		…
278	buf += 8;	281	buf += 8;
279		282
280	// initial map and its origin	283	// initial map and its origin
281	maptile *map = pl->ob->map;	284	maptile *map = pl->ob->map;
282	sint16 dx, dy;	285	sint16 dx, dy;
283	int mapx = pl->socket->mapx / 2 - pl->ob->x;	286	int mapx = pl->ns->mapx / 2 - pl->ob->x;
284	int mapy = pl->socket->mapy / 2 - pl->ob->y;	287	int mapy = pl->ns->mapy / 2 - pl->ob->y;
285	int max_distance = 8; // limit maximum path length to something generous	288	int max_distance = 8; // limit maximum path length to something generous
286		289
287	while (*buf && map && max_distance)	290	while (*buf && map && max_distance)
288	{	291	{
289	int dir = *buf++;	292	int dir = *buf++;
290		293
291	switch (dir)	294	switch (dir)
292	{	295	{
293	case '1':	296	case '1':
294	dx = 0;	297	dx = 0;
295	dy = -1;	298	dy = -1;
296	map = get_map_from_coord (map, &dx, &dy);	299	map = map->xy_find (dx, dy);
297	map && (mapy -= map->height);	300	map && (mapy -= map->height);
298	break;	301	break;
299	case '2':	302	case '2':
300	mapx += map->width;	303	mapx += map->width;
301	dx = map->width;	304	dx = map->width;
302	dy = 0;	305	dy = 0;
303	map = get_map_from_coord (map, &dx, &dy);	306	map = map->xy_find (dx, dy);
304	break;	307	break;
305	case '3':	308	case '3':
306	mapy += map->height;	309	mapy += map->height;
307	dx = 0;	310	dx = 0;
308	dy = map->height;	311	dy = map->height;
309	map = get_map_from_coord (map, &dx, &dy);	312	map = map->xy_find (dx, dy);
310	break;	313	break;
311	case '4':	314	case '4':
312	dx = -1;	315	dx = -1;
313	dy = 0;	316	dy = 0;
314	map = get_map_from_coord (map, &dx, &dy);	317	map = map->xy_find (dx, dy);
315	map && (mapx -= map->width);	318	map && (mapx -= map->width);
316	break;	319	break;
317	}	320	}
318		321
319	--max_distance;	322	--max_distance;
320	}	323	}
321		324
…		…
332	if (map->tile_path[2])	335	if (map->tile_path[2])
333	flags \|= 4;	336	flags \|= 4;
334	if (map->tile_path[3])	337	if (map->tile_path[3])
335	flags \|= 8;	338	flags \|= 8;
336		339
337	snprintf (bigbuf, MAX_BUF, "mapinfo %s spatial %d %d %d %d %d %s", token, flags, mapx, mapy, map->width, map->height, map->path);	340	snprintf (bigbuf, MAX_BUF, "mapinfo %s spatial %d %d %d %d %d %s", token, flags, mapx, mapy, map->width, map->height, &map->path);
338	}	341	}
339	else	342	else
340	snprintf (bigbuf, MAX_BUF, "mapinfo %s nomap", token);	343	snprintf (bigbuf, MAX_BUF, "mapinfo %s nomap", token);
341	}	344	}
342	else	345	else
343	snprintf (bigbuf, MAX_BUF, "mapinfo %s unsupported", token);	346	snprintf (bigbuf, MAX_BUF, "mapinfo %s unsupported", token);
344		347
345	pl->socket->send_packet (bigbuf);	348	pl->ns->send_packet (bigbuf);
346	}	349	}
347		350
348	/** This is the Setup cmd - easy first implementation */	351	/** This is the Setup cmd - easy first implementation */
349	void	352	void
350	SetUp (char buf, int len, client ns)	353	SetUp (char buf, int len, client ns)
…		…
397	{	400	{
398	ns->sound = atoi (param);	401	ns->sound = atoi (param);
399	safe_strcat (cmdback, param, &slen, HUGE_BUF);	402	safe_strcat (cmdback, param, &slen, HUGE_BUF);
400	}	403	}
401	else if (!strcmp (cmd, "exp64"))	404	else if (!strcmp (cmd, "exp64"))
402	{
403	ns->exp64 = atoi (param);
404	safe_strcat (cmdback, param, &slen, HUGE_BUF);	405	safe_strcat (cmdback, param, &slen, HUGE_BUF);
405	}
406	else if (!strcmp (cmd, "spellmon"))	406	else if (!strcmp (cmd, "spellmon"))
407	{	407	{
408	ns->monitor_spells = atoi (param);	408	ns->monitor_spells = atoi (param);
409	safe_strcat (cmdback, param, &slen, HUGE_BUF);	409	safe_strcat (cmdback, param, &slen, HUGE_BUF);
410	}	410	}
…		…
567	* it either has to be here or init_sockets needs to be exported.	567	* it either has to be here or init_sockets needs to be exported.
568	*/	568	*/
569	void	569	void
570	AddMeCmd (char buf, int len, client ns)	570	AddMeCmd (char buf, int len, client ns)
571	{	571	{
572	if (ns->status != Ns_Add \|\| add_player (ns))	572	INVOKE_CLIENT (ADDME, ns, ARG_DATA (buf, len));
573	ns->send_packet ("addme_failed");
574	else
575	ns->send_packet ("addme_success");
576	}	573	}
577		574
578	/** Reply to ExtendedInfos command */	575	/** Reply to ExtendedInfos command */
579	void	576	void
580	ToggleExtendedInfos (char buf, int len, client ns)	577	ToggleExtendedInfos (char buf, int len, client ns)
…		…
717	if (!(ns->faces_sent[smoothface] & NS_FACESENT_FACE))	714	if (!(ns->faces_sent[smoothface] & NS_FACESENT_FACE))
718	esrv_send_face (ns, smoothface, 0);	715	esrv_send_face (ns, smoothface, 0);
719		716
720	ns->faces_sent[face] \|= NS_FACESENT_SMOOTH;	717	ns->faces_sent[face] \|= NS_FACESENT_SMOOTH;
721		718
722	packet sl;	719	packet sl ("smooth");
723		720
724	sl << "smooth "
725	<< uint16 (face)	721	sl << uint16 (face)
726	<< uint16 (smoothface);	722	<< uint16 (smoothface);
727		723
728	ns->send_packet (sl);	724	ns->send_packet (sl);
729	}	725	}
730		726
…		…
807	int time = FABS (pl->ob->speed) < 0.001	803	int time = FABS (pl->ob->speed) < 0.001
808	? time = MAX_TIME * 100	804	? time = MAX_TIME * 100
809	: time = (int) (MAX_TIME / FABS (pl->ob->speed));	805	: time = (int) (MAX_TIME / FABS (pl->ob->speed));
810		806
811	/* Send confirmation of command execution now */	807	/* Send confirmation of command execution now */
812	packet sl;	808	packet sl ("comc");
813	sl << "comc " << uint16 (cmdid) << uint32 (time);	809	sl << uint16 (cmdid) << uint32 (time);
814	pl->socket->send_packet (sl);	810	pl->ns->send_packet (sl);
815	}	811	}
816
817		812
818	/** This is a reply to a previous query. */	813	/** This is a reply to a previous query. */
819	void	814	void
820	ReplyCmd (char buf, int len, player pl)	815	ReplyCmd (char buf, int len, client ns)
821	{	816	{
		817	if (ns->state == ST_CUSTOM)
		818	{
		819	INVOKE_CLIENT (REPLY, ns, ARG_DATA (buf, len));
		820	return;
		821	}
		822
		823	if (!ns->pl)
		824	return; //TODO: depends on the exact reply we are after
		825	//TODO: but right now, we always have a ns->pl
		826
		827	player *pl = ns->pl;
		828
822	/* This is to synthesize how the data would be stored if it	829	/* This is to synthesize how the data would be stored if it
823	* was normally entered. A bit of a hack, and should be cleaned up	830	* was normally entered. A bit of a hack, and should be cleaned up
824	* once all the X11 code is removed from the server.	831	* once all the X11 code is removed from the server.
825	*	832	*
826	* We pass 13 to many of the functions because this way they	833	* We pass 13 to many of the functions because this way they
…		…
829	*/	836	*/
830	snprintf (pl->write_buf, sizeof (pl->write_buf), ":%s", buf);	837	snprintf (pl->write_buf, sizeof (pl->write_buf), ":%s", buf);
831		838
832	/* this avoids any hacking here */	839	/* this avoids any hacking here */
833		840
834	switch (pl->state)	841	switch (ns->state)
835	{	842	{
836	case ST_PLAYING:	843	case ST_PLAYING:
837	LOG (llevError, "Got reply message with ST_PLAYING input state\n");	844	LOG (llevError, "Got reply message with ST_PLAYING input state\n");
838	break;	845	break;
839		846
840	case ST_PLAY_AGAIN:
841	/* We can check this for return value (2==quit). Maybe we
842	* should, and do something appropriate?
843	*/
844	receive_play_again (pl->ob, buf[0]);
845	break;
846
847	case ST_ROLL_STAT:
848	key_roll_stat (pl->ob, buf[0]);
849	break;
850
851	case ST_CHANGE_CLASS:	847	case ST_CHANGE_CLASS:
852
853	key_change_class (pl->ob, buf[0]);	848	key_change_class (pl->ob, buf[0]);
854	break;	849	break;
855		850
856	case ST_CONFIRM_QUIT:	851	case ST_CONFIRM_QUIT:
857	key_confirm_quit (pl->ob, buf[0]);	852	key_confirm_quit (pl->ob, buf[0]);
858	break;	853	break;
859		854
860	case ST_CONFIGURE:
861	LOG (llevError, "In client input handling, but into configure state\n");
862	pl->state = ST_PLAYING;
863	break;
864
865	case ST_GET_NAME:
866	receive_player_name (pl->ob, 13);
867	break;
868
869	case ST_GET_PASSWORD:
870	case ST_CONFIRM_PASSWORD:
871	receive_player_password (pl->ob, 13);
872	break;
873
874	case ST_GET_PARTY_PASSWORD: /* Get password for party */	855	case ST_GET_PARTY_PASSWORD: /* Get password for party */
875	receive_party_password (pl->ob, 13);	856	receive_party_password (pl->ob, 13);
876	break;	857	break;
877		858
878	default:	859	default:
879	LOG (llevError, "Unknown input state: %d\n", pl->state);	860	LOG (llevError, "Unknown input state: %d\n", ns->state);
880	}	861	}
881	}	862	}
882		863
883	/**	864	/**
884	* 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
…		…
934	{	915	{
935	ns->sound = atoi (buf);	916	ns->sound = atoi (buf);
936	}	917	}
937		918
938	/** client wants the map resent */	919	/** client wants the map resent */
939
940	void	920	void
941	MapRedrawCmd (char buf, int len, player pl)	921	MapRedrawCmd (char buf, int len, player pl)
942	{	922	{
943	/* 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
944	* 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.
…		…
1031	esrv_update_stats (player *pl)	1011	esrv_update_stats (player *pl)
1032	{	1012	{
1033	char buf[MAX_BUF];	1013	char buf[MAX_BUF];
1034	uint16 flags;	1014	uint16 flags;
1035		1015
1036	packet sl;	1016	if (!pl->ns)
1037	sl << "stats ";	1017	return;
		1018
		1019	packet sl ("stats");
1038		1020
1039	if (pl->ob)	1021	if (pl->ob)
1040	{	1022	{
1041	AddIfShort (pl->last_stats.hp, pl->ob->stats.hp, CS_STAT_HP);	1023	AddIfShort (pl->last_stats.hp, pl->ob->stats.hp, CS_STAT_HP);
1042	AddIfShort (pl->last_stats.maxhp, pl->ob->stats.maxhp, CS_STAT_MAXHP);	1024	AddIfShort (pl->last_stats.maxhp, pl->ob->stats.maxhp, CS_STAT_MAXHP);
1043	AddIfShort (pl->last_stats.sp, pl->ob->stats.sp, CS_STAT_SP);	1025	AddIfShort (pl->last_stats.sp, pl->ob->stats.sp, CS_STAT_SP);
1044	AddIfShort (pl->last_stats.maxsp, pl->ob->stats.maxsp, CS_STAT_MAXSP);	1026	AddIfShort (pl->last_stats.maxsp, pl->ob->stats.maxsp, CS_STAT_MAXSP);
1045	AddIfShort (pl->last_stats.grace, pl->ob->stats.grace, CS_STAT_GRACE);	1027	AddIfShort (pl->last_stats.grace, pl->ob->stats.grace, CS_STAT_GRACE);
1046	AddIfShort (pl->last_stats.maxgrace, pl->ob->stats.maxgrace, CS_STAT_MAXGRACE);	1028	AddIfShort (pl->last_stats.maxgrace, pl->ob->stats.maxgrace, CS_STAT_MAXGRACE);
1047	AddIfShort (pl->last_stats.Str, pl->ob->stats.Str, CS_STAT_STR);	1029	AddIfShort (pl->last_stats.Str, pl->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);	1030	AddIfShort (pl->last_stats.Dex, pl->ob->stats.Dex, CS_STAT_DEX);
1052	AddIfShort (pl->last_stats.Con, pl->ob->stats.Con, CS_STAT_CON);	1031	AddIfShort (pl->last_stats.Con, pl->ob->stats.Con, CS_STAT_CON);
		1032	AddIfShort (pl->last_stats.Int, pl->ob->stats.Int, CS_STAT_INT);
		1033	AddIfShort (pl->last_stats.Wis, pl->ob->stats.Wis, CS_STAT_WIS);
		1034	AddIfShort (pl->last_stats.Pow, pl->ob->stats.Pow, CS_STAT_POW);
1053	AddIfShort (pl->last_stats.Cha, pl->ob->stats.Cha, CS_STAT_CHA);	1035	AddIfShort (pl->last_stats.Cha, pl->ob->stats.Cha, CS_STAT_CHA);
1054	}	1036	}
1055		1037
1056	if (pl->socket->exp64)
1057	for (int s = 0; s < NUM_SKILLS; s++)	1038	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)	1039	if (pl->last_skill_ob[s] && pl->last_skill_exp[s] != pl->last_skill_ob[s]->stats.exp)
1059	{	1040	{
1060	/* Always send along the level if exp changes. This is only	1041	/* Always send along the level if exp changes. This is only
1061	* 1 extra byte, but keeps processing simpler.	1042	* 1 extra byte, but keeps processing simpler.
1062	*/	1043	*/
1063	sl << uint8 (s + CS_STAT_SKILLINFO)	1044	sl << uint8 (s + CS_STAT_SKILLINFO)
1064	<< uint8 (pl->last_skill_ob[s]->level)	1045	<< uint8 (pl->last_skill_ob[s]->level)
1065	<< uint64 (pl->last_skill_ob[s]->stats.exp);	1046	<< uint64 (pl->last_skill_ob[s]->stats.exp);
1066		1047
1067	pl->last_skill_exp[s] = pl->last_skill_ob[s]->stats.exp;	1048	pl->last_skill_exp[s] = pl->last_skill_ob[s]->stats.exp;
1068	}	1049	}
1069		1050
1070	if (pl->socket->exp64)
1071	{ AddIfInt64 (pl->last_stats.exp, pl->ob->stats.exp, CS_STAT_EXP64) }	1051	AddIfInt64 (pl->last_stats.exp, pl->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);	1052	AddIfShort (pl->last_level, (char) pl->ob->level, CS_STAT_LEVEL);
1076	AddIfShort (pl->last_stats.wc, pl->ob->stats.wc, CS_STAT_WC);	1053	AddIfShort (pl->last_stats.wc, pl->ob->stats.wc, CS_STAT_WC);
1077	AddIfShort (pl->last_stats.ac, pl->ob->stats.ac, CS_STAT_AC);	1054	AddIfShort (pl->last_stats.ac, pl->ob->stats.ac, CS_STAT_AC);
1078	AddIfShort (pl->last_stats.dam, pl->ob->stats.dam, CS_STAT_DAM);	1055	AddIfShort (pl->last_stats.dam, pl->ob->stats.dam, CS_STAT_DAM);
1079	AddIfFloat (pl->last_speed, pl->ob->speed, CS_STAT_SPEED);	1056	AddIfFloat (pl->last_speed, pl->ob->speed, CS_STAT_SPEED);
…		…
1088	if (pl->run_on)	1065	if (pl->run_on)
1089	flags \|= SF_RUNON;	1066	flags \|= SF_RUNON;
1090		1067
1091	AddIfShort (pl->last_flags, flags, CS_STAT_FLAGS);	1068	AddIfShort (pl->last_flags, flags, CS_STAT_FLAGS);
1092		1069
1093	if (pl->socket->sc_version < 1025)	1070	if (pl->ns->sc_version < 1025)
1094	{ AddIfShort (pl->last_resist[ATNR_PHYSICAL], pl->ob->resist[ATNR_PHYSICAL], CS_STAT_ARMOUR) }	1071	{ AddIfShort (pl->last_resist[ATNR_PHYSICAL], pl->ob->resist[ATNR_PHYSICAL], CS_STAT_ARMOUR) }
1095	else	1072	else
1096	for (int i = 0; i < NROFATTACKS; i++)	1073	for (int i = 0; i < NROFATTACKS; i++)
1097	{	1074	{
1098	/* Skip ones we won't send */	1075	/* Skip ones we won't send */
…		…
1100	continue;	1077	continue;
1101		1078
1102	AddIfShort (pl->last_resist[i], pl->ob->resist[i], (char) atnr_cs_stat[i]);	1079	AddIfShort (pl->last_resist[i], pl->ob->resist[i], (char) atnr_cs_stat[i]);
1103	}	1080	}
1104		1081
1105	if (pl->socket->monitor_spells)	1082	if (pl->ns->monitor_spells)
1106	{	1083	{
1107	AddIfInt (pl->last_path_attuned, pl->ob->path_attuned, CS_STAT_SPELL_ATTUNE);	1084	AddIfInt (pl->last_path_attuned, pl->ob->path_attuned, CS_STAT_SPELL_ATTUNE);
1108	AddIfInt (pl->last_path_repelled, pl->ob->path_repelled, CS_STAT_SPELL_REPEL);	1085	AddIfInt (pl->last_path_repelled, pl->ob->path_repelled, CS_STAT_SPELL_REPEL);
1109	AddIfInt (pl->last_path_denied, pl->ob->path_denied, CS_STAT_SPELL_DENY);	1086	AddIfInt (pl->last_path_denied, pl->ob->path_denied, CS_STAT_SPELL_DENY);
1110	}	1087	}
1111		1088
1112	rangetostring (pl->ob, buf); /* we want use the new fire & run system in new client */	1089	rangetostring (pl->ob, buf); /* we want use the new fire & run system in new client */
1113	AddIfString (pl->socket->stats.range, buf, CS_STAT_RANGE);	1090	AddIfString (pl->ns->stats.range, buf, CS_STAT_RANGE);
1114	set_title (pl->ob, buf);	1091	set_title (pl->ob, buf);
1115	AddIfString (pl->socket->stats.title, buf, CS_STAT_TITLE);	1092	AddIfString (pl->ns->stats.title, buf, CS_STAT_TITLE);
1116		1093
1117	/* Only send it away if we have some actual data */	1094	/* Only send it away if we have some actual data */
1118	if (sl.length () > 6)	1095	if (sl.length () > 6)
1119	pl->socket->send_packet (sl);	1096	pl->ns->send_packet (sl);
1120	}	1097	}
1121		1098
1122	/**	1099	/**
1123	* Tells the client that here is a player it should start using.	1100	* Tells the client that here is a player it should start using.
1124	*/	1101	*/
1125	void	1102	void
1126	esrv_new_player (player *pl, uint32 weight)	1103	esrv_new_player (player *pl, uint32 weight)
1127	{	1104	{
1128	pl->last_weight = weight;	1105	pl->last_weight = weight;
1129		1106
1130	packet sl;	1107	packet sl ("player");
1131	sl << "player ";
1132		1108
1133	sl << uint32 (pl->ob->count)	1109	sl << uint32 (pl->ob->count)
1134	<< uint32 (weight)	1110	<< uint32 (weight)
1135	<< uint32 (pl->ob->face->number)	1111	<< uint32 (pl->ob->face->number)
1136	<< data8 (pl->ob->name);	1112	<< data8 (pl->ob->name);
1137		1113
1138	pl->socket->send_packet (sl);	1114	pl->ns->send_packet (sl);
1139	SET_FLAG (pl->ob, FLAG_CLIENT_SENT);	1115	SET_FLAG (pl->ob, FLAG_CLIENT_SENT);
1140	}	1116	}
1141		1117
1142	/**	1118	/**
1143	* Need to send an animation sequence to the client.	1119	* Need to send an animation sequence to the client.
…		…
1157	{	1133	{
1158	LOG (llevError, "esrv_send_anim (%d) out of bounds??\n", anim_num);	1134	LOG (llevError, "esrv_send_anim (%d) out of bounds??\n", anim_num);
1159	return;	1135	return;
1160	}	1136	}
1161		1137
1162	packet sl;	1138	packet sl ("anim");
1163		1139
1164	sl << "anim "
1165	<< uint16 (anim_num)	1140	sl << uint16 (anim_num)
1166	<< uint16 (0); /* flags - not used right now */	1141	<< uint16 (0); /* flags - not used right now */
1167		1142
1168	/* Build up the list of faces. Also, send any information (ie, the	1143	/* Build up the list of faces. Also, send any information (ie, the
1169	* the face itself) down to the client.	1144	* the face itself) down to the client.
1170	*/	1145	*/
…		…
1531	ob = GET_MAP_FACE_OBJ (mp, mx, my, layer);	1506	ob = GET_MAP_FACE_OBJ (mp, mx, my, layer);
1532		1507
1533	/* If there is no object for this space, or if the face for the object	1508	/* If there is no object for this space, or if the face for the object
1534	* is the blank face, set the smoothlevel to zero.	1509	* is the blank face, set the smoothlevel to zero.
1535	*/	1510	*/
1536	if (!ob \|\| ob->face == blank_face \|\| MAP_NOSMOOTH (mp))	1511	if (!ob \|\| ob->face == blank_face)
1537	smoothlevel = 0;	1512	smoothlevel = 0;
1538	else	1513	else
1539	{	1514	{
1540	smoothlevel = ob->smoothlevel;	1515	smoothlevel = ob->smoothlevel;
1541	if (smoothlevel && !(ns.faces_sent[ob->face->number] & NS_FACESENT_SMOOTH))	1516	if (smoothlevel && !(ns.faces_sent[ob->face->number] & NS_FACESENT_SMOOTH))
…		…
1591	* we need 2 bytes for coordinates and 2 bytes for faces, such a trade off	1566	* we need 2 bytes for coordinates and 2 bytes for faces, such a trade off
1592	* maps no sense. Instead, we actually really only use 12 bits for coordinates,	1567	* maps no sense. Instead, we actually really only use 12 bits for coordinates,
1593	* and use the other 4 bits for other informatiion. For full documentation	1568	* and use the other 4 bits for other informatiion. For full documentation
1594	* of what we send, see the doc/Protocol file.	1569	* of what we send, see the doc/Protocol file.
1595	* I will describe internally what we do:	1570	* I will describe internally what we do:
1596	* the socket->lastmap shows how the map last looked when sent to the client.	1571	* the ns->lastmap shows how the map last looked when sent to the client.
1597	* in the lastmap structure, there is a cells array, which is set to the	1572	* in the lastmap structure, there is a cells array, which is set to the
1598	* maximum viewable size (As set in config.h).	1573	* maximum viewable size (As set in config.h).
1599	* in the cells, there are faces and a count value.	1574	* in the cells, there are faces and a count value.
1600	* we use the count value to hold the darkness value. If -1, then this space	1575	* we use the count value to hold the darkness value. If -1, then this space
1601	* is not viewable.	1576	* is not viewable.
…		…
1612	uint8 eentrysize;	1587	uint8 eentrysize;
1613	uint16 ewhatstart, ewhatflag;	1588	uint16 ewhatstart, ewhatflag;
1614	uint8 extendedinfos;	1589	uint8 extendedinfos;
1615	maptile *m;	1590	maptile *m;
1616		1591
1617	client &socket = *pl->contr->socket;	1592	client &socket = *pl->contr->ns;
		1593
		1594	if (!pl->active ())
		1595	return;
1618		1596
1619	check_map_change (pl->contr);	1597	check_map_change (pl->contr);
1620		1598
1621	packet sl;	1599	packet sl (socket.mapmode == Map1Cmd ? "map1" : "map1a");
1622	packet esl;	1600	packet esl;
1623		1601
1624	sl << (socket.mapmode == Map1Cmd ? "map1 " : "map1a ");
1625	startlen = sl.length ();	1602	startlen = sl.length ();
1626		1603
1627	/Extendedmapinfo structure initialisation /	1604	/Extendedmapinfo structure initialisation /
1628	if (socket.ext_mapinfos)	1605	if (socket.ext_mapinfos)
1629	{	1606	{
…		…
1673	for (y = pl->y - socket.mapy / 2; y < max_y; y++, ay++)	1650	for (y = pl->y - socket.mapy / 2; y < max_y; y++, ay++)
1674	{	1651	{
1675	ax = 0;	1652	ax = 0;
1676	for (x = pl->x - socket.mapx / 2; x < max_x; x++, ax++)	1653	for (x = pl->x - socket.mapx / 2; x < max_x; x++, ax++)
1677	{	1654	{
1678
1679	emask = mask = (ax & 0x3f) << 10 \| (ay & 0x3f) << 4;	1655	emask = mask = (ax & 0x3f) << 10 \| (ay & 0x3f) << 4;
1680		1656
1681	/* If this space is out of the normal viewable area, we only check	1657	/* If this space is out of the normal viewable area, we only check
1682	* the heads value ax or ay will only be greater than what	1658	* the heads value ax or ay will only be greater than what
1683	* the client wants if using the map1a command - this is because	1659	* the client wants if using the map1a command - this is because
…		…
1745	map_clearcell (&lastcell, 0, 0, 0, -1);	1721	map_clearcell (&lastcell, 0, 0, 0, -1);
1746	}	1722	}
1747	}	1723	}
1748	else if (d > 3)	1724	else if (d > 3)
1749	{	1725	{
		1726	m->touch ();
		1727
1750	int need_send = 0, count;	1728	int need_send = 0, count;
1751		1729
1752	/* This block deals with spaces that are not visible for whatever	1730	/* This block deals with spaces that are not visible for whatever
1753	* reason. Still may need to send the head for this space.	1731	* reason. Still may need to send the head for this space.
1754	*/	1732	*/
…		…
1787	else	1765	else
1788	sl.reset (oldlen);	1766	sl.reset (oldlen);
1789	}	1767	}
1790	else	1768	else
1791	{	1769	{
		1770	m->touch ();
		1771
1792	/* In this block, the space is visible or there are head objects	1772	/* In this block, the space is visible or there are head objects
1793	* we need to send.	1773	* we need to send.
1794	*/	1774	*/
1795		1775
1796	/* Rather than try to figure out what everything that we might	1776	/* Rather than try to figure out what everything that we might
…		…
2013	if (pm == NULL \|\| pm->in_memory != MAP_IN_MEMORY)	1993	if (pm == NULL \|\| pm->in_memory != MAP_IN_MEMORY)
2014	return;	1994	return;
2015		1995
2016	memset (&newmap, 0, sizeof (struct Map));	1996	memset (&newmap, 0, sizeof (struct Map));
2017		1997
2018	for (j = (pl->y - pl->contr->socket->mapy / 2); j < (pl->y + (pl->contr->socket->mapy + 1) / 2); j++)	1998	for (j = (pl->y - pl->contr->ns->mapy / 2); j < (pl->y + (pl->contr->ns->mapy + 1) / 2); j++)
2019	{
2020	for (i = (pl->x - pl->contr->socket->mapx / 2); i < (pl->x + (pl->contr->socket->mapx + 1) / 2); i++)	1999	for (i = (pl->x - pl->contr->ns->mapx / 2); i < (pl->x + (pl->contr->ns->mapx + 1) / 2); i++)
2021	{	2000	{
2022	ax = i;	2001	ax = i;
2023	ay = j;	2002	ay = j;
2024	m = pm;	2003	m = pm;
2025	mflags = get_map_flags (m, &m, ax, ay, &ax, &ay);	2004	mflags = get_map_flags (m, &m, ax, ay, &ax, &ay);
2026		2005
2027	if (mflags & P_OUT_OF_MAP)	2006	if (mflags & P_OUT_OF_MAP)
2028	continue;	2007	continue;
2029		2008
2030	if (mflags & P_NEED_UPDATE)
2031	update_position (m, ax, ay);
2032
2033	/* If a map is visible to the player, we don't want to swap it out	2009	/* If a map is visible to the player, we don't want to swap it out
2034	* just to reload it. This should really call something like	2010	* just to reload it. This should really call something like
2035	* swap_map, but this is much more efficient and 'good enough'	2011	* swap_map, but this is much more efficient and 'good enough'
2036	*/	2012	*/
2037	if (mflags & P_NEW_MAP)	2013	if (mflags & P_NEW_MAP)
2038	m->timeout = 50;	2014	m->timeout = 50;
2039	}	2015	}
2040	}	2016
2041	/* do LOS after calls to update_position */	2017	/* do LOS after calls to update_position */
2042	if (pl->contr->do_los)	2018	if (pl->contr->do_los)
2043	{	2019	{
2044	update_los (pl);	2020	update_los (pl);
2045	pl->contr->do_los = 0;	2021	pl->contr->do_los = 0;
…		…
2060		2036
2061	/*****************************************************************************/	2037	/*****************************************************************************/
2062	void	2038	void
2063	send_plugin_custom_message (object pl, char buf)	2039	send_plugin_custom_message (object pl, char buf)
2064	{	2040	{
2065	pl->contr->socket->send_packet (buf);	2041	pl->contr->ns->send_packet (buf);
2066	}	2042	}
2067		2043
2068	/**	2044	/**
2069	* This sends the skill number to name mapping. We ignore	2045	* This sends the skill number to name mapping. We ignore
2070	* the params - we always send the same info no matter what.	2046	* the params - we always send the same info no matter what.
…		…
2115	* it then sends an updspell packet for each spell that has changed in this way	2091	* it then sends an updspell packet for each spell that has changed in this way
2116	*/	2092	*/
2117	void	2093	void
2118	esrv_update_spells (player *pl)	2094	esrv_update_spells (player *pl)
2119	{	2095	{
		2096	if (!pl->ns)
		2097	return;
		2098
2120	if (!pl->socket->monitor_spells)	2099	if (!pl->ns->monitor_spells)
2121	return;	2100	return;
2122		2101
2123	for (object *spell = pl->ob->inv; spell; spell = spell->below)	2102	for (object *spell = pl->ob->inv; spell; spell = spell->below)
2124	{	2103	{
2125	if (spell->type == SPELL)	2104	if (spell->type == SPELL)
…		…
2155		2134
2156	if (flags & UPD_SP_MANA ) sl << uint16 (spell->last_sp);	2135	if (flags & UPD_SP_MANA ) sl << uint16 (spell->last_sp);
2157	if (flags & UPD_SP_GRACE ) sl << uint16 (spell->last_grace);	2136	if (flags & UPD_SP_GRACE ) sl << uint16 (spell->last_grace);
2158	if (flags & UPD_SP_DAMAGE) sl << uint16 (spell->last_eat);	2137	if (flags & UPD_SP_DAMAGE) sl << uint16 (spell->last_eat);
2159		2138
2160	pl->socket->send_packet (sl);	2139	pl->ns->send_packet (sl);
2161	}	2140	}
2162	}	2141	}
2163	}	2142	}
2164	}	2143	}
2165		2144
2166	void	2145	void
2167	esrv_remove_spell (player pl, object spell)	2146	esrv_remove_spell (player pl, object spell)
2168	{	2147	{
2169	if (!pl->socket->monitor_spells)	2148	if (!pl->ns->monitor_spells)
2170	return;	2149	return;
2171		2150
2172	if (!pl \|\| !spell \|\| spell->env != pl->ob)	2151	if (!pl \|\| !spell \|\| spell->env != pl->ob)
2173	{	2152	{
2174	LOG (llevError, "Invalid call to esrv_remove_spell");	2153	LOG (llevError, "Invalid call to esrv_remove_spell");
2175	return;	2154	return;
2176	}	2155	}
2177		2156
2178	packet sl;	2157	packet sl ("delspell");
2179		2158
2180	sl << "delspell "
2181	<< uint32 (spell->count);	2159	sl << uint32 (spell->count);
2182		2160
2183	pl->socket->send_packet (sl);	2161	pl->ns->send_packet (sl);
2184	}	2162	}
2185		2163
2186	/* appends the spell spell to the Socklist we will send the data to. /	2164	/* appends the spell spell to the Socklist we will send the data to. /
2187	static void	2165	static void
2188	append_spell (player pl, packet &sl, object spell)	2166	append_spell (player pl, packet &sl, object spell)
…		…
2236	{	2214	{
2237	LOG (llevError, "esrv_add_spells, tried to add a spell to a NULL player");	2215	LOG (llevError, "esrv_add_spells, tried to add a spell to a NULL player");
2238	return;	2216	return;
2239	}	2217	}
2240		2218
2241	if (!pl->socket->monitor_spells)	2219	if (!pl->ns->monitor_spells)
2242	return;	2220	return;
2243		2221
2244	packet sl;	2222	packet sl ("addspell");
2245	sl << "addspell ";
2246		2223
2247	if (!spell)	2224	if (!spell)
2248	{	2225	{
2249	for (spell = pl->ob->inv; spell != NULL; spell = spell->below)	2226	for (spell = pl->ob->inv; spell != NULL; spell = spell->below)
2250	{	2227	{
…		…
2264	if (spell->type != SPELL)	2241	if (spell->type != SPELL)
2265	continue;	2242	continue;
2266		2243
2267	if (sl.length () >= (MAXSOCKBUF - (26 + strlen (spell->name) + (spell->msg ? strlen (spell->msg) : 0))))	2244	if (sl.length () >= (MAXSOCKBUF - (26 + strlen (spell->name) + (spell->msg ? strlen (spell->msg) : 0))))
2268	{	2245	{
2269	pl->socket->send_packet (sl);	2246	pl->ns->send_packet (sl);
2270		2247
2271	sl.reset ();	2248	sl.reset ();
2272	sl << "addspell ";	2249	sl << "addspell ";
2273	}	2250	}
2274		2251
…		…
2288	LOG (llevError, "Buffer overflow in esrv_add_spells!\n");	2265	LOG (llevError, "Buffer overflow in esrv_add_spells!\n");
2289	fatal (0);	2266	fatal (0);
2290	}	2267	}
2291		2268
2292	/* finally, we can send the packet */	2269	/* finally, we can send the packet */
2293	pl->socket->send_packet (sl);	2270	pl->ns->send_packet (sl);
2294	}	2271	}
2295		2272

Diff Legend

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

Comparing deliantra/server/socket/request.C (file contents): Revision 1.44 by root, Sat Dec 16 21:40:26 2006 UTC vs. Revision 1.59 by pippijn, Sat Jan 6 14:42:31 2007 UTC

Diff Legend

Comparing deliantra/server/socket/request.C (file contents):
Revision 1.44 by root, Sat Dec 16 21:40:26 2006 UTC vs.
Revision 1.59 by pippijn, Sat Jan 6 14:42:31 2007 UTC