static int write_level_file(void)
{
char name[MAX_OSPATH];
int i;
char *s;
size_t len;
byte portalbits[MAX_MAP_PORTAL_BYTES];
qerror_t ret;
// write magic
MSG_WriteLong(SAVE_MAGIC2);
MSG_WriteLong(SAVE_VERSION);
// write configstrings
for (i = 0; i < MAX_CONFIGSTRINGS; i++) {
s = sv.configstrings[i];
if (!s[0])
continue;
len = strlen(s);
if (len > MAX_QPATH)
len = MAX_QPATH;
MSG_WriteShort(i);
MSG_WriteData(s, len);
MSG_WriteByte(0);
}
MSG_WriteShort(MAX_CONFIGSTRINGS);
len = CM_WritePortalBits(&sv.cm, portalbits);
MSG_WriteByte(len);
MSG_WriteData(portalbits, len);
len = Q_snprintf(name, MAX_QPATH, "save/" SAVE_CURRENT "/%s.sv2", sv.name);
if (len >= MAX_QPATH)
ret = -1;
else
ret = FS_WriteFile(name, msg_write.data, msg_write.cursize);
SZ_Clear(&msg_write);
if (ret < 0)
return -1;
// write game level
len = Q_snprintf(name, MAX_OSPATH,
"%s/save/" SAVE_CURRENT "/%s.sav", fs_gamedir, sv.name);
if (len >= MAX_OSPATH)
return -1;
ge->WriteLevel(name);
return 0;
}
/*
================
rvDebuggerClient::InspectVariable
Instructs the client to inspect the given variable at the given callstack depth. The
variable is inspected by sending a DBMSG_INSPECTVARIABLE message to the server which
will in turn respond back to the client with the variable value
================
*/
void rvDebuggerClient::InspectVariable ( const char* name, int callstackDepth )
{
msg_t msg;
byte buffer[MAX_MSGLEN];
MSG_Init( &msg, buffer, sizeof( buffer ) );
MSG_WriteShort ( &msg, (int)DBMSG_INSPECTVARIABLE );
MSG_WriteShort ( &msg, (short)(mCallstack.Num()-callstackDepth) );
MSG_WriteString ( &msg, name );
SendPacket ( msg.data, msg.cursize );
}
void GTH_SendMessageRequestItemSyncItem()
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, EXTEND_SECOND);
MSG_WriteShort(&netMessage, ITEM_EXTEND_SYSTEM);
MSG_WriteShort(&netMessage, REQUEST_ITEM_SYNC_TIME);
NET_SendMessage(&gsSocket, &netMessage);
}
MSG_EndWriting(&netMessage);
}
/*
=================
Netchan_TransmitNextFragment
Send one fragment of the current message
=================
*/
void Netchan_TransmitNextFragment( netchan_t *chan )
{
msg_t send;
byte send_buf[ MAX_PACKETLEN ];
int fragmentLength;
// write the packet header
MSG_InitOOB( &send, send_buf, sizeof( send_buf ) ); // <-- only do the oob here
MSG_WriteLong( &send, chan->outgoingSequence | FRAGMENT_BIT );
// send the qport if we are a client
if ( chan->sock == NS_CLIENT )
{
MSG_WriteShort( &send, qport->integer );
}
// copy the reliable message to the packet first
fragmentLength = FRAGMENT_SIZE;
if ( chan->unsentFragmentStart + fragmentLength > chan->unsentLength )
{
fragmentLength = chan->unsentLength - chan->unsentFragmentStart;
}
MSG_WriteShort( &send, chan->unsentFragmentStart );
MSG_WriteShort( &send, fragmentLength );
MSG_WriteData( &send, chan->unsentBuffer + chan->unsentFragmentStart, fragmentLength );
// send the datagram
NET_SendPacket( chan->sock, send.cursize, send.data, chan->remoteAddress );
if ( showpackets->integer )
{
Com_Printf( "%s send %4i : s=%i fragment=%i,%i\n"
, netsrcString[ chan->sock ]
, send.cursize
, chan->outgoingSequence
, chan->unsentFragmentStart, fragmentLength );
}
chan->unsentFragmentStart += fragmentLength;
// this exit condition is a little tricky, because a packet
// that is exactly the fragment length still needs to send
// a second packet of zero length so that the other side
// can tell there aren't more to follow
if ( chan->unsentFragmentStart == chan->unsentLength && fragmentLength != FRAGMENT_SIZE )
{
chan->outgoingSequence++;
chan->unsentFragments = qfalse;
}
}
void CHelperManager_Encoder::SendMessage_Helper_StackOpen(playerCharacter_t* pHelper)
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, EXTEND_SECOND);
MSG_WriteShort ( &netMessage, HELPER_SYSTEM );
MSG_WriteShort(&netMessage, SC_STACK_OPEN_Req_toPlayer);
NET_SendMessage(&pHelper->sock, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void CGs_To_Cc::Send(playerCharacter_t* pPlayer,int SystemType,int mainType, int subType)
{
MSG_BeginWriting( &netMessage );
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, EXTEND_SECOND);
MSG_WriteShort(&netMessage, SystemType);
MSG_WriteShort(&netMessage, mainType);
MSG_WriteShort(&netMessage, subType);
NET_SendMessage(&pPlayer->sock, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void CHelperManager_Encoder::SendMessage_Helper_Helppoint(playerCharacter_t* pHelper)
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, EXTEND_SECOND);
MSG_WriteShort ( &netMessage, HELPER_SYSTEM );
MSG_WriteShort(&netMessage, SC_CONFIRM_HELPPOINT_Res_toPlayer);
MSG_WriteLong(&netMessage, pHelper->tHelper.tPoint.iHelpPoint);
NET_SendMessage(&pHelper->sock, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void CGMCtrl::TransmitePacket_cs_request_AUTHstate(void)
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, EXTEND_SECOND);
MSG_WriteShort(&netMessage, GMsystem);
MSG_WriteShort(&netMessage, tagExtendSecondPacket_GMsystem::GMsystem_NProtect);
MSG_WriteShort(&netMessage, tagExtendSecondPacket_GMsystem::tagNProtect::cs_request_AUTHstate);
NET_SendMessage(&gsSocket, &netMessage);
}
MSG_EndWriting( &netMessage );
}
//
// SV_UpdateMasterServer
//
void SV_UpdateMasterServer(masterserver &m)
{
SZ_Clear(&ml_message);
MSG_WriteLong(&ml_message, CHALLENGE);
// send out actual port, because NAT may present an incorrect port to the master
if(natport)
MSG_WriteShort(&ml_message, natport);
else
MSG_WriteShort(&ml_message, port);
NET_SendPacket(ml_message, m.masteraddr);
}
void CGMCtrl::TransmitePacket_cs_request_AUTH_dll_change(const char* in_strDLLFileName)
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, EXTEND_SECOND);
MSG_WriteShort(&netMessage, GMsystem);
MSG_WriteShort(&netMessage, tagExtendSecondPacket_GMsystem::GMsystem_NProtect);
MSG_WriteShort(&netMessage, tagExtendSecondPacket_GMsystem::tagNProtect::cs_request_AUTH_dll_change);
MSG_WriteString(&netMessage,(char*)in_strDLLFileName);
NET_SendMessage(&gsSocket, &netMessage);
}
MSG_EndWriting( &netMessage );
}
// 2000-05-02 NVS SVC by Maddes
void NVS_WriteShort (int dest, int c, sizebuf_t *sb)
{
int i;
switch (dest)
{
case MSG_INIT:
if (sv.nvs_msgsignon->conversion_tab[sv.nvs_msgserver->numwrites-sv.nvs_msgwrites])
{
if (sb) // special signon
{
MSG_WriteShort (sb, c);
}
else
{
MSG_WriteShort (&sv.signon, c);
}
}
break;
case MSG_ONE:
case MSG_ALL:
case MSG_BROADCAST:
for (i=0 ; i<svs.maxclients ; i++)
{
if (NVS_CheckClient(&svs.clients[i]))
{
if (dest == MSG_BROADCAST) // unreliable
{
MSG_WriteShort (&svs.clients[i].datagram, c);
}
else if (dest == MSG_ONE && sb) // special reliable MSG_ONE
{
MSG_WriteShort (sb, c);
}
else // reliable MSG_ONE, MSG_ALL
{
MSG_WriteShort (&svs.clients[i].message, c);
}
}
}
break;
default:
Host_Error ("NVS_WriteShort: bad destination");
break;
}
NVS_CheckCounter();
}
void CGMCtrl::TransmitePacket_NProtect_sc_response_AUTH(playerCharacter_t* pPlayer) const
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, EXTEND_SECOND);
MSG_WriteShort(&netMessage, GMsystem);
MSG_WriteShort(&netMessage, tagExtendSecondPacket_GMsystem::GMsystem_NProtect);
MSG_WriteShort(&netMessage, tagExtendSecondPacket_GMsystem::tagNProtect::sc_response_AUTH);
MSG_WriteLong(&netMessage, m_cpServerStateDataCtrl->isNProtectAUTH());
NET_SendMessage( &(pPlayer->sock), &netMessage );
}
MSG_EndWriting(&netMessage);
}
void CHelperManager_Encoder::SendMessage_Invite_Respond_toTaker(
playerCharacter_t* pTaker,int errorCode)
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, EXTEND_SECOND);
MSG_WriteShort(&netMessage, HELPER_SYSTEM);
MSG_WriteShort(&netMessage, SC_INVITE_Res_toTAKER);
MSG_WriteShort(&netMessage, errorCode);
NET_SendMessage(&pTaker->sock, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void GTH_SendMessage_GambleSystem_Active(BOOL bActive)
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, EXTEND_SECOND);
MSG_WriteShort(&netMessage, GAMBLE_SYSTEM );
MSG_WriteShort(&netMessage, ACTIVE_SYSTEM_REQUEST );
MSG_WriteLong(&netMessage, bActive);
NET_SendMessage(&gsSocket, &netMessage);
}
MSG_EndWriting( &netMessage );
}
void SV_FullClientUpdate (client_t *client, sizebuf_t *buf)
{
int i;
char info[MAX_INFO_STRING];
// Con_Printf("%s\n", __thisfunc__);
i = client - svs.clients;
// Sys_Printf("%s: Updated frags for client %d\n", __thisfunc__, i);
MSG_WriteByte (buf, svc_updatedminfo);
MSG_WriteByte (buf, i);
MSG_WriteShort (buf, client->old_frags);
MSG_WriteByte (buf, (client->playerclass<<5)|((int)client->edict->v.level&31));
if (dmMode.integer == DM_SIEGE)
{
MSG_WriteByte (buf, svc_updatesiegeinfo);
MSG_WriteByte (buf, (int)ceil(timelimit.value));
MSG_WriteByte (buf, (int)ceil(fraglimit.value));
MSG_WriteByte (buf, svc_updatesiegeteam);
MSG_WriteByte (buf, i);
MSG_WriteByte (buf, client->siege_team);
MSG_WriteByte (buf, svc_updatesiegelosses);
MSG_WriteByte (buf, PR_GLOBAL_STRUCT(defLosses));
MSG_WriteByte (buf, PR_GLOBAL_STRUCT(attLosses));
MSG_WriteByte (buf, svc_time);//send server time upon connection
MSG_WriteFloat (buf, sv.time);
}
MSG_WriteByte (buf, svc_updateping);
MSG_WriteByte (buf, i);
MSG_WriteShort (buf, SV_CalcPing (client));
MSG_WriteByte (buf, svc_updateentertime);
MSG_WriteByte (buf, i);
MSG_WriteFloat (buf, realtime - client->connection_started);
strcpy (info, client->userinfo);
Info_RemovePrefixedKeys (info, '_'); // server passwords, etc
MSG_WriteByte (buf, svc_updateuserinfo);
MSG_WriteByte (buf, i);
MSG_WriteLong (buf, client->userid);
MSG_WriteString (buf, info);
}
void Server_MakeStatic(ServerEntity_t *ent)
{
int i,bits=0;
if(ent->alpha == ENTALPHA_ZERO)
{
ED_Free(ent);
return;
}
if(SV_ModelIndex(ent->v.model) & 0xFF00)
bits |= B_LARGEMODEL;
if((int)(ent->v.frame) & 0xFF00)
bits |= B_LARGEFRAME;
if(ent->alpha != ENTALPHA_DEFAULT)
bits |= B_ALPHA;
if(bits)
{
MSG_WriteByte(&sv.signon, SVC_SPAWNSTATIC2);
MSG_WriteByte(&sv.signon, bits);
}
else
MSG_WriteByte(&sv.signon, svc_spawnstatic);
if(bits & B_LARGEMODEL)
MSG_WriteShort(&sv.signon, SV_ModelIndex(ent->v.model));
else
MSG_WriteByte(&sv.signon, SV_ModelIndex(ent->v.model));
if(bits & B_LARGEFRAME)
MSG_WriteShort(&sv.signon,ent->v.frame);
else
MSG_WriteByte(&sv.signon,ent->v.frame);
MSG_WriteByte(&sv.signon,ent->Model.fScale);
MSG_WriteByte(&sv.signon,ent->v.colormap);
MSG_WriteByte(&sv.signon,ent->Model.iSkin);
for (i=0 ; i<3 ; i++)
{
MSG_WriteCoord(&sv.signon, ent->v.origin[i]);
MSG_WriteAngle(&sv.signon, ent->v.angles[i]);
}
if (bits & B_ALPHA)
MSG_WriteByte (&sv.signon, ent->alpha);
ED_Free (ent);
}
void CHelperManager::MemberList_Request_Update_OtherServer ( playerCharacter_t* pHelper, int fstate )
{
MSG_BeginWriting ( &netMessage );
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, EXTEND_SECOND);
MSG_WriteShort ( &netMessage, HELPER_SYSTEM );
MSG_WriteShort ( &netMessage, SS_REQUEST_UPDATE_MemberList_toServer);
MSG_WriteString ( &netMessage, pHelper->name );
MSG_WriteByte ( &netMessage, fstate );
NET_SendUnreliableMessage ( &localSocket, &netMessage );
}
MSG_EndWriting(&netMessage);
}
inline void CGMCtrl::TransmitePacket_NProtect_gsms_request_change(const BOOL in_bEnable) const
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, EXTEND_SECOND);
MSG_WriteShort(&netMessage, GMsystem);
MSG_WriteShort(&netMessage, tagExtendSecondPacket_GMsystem::GMsystem_NProtect);
MSG_WriteShort(&netMessage, tagExtendSecondPacket_GMsystem::tagNProtect::gsms_request_change);
MSG_WriteLong(&netMessage,in_bEnable);
NET_SendUnreliableMessage(&localSocket, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void CGMCtrl::TransmitePacket_NProtect_sc_response_AUTH_dll_change(playerCharacter_t* in_pPlayer,const BOOL in_bSuccess,const char* in_strDLLname)
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, EXTEND_SECOND);
MSG_WriteShort(&netMessage, GMsystem);
MSG_WriteShort(&netMessage, tagExtendSecondPacket_GMsystem::GMsystem_NProtect);
MSG_WriteShort(&netMessage, tagExtendSecondPacket_GMsystem::tagNProtect::sc_response_AUTH_dll_change);
MSG_WriteLong(&netMessage,in_bSuccess);
MSG_WriteString(&netMessage,(char*)in_strDLLname);
NET_SendMessage( &(in_pPlayer->sock), &netMessage );
}
MSG_EndWriting(&netMessage);
}
void CWeatherSystem::GTH_SendUserNotice(char *notice)
{
MSG_BeginWriting( &netMessage );
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, EXTEND_SECOND);
MSG_WriteShort(&netMessage, WEATHER_SYSTEM );
MSG_WriteShort(&netMessage, CC_WEATHER_SYSTEM );
MSG_WriteByte(&netMessage, CC_WEATHER_SYSTEM_NOTICE);
MSG_WriteString(&netMessage, notice);
NET_SendMessage(&gsSocket, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void CWeatherSystem::GTH_SendMessage_Request_WorldState(int worldidx)
{
MSG_BeginWriting( &netMessage );
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, EXTEND_SECOND);
MSG_WriteShort(&netMessage, WEATHER_SYSTEM );
MSG_WriteShort(&netMessage, CC_WEATHER_SYSTEM );
MSG_WriteByte(&netMessage, CC_WEATHER_SYSTEM_REQUEST_WORLD_STATE);
MSG_WriteByte(&netMessage, worldidx);
NET_SendMessage(&gsSocket, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void CHelperManager_Encoder::SendMessage_Helppoint_toHelper(
playerCharacter_t* pc, char* pGiverName, int HelpPoint)
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, EXTEND_SECOND);
MSG_WriteShort ( &netMessage, HELPER_SYSTEM );
MSG_WriteShort(&netMessage, SC_SENDHELPPOINT_toHelper);
MSG_WriteString(&netMessage,pGiverName);
MSG_WriteLong(&netMessage,HelpPoint);
NET_SendMessage(&pc->sock, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void SV_CreateClientGameStateMessage( client_t *client, msg_t *msg ) {
int start;
entityState_t *base, nullstate;
// NOTE, MRE: all server->client messages now acknowledge
// let the client know which reliable clientCommands we have received
MSG_WriteLong( msg, client->lastClientCommand );
// send any server commands waiting to be sent first.
// we have to do this cause we send the client->reliableSequence
// with a gamestate and it sets the clc.serverCommandSequence at
// the client side
SV_UpdateServerCommandsToClient( client, msg );
// send the gamestate
MSG_WriteByte( msg, svc_gamestate );
MSG_WriteLong( msg, client->reliableSequence );
// write the configstrings
for ( start = 0 ; start < MAX_CONFIGSTRINGS ; start++ ) {
if (sv.configstrings[start][0]) {
MSG_WriteByte( msg, svc_configstring );
MSG_WriteShort( msg, start );
MSG_WriteBigString( msg, sv.configstrings[start] );
}
}
// write the baselines
Com_Memset( &nullstate, 0, sizeof( nullstate ) );
for ( start = 0 ; start < MAX_GENTITIES; start++ ) {
base = &sv.svEntities[start].baseline;
if ( !base->number ) {
continue;
}
MSG_WriteByte( msg, svc_baseline );
MSG_WriteDeltaEntity( msg, &nullstate, base, qtrue );
}
MSG_WriteByte( msg, svc_EOF );
MSG_WriteLong( msg, client - svs.clients);
// write the checksum feed
MSG_WriteLong( msg, sv.checksumFeed);
// For old RMG system.
MSG_WriteShort ( msg, 0 );
}
/*
================
SV_New_f
Sends the first message from the server to a connected client.
This will be sent on the initial connection and upon each server load.
================
*/
void SV_New_f(void)
{
char * gamedir;
int playernum;
edict_t * ent;
Com_DPrintf("New() from %s\n", sv_client->name);
if (sv_client->state != cs_connected)
{
Com_Printf("New not valid -- already spawned\n");
return;
}
// demo servers just dump the file message
if (sv.state == ss_demo)
{
SV_BeginDemoserver();
return;
}
//
// serverdata needs to go over for all types of servers
// to make sure the protocol is right, and to set the gamedir
//
gamedir = Cvar_VariableString("gamedir");
// send the serverdata
MSG_WriteByte(&sv_client->netchan.message, svc_serverdata);
MSG_WriteLong(&sv_client->netchan.message, PROTOCOL_VERSION);
MSG_WriteLong(&sv_client->netchan.message, svs.spawncount);
MSG_WriteByte(&sv_client->netchan.message, sv.attractloop);
MSG_WriteString(&sv_client->netchan.message, gamedir);
if (sv.state == ss_cinematic || sv.state == ss_pic)
playernum = -1;
else
playernum = sv_client - svs.clients;
MSG_WriteShort(&sv_client->netchan.message, playernum);
// send full levelname
MSG_WriteString(&sv_client->netchan.message, sv.configstrings[CS_NAME]);
//
// game server
//
if (sv.state == ss_game)
{
// set up the entity for the client
ent = EDICT_NUM(playernum + 1);
ent->s.number = playernum + 1;
sv_client->edict = ent;
memset(&sv_client->lastcmd, 0, sizeof(sv_client->lastcmd));
// begin fetching configstrings
MSG_WriteByte(&sv_client->netchan.message, svc_stufftext);
MSG_WriteString(&sv_client->netchan.message, va("cmd configstrings %i 0\n", svs.spawncount));
}
}
/*
==================
SV_NextDownload_f
==================
*/
static void SV_NextDownload_f (void)
{
byte buffer[1024];
int r;
int percent;
int size;
if (!host_client->download)
return;
r = host_client->downloadsize - host_client->downloadcount;
if (r > 1024)
r = 1024;
r = fread (buffer, 1, r, host_client->download);
MSG_WriteByte (&host_client->netchan.message, svc_download);
MSG_WriteShort (&host_client->netchan.message, r);
host_client->downloadcount += r;
size = host_client->downloadsize;
if (!size)
size = 1;
percent = host_client->downloadcount*100/size;
MSG_WriteByte (&host_client->netchan.message, percent);
SZ_Write (&host_client->netchan.message, buffer, r);
if (host_client->downloadcount != host_client->downloadsize)
return;
fclose (host_client->download);
host_client->download = NULL;
}
void Game_AmbientSound(MathVectorf_t *vPosition,const char *cPath,int iVolume,int iAttenuation)
{
char **cCheck;
int i,iSoundNumber;
bool bLarge = false;
for(iSoundNumber = 0,cCheck = sv.sound_precache; *cCheck; cCheck++,iSoundNumber++)
if(!strcmp(*cCheck,cPath))
break;
if(!*cCheck)
Console_ErrorMessage(false,(char*)cPath,"Sound was not registered.");
if(iSoundNumber > 255)
bLarge = true;
if(bLarge)
MSG_WriteByte(&sv.signon,svc_spawnstaticsound2);
else
MSG_WriteByte(&sv.signon,svc_spawnstaticsound);
for(i = 0; i < 3; i++)
MSG_WriteCoord(&sv.signon,vPosition[i]);
if(bLarge)
MSG_WriteShort(&sv.signon,iSoundNumber);
else
MSG_WriteByte(&sv.signon,iSoundNumber);
MSG_WriteByte(&sv.signon,iVolume);
MSG_WriteByte(&sv.signon,iAttenuation*64);
}
void GTH_SendMessageRequestItemTimeSet(const enum sItemUseTimeInfo::enumInventoryType type, int iItemIdx, int iinvenIdx)
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, EXTEND_SECOND);
MSG_WriteShort(&netMessage, ITEM_EXTEND_SYSTEM);
MSG_WriteShort(&netMessage, REQUEST_ITEM_TIME_SET);
MSG_WriteLong(&netMessage, (int)type);
MSG_WriteLong(&netMessage, iItemIdx);
MSG_WriteLong(&netMessage, iinvenIdx);
NET_SendMessage(&gsSocket, &netMessage);
}
MSG_EndWriting(&netMessage);
}
/*
==================
SV_NextDownload_f
==================
*/
void SV_NextDownload_f(void){
int percent, size, r;
if(!sv_client->download)
return;
r = sv_client->downloadsize - sv_client->downloadcount;
if(r > 1024)
r = 1024;
MSG_WriteByte(&sv_client->netchan.message, svc_download);
MSG_WriteShort(&sv_client->netchan.message, r);
sv_client->downloadcount += r;
size = sv_client->downloadsize;
if(!size)
size = 1;
percent = sv_client->downloadcount * 100 / size;
MSG_WriteByte(&sv_client->netchan.message, percent);
SZ_Write(&sv_client->netchan.message,
sv_client->download + sv_client->downloadcount - r, r);
if(sv_client->downloadcount != sv_client->downloadsize)
return;
FS_FreeFile(sv_client->download);
sv_client->download = NULL;
}
/*
================
SV_FindIndex
================
*/
int SV_FindIndex (char *name, int start, int max, qboolean create)
{
int i;
if (!name || !name[0])
return 0;
for (i=1 ; i<max && sv.configstrings[start+i][0] ; i++)
if (!strcmp(sv.configstrings[start+i], name))
return i;
if (!create)
return 0;
if (i == max)
Com_Error (ERR_DROP, "*Index: overflow");
strncpy (sv.configstrings[start+i], name, sizeof(sv.configstrings[i]));
if (sv.state != ss_loading)
{ // send the update to everyone
SZ_Clear (&sv.multicast);
MSG_WriteChar (&sv.multicast, svc_configstring);
MSG_WriteShort (&sv.multicast, start+i);
MSG_WriteString (&sv.multicast, name);
SV_Multicast (vec3_origin, MULTICAST_ALL_R);
}
return i;
}
/*
=====================
SV_DropClient
Called when the player is getting totally kicked off the host
if (crash = true), don't bother sending signofs
=====================
*/
void SV_DropClient (bool crash)
{
int saveSelf;
int i;
client_t *client;
if (!host_client->active)
return;
if (!crash)
{
// send any final messages (don't check for errors)
if (NET_CanSendMessage (host_client->netconnection))
{
MSG_WriteByte (&host_client->message, svc_disconnect);
NET_SendMessage (host_client->netconnection, &host_client->message);
}
if (host_client->edict && host_client->spawned)
{
// call the prog function for removing a client
// this will set the body to a dead frame, among other things
saveSelf = pr_global_struct->self;
pr_global_struct->self = EDICT_TO_PROG(host_client->edict);
PR_ExecuteProgram (pr_global_struct->ClientDisconnect);
pr_global_struct->self = saveSelf;
}
Sys_Printf ("Client %s removed\n",host_client->name);
}
/*if (host_client->netconnection->proquake_connection == MOD_QSMACK)
qsmackActive = false;*/
// break the net connection
NET_Close (host_client->netconnection);
host_client->netconnection = NULL;
// free the client (the body stays around)
host_client->active = false;
host_client->name[0] = 0;
host_client->old_frags = -999999;
net_activeconnections--;
// send notification to all clients
for (i=0, client = svs.clients ; i<svs.maxclients ; i++, client++)
{
if (!client->active)
continue;
MSG_WriteByte (&client->message, svc_updatename);
MSG_WriteByte (&client->message, host_client - svs.clients);
MSG_WriteString (&client->message, "");
MSG_WriteByte (&client->message, svc_updatefrags);
MSG_WriteByte (&client->message, host_client - svs.clients);
MSG_WriteShort (&client->message, 0);
MSG_WriteByte (&client->message, svc_updatecolors);
MSG_WriteByte (&client->message, host_client - svs.clients);
MSG_WriteByte (&client->message, 0);
}
}
