Xash3DArchive/engine/client/cl_parse.c

//=======================================================================
//			Copyright XashXT Group 2009 <20>
//	      cl_parse.c  -- parse a message received from the server
//=======================================================================

#include "common.h"
#include "client.h"
#include "net_sound.h"

#define NET_TIMINGS		256
#define NET_TIMINGSMASK	(NET_TIMINGS - 1)

char *svc_strings[256] =
{
	"svc_bad",
// user messages space
	"svc_nop",
	"svc_disconnect",
	"svc_reconnect",
	"svc_stufftext",
	"svc_serverdata",
	"svc_configstring",
	"svc_spawnbaseline",
	"svc_download",
	"svc_playerinfo",
	"svc_physinfo",
	"svc_packetentities",
	"svc_frame",
	"svc_sound",
	"svc_setangle",
	"svc_setview",
	"svc_print",
	"svc_centerprint",
	"svc_crosshairangle",
	"svc_setpause",
	"svc_movevars",
	"svc_particle",
	"svc_soundfade",
	"svc_bspdecal",
	"svc_event",
	"svc_event_reliable"
};

int	packet_latency[NET_TIMINGS];
int	packet_loss;

int CL_CalcNet( void )
{
	int	a, i;
	frame_t	*frame;
	int	lost = 0;

	for( i = cls.netchan.outgoing_sequence - UPDATE_BACKUP + 1; i <= cls.netchan.outgoing_sequence; i++ )
	{
		frame = &cl.frames[i & UPDATE_MASK];

		if( frame->recvtime == -1 )
			packet_latency[i & NET_TIMINGSMASK] = 9999;	// dropped
		else if( frame->recvtime == -2 )
			packet_latency[i & NET_TIMINGSMASK] = 10000;	// choked
		else if( !frame->valid )
			packet_latency[i&NET_TIMINGSMASK] = 9998;	// invalid delta
		else packet_latency[i & NET_TIMINGSMASK] = (frame->recvtime - frame->senttime) * 20;
	}

	for( a = 0; a < NET_TIMINGS; a++ )
	{
		i = (cls.netchan.outgoing_sequence - a) & NET_TIMINGSMASK;
		if( packet_latency[i] == 9999 ) lost++;
	}

	packet_loss = lost * 100 / NET_TIMINGS;

	return packet_loss;
}

/*
===============
CL_CheckOrDownloadFile

Returns true if the file exists, otherwise it attempts
to start a download from the server.
===============
*/
bool CL_CheckOrDownloadFile( const char *filename )
{
	string	name;
	file_t	*f;

	if( FS_FileExists( filename ))
	{
		// it exists, no need to download
		return true;
	}

	com.strncpy( cls.downloadname, filename, MAX_STRING );
	com.strncpy( cls.downloadtempname, filename, MAX_STRING );

	// download to a temp name, and only rename to the real name when done,
	// so if interrupted a runt file won't be left
	FS_StripExtension( cls.downloadtempname );
	FS_DefaultExtension( cls.downloadtempname, ".tmp" );
	com.strncpy( name, cls.downloadtempname, MAX_STRING );

	f = FS_Open( name, "a+b" );
	if( f )
	{
		// it exists
		size_t	len = FS_Tell( f );

		cls.download = f;
		// give the server an offset to start the download
		MsgDev( D_INFO, "Resume download %s at %i\n", cls.downloadname, len );
		MSG_WriteByte( &cls.netchan.message, clc_stringcmd );
		MSG_Print( &cls.netchan.message, va("download %s %i", cls.downloadname, len ));
	}
	else
	{
		MsgDev( D_INFO, "Start download %s\n", cls.downloadname );
		MSG_WriteByte( &cls.netchan.message, clc_stringcmd );
		MSG_Print( &cls.netchan.message, va("download %s", cls.downloadname ));
	}

	cls.downloadnumber++;
	return false;
}

