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

Comparing deliantra/server/socket/request.C (file contents):
Revision 1.156 by root, Fri Nov 6 12:49:19 2009 UTC vs.
Revision 1.196 by root, Sun Nov 18 00:37:11 2018 UTC

…		…
1	/*	1	/*
2	* This file is part of Deliantra, the Roguelike Realtime MMORPG.	2	* This file is part of Deliantra, the Roguelike Realtime MMORPG.
3	*	3	*
		4	* Copyright (©) 2017,2018 Marc Alexander Lehmann / the Deliantra team
4	* Copyright (©) 2005,2006,2007,2008 Marc Alexander Lehmann / Robin Redeker / the Deliantra team	5	* Copyright (©) 2005,2006,2007,2008,2009,2010,2011,2012,2013,2014,2015,2016 Marc Alexander Lehmann / Robin Redeker / the Deliantra team
5	* Copyright (©) 2001,2007 Mark Wedel	6	* Copyright (©) 2001 Mark Wedel
6	* Copyright (©) 1992,2007 Frank Tore Johansen	7	* Copyright (©) 1992 Frank Tore Johansen
7	*	8	*
8	* Deliantra is free software: you can redistribute it and/or modify it under	9	* Deliantra is free software: you can redistribute it and/or modify it under
9	* the terms of the Affero GNU General Public License as published by the	10	* the terms of the Affero GNU General Public License as published by the
10	* Free Software Foundation, either version 3 of the License, or (at your	11	* Free Software Foundation, either version 3 of the License, or (at your
11	* option) any later version.	12	* option) any later version.
12	*	13	*
13	* This program is distributed in the hope that it will be useful,	14	* This program is distributed in the hope that it will be useful,
14	* but WITHOUT ANY WARRANTY; without even the implied warranty of	15	* but WITHOUT ANY WARRANTY; without even the implied warranty of
15	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the	16	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16	* GNU General Public License for more details.	17	* GNU General Public License for more details.
17	*	18	*
18	* You should have received a copy of the Affero GNU General Public License	19	* You should have received a copy of the Affero GNU General Public License
19	* and the GNU General Public License along with this program. If not, see	20	* and the GNU General Public License along with this program. If not, see
20	* <http://www.gnu.org/licenses/>.	21	* <http://www.gnu.org/licenses/>.
21	*	22	*
22	* The authors can be reached via e-mail to <support@deliantra.net>	23	* The authors can be reached via e-mail to <support@deliantra.net>
23	*/	24	*/
24		25
25	//+GPL	26	//+GPL
26		27
28	* \file	29	* \file
29	* Client handling.	30	* Client handling.
30	*	31	*
31	* \date 2003-12-02	32	* \date 2003-12-02
32	*	33	*
33	* This file implements all of the goo on the server side for handling	34	* This file implements all of the goo on the server side for handling
34	* clients. It's got a bunch of global variables for keeping track of	35	* clients. It's got a bunch of global variables for keeping track of
35	* each of the clients.	36	* each of the clients.
36	*	37	*
37	* Note: All functions that are used to process data from the client	38	* Note: All functions that are used to process data from the client
38	* have the prototype of (char *data, int datalen, int client_num). This	39	* have the prototype of (char *data, int datalen, int client_num). This
39	* way, we can use one dispatch table.	40	* way, we can use one dispatch table.
40	*	41	*
…		…
44		45
45	#include <global.h>	46	#include <global.h>
46	#include <sproto.h>	47	#include <sproto.h>
47		48
48	#include <living.h>	49	#include <living.h>
49	#include <commands.h>
50		50
51	/* This block is basically taken from socket.c - I assume if it works there,	51	/* This block is basically taken from socket.c - I assume if it works there,
52	* it should work here.	52	* it should work here.
53	*/	53	*/
54	#include <sys/types.h>	54	#include <sys/types.h>
…		…
66	* This table translates the attack numbers as used within the	66	* This table translates the attack numbers as used within the
67	* program to the value we use when sending STATS command to the	67	* program to the value we use when sending STATS command to the
68	* client. If a value is -1, then we don't send that to the	68	* client. If a value is -1, then we don't send that to the
69	* client.	69	* client.
70	*/	70	*/
71	static short atnr_cs_stat[NROFATTACKS] = { CS_STAT_RES_PHYS,	71	static short atnr_cs_stat[NROFATTACKS] =
72	CS_STAT_RES_MAG, CS_STAT_RES_FIRE, CS_STAT_RES_ELEC,	72	{
73	CS_STAT_RES_COLD, CS_STAT_RES_CONF, CS_STAT_RES_ACID,	73	CS_STAT_RES_PHYS,
74	CS_STAT_RES_DRAIN, -1 /* weaponmagic */ ,	74	CS_STAT_RES_MAG,
75	CS_STAT_RES_GHOSTHIT, CS_STAT_RES_POISON,	75	CS_STAT_RES_FIRE,
76	CS_STAT_RES_SLOW, CS_STAT_RES_PARA, CS_STAT_TURN_UNDEAD,	76	CS_STAT_RES_ELEC,
77	CS_STAT_RES_FEAR, -1 /* Cancellation */ ,	77	CS_STAT_RES_COLD,
78	CS_STAT_RES_DEPLETE, CS_STAT_RES_DEATH,	78	CS_STAT_RES_CONF,
79	-1 /* Chaos / , -1 / Counterspell */ ,	79	CS_STAT_RES_ACID,
80	-1 /* Godpower */ , CS_STAT_RES_HOLYWORD,	80	CS_STAT_RES_DRAIN,
		81	-1 /* weaponmagic */,
		82	CS_STAT_RES_GHOSTHIT,
		83	CS_STAT_RES_POISON,
		84	CS_STAT_RES_SLOW,
		85	CS_STAT_RES_PARA,
		86	CS_STAT_TURN_UNDEAD,
		87	CS_STAT_RES_FEAR,
		88	-1 /* Cancellation */,
		89	CS_STAT_RES_DEPLETE,
		90	CS_STAT_RES_DEATH,
		91	-1 /* Chaos */,
		92	-1 /* Counterspell */,
		93	-1 /* Godpower */,
		94	CS_STAT_RES_HOLYWORD,
81	CS_STAT_RES_BLIND,	95	CS_STAT_RES_BLIND,
82	-1, /* Internal */	96	-1, /* Internal */
83	-1, /* life stealing */	97	-1, /* life stealing */
84	-1 /* Disease - not fully done yet */	98	-1 /* Disease - not fully done yet */
85	};	99	};
…		…
133	pl->ns->mapinfo_queue_clear ();	147	pl->ns->mapinfo_queue_clear ();
134		148
135	memset (&pl->ns->lastmap, 0, sizeof (pl->ns->lastmap));	149	memset (&pl->ns->lastmap, 0, sizeof (pl->ns->lastmap));
136		150
137	pl->ns->force_newmap = false;	151	pl->ns->force_newmap = false;
138
139	if (pl->ns->newmapcmd == 1)
140	pl->ns->send_packet ("newmap");	152	pl->ns->send_packet ("newmap");
141
142	pl->ns->floorbox_reset ();	153	pl->ns->floorbox_reset ();
143	}	154	}
144		155
145	static void	156	static void
146	send_map_info (player *pl)	157	send_map_info (player *pl)
…		…
148	client &socket = *pl->ns;	159	client &socket = *pl->ns;
149	object *ob = pl->viewpoint;	160	object *ob = pl->viewpoint;
150		161
151	if (socket.mapinfocmd)	162	if (socket.mapinfocmd)
152	{	163	{
153	if (ob->map && ob->map->path[0])	164	if (ob->map && ob->map->path)
154	{	165	{
155	int flags = 0;	166	int flags = 0;
156		167
		168	// due to historical glitches, the bit ordering and map index ordering differs
157	if (ob->map->tile_path[0]) flags \|= 1;	169	if (ob->map->tile_path [TILE_NORTH]) flags \|= 0x01;
158	if (ob->map->tile_path[1]) flags \|= 2;	170	if (ob->map->tile_path [TILE_EAST ]) flags \|= 0x02;
159	if (ob->map->tile_path[2]) flags \|= 4;	171	if (ob->map->tile_path [TILE_SOUTH]) flags \|= 0x04;
160	if (ob->map->tile_path[3]) flags \|= 8;	172	if (ob->map->tile_path [TILE_WEST ]) flags \|= 0x08;
		173	// these two are debatable
		174	if (ob->map->tile_path [TILE_UP ]) flags \|= 0x10;
		175	if (ob->map->tile_path [TILE_DOWN ]) flags \|= 0x20;
161		176
162	socket.send_packet_printf ("mapinfo - spatial %d %d %d %d %d %s",	177	socket.send_packet_printf ("mapinfo - spatial %d %d %d %d %d %s",
163	flags, socket.mapx / 2 - ob->x, socket.mapy / 2 - ob->y,	178	flags, socket.mapx / 2 - ob->x, socket.mapy / 2 - ob->y,
164	ob->map->width, ob->map->height, &ob->map->path);	179	ob->map->width, ob->map->height, &ob->map->path);
165	}	180	}
…		…
180	{	195	{
181	INVOKE_PLAYER (REGION_CHANGE, pl, ARG_REGION (reg), ARG_REGION (socket.current_region));	196	INVOKE_PLAYER (REGION_CHANGE, pl, ARG_REGION (reg), ARG_REGION (socket.current_region));
182	socket.current_region = reg;	197	socket.current_region = reg;
183	}	198	}
184		199
185	// first try to aovid a full newmap on tiled map scrolls	200	// first try to avoid a full newmap on tiled map scrolls
186	if (socket.current_map != ob->map && !socket.force_newmap)	201	if (socket.current_map != ob->map && !socket.force_newmap)
187	{	202	{
188	rv_vector rv;	203	rv_vector rv;
189		204
190	get_rangevector_from_mapcoord (socket.current_map, socket.current_x, socket.current_y, ob, &rv, 0);	205	get_rangevector_from_mapcoord (socket.current_map, socket.current_x, socket.current_y, ob, &rv, 0);
…		…
220	socket.current_x = ob->x;	235	socket.current_x = ob->x;
221	socket.current_y = ob->y;	236	socket.current_y = ob->y;
222	}	237	}
223		238
224	/**	239	/**
		240	* This sends the skill number to name mapping. We ignore
		241	* the params - we always send the same info no matter what.
		242	*/
		243	static void
		244	send_skill_info (client ns, char params)
		245	{
		246	packet sl;
		247	sl << "replyinfo skill_info\n";
		248
		249	for (int i = 0; i < skillvec.size (); ++i)
		250	sl.printf ("%d:%s\n", CS_STAT_SKILLINFO + i, &skillvec [i]->name);
		251
		252	if (sl.length () > MAXSOCKBUF)
		253	cleanup ("buffer overflow in send_skill_info!");
		254
		255	ns->send_packet (sl);
		256	}
		257
		258	/**
		259	* This sends the spell path to name mapping. We ignore
		260	* the params - we always send the same info no matter what.
		261	*/
		262	static void
		263	send_spell_paths (client * ns, char *params)
		264	{
		265	packet sl;
		266
		267	sl << "replyinfo spell_paths\n";
		268
		269	for (int i = 0; i < NRSPELLPATHS; i++)
		270	sl.printf ("%d:%s\n", 1 << i, spellpathnames[i]);
		271
		272	if (sl.length () > MAXSOCKBUF)
		273	cleanup ("buffer overflow in send_spell_paths!");
		274
		275	ns->send_packet (sl);
		276	}
		277
		278	/**
225	* RequestInfo is sort of a meta command. There is some specific	279	* RequestInfo is sort of a meta command. There is some specific
226	* request of information, but we call other functions to provide	280	* request of information, but we call other functions to provide
227	* that information.	281	* that information.
		282	* requestinfo is completely deprecated, use resource exti request
		283	* and the fxix or http protocols.
228	*/	284	*/
229	void	285	void
230	RequestInfo (char buf, int len, client ns)	286	RequestInfo (char buf, int len, client ns)
231	{	287	{
232	char *params;	288	char *params;
…		…
270	//-GPL	326	//-GPL
271		327
272	void	328	void
273	client::mapinfo_queue_clear ()	329	client::mapinfo_queue_clear ()
274	{	330	{
275	for (auto (i, mapinfo_queue.begin ()); i != mapinfo_queue.end (); ++i)	331	for (auto &&i : mapinfo_queue)
276	free (*i);	332	free (i);
277		333
278	mapinfo_queue.clear ();	334	mapinfo_queue.clear ();
279	}	335	}
280		336
281	bool	337	bool
…		…
292		348
293	while (*buf && map && max_distance)	349	while (*buf && map && max_distance)
294	{	350	{
295	int dir = *buf++ - '1';	351	int dir = *buf++ - '1';
296		352
297	if (dir >= 0 && dir <= 3)	353	// due to historical glitches, the mapinfo index and tile index differs
		354	static unsigned char dirmap [] = { TILE_NORTH, TILE_EAST, TILE_SOUTH, TILE_WEST, TILE_UP, TILE_DOWN };
		355
		356	// maybe we should only allow the four flat directions
		357	if (IN_RANGE_EXC (dir, 0, array_length (dirmap)))
298	{	358	{
		359	dir = dirmap [dir];
		360
299	if (!map->tile_path [dir])	361	if (!map->tile_path [dir])
300	map = 0;	362	map = 0;
301	else if (map->tile_available (dir, false))	363	else if (map->tile_available (dir, false))
302	{	364	{
303	maptile *neigh = map->tile_map [dir];	365	maptile *neigh = map->tile_map [dir];
…		…
326	send_packet_printf ("mapinfo %s nomap", token);	388	send_packet_printf ("mapinfo %s nomap", token);
327	else	389	else
328	{	390	{
329	int flags = 0;	391	int flags = 0;
330		392
		393	// due to historical glitches, the bit ordering and map index ordering differs
331	if (map->tile_path[0]) flags \|= 1;	394	if (map->tile_path [TILE_NORTH]) flags \|= 0x01;
332	if (map->tile_path[1]) flags \|= 2;	395	if (map->tile_path [TILE_EAST ]) flags \|= 0x02;
333	if (map->tile_path[2]) flags \|= 4;	396	if (map->tile_path [TILE_SOUTH]) flags \|= 0x04;
334	if (map->tile_path[3]) flags \|= 8;	397	if (map->tile_path [TILE_WEST ]) flags \|= 0x08;
		398	// these two are debatable
		399	if (map->tile_path [TILE_UP ]) flags \|= 0x10;
		400	if (map->tile_path [TILE_DOWN ]) flags \|= 0x20;
335		401
336	send_packet_printf ("mapinfo %s spatial %d %d %d %d %d %s", token, flags, mapx, mapy, map->width, map->height, &map->path);	402	send_packet_printf ("mapinfo %s spatial %d %d %d %d %d %s", token, flags, mapx, mapy, map->width, map->height, &map->path);
337	}	403	}
338		404
339	return 1;	405	return 1;
…		…
402	INVOKE_CLIENT (ADDME, ns, ARG_DATA (buf, len));	468	INVOKE_CLIENT (ADDME, ns, ARG_DATA (buf, len));
403	}	469	}
404		470
405	//+GPL	471	//+GPL
406		472
407	/*
408	#define MSG_TYPE_BOOK 1
409	#define MSG_TYPE_CARD 2
410	#define MSG_TYPE_PAPER 3
411	#define MSG_TYPE_SIGN 4
412	#define MSG_TYPE_MONUMENT 5
413	#define MSG_TYPE_SCRIPTED_DIALOG 6*/
414
415	/** Reply to ExtendedInfos command */
416	void
417	ToggleExtendedText (char buf, int len, client ns)
418	{
419	char cmdback[MAX_BUF];
420	char temp[10];
421	char command[50];
422	int info, nextinfo, i, flag;
423
424	cmdback[0] = '\0';
425
426	nextinfo = 0;
427	while (1)
428	{
429	/* 1. Extract an info */
430	info = nextinfo;
431
432	while ((info < len) && (buf [info] == ' '))
433	info++;
434
435	if (info >= len)
436	break;
437
438	nextinfo = info + 1;
439
440	while ((nextinfo < len) && (buf [nextinfo] != ' '))
441	nextinfo++;
442
443	if (nextinfo - info >= 49) /Erroneous info asked /
444	continue;
445
446	memcpy (command, buf + info, nextinfo - info);
447	command [nextinfo - info] = 0;
448
449	/* 2. Interpret info */
450	i = sscanf (command, "%d", &flag);
451
452	if ((i == 1) && (flag > 0) && (flag <= MSG_TYPE_LAST))
453	ns->supported_readables \|= (1 << flag);
454	/3. Next info /
455	}
456
457	/* Send resulting state */
458	strcpy (cmdback, "ExtendedTextSet");
459
460	for (i = 0; i <= MSG_TYPE_LAST; i++)
461	if (ns->supported_readables & (1 << i))
462	{
463	strcat (cmdback, " ");
464	snprintf (temp, sizeof (temp), "%d", i);
465	strcat (cmdback, temp);
466	}
467
468	ns->send_packet (cmdback);
469	}
470
471	/**	473	/**
472	* This handles the general commands from the client (ie, north, fire, cast,	474	* This handles the general commands from the client (ie, north, fire, cast,
473	* etc.)	475	* etc.)
474	*/	476	*/
475	void	477	void
…		…
495	* Cleaning up the input should probably be done first - all actions	497	* Cleaning up the input should probably be done first - all actions
496	* for the command that issued the count should be done before any other	498	* for the command that issued the count should be done before any other
497	* commands.	499	* commands.
498	*/	500	*/
499	pl->count = 0;	501	pl->count = 0;
500	}
501
502	/**
503	* This handles the general commands from the client (ie, north, fire, cast,
504	* etc.). It is a lot like PlayerCmd above, but is called with the
505	* 'ncom' method which gives more information back to the client so it
506	* can throttle.
507	*/
508	void
509	NewPlayerCmd (char buf, int len, player pl)
510	{
511	if (len <= 6)
512	{
513	LOG (llevDebug, "%s: corrupt ncom command <%s>: not long enough (%d) - discarding\n", pl->ns->host, buf, len);
514	return;
515	}
516
517	uint16 cmdid = net_uint16 ((uint8 *)buf);
518	sint32 repeat = net_sint32 ((uint8 *)buf + 2);
519
520	/* -1 is special - no repeat, but don't update */
521	if (repeat != -1)
522	pl->count = repeat;
523
524	buf += 6; //len -= 6;
525
526	execute_newserver_command (pl->ob, buf);
527
528	/* Perhaps something better should be done with a left over count.
529	* Cleaning up the input should probably be done first - all actions
530	* for the command that issued the count should be done before any other
531	* commands.
532	*/
533	pl->count = 0;
534
535	//TODO: schmorp thinks whatever this calculates, it makes no sense at all
536	int time = fabs (pl->ob->speed) < 0.001
537	? time = MAX_TIME * 100
538	: time = (int) (MAX_TIME / fabs (pl->ob->speed));
539
540	/* Send confirmation of command execution now */
541	packet sl ("comc");
542	sl << uint16 (cmdid) << uint32 (time);
543	pl->ns->send_packet (sl);
544	}	502	}
545		503
546	/** This is a reply to a previous query. */	504	/** This is a reply to a previous query. */
547	void	505	void
548	ReplyCmd (char buf, int len, client ns)	506	ReplyCmd (char buf, int len, client ns)
…		…
585	LOG (llevError, "Unknown input state: %d\n", ns->state);	543	LOG (llevError, "Unknown input state: %d\n", ns->state);
586	}	544	}
587	}	545	}
588		546
589	/**	547	/**
590	* Client tells its version. If there is a mismatch, we close the	548	* Client tells its version info.
591	* socket. In real life, all we should care about is the client having
592	* something older than the server. If we assume the client will be
593	* backwards compatible, having it be a later version should not be a
594	* problem.
595	*/	549	*/
596	void	550	void
597	VersionCmd (char buf, int len, client ns)	551	VersionCmd (char buf, int len, client ns)
598	{	552	{
599	if (!buf)	553	INVOKE_CLIENT (VERSION, ns, ARG_DATA (buf, len));
600	{
601	LOG (llevError, "CS: received corrupted version command\n");
602	return;
603	}
604
605	ns->cs_version = atoi (buf);
606	ns->sc_version = ns->cs_version;
607
608	LOG (llevDebug, "connection from client <%s>\n", buf);
609
610	//TODO: should log here just for statistics
611
612	//if (VERSION_CS != ns->cs_version)
613	// unchecked;
614
615	char *cp = strchr (buf + 1, ' ');
616	if (!cp)
617	return;
618
619	ns->sc_version = atoi (cp);
620
621	//if (VERSION_SC != ns->sc_version)
622	// unchecked;
623
624	cp = strchr (cp + 1, ' ');
625
626	if (cp)
627	{
628	ns->version = cp + 1;
629
630	if (ns->sc_version < 1026)
631	ns->send_packet_printf ("drawinfo %d %s", NDI_RED,
632	"** VERSION WARNING \n CLIENT IS TOO OLD!! UPDATE THE CLIENT!! **");
633	}
634	}	554	}
635		555
636	/** sound related functions. */	556	/** sound related functions. */
637	void	557	void
638	SetSound (char buf, int len, client ns)	558	SetSound (char buf, int len, client ns)
…		…
691	static void	611	static void
692	rangetostring (player pl, char obuf)	612	rangetostring (player pl, char obuf)
693	{	613	{
694	dynbuf_text &buf = msg_dynbuf; buf.clear ();	614	dynbuf_text &buf = msg_dynbuf; buf.clear ();
695		615
		616	#if 0
		617	// print ranged/chosen_skill etc. objects every call
		618	printf ("%s %s => %s (%s)\n",
		619	pl->ranged_ob ? &pl->ranged_ob->name : "-",
		620	pl->combat_ob ? &pl->combat_ob->name : "-",
		621	pl->ob->current_weapon ? &pl->ob->current_weapon->name : "-",
		622	pl->ob->chosen_skill ? &pl->ob->chosen_skill->name : "-"
		623	);
		624	#endif
		625
696	if (pl->ranged_ob)	626	if (pl->ranged_ob)
697	buf << " Range" << (pl->ob->current_weapon == pl->ranged_ob ? "*" : "") << ": " << pl->ranged_ob->name;	627	buf << " Range" << (pl->ob->current_weapon == pl->ranged_ob ? "*" : "") << ": " << pl->ranged_ob->name;
698		628
699	if (pl->combat_ob)	629	if (pl->combat_ob)
700	buf << " Combat" << (pl->ob->current_weapon == pl->combat_ob ? "*" : "") << ": " << pl->combat_ob->name;	630	buf << " Combat" << (pl->ob->current_weapon == pl->combat_ob ? "*" : "") << ": " << pl->combat_ob->name;
…		…
745	* commands for now.	675	* commands for now.
746	*/	676	*/
747	void	677	void
748	esrv_update_stats (player *pl)	678	esrv_update_stats (player *pl)
749	{	679	{
750	char buf[MAX_BUF];
751	uint16 flags;
752
753	client *ns = pl->ns;	680	client *ns = pl->ns;
754	if (!ns)	681	if (!ns)
755	return;	682	return;
756		683
757	object *ob = pl->observe;	684	object *ob = pl->observe;
…		…
774	AddIfShort (ns->last_stats.Int, ob->stats.Int, CS_STAT_INT);	701	AddIfShort (ns->last_stats.Int, ob->stats.Int, CS_STAT_INT);
775	AddIfShort (ns->last_stats.Wis, ob->stats.Wis, CS_STAT_WIS);	702	AddIfShort (ns->last_stats.Wis, ob->stats.Wis, CS_STAT_WIS);
776	AddIfShort (ns->last_stats.Pow, ob->stats.Pow, CS_STAT_POW);	703	AddIfShort (ns->last_stats.Pow, ob->stats.Pow, CS_STAT_POW);
777	AddIfShort (ns->last_stats.Cha, ob->stats.Cha, CS_STAT_CHA);	704	AddIfShort (ns->last_stats.Cha, ob->stats.Cha, CS_STAT_CHA);
778		705
779	for (int s = 0; s < NUM_SKILLS; s++)	706	for (int s = 0; s < CS_NUM_SKILLS; s++)
780	if (object *skill = opl->last_skill_ob [s])	707	if (object *skill = opl->last_skill_ob [s])
781	if (skill->stats.exp != ns->last_skill_exp [s])	708	if (skill->stats.exp != ns->last_skill_exp [s])
782	{	709	{
783	ns->last_skill_exp [s] = skill->stats.exp;	710	ns->last_skill_exp [s] = skill->stats.exp;
784		711
785	/* Always send along the level if exp changes. This is only	712	/* Always send along the level if exp changes. This is only
786	* 1 extra byte, but keeps processing simpler.	713	* 1 extra byte, but keeps processing simpler.
787	*/	714	*/
788	sl << uint8 (s + CS_STAT_SKILLINFO)	715	sl << uint8 (CS_STAT_SKILLINFO + s)
789	<< uint8 (skill->level)	716	<< uint8 (skill->level)
790	<< uint64 (skill->stats.exp);	717	<< uint64 (skill->stats.exp);
791	}	718	}
792		719
793	AddIfInt64 (ns->last_stats.exp, ob->stats.exp, CS_STAT_EXP64);	720	AddIfInt64 (ns->last_stats.exp, ob->stats.exp, CS_STAT_EXP64);
794	AddIfShort (ns->last_level, ob->level, CS_STAT_LEVEL);	721	AddIfShort (ns->last_level, ob->level, CS_STAT_LEVEL);
795	AddIfShort (ns->last_stats.wc, ob->stats.wc, CS_STAT_WC);	722	AddIfShort (ns->last_stats.wc, ob->stats.wc, CS_STAT_WC);
796	AddIfShort (ns->last_stats.ac, ob->stats.ac, CS_STAT_AC);	723	AddIfShort (ns->last_stats.ac, ob->stats.ac, CS_STAT_AC);
797	AddIfShort (ns->last_stats.dam, ob->stats.dam, CS_STAT_DAM);	724	AddIfShort (ns->last_stats.dam, ob->stats.dam, CS_STAT_DAM);
798	AddIfFloat (ns->last_speed, ob->speed, CS_STAT_SPEED, 1.f/TICK);	725	AddIfFloat (ns->last_speed, ob->speed, CS_STAT_SPEED, 1.f / TICK);
799	AddIfShort (ns->last_stats.food, ob->stats.food, CS_STAT_FOOD);	726	AddIfShort (ns->last_stats.food, ob->stats.food, CS_STAT_FOOD);
800	AddIfFloat (ns->last_weapon_sp, pl->weapon_sp, CS_STAT_WEAP_SP, 1.f/TICK);	727	AddIfFloat (ns->last_weapon_sp, pl->weapon_sp, CS_STAT_WEAP_SP, 1.f / TICK);
801	AddIfInt (ns->last_weight_limit, weight_limit[ob->stats.Str], CS_STAT_WEIGHT_LIM);	728	AddIfInt (ns->last_weight_limit, weight_limit[ob->stats.Str], CS_STAT_WEIGHT_LIM);
802		729
803	flags = 0;	730	int flags = (opl->fire_on ? SF_FIREON : 0)
804		731	\| (opl->run_on ? SF_RUNON : 0);
805	if (opl->fire_on)
806	flags \|= SF_FIREON;
807
808	if (opl->run_on)
809	flags \|= SF_RUNON;
810		732
811	AddIfShort (ns->last_flags, flags, CS_STAT_FLAGS);	733	AddIfShort (ns->last_flags, flags, CS_STAT_FLAGS);
812		734
813	if (ns->sc_version < 1025)
814	{ AddIfShort (ns->last_resist[ATNR_PHYSICAL], ob->resist[ATNR_PHYSICAL], CS_STAT_ARMOUR) }
815	else
816	for (int i = 0; i < NROFATTACKS; i++)	735	for (int i = 0; i < NROFATTACKS; i++)
817	{
818	/* Skip ones we won't send */	736	/* Skip ones we won't send */
819	if (atnr_cs_stat[i] == -1)	737	if (atnr_cs_stat[i] >= 0)
820	continue;
821
822	AddIfShort (ns->last_resist[i], ob->resist[i], atnr_cs_stat[i]);	738	AddIfShort (ns->last_resist[i], ob->resist[i], atnr_cs_stat[i]);
823	}
824		739
825	if (pl->ns->monitor_spells)	740	if (pl->ns->monitor_spells)
826	{	741	{
827	AddIfInt (ns->last_path_attuned, ob->path_attuned, CS_STAT_SPELL_ATTUNE);	742	AddIfInt (ns->last_path_attuned, ob->path_attuned, CS_STAT_SPELL_ATTUNE);
828	AddIfInt (ns->last_path_repelled, ob->path_repelled, CS_STAT_SPELL_REPEL);	743	AddIfInt (ns->last_path_repelled, ob->path_repelled, CS_STAT_SPELL_REPEL);
829	AddIfInt (ns->last_path_denied, ob->path_denied, CS_STAT_SPELL_DENY);	744	AddIfInt (ns->last_path_denied, ob->path_denied, CS_STAT_SPELL_DENY);
830	}	745	}
831		746
		747	char buf[MAX_BUF];
832	rangetostring (opl, buf); /* we want use the new fire & run system in new client */	748	rangetostring (opl, buf); /* we want use the new fire & run system in new client */
833	AddIfString (ns->stats.range, buf, CS_STAT_RANGE);	749	AddIfString (ns->stats.range, buf, CS_STAT_RANGE);
834	set_title (ob, buf);	750	set_title (ob, buf);
835	AddIfString (ns->stats.title, buf, CS_STAT_TITLE);	751	AddIfString (ns->stats.title, buf, CS_STAT_TITLE);
836		752
…		…
930		846
931	/* Nothing changed */	847	/* Nothing changed */
932	return 0;	848	return 0;
933	}	849	}
934		850
935	//-GPL
936
937	// prefetch (and touch) all maps within a specific distancd
938	static void
939	prefetch_surrounding_maps (maptile *map, int distance)
940	{
941	map->touch ();
942
943	if (--distance)
944	for (int dir = 4; --dir; )
945	if (const shstr &path = map->tile_path [dir])
946	if (maptile *&neigh = map->tile_map [dir])
947	prefetch_surrounding_maps (neigh, distance);
948	else
949	neigh = maptile::find_async (path, map);
950	}
951
952	// prefetch a generous area around the player
953	static void
954	prefetch_surrounding_maps (object *op)
955	{
956	prefetch_surrounding_maps (op->map, 3);
957	}
958
959	//+GPL
960
961	/**	851	/**
962	* Draws client map.	852	* Draws client map.
963	*/	853	*/
964	void	854	void
965	draw_client_map (player *pl)	855	draw_client_map (player *pl)
…		…
970		860
971	/* If player is just joining the game, he isn't here yet, so the map	861	/* If player is just joining the game, he isn't here yet, so the map
972	* can get swapped out. If so, don't try to send them a map. All will	862	* can get swapped out. If so, don't try to send them a map. All will
973	* be OK once they really log in.	863	* be OK once they really log in.
974	*/	864	*/
975	if (!ob->map \|\| ob->map->in_memory != MAP_ACTIVE)	865	if (!ob->map \|\| ob->map->state != MAP_ACTIVE)
976	return;	866	return;
977		867
978	int startlen, oldlen;	868	int startlen, oldlen;
979		869
980	check_map_change (pl);	870	check_map_change (pl);
981	prefetch_surrounding_maps (pl->ob);	871	pl->ob->prefetch_surrounding_maps ();
982		872
983	/* do LOS after calls to update_position */	873	/* do LOS after calls to update_position */
984	/* unfortunately, we need to udpate los when observing, currently */	874	/* unfortunately, we need to udpate los when observing, currently */
985	if (pl->do_los \|\| pl->viewpoint != pl->ob)	875	if (pl->do_los \|\| pl->viewpoint != pl->ob)
986	{	876	{
…		…
1011	* look like.	901	* look like.
1012	*/	902	*/
1013		903
1014	client &socket = *pl->ns;	904	client &socket = *pl->ns;
1015		905
1016	packet sl (socket.mapmode == Map1Cmd ? "map1" : "map1a");	906	packet sl ("map1a");
1017		907
1018	startlen = sl.length ();	908	startlen = sl.length ();
1019		909
1020	int hx = socket.mapx / 2;	910	int hx = socket.mapx / 2;
1021	int hy = socket.mapy / 2;	911	int hy = socket.mapy / 2;
…		…
1042	map_clearcell (&lastcell, -1);	932	map_clearcell (&lastcell, -1);
1043	}	933	}
1044		934
1045	continue;	935	continue;
1046	}	936	}
1047		937
1048	int d = pl->blocked_los_uc (dx, dy);	938	int d = pl->blocked_los_uc (dx, dy);
1049		939
1050	if (d > 3)	940	if (d > 3)
1051	{	941	{
1052	/* This block deals with spaces that are not visible for whatever	942	/* This block deals with spaces that are not visible for whatever
1053	* reason. Still may need to send the head for this space.	943	* reason. Still may need to send the head for this space.
1054	*/	944	*/
1055	if (lastcell.count != -1	945	if (lastcell.count != -1
1056	\|\| lastcell.faces[0]	946	\|\| lastcell.faces[0]
1057	\|\| lastcell.faces[1]	947	\|\| lastcell.faces[1]
1058	\|\| lastcell.faces[2]	948	\|\| lastcell.faces[2]
1059	\|\| lastcell.stat_hp	949	\|\| lastcell.stat_hp
1060	\|\| lastcell.flags	950	\|\| lastcell.flags
1061	\|\| lastcell.player)	951	\|\| lastcell.player)
1062	sl << uint16 (mask);	952	sl << uint16 (mask);
1063		953
1064	/* properly clear a previously sent big face */	954	/* properly clear a previously sent big face */
1065	map_clearcell (&lastcell, -1);	955	map_clearcell (&lastcell, -1);
…		…
1113	{	1003	{
1114	if (op->stats.maxhp > op->stats.hp	1004	if (op->stats.maxhp > op->stats.hp
1115	&& op->stats.maxhp > 0	1005	&& op->stats.maxhp > 0
1116	&& (op->type == PLAYER	1006	&& (op->type == PLAYER
1117	\|\| op->type == DOOR // does not work, have maxhp 0	1007	\|\| op->type == DOOR // does not work, have maxhp 0
1118	\|\| QUERY_FLAG (op, FLAG_MONSTER)	1008	\|\| op->flag [FLAG_MONSTER]
1119	\|\| QUERY_FLAG (op, FLAG_ALIVE)	1009	\|\| op->flag [FLAG_ALIVE]
1120	\|\| QUERY_FLAG (op, FLAG_GENERATOR)))	1010	\|\| op->flag [FLAG_GENERATOR]))
1121	{	1011	{
1122	stat_hp = 255 - (op->stats.hp * 255 + 254) / op->stats.maxhp;	1012	stat_hp = 255 - (op->stats.hp * 255 + 254) / op->stats.maxhp;
1123	stat_width = op->arch->max_x - op->arch->x; //TODO: should be upper-left edge	1013	stat_width = op->arch->max_x - op->arch->x; //TODO: should be upper-left edge
1124	}	1014	}
1125		1015
…		…
1221	socket.send_packet (sl);	1111	socket.send_packet (sl);
1222	socket.sent_scroll = 0;	1112	socket.sent_scroll = 0;
1223	}	1113	}
1224	}	1114	}
1225		1115
1226	/*****************************************************************************/
1227	/* GROS: The following one is used to allow a plugin to send a generic cmd to*/
1228	/* a player. Of course, the client need to know the command to be able to */
1229	/* manage it ! */
1230	/*****************************************************************************/
1231	void
1232	send_plugin_custom_message (object pl, char buf)
1233	{
1234	pl->contr->ns->send_packet (buf);
1235	}
1236
1237	/**
1238	* This sends the skill number to name mapping. We ignore
1239	* the params - we always send the same info no matter what.
1240	*/
1241	void
1242	send_skill_info (client ns, char params)
1243	{
1244	packet sl;
1245	sl << "replyinfo skill_info\n";
1246
1247	for (int i = 1; i < NUM_SKILLS; i++)
1248	sl.printf ("%d:%s\n", i + CS_STAT_SKILLINFO, &skill_names [i]);
1249
1250	if (sl.length () > MAXSOCKBUF)
1251	{
1252	LOG (llevError, "Buffer overflow in send_skill_info!\n");
1253	fatal (0);
1254	}
1255
1256	ns->send_packet (sl);
1257	}
1258
1259	/**
1260	* This sends the spell path to name mapping. We ignore
1261	* the params - we always send the same info no matter what.
1262	*/
1263	void
1264	send_spell_paths (client * ns, char *params)
1265	{
1266	packet sl;
1267
1268	sl << "replyinfo spell_paths\n";
1269
1270	for (int i = 0; i < NRSPELLPATHS; i++)
1271	sl.printf ("%d:%s\n", 1 << i, spellpathnames[i]);
1272
1273	if (sl.length () > MAXSOCKBUF)
1274	{
1275	LOG (llevError, "Buffer overflow in send_spell_paths!\n");
1276	fatal (0);
1277	}
1278
1279	ns->send_packet (sl);
1280	}
1281
1282	/**	1116	/**
1283	* This looks for any spells the player may have that have changed their stats.	1117	* This looks for any spells the player may have that have changed their stats.
1284	* it then sends an updspell packet for each spell that has changed in this way	1118	* it then sends an updspell packet for each spell that has changed in this way
1285	*/	1119	*/
1286	void	1120	void
1287	esrv_update_spells (player *pl)	1121	esrv_update_spells (player *pl)
1288	{	1122	{
1289	if (!pl->ns)	1123	if (!pl->ns)
1290	return;	1124	return;
1291		1125
		1126	pl->ns->update_spells = false;
		1127
1292	if (!pl->ns->monitor_spells)	1128	if (!pl->ns->monitor_spells)
1293	return;	1129	return;
1294		1130
1295	for (object *spell = pl->ob->inv; spell; spell = spell->below)	1131	for (object *spell = pl->ob->inv; spell; spell = spell->below)
1296	{
1297	if (spell->type == SPELL)	1132	if (spell->type == SPELL)
1298	{	1133	{
1299	int flags = 0;	1134	int flags = 0;
		1135	int val;
1300		1136
1301	/* check if we need to update it */	1137	/* check if we need to update it */
1302	if (spell->cached_sp != SP_level_spellpoint_cost (pl->ob, spell, SPELL_MANA))	1138	val = SP_level_spellpoint_cost (pl->ob, spell, SPELL_MANA);
		1139	if (spell->cached_sp != val)
1303	{	1140	{
1304	spell->cached_sp = SP_level_spellpoint_cost (pl->ob, spell, SPELL_MANA);	1141	spell->cached_sp = val;
1305	flags \|= UPD_SP_MANA;	1142	flags \|= UPD_SP_MANA;
1306	}	1143	}
1307		1144
1308	if (spell->cached_grace != SP_level_spellpoint_cost (pl->ob, spell, SPELL_GRACE))	1145	val = SP_level_spellpoint_cost (pl->ob, spell, SPELL_GRACE);
		1146	if (spell->cached_grace != val)
1309	{	1147	{
1310	spell->cached_grace = SP_level_spellpoint_cost (pl->ob, spell, SPELL_GRACE);	1148	spell->cached_grace = val;
1311	flags \|= UPD_SP_GRACE;	1149	flags \|= UPD_SP_GRACE;
1312	}	1150	}
1313		1151
1314	if (spell->cached_eat != spell->stats.dam + SP_level_dam_adjust (pl->ob, spell))	1152	val = casting_level (pl->ob, spell);
		1153	if (spell->cached_eat != val)
1315	{	1154	{
1316	spell->cached_eat = spell->stats.dam + SP_level_dam_adjust (pl->ob, spell);	1155	spell->cached_eat = val;
1317	flags \|= UPD_SP_DAMAGE;	1156	flags \|= UPD_SP_LEVEL;
1318	}	1157	}
1319		1158
1320	if (flags)	1159	if (flags)
1321	{	1160	{
1322	packet sl;	1161	packet sl;
1323		1162
1324	sl << "updspell "	1163	sl << "updspell "
1325	<< uint8 (flags)	1164	<< uint8 (flags)
1326	<< uint32 (spell->count);	1165	<< uint32 (spell->count);
1327		1166
1328	if (flags & UPD_SP_MANA ) sl << uint16 (spell->cached_sp);	1167	if (flags & UPD_SP_MANA ) sl << uint16 (spell->cached_sp);
1329	if (flags & UPD_SP_GRACE ) sl << uint16 (spell->cached_grace);	1168	if (flags & UPD_SP_GRACE) sl << uint16 (spell->cached_grace);
1330	if (flags & UPD_SP_DAMAGE) sl << uint16 (spell->cached_eat);	1169	if (flags & UPD_SP_LEVEL) sl << uint16 (spell->cached_eat);
1331		1170
1332	pl->ns->send_packet (sl);	1171	pl->ns->send_packet (sl);
1333	}	1172	}
1334	}	1173	}
1335	}
1336	}	1174	}
1337		1175
1338	void	1176	void
1339	esrv_remove_spell (player pl, object spell)	1177	esrv_remove_spell (player pl, object spell)
1340	{	1178	{
…		…
1356		1194
1357	/* appends the spell spell to the Socklist we will send the data to. /	1195	/* appends the spell spell to the Socklist we will send the data to. /
1358	static void	1196	static void
1359	append_spell (player pl, packet &sl, object spell)	1197	append_spell (player pl, packet &sl, object spell)
1360	{	1198	{
1361	int i, skill = 0;	1199	int skill = 0;
1362		1200
1363	if (!(spell->name))	1201	if (!(spell->name))
1364	{	1202	{
1365	LOG (llevError, "item number %d is a spell with no name.\n", spell->count);	1203	LOG (llevError, "item number %d is a spell with no name.\n", spell->count);
1366	return;	1204	return;
1367	}	1205	}
1368		1206
1369	/* store costs and damage in the object struct, to compare to later */	1207	/* store costs and damage in the object struct, to compare to later */
1370	spell->cached_sp = SP_level_spellpoint_cost (pl->ob, spell, SPELL_MANA);	1208	spell->cached_sp = SP_level_spellpoint_cost (pl->ob, spell, SPELL_MANA);
1371	spell->cached_grace = SP_level_spellpoint_cost (pl->ob, spell, SPELL_GRACE);	1209	spell->cached_grace = SP_level_spellpoint_cost (pl->ob, spell, SPELL_GRACE);
1372	spell->cached_eat = spell->stats.dam + SP_level_dam_adjust (pl->ob, spell);	1210	spell->cached_eat = casting_level (pl->ob, spell);
1373		1211
1374	/* figure out which skill it uses, if it uses one */	1212	/* figure out which skill it uses, if it uses one */
1375	if (spell->skill)	1213	if (spell->skill)
1376	if (object *tmp = pl->find_skill (spell->skill))	1214	if (object *tmp = pl->find_skill (spell->skill))
1377	skill = tmp->subtype + CS_STAT_SKILLINFO;	1215	skill = CS_STAT_SKILLINFO + SKILL_INDEX (tmp);
1378		1216
1379	// spells better have a face	1217	// spells better have a face
1380	if (!spell->face)	1218	if (!spell->face)
1381	{	1219	{
1382	LOG (llevError, "%s: spell has no face, but face is mandatory.\n", &spell->name);	1220	LOG (llevError, "%s: spell has no face, but face is mandatory.\n", &spell->name);
…		…
1393	<< uint16 (spell->cached_grace)	1231	<< uint16 (spell->cached_grace)
1394	<< uint16 (spell->cached_eat)	1232	<< uint16 (spell->cached_eat)
1395	<< uint8 (skill)	1233	<< uint8 (skill)
1396	<< uint32 (spell->path_attuned)	1234	<< uint32 (spell->path_attuned)
1397	<< uint32 (spell->face)	1235	<< uint32 (spell->face)
1398	<< data8 (spell->name)	1236	<< data8 (spell->name);
		1237
		1238	if (pl->ns->monitor_spells < 2)
1399	<< data16 (spell->msg);	1239	sl << data16 (spell->msg);
1400	}	1240	}
1401		1241
1402	/**	1242	/**
1403	* This tells the client to add the spell ob, if ob is NULL, then add	1243	* This tells the client to add the spell ob, if ob is NULL, then add
1404	* all spells in the player's inventory.	1244	* all spells in the player's inventory.
1405	*/	1245	*/
1406	void	1246	void
1407	esrv_add_spells (player pl, object spell)	1247	esrv_add_spells (player pl, object spell)
1408	{	1248	{
…		…
1419		1259
1420	if (!spell)	1260	if (!spell)
1421	{	1261	{
1422	for (spell = pl->ob->inv; spell; spell = spell->below)	1262	for (spell = pl->ob->inv; spell; spell = spell->below)
1423	{	1263	{
1424	/* were we to simply keep appending data here, we could exceed	1264	/* were we to simply keep appending data here, we could exceed
1425	* MAXSOCKBUF if the player has enough spells to add, we know that	1265	* MAXSOCKBUF if the player has enough spells to add, we know that
1426	* append_spells will always append 19 data bytes, plus 4 length	1266	* append_spells will always append 19 data bytes, plus 4 length
1427	* bytes and 3 strings (because that is the spec) so we need to	1267	* bytes and 3 strings (because that is the spec) so we need to
1428	* check that the length of those 3 strings, plus the 23 bytes,	1268	* check that the length of those 3 strings, plus the 23 bytes,
1429	* won't take us over the length limit for the socket, if it does,	1269	* won't take us over the length limit for the socket, if it does,
1430	* we need to send what we already have, and restart packet formation	1270	* we need to send what we already have, and restart packet formation
1431	*/	1271	*/
1432	if (spell->type != SPELL)	1272	if (spell->type != SPELL)
1433	continue;	1273	continue;
1434		1274
1435	/* Seeing crashes by overflowed buffers. Quick arithemetic seems	1275	/* Seeing crashes by overflowed buffers. Quick arithemetic seems
…		…
1456	}	1296	}
1457	else	1297	else
1458	append_spell (pl, sl, spell);	1298	append_spell (pl, sl, spell);
1459		1299
1460	if (sl.length () > MAXSOCKBUF)	1300	if (sl.length () > MAXSOCKBUF)
1461	{
1462	LOG (llevError, "Buffer overflow in esrv_add_spells!\n");	1301	cleanup ("buffer overflow in esrv_add_spells!");
1463	fatal (0);
1464	}
1465		1302
1466	/* finally, we can send the packet */	1303	/* finally, we can send the packet */
1467	pl->ns->flush_fx ();	1304	pl->ns->flush_fx ();
1468	pl->ns->send_packet (sl);	1305	pl->ns->send_packet (sl);
1469	}	1306	}

Diff Legend

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

Comparing deliantra/server/socket/request.C (file contents): Revision 1.156 by root, Fri Nov 6 12:49:19 2009 UTC vs. Revision 1.196 by root, Sun Nov 18 00:37:11 2018 UTC

Diff Legend

Comparing deliantra/server/socket/request.C (file contents):
Revision 1.156 by root, Fri Nov 6 12:49:19 2009 UTC vs.
Revision 1.196 by root, Sun Nov 18 00:37:11 2018 UTC