Xash3DArchive/engine/client/cl_parse.c

/*
Copyright (C) 1997-2001 Id Software, Inc.

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

*/
// cl_parse.c  -- parse a message received from the server

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

/*
===============
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
		int 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
		cls.downloadpercent = 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;
		cls.downloadpercent = 0;

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

/*
======================
CL_RegisterSounds
======================
*/
void CL_RegisterSounds( void )
{
	int	i;

	S_BeginRegistration();
	for( i = 1; i < MAX_SOUNDS; i++ )
	{
		if (!cl.configstrings[CS_SOUNDS+i][0]) break;
		cl.sound_precache[i] = S_RegisterSound (cl.configstrings[CS_SOUNDS+i]);
		Sys_SendKeyEvents(); // pump message loop
	}
	S_EndRegistration();
}


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

  SERVER CONNECTING MESSAGES

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

/*
==================
CL_ParseServerData
==================
*/
void CL_ParseServerData( sizebuf_t *msg )
{
	char		*str;
	int		i;

	MsgDev(D_INFO, "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_ReadShort( msg );
	str = MSG_ReadString( msg );

	// get splash name
	Cvar_Set( "cl_levelshot_name", va("background/%s.tga", str ));
	Cvar_SetValue("scr_loading", 0.0f ); // reset progress bar
	if(!FS_FileExists(va("gfx/%s", Cvar_VariableString("cl_levelshot_name")))) 
	{
		Cvar_Set("cl_levelshot_name", "common/black");
		cl.make_levelshot = true; // 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");
	// need to prep refresh at next oportunity
	cl.refresh_prepped = false;
}

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

	CL_VM_Begin();
	memset( &nullstate, 0, sizeof(nullstate));
	newnum = MSG_ReadBits( msg, NET_WORD );

	// increase edicts
	while( newnum >= prog->num_edicts ) PRVM_ED_Alloc();
	ent = PRVM_EDICT_NUM( newnum );

	MSG_ReadDeltaEntity( msg, &nullstate, &ent->priv.cl->baseline, newnum );
}

/*
================
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_MODELS && i < CS_MODELS+MAX_MODELS )
	{
		if( cl.refresh_prepped )
		{
			re->RegisterModel( cl.configstrings[i], i-CS_MODELS );
			cl.models[i-CS_MODELS] = pe->RegisterModel( cl.configstrings[i] );
		}
	}
	else if( i >= CS_SOUNDS && i < CS_SOUNDS+MAX_MODELS )
	{
		if( cl.refresh_prepped )
			cl.sound_precache[i-CS_SOUNDS] = S_RegisterSound( cl.configstrings[i] );
	}
	else if( i >= CS_CLASSNAMES && i < CS_CLASSNAMES+MAX_CLASSNAMES )
	{
		// prvm classnames for search by classname on client vm
		cl.edict_classnames[i-CS_CLASSNAMES] = PRVM_SetEngineString( cl.configstrings[i] );
	}
	else if( i >= CS_LIGHTSTYLES && i < CS_LIGHTSTYLES+MAX_LIGHTSTYLES )
	{
		CL_SetLightstyle( i - CS_LIGHTSTYLES );
	}
}


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

ACTION MESSAGES

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

/*
==================
CL_ParseStartSoundPacket
==================
*/
void CL_ParseStartSoundPacket( sizebuf_t *msg )
{
	vec3_t	pos_v;
	float	*pos = NULL;
	int 	channel = 0;
	int 	sound_num;
	float 	volume;
	int 	attenuation;  
	int	flags, ent = 0;

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

	if( flags & SND_VOL ) volume = MSG_ReadBits( msg, NET_COLOR );
	else volume = 1.0f;
	if( flags & SND_ATTN ) attenuation = MSG_ReadByte( msg );
	else attenuation = ATTN_NORM;	

	if( flags & SND_ENT )
	{	
		// entity reletive
		channel = MSG_ReadShort( msg ); 
		ent = channel>>3;
		if( ent > host.max_edicts ) Host_Error("CL_ParseStartSoundPacket: ent out of range\n" );
		channel &= 7;
	}
	if( flags & SND_POS )
	{	
		// positioned in space
		MSG_ReadPos( msg, pos_v );
		pos = pos_v;
	}
	if(!cl.sound_precache[sound_num]) return;
	S_StartSound( pos, ent, channel, cl.sound_precache[sound_num], volume, attenuation );
}       

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

	// client progs can recivied messages too
	cls.multicast = msg;

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

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

		// 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_sound:
			CL_ParseStartSoundPacket( msg );
			break;
		case svc_spawnbaseline:
			CL_ParseBaseline( msg );
			break;
		case svc_temp_entity:
			CL_ParseTempEnts( msg );
			break;
		case svc_download:
			CL_ParseDownload( msg );
			break;
		case svc_frame:
			CL_ParseFrame( msg );
			break;
		case svc_clientindex:
		case svc_packetentities:
		case svc_deltapacketentities:
			Host_Error( "CL_ParseServerMessage: out of place frame data\n" );
			break;
		case svc_bad:
			Host_Error( "CL_ParseServerMessage: svc_bad\n" );
			break;
		default:
			// parse user messages
			if(!CL_ParseUserMessage( cmd ))
				Host_Error("CL_ParseServerMessage: illegible server message %d\n", cmd );
			break;
		}
	}
}