/*
=====================
CL_ParseDownload

A download message has been received from the server
=====================
*/
void CL_ParseDownload( sizebuf_t *msg )
{
	int		size, percent;
	string		name;
	int		r;

	// read the data
	size = MSG_ReadShort( msg );
	percent = MSG_ReadByte( msg );

	if( size == -1 )
	{
		Msg( "Server does not have this file.\n" );
		if( cls.download )
		{
			// if here, we tried to resume a file but the server said no
			FS_Close( cls.download );
			cls.download = NULL;
		}
		CL_RequestNextDownload();
		return;
	}

	// open the file if not opened yet
	if( !cls.download )
	{
		com.strncpy( name, cls.downloadtempname, MAX_STRING );
		cls.download = FS_Open ( name, "wb" );

		if( !cls.download )
		{
			msg->readcount += size;
			Msg( "Failed to open %s\n", cls.downloadtempname );
			CL_RequestNextDownload();
			return;
		}
	}

	FS_Write( cls.download, msg->data + msg->readcount, size );
	msg->readcount += size;

	if( percent != 100 )
	{
		// request next block
		Cvar_SetValue("scr_download", percent );
		MSG_WriteByte( &cls.netchan.message, clc_stringcmd );
		MSG_Print( &cls.netchan.message, "nextdl" );
	}
	else
	{
		string	oldn, newn;

		FS_Close( cls.download );

		// rename the temp file to it's final name
		com.strncpy( oldn, cls.downloadtempname, MAX_STRING );
		com.strncpy( newn, cls.downloadname, MAX_STRING );
		r = rename( oldn, newn );
		if( r ) MsgDev( D_ERROR, "failed to rename.\n" );

		cls.download = NULL;
		Cvar_SetValue( "scr_download", 0.0f );

		// get another file if needed
		CL_RequestNextDownload();
	}
}

void CL_RunBackgroundTrack( void )
{
	string	intro, main, track;

	// run background track
	com.strncpy( track, cl.configstrings[CS_BACKGROUND_TRACK], MAX_STRING );
	com.snprintf( intro, MAX_STRING, "%s_intro", cl.configstrings[CS_BACKGROUND_TRACK] );
	com.snprintf( main, MAX_STRING, "%s_main", cl.configstrings[CS_BACKGROUND_TRACK] );

	if( FS_FileExists( va( "media/%s.ogg", intro )) && FS_FileExists( va( "media/%s.ogg", main )))
	{
		// combined track with introduction and main loop theme
		S_StartBackgroundTrack( intro, main );
	}
	else if( FS_FileExists( va( "media/%s.ogg", track )))
	{
		// single looped theme
		S_StartBackgroundTrack( track, track );
	}
	else if( !com.strcmp( track, "" ))
	{
		// blank name stopped last track
		S_StopBackgroundTrack();
	}
}

/*
==================
CL_ParseSoundPacket

==================
*/
void CL_ParseSoundPacket( sizebuf_t *msg )
{
	vec3_t	pos_;
	float	*pos = NULL;
	int 	channel, sound_num;
	float 	volume, attenuation;  
	int	flags, pitch, entnum;

	flags = MSG_ReadWord( msg );
	sound_num = MSG_ReadWord( msg );
	channel = MSG_ReadByte( msg );

	if( flags & SND_VOLUME )
		volume = MSG_ReadByte( msg ) / 255.0f;
	else volume = VOL_NORM;
	if( flags & SND_SOUNDLEVEL )
	{
		int soundlevel = MSG_ReadByte( msg );
		attenuation = SNDLVL_TO_ATTN( soundlevel );
	}
	else attenuation = ATTN_NONE;	
	if( flags & SND_PITCH )
		pitch = MSG_ReadByte( msg );
	else pitch = PITCH_NORM;

	// entity reletive
	entnum = MSG_ReadWord( msg ); 

	// positioned in space
	if( flags & SND_FIXED_ORIGIN )
	{
		pos = pos_;
		MSG_ReadPos( msg, pos );
	}
	S_StartSound( pos, entnum, channel, cl.sound_precache[sound_num], volume, attenuation, pitch, flags );
}

/*
==================
CL_ParseMovevars

==================
*/
void CL_ParseMovevars( sizebuf_t *msg )
{
	MSG_ReadDeltaMovevars( msg, &clgame.oldmovevars, &clgame.movevars );
	Mem_Copy( &clgame.oldmovevars, &clgame.movevars, sizeof( movevars_t ));
}

/*
==================
CL_ParseParticles

==================
*/
void CL_ParseParticles( sizebuf_t *msg )
{
	vec3_t		org, dir;
	int		i, count, color;
	
	MSG_ReadPos( msg, org );	

	for( i = 0; i < 3; i++ )
		dir[i] = MSG_ReadChar( msg ) * (1.0f / 16);

	count = MSG_ReadByte( msg );
	color = MSG_ReadByte( msg );

	CL_ParticleEffect( org, dir, color, count );
}

/*
==================
CL_ParseStaticDecal

==================
*/
void CL_ParseStaticDecal( sizebuf_t *msg )
{
	vec3_t	origin;
	int	decalIndex, entityIndex, modelIndex;

	MSG_ReadPos( msg, origin );
	decalIndex = MSG_ReadWord( msg );
	entityIndex = MSG_ReadShort( msg );

	if( entityIndex > 0 )
		modelIndex = MSG_ReadWord( msg );

	CL_SpawnStaticDecal( origin, decalIndex, entityIndex, modelIndex );
}

void CL_ParseSoundFade( sizebuf_t *msg )
{
	float	fadePercent, fadeOutSeconds;
	float	holdTime, fadeInSeconds;

	fadePercent = MSG_ReadFloat( msg );
	fadeOutSeconds = MSG_ReadFloat( msg );
	holdTime = MSG_ReadFloat( msg );
	fadeInSeconds = MSG_ReadFloat( msg );

	S_FadeClientVolume( fadePercent, fadeOutSeconds, holdTime, fadeInSeconds );
}

void CL_ParseReliableEvent( sizebuf_t *msg, int flags )
{
	int		event_index;
	event_args_t	nullargs, args;
	float		delay;

	Mem_Set( &nullargs, 0, sizeof( nullargs ));
	event_index = MSG_ReadWord( msg );		// read event index
	delay = MSG_ReadWord( msg ) / 100.0f;		// read event delay
	MSG_ReadDeltaEvent( msg, &nullargs, &args );	// FIXME: zero-compressing

	CL_QueueEvent( flags, event_index, delay, &args );
}

void CL_ParseEvent( sizebuf_t *msg )
{
	int	i, num_events;

	num_events = MSG_ReadByte( msg );

	// parse events queue
	for( i = 0 ; i < num_events; i++ )
		CL_ParseReliableEvent( msg, 0 );
}

/*
=====================================================================

  SERVER CONNECTING MESSAGES

=====================================================================
*/
/*
==================
CL_ParseServerData
==================
*/
void CL_ParseServerData( sizebuf_t *msg )
{
	string		str;
	const char	*levelshot_ext[] = { "tga", "jpg", "png" };
	int		i;

	MsgDev( D_NOTE, "Serverdata packet received.\n" );

	// wipe the client_t struct
	CL_ClearState();
	cls.state = ca_connected;

	// parse protocol version number
	i = MSG_ReadLong( msg );
	cls.serverProtocol = i;

	if( i != PROTOCOL_VERSION )
		Host_Error( "Server use invalid protocol (%i should be %i)\n", i, PROTOCOL_VERSION );

	cl.servercount = MSG_ReadLong( msg );
	cl.playernum = MSG_ReadByte( msg );
	clgame.globals->maxClients = MSG_ReadByte( msg );
	clgame.globals->maxEntities = MSG_ReadWord( msg );
	com.strncpy( str, MSG_ReadString( msg ), MAX_STRING );
	com.strncpy( clgame.maptitle, MSG_ReadString( msg ), MAX_STRING );

	CL_InitEdicts (); // re-arrange edicts

	// get splash name
	Cvar_Set( "cl_levelshot_name", va( "levelshots/%s", str ));
	Cvar_SetValue( "scr_loading", 0.0f ); // reset progress bar

	for( i = 0; i < 3; i++ )
		if( FS_FileExists( va( "%s.%s", cl_levelshot_name->string, levelshot_ext[i] ))) 
			break;
	if( i == 3 )
	{
		Cvar_Set( "cl_levelshot_name", MAP_DEFAULT_SHADER );	// render a black screen
		cls.scrshot_request = scrshot_plaque;			// make levelshot
	}
	// seperate the printfs so the server message can have a color
	Msg("\35\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\37\n");
	Msg( "^2%s\n", clgame.maptitle );

	// need to prep refresh at next oportunity
	cl.video_prepped = false;
	cl.audio_prepped = false;

	// initialize world and clients
	CL_InitWorld ();
}

/*
==================
CL_ParseBaseline
==================
*/
void CL_ParseBaseline( sizebuf_t *msg )
{
	int		newnum;
	entity_state_t	nullstate;
	entity_state_t	*baseline;
	edict_t		*ent;

	Mem_Set( &nullstate, 0, sizeof( nullstate ));
	newnum = MSG_ReadWord( msg );

	if( newnum < 0 ) Host_Error( "CL_SpawnEdict: invalid number %i\n", newnum );
	if( newnum > clgame.globals->maxEntities ) Host_Error( "CL_AllocEdict: no free edicts\n" );

	// increase edicts
	while( newnum >= clgame.globals->numEntities )
		clgame.globals->numEntities++;

	ent = EDICT_NUM( newnum );
	if( ent->free ) CL_InitEdict( ent ); // initialize edict

	baseline = &clgame.baselines[newnum];
	MSG_ReadDeltaEntity( msg, &nullstate, baseline, newnum );
	CL_LinkEdict( ent, false ); // first entering, link always
}

/*
================
CL_ParseConfigString
================
*/
void CL_ParseConfigString( sizebuf_t *msg )
{
	int	i;

	i = MSG_ReadShort( msg );
	if( i < 0 || i >= MAX_CONFIGSTRINGS )
		Host_Error( "configstring > MAX_CONFIGSTRINGS\n" );
	com.strcpy( cl.configstrings[i], MSG_ReadString( msg ));
		
	// do something apropriate 
	if( i == CS_SKYNAME && cl.video_prepped )
	{
		re->RegisterShader( cl.configstrings[CS_SKYNAME], SHADER_SKY );
	}
	else if( i == CS_SERVERFLAGS )
	{
		// update shared serverflags
		clgame.globals->serverflags = com.atoi( cl.configstrings[CS_SERVERFLAGS] );
	}
	else if( i > CS_SERVERFLAGS && i < CS_MODELS )
	{
		Host_Error( "CL_ParseConfigString: reserved configstring #%i are used\n", i );
	}
	else if( i == CS_BACKGROUND_TRACK && cl.audio_prepped )
	{
		CL_RunBackgroundTrack();
	}
	else if( i >= CS_MODELS && i < CS_MODELS+MAX_MODELS && cl.video_prepped )
	{
		re->RegisterModel( cl.configstrings[i], i-CS_MODELS );
		CM_RegisterModel( cl.configstrings[i], i-CS_MODELS );
	}
	else if( i >= CS_SOUNDS && i < CS_SOUNDS+MAX_SOUNDS && cl.audio_prepped )
	{
		cl.sound_precache[i-CS_SOUNDS] = S_RegisterSound( cl.configstrings[i] );
	}
	else if( i >= CS_DECALS && i < CS_DECALS+MAX_DECALS && cl.video_prepped )
	{
		cl.decal_shaders[i-CS_DECALS] = re->RegisterShader( cl.configstrings[i], SHADER_GENERIC );
	}
	else if( i >= CS_USER_MESSAGES && i < CS_USER_MESSAGES+MAX_USER_MESSAGES )
	{
		CL_LinkUserMessage( cl.configstrings[i], i - CS_USER_MESSAGES );
	}
	else if( i >= CS_EVENTS && i < CS_EVENTS+MAX_EVENTS )
	{
		CL_SetEventIndex( cl.configstrings[i], i - CS_EVENTS );
	}
	else if( i >= CS_CLASSNAMES && i < CS_CLASSNAMES+MAX_CLASSNAMES )
	{
		// edicts classnames for search by classname on client
		cl.edict_classnames[i-CS_CLASSNAMES] = MAKE_STRING( cl.configstrings[i] );
	}
	else if( i >= CS_LIGHTSTYLES && i < CS_LIGHTSTYLES+MAX_LIGHTSTYLES )
	{
		CL_SetLightstyle( i - CS_LIGHTSTYLES );
	}
}

/*
================
CL_ParseSetAngle

set the view angle to this absolute value
================
*/
void CL_ParseSetAngle( sizebuf_t *msg )
{
	cl.refdef.cl_viewangles[0] = MSG_ReadAngle32( msg );
	cl.refdef.cl_viewangles[1] = MSG_ReadAngle32( msg );
	cl.refdef.cl_viewangles[2] = MSG_ReadAngle32( msg );
}

/*
================
CL_ParseCrosshairAngle

offset crosshair angles
================
*/
void CL_ParseCrosshairAngle( sizebuf_t *msg )
{
	cl.refdef.crosshairangle[0] = MSG_ReadAngle8( msg );
	cl.refdef.crosshairangle[1] = MSG_ReadAngle8( msg );
	cl.refdef.crosshairangle[2] = 0; // not used for screen space
}

/*
=====================================================================

ACTION MESSAGES

=====================================================================
*/
/*
=====================
CL_ParseServerMessage
=====================
*/
void CL_ParseServerMessage( sizebuf_t *msg )
{
	char	*s;
	int	i, cmd;

	// parse the message
	while( 1 )
	{
		if( msg->error )
		{
			Host_Error("CL_ParseServerMessage: Bad server message\n");
			return;
		}

		cmd = MSG_ReadByte( msg );
		if( cmd == -1 ) break;

//		if( cmd > 200 ) MsgDev( D_INFO, "CL_Parse: %s received.\n", svc_strings[cmd - 200] );
			
		// other commands
		switch( cmd )
		{
		case svc_nop:
			MsgDev( D_ERROR, "CL_ParseServerMessage: user message out of bounds\n" );
			break;
		case svc_disconnect:
			CL_Drop ();
			Host_AbortCurrentFrame();
			break;
		case svc_reconnect:
			Msg( "Server disconnected, reconnecting\n" );
			if( cls.download )
			{
				FS_Close( cls.download );
				cls.download = NULL;
			}
			cls.state = ca_connecting;
			cls.connect_time = MAX_HEARTBEAT; // CL_CheckForResend() will fire immediately
			break;
		case svc_stufftext:
			s = MSG_ReadString( msg );
			Cbuf_AddText( s );
			break;
		case svc_serverdata:
			Cbuf_Execute(); // make sure any stuffed commands are done
			CL_ParseServerData( msg );
			break;
		case svc_configstring:
			CL_ParseConfigString( msg );
			break;
		case svc_spawnbaseline:
			CL_ParseBaseline( msg );
			break;
		case svc_download:
			CL_ParseDownload( msg );
			break;
		case svc_sound:
			CL_ParseSoundPacket( msg );
			break;
		case svc_setangle:
			CL_ParseSetAngle( msg );
			break;
		case svc_setview:
			cl.refdef.viewentity = MSG_ReadWord( msg );
			break;
		case svc_crosshairangle:
			CL_ParseCrosshairAngle( msg );
			break;
		case svc_physinfo:
			com.strncpy( cl.physinfo, MSG_ReadString( msg ), sizeof( cl.physinfo ));
			break;
		case svc_print:
			i = MSG_ReadByte( msg );
			if( i == PRINT_CHAT ) // chat
				S_StartLocalSound( "misc/talk.wav", 1.0f, 100, NULL );
			Con_Print( va( "^6%s\n", MSG_ReadString( msg )));
			break;
		case svc_centerprint:
			CL_CenterPrint( MSG_ReadString( msg ), SCREEN_HEIGHT/2, BIGCHAR_WIDTH );
			break;
		case svc_setpause:
			cl.refdef.paused = (MSG_ReadByte( msg ) != 0 );
			break;
		case svc_movevars:
			CL_ParseMovevars( msg );
			break;
		case svc_particle:
			CL_ParseParticles( msg );
			break;
		case svc_bspdecal:
			CL_ParseStaticDecal( msg );
			break;
		case svc_soundfade:
			CL_ParseSoundFade( msg );
			break;
		case svc_event:
			CL_ParseEvent( msg );
			break;
		case svc_event_reliable:
			CL_ParseReliableEvent( msg, FEV_RELIABLE );
			break;
		case svc_frame:
			CL_ParseFrame( msg );
			break;
		case svc_playerinfo:
		case svc_packetentities:
			Host_Error( "CL_ParseServerMessage: out of place frame data\n" );
			break;
		case svc_bad:
			Host_Error( "CL_ParseServerMessage: svc_bad\n" );
			break;
		default:
			CL_ParseUserMessage( msg, cmd );
			break;
		}
	}
}