3894 lines
109 KiB
C++
3894 lines
109 KiB
C++
|
// Copyright (C) 2007 Id Software, Inc.
|
||
|
|
//
|
||
|
|
|
||
|
|
#include "precompiled.h"
|
||
|
|
#pragma hdrstop
|
||
|
|
|
||
|
|
#if defined( _DEBUG ) && !defined( ID_REDIRECT_NEWDELETE )
|
||
|
|
#define new DEBUG_NEW
|
||
|
|
#undef THIS_FILE
|
||
|
|
static char THIS_FILE[] = __FILE__;
|
||
|
|
#endif
|
||
|
|
|
||
|
|
#include "gamesys/SysCmds.h"
|
||
|
|
#include "rules/GameRules.h"
|
||
|
|
#include "rules/AdminSystem.h"
|
||
|
|
#include "Entity.h"
|
||
|
|
#include "Player.h"
|
||
|
|
#include "structures/TeamManager.h"
|
||
|
|
#include "client/ClientEntity.h"
|
||
|
|
#include "client/ClientEffect.h"
|
||
|
|
#include "structures/DeployRequest.h"
|
||
|
|
#include "roles/FireTeams.h"
|
||
|
|
#include "roles/ObjectiveManager.h"
|
||
|
|
#include "roles/Tasks.h"
|
||
|
|
#include "demos/DemoManager.h"
|
||
|
|
#include "script/Script_Helper.h"
|
||
|
|
#include "script/Script_ScriptObject.h"
|
||
|
|
#include "effects/Effects.h"
|
||
|
|
#include "effects/Wakes.h"
|
||
|
|
#include "effects/TireTread.h"
|
||
|
|
#include "effects/FootPrints.h"
|
||
|
|
#include "rules/VoteManager.h"
|
||
|
|
#include "roles/WayPointManager.h"
|
||
|
|
#include "vehicles/Transport.h"
|
||
|
|
#include "proficiency/StatsTracker.h"
|
||
|
|
#include "guis/UserInterfaceManager.h"
|
||
|
|
|
||
|
|
#include "../bse/BSEInterface.h"
|
||
|
|
#include "../bse/BSE_Envelope.h"
|
||
|
|
#include "../bse/BSE_SpawnDomains.h"
|
||
|
|
#include "../bse/BSE_Particle.h"
|
||
|
|
#include "../bse/BSE.h"
|
||
|
|
|
||
|
|
#include "botai/BotThreadData.h"
|
||
|
|
#include "botai/Bot.h"
|
||
|
|
|
||
|
|
#include "misc/ProfileHelper.h"
|
||
|
|
#include "AntiLag.h"
|
||
|
|
|
||
|
|
extern rvBSEManager* bse;
|
||
|
|
|
||
|
|
/*
|
||
|
|
===============================================================================
|
||
|
|
|
||
|
|
Client running game code:
|
||
|
|
|
||
|
|
===============================================================================
|
||
|
|
*/
|
||
|
|
|
||
|
|
idCVar net_clientShowSnapshot( "net_clientShowSnapshot", "0", CVAR_GAME | CVAR_INTEGER, "", 0, 4, idCmdSystem::ArgCompletion_Integer<0,4> );
|
||
|
|
idCVar net_clientShowSnapshotRadius( "net_clientShowSnapshotRadius", "128", CVAR_GAME | CVAR_FLOAT, "" );
|
||
|
|
idCVar net_clientShowAOR( "net_clientShowAOR", "0", CVAR_GAME | CVAR_INTEGER, "", 0, 3, idCmdSystem::ArgCompletion_Integer< 0, 3 > );
|
||
|
|
idCVar net_clientAORFilter( "net_clientAORFilter", "0", CVAR_GAME, "", 0, 0, idClass::ArgCompletion_ClassName );
|
||
|
|
idCVar net_clientMaxPrediction( "net_clientMaxPrediction", "1000", CVAR_SYSTEM | CVAR_INTEGER | CVAR_NOCHEAT, "maximum number of milliseconds a client can predict ahead of server." );
|
||
|
|
idCVar net_clientLagOMeter( "net_clientLagOMeter", "0", CVAR_GAME | CVAR_BOOL | CVAR_NOCHEAT | CVAR_ARCHIVE | CVAR_PROFILE, "draw prediction graph" );
|
||
|
|
|
||
|
|
idCVar net_clientSelfSmoothing( "net_clientSelfSmoothing", "1", CVAR_GAME | CVAR_BOOL, "smooth local client position" );
|
||
|
|
|
||
|
|
idCVar net_serverMaxReservedClientSlots( "net_serverMaxReservedClientSlots", "2", CVAR_GAME | CVAR_INTEGER, "maximum number of player slots reserved for session invites", 0, MAX_CLIENTS, idCmdSystem::ArgCompletion_Integer< 0, MAX_CLIENTS > );
|
||
|
|
|
||
|
|
const int RESERVEDCLIENTSLOT_TIMEOUT = 45000;
|
||
|
|
|
||
|
|
const int CLIENTBITS = idMath::BitsForInteger( MAX_CLIENTS );
|
||
|
|
|
||
|
|
/*
|
||
|
|
===============================================================================
|
||
|
|
|
||
|
|
sdReliableServerMessage
|
||
|
|
|
||
|
|
===============================================================================
|
||
|
|
*/
|
||
|
|
void sdReliableServerMessage::Send( const sdReliableMessageClientInfoBase& info ) const {
|
||
|
|
#ifdef SD_SUPPORT_REPEATER
|
||
|
|
if ( info.SendToRepeaterClients() ) {
|
||
|
|
networkSystem->RepeaterSendReliableMessage( info.GetClientNum(), *this, info.DontSendToRelays() );
|
||
|
|
}
|
||
|
|
#endif // SD_SUPPORT_REPEATER
|
||
|
|
if ( info.SendToClients() ) {
|
||
|
|
networkSystem->ServerSendReliableMessage( info.GetClientNum(), *this );
|
||
|
|
if ( info.SendToAll() && g_debugNetworkWrite.GetBool() ) {
|
||
|
|
gameLocal.LogNetwork( va( "Reliable Broadcast: %d Size: %d bits\n", type, GetNumBitsWritten() ) );
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
===============================================================================
|
||
|
|
|
||
|
|
sdEntityNetEvent
|
||
|
|
|
||
|
|
===============================================================================
|
||
|
|
*/
|
||
|
|
|
||
|
|
/*
|
||
|
|
================
|
||
|
|
sdEntityNetEvent::sdEntityNetEvent
|
||
|
|
================
|
||
|
|
*/
|
||
|
|
sdEntityNetEvent::sdEntityNetEvent( void ) {
|
||
|
|
node.SetOwner( this );
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
================
|
||
|
|
sdEntityNetEvent::OutputParms
|
||
|
|
================
|
||
|
|
*/
|
||
|
|
void sdEntityNetEvent::OutputParms( idBitMsg& msg ) const {
|
||
|
|
msg.InitRead( paramsBuf, sizeof( paramsBuf ) );
|
||
|
|
msg.SetSize( paramsSize );
|
||
|
|
msg.BeginReading();
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
================
|
||
|
|
sdEntityNetEvent::Read
|
||
|
|
================
|
||
|
|
*/
|
||
|
|
void sdEntityNetEvent::Read( const idBitMsg& msg ) {
|
||
|
|
spawnId = msg.ReadLong();
|
||
|
|
event = msg.ReadByte();
|
||
|
|
time = msg.ReadLong();
|
||
|
|
saveEvent = msg.ReadBool();
|
||
|
|
paramsSize = msg.ReadBits( idMath::BitsForInteger( MAX_EVENT_PARAM_SIZE ) );
|
||
|
|
|
||
|
|
if ( paramsSize ) {
|
||
|
|
if ( paramsSize > MAX_EVENT_PARAM_SIZE ) {
|
||
|
|
gameLocal.NetworkEventWarning( *this, "invalid param size" );
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
msg.ReadData( paramsBuf, paramsSize );
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
================
|
||
|
|
sdEntityNetEvent::GetTotalSize
|
||
|
|
================
|
||
|
|
*/
|
||
|
|
int sdEntityNetEvent::GetTotalSize( void ) const {
|
||
|
|
return 4 + 1 + 4 + ( ( ( idMath::BitsForInteger( MAX_EVENT_PARAM_SIZE ) + 1 ) + 7 ) >> 3 ) + paramsSize;
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
================
|
||
|
|
sdEntityNetEvent::Write
|
||
|
|
================
|
||
|
|
*/
|
||
|
|
void sdEntityNetEvent::Write( idBitMsg& msg ) const {
|
||
|
|
msg.WriteLong( spawnId );
|
||
|
|
msg.WriteByte( event );
|
||
|
|
msg.WriteLong( time );
|
||
|
|
msg.WriteBool( saveEvent );
|
||
|
|
msg.WriteBits( paramsSize, idMath::BitsForInteger( MAX_EVENT_PARAM_SIZE ) );
|
||
|
|
if ( paramsSize ) {
|
||
|
|
msg.WriteData( paramsBuf, paramsSize );
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
================
|
||
|
|
sdEntityNetEvent::Read
|
||
|
|
================
|
||
|
|
*/
|
||
|
|
void sdEntityNetEvent::Read( idFile* file ) {
|
||
|
|
file->ReadInt( spawnId );
|
||
|
|
file->ReadInt( event );
|
||
|
|
file->ReadInt( time );
|
||
|
|
file->ReadInt( paramsSize );
|
||
|
|
file->ReadBool( saveEvent );
|
||
|
|
if ( paramsSize ) {
|
||
|
|
file->Read( paramsBuf, paramsSize );
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
/*
|
||
|
|
================
|
||
|
|
sdEntityNetEvent::Write
|
||
|
|
================
|
||
|
|
*/
|
||
|
|
void sdEntityNetEvent::Write( idFile* file ) const {
|
||
|
|
file->WriteInt( spawnId );
|
||
|
|
file->WriteInt( event );
|
||
|
|
file->WriteInt( time );
|
||
|
|
file->WriteBool( saveEvent );
|
||
|
|
file->WriteInt( paramsSize );
|
||
|
|
if ( paramsSize ) {
|
||
|
|
file->Write( paramsBuf, paramsSize );
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
================
|
||
|
|
sdEntityNetEvent::Create
|
||
|
|
================
|
||
|
|
*/
|
||
|
|
void sdEntityNetEvent::Create( const idEntity* _entity, int _event, bool _saveEvent, const idBitMsg* _msg ) {
|
||
|
|
spawnId = gameLocal.GetSpawnId( _entity );
|
||
|
|
event = _event;
|
||
|
|
time = gameLocal.time;
|
||
|
|
saveEvent = _saveEvent;
|
||
|
|
|
||
|
|
if ( _msg ) {
|
||
|
|
paramsSize = _msg->GetSize();
|
||
|
|
memcpy( paramsBuf, _msg->GetData(), _msg->GetSize() );
|
||
|
|
} else {
|
||
|
|
paramsSize = 0;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
================
|
||
|
|
sdEntityNetEvent::Create
|
||
|
|
================
|
||
|
|
*/
|
||
|
|
void sdEntityNetEvent::Create( const sdEntityNetEvent& other ) {
|
||
|
|
spawnId = other.spawnId;
|
||
|
|
event = other.event;
|
||
|
|
time = other.time;
|
||
|
|
saveEvent = other.saveEvent;
|
||
|
|
paramsSize = other.paramsSize;
|
||
|
|
memcpy( paramsBuf, other.paramsBuf, other.paramsSize );
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
===============================================================================
|
||
|
|
|
||
|
|
sdUnreliableEntityNetEvent
|
||
|
|
|
||
|
|
===============================================================================
|
||
|
|
*/
|
||
|
|
|
||
|
|
/*
|
||
|
|
================
|
||
|
|
sdUnreliableEntityNetEvent::sdUnreliableEntityNetEvent
|
||
|
|
================
|
||
|
|
*/
|
||
|
|
sdUnreliableEntityNetEvent::sdUnreliableEntityNetEvent( void ) {
|
||
|
|
unreliableNode.SetOwner( this );
|
||
|
|
#ifdef SD_SUPPORT_REPEATER
|
||
|
|
numRepeaterClients = 0;
|
||
|
|
#endif // SD_SUPPORT_REPEATER
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
================
|
||
|
|
sdUnreliableEntityNetEvent::ClearSent
|
||
|
|
================
|
||
|
|
*/
|
||
|
|
void sdUnreliableEntityNetEvent::ClearSent( void ) {
|
||
|
|
// mark client slots that aren't occupied as already having been sent
|
||
|
|
for ( int i = 0; i < MAX_CLIENTS; i++ ) {
|
||
|
|
idPlayer* client = gameLocal.GetClient( i );
|
||
|
|
if ( client != NULL && client != gameLocal.GetLocalPlayer() && gameLocal.isServer ) {
|
||
|
|
sentClients.Clear( i );
|
||
|
|
} else {
|
||
|
|
sentClients.Set( i );
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if ( sdDemoManager::GetInstance().GetState() == sdDemoManagerLocal::DS_RECORDING && gameLocal.localClientNum == ASYNC_DEMO_CLIENT_INDEX ) {
|
||
|
|
sentClients.Clear( MAX_CLIENTS );
|
||
|
|
} else {
|
||
|
|
sentClients.Set( MAX_CLIENTS );
|
||
|
|
}
|
||
|
|
|
||
|
|
#ifdef SD_SUPPORT_REPEATER
|
||
|
|
numRepeaterClients = gameLocal.GetNumRepeaterClients();
|
||
|
|
sentRepeaterClients.Init( numRepeaterClients );
|
||
|
|
sentRepeaterClients.SetAll();
|
||
|
|
for ( int i = 0; i < numRepeaterClients; i++ ) {
|
||
|
|
if ( gameLocal.IsRepeaterClientConnected( i ) ) {
|
||
|
|
sentRepeaterClients.Clear( i );
|
||
|
|
}
|
||
|
|
}
|
||
|
|
#endif // SD_SUPPORT_REPEATER
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
================
|
||
|
|
sdUnreliableEntityNetEvent::SetSent
|
||
|
|
================
|
||
|
|
*/
|
||
|
|
void sdUnreliableEntityNetEvent::SetSent( int clientTo ) {
|
||
|
|
assert( clientTo >= 0 && clientTo < ( MAX_CLIENTS + 1 ) );
|
||
|
|
sentClients.Set( clientTo );
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
================
|
||
|
|
sdUnreliableEntityNetEvent::HasExpired
|
||
|
|
================
|
||
|
|
*/
|
||
|
|
bool sdUnreliableEntityNetEvent::HasExpired( void ) const {
|
||
|
|
bool allSent = true;
|
||
|
|
for ( int i = 0; i < MAX_CLIENTS + 1; i++ ) {
|
||
|
|
if ( sentClients.Get( i ) != 0 ) {
|
||
|
|
allSent = false;
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
#ifdef SD_SUPPORT_REPEATER
|
||
|
|
for ( int i = 0; i < numRepeaterClients; i++ ) {
|
||
|
|
if ( sentRepeaterClients.Get( i ) != 0 ) {
|
||
|
|
allSent = false;
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
#endif // SD_SUPPORT_REPEATER
|
||
|
|
|
||
|
|
if ( allSent ) {
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
// expire 2 second old messages
|
||
|
|
if ( gameLocal.time - GetTime() > 2000 ) {
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
================
|
||
|
|
sdUnreliableEntityNetEvent::GetSent
|
||
|
|
================
|
||
|
|
*/
|
||
|
|
bool sdUnreliableEntityNetEvent::GetSent( int clientTo ) const {
|
||
|
|
return sentClients.Get( clientTo ) != 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
#ifdef SD_SUPPORT_REPEATER
|
||
|
|
/*
|
||
|
|
================
|
||
|
|
sdUnreliableEntityNetEvent::SetRepeaterSent
|
||
|
|
================
|
||
|
|
*/
|
||
|
|
void sdUnreliableEntityNetEvent::SetRepeaterSent( int clientTo ) {
|
||
|
|
if ( clientTo >= numRepeaterClients ) {
|
||
|
|
assert( false );
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
sentRepeaterClients.Set( clientTo );
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
================
|
||
|
|
sdUnreliableEntityNetEvent::GetRepeaterSent
|
||
|
|
================
|
||
|
|
*/
|
||
|
|
bool sdUnreliableEntityNetEvent::GetRepeaterSent( int clientTo ) const {
|
||
|
|
if ( clientTo >= numRepeaterClients ) {
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
return sentRepeaterClients.Get( clientTo ) != 0;
|
||
|
|
}
|
||
|
|
#endif // SD_SUPPORT_REPEATER
|
||
|
|
|
||
|
|
/*
|
||
|
|
===============================================================================
|
||
|
|
|
||
|
|
idGameLocal
|
||
|
|
|
||
|
|
===============================================================================
|
||
|
|
*/
|
||
|
|
|
||
|
|
/*
|
||
|
|
================
|
||
|
|
idGameLocal::InitAsyncNetwork
|
||
|
|
================
|
||
|
|
*/
|
||
|
|
void idGameLocal::InitAsyncNetwork( void ) {
|
||
|
|
entityNetEventQueue.Clear();
|
||
|
|
savedEntityNetEventQueue.Clear();
|
||
|
|
|
||
|
|
numEntityDefBits = idMath::BitsForInteger( declEntityDefType.Num() + 1 );
|
||
|
|
numSkinDeclBits = idMath::BitsForInteger( declSkinType.Num() + 1 );
|
||
|
|
numDamageDeclBits = idMath::BitsForInteger( declDamageType.Num() + 1 );
|
||
|
|
numInvItemBits = idMath::BitsForInteger( declInvItemType.Num() + 1 );
|
||
|
|
numDeployObjectBits = idMath::BitsForInteger( declDeployableObjectType.Num() + 1 );
|
||
|
|
numPlayerClassBits = idMath::BitsForInteger( declPlayerClassType.Num() + 1 );
|
||
|
|
numClientIndexBits = idMath::BitsForInteger( MAX_CLIENTS + 1 );
|
||
|
|
|
||
|
|
realClientTime = 0;
|
||
|
|
|
||
|
|
targetTimers.Clear();
|
||
|
|
targetTimerLookup.Clear();
|
||
|
|
numServerTimers = 0;
|
||
|
|
|
||
|
|
if ( isClient ) {
|
||
|
|
SetupGameStateBase( GetNetworkInfo( localClientNum ) );
|
||
|
|
SetupEntityStateBase( GetNetworkInfo( localClientNum ) );
|
||
|
|
}
|
||
|
|
|
||
|
|
SetupGameStateBase( GetNetworkInfo( ASYNC_DEMO_CLIENT_INDEX ) );
|
||
|
|
SetupEntityStateBase( GetNetworkInfo( ASYNC_DEMO_CLIENT_INDEX ) );
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
================
|
||
|
|
idGameLocal::ShutdownAsyncNetwork
|
||
|
|
================
|
||
|
|
*/
|
||
|
|
void idGameLocal::ShutdownAsyncNetwork( void ) {
|
||
|
|
for ( int i = 0; i < MAX_CLIENTS; i++ ) {
|
||
|
|
ShutdownClientNetworkState( i );
|
||
|
|
}
|
||
|
|
ShutdownClientNetworkState( ASYNC_DEMO_CLIENT_INDEX );
|
||
|
|
#ifdef SD_SUPPORT_REPEATER
|
||
|
|
ShutdownClientNetworkState( REPEATER_CLIENT_INDEX );
|
||
|
|
ShutdownRepeatersNetworkStates();
|
||
|
|
#endif // SD_SUPPORT_REPEATER
|
||
|
|
|
||
|
|
for ( int i = 0; i < ENSM_NUM_MODES; i++ ) {
|
||
|
|
sdNetworkStateObject& object = GetGameStateObject( ( extNetworkStateMode_t )i );
|
||
|
|
object.Clear();
|
||
|
|
}
|
||
|
|
|
||
|
|
snapshotAllocator.Shutdown();
|
||
|
|
entityNetEventAllocator.Shutdown();
|
||
|
|
unreliableEntityNetEventAllocator.Shutdown();
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
================
|
||
|
|
idGameLocal::InitLocalClient
|
||
|
|
================
|
||
|
|
*/
|
||
|
|
void idGameLocal::InitLocalClient( int clientNum, bool server ) {
|
||
|
|
isServer = server;
|
||
|
|
isClient = !server;
|
||
|
|
localClientNum = clientNum;
|
||
|
|
#ifdef SD_SUPPORT_REPEATER
|
||
|
|
serverIsRepeater = clientNum == REPEATER_CLIENT_INDEX;
|
||
|
|
#else
|
||
|
|
serverIsRepeater = false;
|
||
|
|
#endif // SD_SUPPORT_REPEATER
|
||
|
|
|
||
|
|
if ( isClient ) {
|
||
|
|
SetupGameStateBase( GetNetworkInfo( clientNum ) );
|
||
|
|
SetupEntityStateBase( GetNetworkInfo( clientNum ) );
|
||
|
|
}
|
||
|
|
sdFireTeamManager::GetInstance().Clear();
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
================
|
||
|
|
idGameLocal::OnServerShutdown
|
||
|
|
================
|
||
|
|
*/
|
||
|
|
void idGameLocal::OnServerShutdown() {
|
||
|
|
#ifndef _XENON
|
||
|
|
sdnet.StopGameSession( true );
|
||
|
|
|
||
|
|
if ( networkService->GetDedicatedServerState() == sdNetService::DS_ONLINE ) {
|
||
|
|
#if !defined( SD_DEMO_BUILD )
|
||
|
|
sdnet.FlushStats( true );
|
||
|
|
#endif /* !SD_DEMO_BUILD */
|
||
|
|
sdnet.SignOutDedicated();
|
||
|
|
}
|
||
|
|
#endif
|
||
|
|
|
||
|
|
for ( int i = 0; i < MAX_CLIENTS; i++ ) {
|
||
|
|
ServerClientDisconnect( i );
|
||
|
|
}
|
||
|
|
|
||
|
|
reservedClientSlots.Clear();
|
||
|
|
isServer = false;
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
================
|
||
|
|
idGameLocal::ReserveClientSlot
|
||
|
|
================
|
||
|
|
*/
|
||
|
|
void idGameLocal::ReserveClientSlot( const sdNetClientId& netClientId ) {
|
||
|
|
CheckForExpiredReservedSlots();
|
||
|
|
|
||
|
|
if ( reservedClientSlots.Num() == MAX_CLIENTS ) {
|
||
|
|
// find the oldest one and remove it
|
||
|
|
int oldestIndex = 0;
|
||
|
|
int oldestTime = reservedClientSlots[0].time;
|
||
|
|
for ( int i = 1; i < reservedClientSlots.Num(); i++ ) {
|
||
|
|
if ( reservedClientSlots[i].time < oldestTime ) {
|
||
|
|
oldestIndex = i;
|
||
|
|
oldestTime = reservedClientSlots[i].time;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
reservedClientSlots.RemoveIndexFast( oldestIndex );
|
||
|
|
}
|
||
|
|
|
||
|
|
reservedSlot_t* reservedSlot = reservedClientSlots.Alloc();
|
||
|
|
reservedSlot->netClientId = netClientId;
|
||
|
|
reservedSlot->time = sys->Milliseconds();
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
================
|
||
|
|
idGameLocal::CheckForExpiredReservedSlots
|
||
|
|
================
|
||
|
|
*/
|
||
|
|
void idGameLocal::CheckForExpiredReservedSlots( void ) {
|
||
|
|
int currentTime = sys->Milliseconds();
|
||
|
|
int i = 0;
|
||
|
|
while ( i < reservedClientSlots.Num() ) {
|
||
|
|
if ( reservedClientSlots[i].time < currentTime - RESERVEDCLIENTSLOT_TIMEOUT ) {
|
||
|
|
reservedClientSlots.RemoveIndexFast( i );
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
i++;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
================
|
||
|
|
idGameLocal::GetMaxPrivateClients
|
||
|
|
================
|
||
|
|
*/
|
||
|
|
int idGameLocal::GetMaxPrivateClients( void ) {
|
||
|
|
const int MAX_RANKED_PRIVATE_SLOTS = 4;
|
||
|
|
int max = si_privateClients.GetInteger();
|
||
|
|
if ( networkSystem->IsRankedServer() ) {
|
||
|
|
if ( max > MAX_RANKED_PRIVATE_SLOTS ) {
|
||
|
|
max = MAX_RANKED_PRIVATE_SLOTS;
|
||
|
|
si_privateClients.SetInteger( MAX_RANKED_PRIVATE_SLOTS );
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
return max;
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
================
|
||
|
|
idGameLocal::ServerAllowClient
|
||
|
|
================
|
||
|
|
*/
|
||
|
|
allowReply_t idGameLocal::ServerAllowClient( int numClients, int numBots, const clientNetworkAddress_t& address, const sdNetClientId& netClientId, const char *guid, const char *password, allowFailureReason_t& reason ) {
|
||
|
|
clientGUIDLookup_t lookup;
|
||
|
|
lookup.ip = ( *( int* )address.ip );
|
||
|
|
lookup.pbid = 0;
|
||
|
|
lookup.clientId = netClientId;
|
||
|
|
|
||
|
|
sdGUIDFile::banState_t banState = guidFile.CheckForBan( lookup );
|
||
|
|
switch ( banState ) {
|
||
|
|
case sdGUIDFile::BS_PERM_BAN:
|
||
|
|
reason = ALLOWFAIL_PERMBAN;
|
||
|
|
return ALLOW_NO;
|
||
|
|
case sdGUIDFile::BS_TEMP_BAN:
|
||
|
|
reason = ALLOWFAIL_TEMPBAN;
|
||
|
|
return ALLOW_NO;
|
||
|
|
case sdGUIDFile::BS_NOT_BANNED:
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
|
||
|
|
if ( serverInfo.GetInt( "si_pure" ) && !rules->IsPureReady() ) {
|
||
|
|
reason = ALLOWFAIL_SERVERSPAWNING;
|
||
|
|
return ALLOW_NOTYET;
|
||
|
|
}
|
||
|
|
|
||
|
|
int maxPlayers = si_maxPlayers.GetInteger();
|
||
|
|
if ( maxPlayers == 0 ) {
|
||
|
|
reason = ALLOWFAIL_SERVERSPAWNING;
|
||
|
|
return ALLOW_NOTYET;
|
||
|
|
}
|
||
|
|
|
||
|
|
int maxPrivatePlayers = GetMaxPrivateClients();
|
||
|
|
if ( maxPrivatePlayers > maxPlayers ) {
|
||
|
|
maxPrivatePlayers = maxPlayers;
|
||
|
|
}
|
||
|
|
int maxRegularPlayers = maxPlayers - maxPrivatePlayers;
|
||
|
|
|
||
|
|
// check if there is a reserved slot for this client, expire old slots first
|
||
|
|
CheckForExpiredReservedSlots();
|
||
|
|
|
||
|
|
int numReservedSlots = 0;
|
||
|
|
if ( !networkSystem->IsRankedServer() ) {
|
||
|
|
numReservedSlots = Min( reservedClientSlots.Num(), net_serverMaxReservedClientSlots.GetInteger() );
|
||
|
|
}
|
||
|
|
int numAvailableSlots = maxRegularPlayers - numReservedSlots;
|
||
|
|
|
||
|
|
bool isPrivateClient = false;
|
||
|
|
const char* privatePass = g_privatePassword.GetString();
|
||
|
|
if ( *privatePass != '\0' && idStr::Cmp( privatePass, password ) == 0 ) {
|
||
|
|
isPrivateClient = true;
|
||
|
|
numAvailableSlots = maxPlayers; // with private password, any slot is available
|
||
|
|
} else if ( numReservedSlots > 0 ) {
|
||
|
|
for ( int i = 0; i < reservedClientSlots.Num(); i++ ) {
|
||
|
|
if ( reservedClientSlots[ i ].netClientId == netClientId ) {
|
||
|
|
reservedClientSlots.RemoveIndexFast( i );
|
||
|
|
numAvailableSlots = maxRegularPlayers; // with reserved id, any slot is available, bar the private slots
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if ( numClients >= numAvailableSlots ) {
|
||
|
|
if ( numClients >= maxPrivatePlayers ) {
|
||
|
|
reason = ALLOWFAIL_SERVERFULL;
|
||
|
|
return ALLOW_NOTYET;
|
||
|
|
}
|
||
|
|
reason = ALLOWFAIL_INVALIDPASSWORD;
|
||
|
|
return ALLOW_BADPASS;
|
||
|
|
}
|
||
|
|
|
||
|
|
if ( !isPrivateClient ) {
|
||
|
|
if ( si_needPass.GetBool() ) {
|
||
|
|
const char* pass = g_password.GetString();
|
||
|
|
if ( *pass == '\0' ) {
|
||
|
|
// Gordon: FIXME: This is rubbish
|
||
|
|
gameLocal.Warning( "si_needPass is set but g_password is empty" );
|
||
|
|
cmdSystem->BufferCommandText( CMD_EXEC_NOW, "say si_needPass is set but g_password is empty" );
|
||
|
|
// avoids silent misconfigured state
|
||
|
|
reason = ALLOWFAIL_SERVERMISCONFIGURED;
|
||
|
|
return ALLOW_NOTYET;
|
||
|
|
}
|
||
|
|
|
||
|
|
if ( idStr::Cmp( pass, password ) != 0 ) {
|
||
|
|
reason = ALLOWFAIL_INVALIDPASSWORD;
|
||
|
|
Printf( "Rejecting client %s from IP '%i.%i.%i.%i': invalid password\n", guid, address.ip[ 0 ], address.ip[ 1 ], address.ip[ 2 ], address.ip[ 3 ] );
|
||
|
|
return ALLOW_BADPASS;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if ( ( numClients + numBots ) >= numAvailableSlots ) {
|
||
|
|
// We need to kick a bot to let the player in
|
||
|
|
for ( int i = 0; i < MAX_CLIENTS; i++ ) {
|
||
|
|
idPlayer* player = GetClient( i );
|
||
|
|
if ( player == NULL ) {
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
|
||
|
|
if ( player->IsType( idBot::Type ) ) {
|
||
|
|
networkSystem->ServerKickClient( i, "", false );
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
return ALLOW_YES;
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
================
|
||
|
|
idGameLocal::ServerClientConnect
|
||
|
|
================
|
||
|
|
*/
|
||
|
|
void idGameLocal::ServerClientConnect( int clientNum ) {
|
||
|
|
Printf( "client %d connected.\n", clientNum );
|
||
|
|
|
||
|
|
if ( !clientConnected[ clientNum ] ) {
|
||
|
|
clientConnected[ clientNum ] = true;
|
||
|
|
clientRanks[ clientNum ].calculated = false;
|
||
|
|
clientRanks[ clientNum ].rank = -1;
|
||
|
|
clientStatsRequestsPending = true;
|
||
|
|
#if !defined( SD_DEMO_BUILD )
|
||
|
|
clientStatsList[ clientNum ].SetNum( 0, false );
|
||
|
|
clientStatsHash[ clientNum ].Clear();
|
||
|
|
#endif /* !SD_DEMO_BUILD */
|
||
|
|
clientCompaintCount[ clientNum ] = 0;
|
||
|
|
clientUniqueComplaints[ clientNum ].SetNum( 0, false );
|
||
|
|
clientLastBanIndexReceived[ clientNum ] = -1;
|
||
|
|
|
||
|
|
clientGUIDLookup_t lookup;
|
||
|
|
|
||
|
|
clientNetworkAddress_t netAddr;
|
||
|
|
networkSystem->ServerGetClientNetworkInfo( clientNum, netAddr );
|
||
|
|
|
||
|
|
lookup.ip = ( *( int* )netAddr.ip );
|
||
|
|
lookup.pbid = 0;
|
||
|
|
|
||
|
|
networkSystem->ServerGetClientNetId( clientNum, lookup.clientId );
|
||
|
|
|
||
|
|
gameLocal.guidFile.AuthUser( clientNum, lookup );
|
||
|
|
|
||
|
|
#ifndef _XENON
|
||
|
|
if ( sdnet.HasGameSession() ) {
|
||
|
|
sdnet.ServerClientConnect( clientNum );
|
||
|
|
sdnet.UpdateGameSession( false, false );
|
||
|
|
}
|
||
|
|
#endif
|
||
|
|
}
|
||
|
|
|
||
|
|
sdInstanceCollector< sdTransport > vehicles( true );
|
||
|
|
for ( int i = 0; i < vehicles.Num(); i++ ) {
|
||
|
|
vehicles[ i ]->GetPositionManager().ResetBan( clientNum );
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
================
|
||
|
|
idGameLocal::ServerClientBegin
|
||
|
|
================
|
||
|
|
*/
|
||
|
|
void idGameLocal::ServerClientBegin( int clientNum, bool isBot ) {
|
||
|
|
if ( isServer ) { // client needs to get this straight away
|
||
|
|
sdReliableServerMessage ruleMsg( GAME_RELIABLE_SMESSAGE_RULES_DATA );
|
||
|
|
ruleMsg.WriteLong( sdGameRules::EVENT_CREATE );
|
||
|
|
ruleMsg.WriteLong( rules->GetType()->typeNum );
|
||
|
|
ruleMsg.Send( sdReliableMessageClientInfo( clientNum ) );
|
||
|
|
|
||
|
|
rules->WriteInitialReliableMessages( sdReliableMessageClientInfo( clientNum ) );
|
||
|
|
}
|
||
|
|
|
||
|
|
idPlayer* player = GetClient( clientNum );
|
||
|
|
if ( player == NULL ) {
|
||
|
|
// spawn the player
|
||
|
|
SpawnPlayer( clientNum, isBot );
|
||
|
|
player = GetClient( clientNum );
|
||
|
|
}
|
||
|
|
|
||
|
|
if ( player != NULL ) {
|
||
|
|
sdProficiencyManager::GetInstance().RestoreProficiency( player );
|
||
|
|
}
|
||
|
|
sdGlobalStatsTracker::GetInstance().Restore( clientNum );
|
||
|
|
SetupFixedClientRank( clientNum );
|
||
|
|
|
||
|
|
if ( clientNum == localClientNum ) {
|
||
|
|
rules->EnterGame( GetLocalPlayer() );
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
================
|
||
|
|
idGameLocal::SetClientNum
|
||
|
|
================
|
||
|
|
*/
|
||
|
|
void idGameLocal::SetClientNum( int clientNum, bool server ) {
|
||
|
|
InitLocalClient( clientNum, server );
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
================
|
||
|
|
idGameLocal::ShutdownClientNetworkState
|
||
|
|
================
|
||
|
|
*/
|
||
|
|
void idGameLocal::ShutdownClientNetworkState( int clientNum ) {
|
||
|
|
GetNetworkInfo( clientNum ).Reset();
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
================
|
||
|
|
idGameLocal::ServerClientDisconnect
|
||
|
|
================
|
||
|
|
*/
|
||
|
|
void idGameLocal::ServerClientDisconnect( int clientNum ) {
|
||
|
|
idPlayer* disconnectClient = GetClient( clientNum );
|
||
|
|
|
||
|
|
if ( disconnectClient != NULL ) {
|
||
|
|
for ( int i = 0; i < MAX_CLIENTS; i++ ) {
|
||
|
|
if ( i == clientNum ) {
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
|
||
|
|
idPlayer* player = GetClient( i );
|
||
|
|
if ( player == NULL ) {
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
if ( player->GetSpectateClient() != disconnectClient ) {
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
|
||
|
|
player->SpectateCycle( true );
|
||
|
|
|
||
|
|
if ( player->GetSpectateClient() != disconnectClient ) {
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
|
||
|
|
player->SetSpectateClient( player );
|
||
|
|
}
|
||
|
|
|
||
|
|
if ( !disconnectClient->userInfo.isBot ) {
|
||
|
|
sdProficiencyManager::GetInstance().CacheProficiency( disconnectClient );
|
||
|
|
}
|
||
|
|
disconnectClient->PostEventMS( &EV_Remove, 0 );
|
||
|
|
}
|
||
|
|
|
||
|
|
if ( !clientConnected[ clientNum ] ) {
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
Printf( "client %d disconnected.\n", clientNum );
|
||
|
|
|
||
|
|
clientConnected[ clientNum ] = false;
|
||
|
|
#if !defined( SD_DEMO_BUILD )
|
||
|
|
clientStatsList[ clientNum ].SetNum( 0, false );
|
||
|
|
clientStatsHash[ clientNum ].Clear();
|
||
|
|
#endif // SD_DEMO_BUILD
|
||
|
|
clientRanks[ clientNum ].calculated = false;
|
||
|
|
clientRanks[ clientNum ].rank = -1;
|
||
|
|
clientLastBanIndexReceived[ clientNum ] = -1;
|
||
|
|
clientMuteMask[ clientNum ].Clear();
|
||
|
|
for ( int i = 0; i < MAX_CLIENTS; i++ ) {
|
||
|
|
clientMuteMask[ i ].Clear( clientNum );
|
||
|
|
}
|
||
|
|
|
||
|
|
for ( int i = 0; i < endGameStats.Num(); i++ ) {
|
||
|
|
endGameStats[ i ].data[ clientNum ] = -1.f;
|
||
|
|
}
|
||
|
|
|
||
|
|
if ( botThreadData.GetGameWorldState() != NULL ) {
|
||
|
|
botThreadData.InitClientInfo( clientNum, true, true );
|
||
|
|
}
|
||
|
|
|
||
|
|
ShutdownClientNetworkState( clientNum );
|
||
|
|
|
||
|
|
for ( int i = 0; i < declVehicleScriptDefType.Num(); i++ ) {
|
||
|
|
const sdDeclVehicleScript* script = declVehicleScriptDefType.LocalFindByIndex( i, false );
|
||
|
|
script->ResetCameraMode( clientNum );
|
||
|
|
}
|
||
|
|
|
||
|
|
rules->DisconnectClient( clientNum );
|
||
|
|
|
||
|
|
#ifndef _XENON
|
||
|
|
if ( sdnet.HasGameSession() ) {
|
||
|
|
sdnet.ServerClientDisconnect( clientNum );
|
||
|
|
sdnet.UpdateGameSession( false, false );
|
||
|
|
}
|
||
|
|
#endif
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
================
|
||
|
|
idGameLocal::ServerWriteInitialReliableMessages
|
||
|
|
|
||
|
|
Send reliable messages to initialize the client game up to a certain initial state.
|
||
|
|
================
|
||
|
|
*/
|
||
|
|
void idGameLocal::ServerWriteInitialReliableMessages( int clientNum ) {
|
||
|
|
WriteInitialReliableMessages( sdReliableMessageClientInfo( clientNum ) );
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
================
|
||
|
|
idGameLocal::WriteInitialReliableMessages
|
||
|
|
================
|
||
|
|
*/
|
||
|
|
void idGameLocal::WriteInitialReliableMessages( const sdReliableMessageClientInfoBase& target ) {
|
||
|
|
assert( !target.SendToAll() );
|
||
|
|
|
||
|
|
if ( target.SendToClients() ) {
|
||
|
|
idPlayer* player = GetClient( target.GetClientNum() );
|
||
|
|
if ( player == NULL ) {
|
||
|
|
Error( "idGameLocal::ServerWriteInitialReliableMessages Client '%d' was NULL", target.GetClientNum() );
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
SendPauseInfo( target );
|
||
|
|
|
||
|
|
for ( int i = 0; i < targetTimers.Num(); i++ ) {
|
||
|
|
sdReliableServerMessage outMsg( GAME_RELIABLE_SMESSAGE_CREATEPLAYERTARGETTIMER );
|
||
|
|
outMsg.WriteString( targetTimers[ i ].name );
|
||
|
|
outMsg.WriteShort( i );
|
||
|
|
outMsg.Send( target );
|
||
|
|
}
|
||
|
|
|
||
|
|
int count = 0;
|
||
|
|
int totalCount = 0;
|
||
|
|
int totalBits = 0;
|
||
|
|
int batchCount = 0;
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
count = networkedEntities.Num();
|
||
|
|
totalCount = count;
|
||
|
|
batchCount = 0;
|
||
|
|
|
||
|
|
idEntity* ent = networkedEntities.Next();
|
||
|
|
|
||
|
|
totalBits = 0;
|
||
|
|
while ( count > 0 ) {
|
||
|
|
const int MAX_COMBINED_CREATE = 128;
|
||
|
|
int use = Min( count, MAX_COMBINED_CREATE );
|
||
|
|
|
||
|
|
batchCount++;
|
||
|
|
|
||
|
|
sdReliableServerMessage entMsg( GAME_RELIABLE_SMESSAGE_MULTI_CREATE_ENT );
|
||
|
|
entMsg.WriteLong( use );
|
||
|
|
|
||
|
|
for ( int j = 0; j < use; j++ ) {
|
||
|
|
ent->WriteCreateEvent( &entMsg, target );
|
||
|
|
ent = ent->networkNode.Next();
|
||
|
|
}
|
||
|
|
|
||
|
|
entMsg.Send( target );
|
||
|
|
|
||
|
|
totalBits += entMsg.GetNumBitsWritten();
|
||
|
|
count -= use;
|
||
|
|
}
|
||
|
|
|
||
|
|
// gameLocal.Printf( "idGameLocal::ServerWriteInitialReliableMessages Writing %d Entities Using %d bits in %d batches\n", totalCount, totalBits, batchCount );
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
// send all saved events
|
||
|
|
totalCount = 0;
|
||
|
|
batchCount = 0;
|
||
|
|
|
||
|
|
sdEntityNetEvent* start = savedEntityNetEventQueue.Next();
|
||
|
|
while ( start != NULL ) {
|
||
|
|
count = 0;
|
||
|
|
|
||
|
|
const int maxEventSizeTotal = MAX_GAME_MESSAGE_SIZE - 16;
|
||
|
|
|
||
|
|
sdEntityNetEvent* last = start;
|
||
|
|
|
||
|
|
int totalSize = 0;
|
||
|
|
while ( last != NULL ) {
|
||
|
|
totalSize += last->GetTotalSize();
|
||
|
|
if ( totalSize >= maxEventSizeTotal ) {
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
count++;
|
||
|
|
totalCount++;
|
||
|
|
last = last->GetNode().Next();
|
||
|
|
}
|
||
|
|
|
||
|
|
assert( count > 0 );
|
||
|
|
|
||
|
|
batchCount++;
|
||
|
|
|
||
|
|
sdReliableServerMessage evtMsg( GAME_RELIABLE_SMESSAGE_MULTI_ENTITY_EVENT );
|
||
|
|
evtMsg.WriteLong( count );
|
||
|
|
|
||
|
|
while ( start != last ) {
|
||
|
|
idEntity* temp = gameLocal.EntityForSpawnId( start->GetSpawnId() );
|
||
|
|
if ( temp == NULL ) {
|
||
|
|
gameLocal.Warning( "idGameLocal::ServerWriteInitialReliableMessages NULL entity" );
|
||
|
|
}
|
||
|
|
|
||
|
|
start->Write( evtMsg );
|
||
|
|
start = start->GetNode().Next();
|
||
|
|
}
|
||
|
|
|
||
|
|
evtMsg.Send( target );
|
||
|
|
|
||
|
|
totalBits += evtMsg.GetNumBitsWritten();
|
||
|
|
}
|
||
|
|
|
||
|
|
// gameLocal.Printf( "idGameLocal::ServerWriteInitialReliableMessages Writing %d Saved Events Using %d bits in %d batches\n", totalCount, totalBits, batchCount );
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
for ( idEntity* ent = networkedEntities.Next(); ent; ent = ent->networkNode.Next() ) {
|
||
|
|
ent->WriteInitialReliableMessages( target );
|
||
|
|
}
|
||
|
|
|
||
|
|
for ( int i = 0; i < NUM_DEPLOY_REQUESTS; i++ ) {
|
||
|
|
if ( !deployRequests[ i ] ) {
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
deployRequests[ i ]->WriteCreateEvent( i, target );
|
||
|
|
}
|
||
|
|
|
||
|
|
sdTaskManager::GetInstance().WriteInitialReliableMessages( target );
|
||
|
|
sdFireTeamManager::GetInstance().WriteInitialReliableMessages( target );
|
||
|
|
sdObjectiveManager::GetInstance().WriteInitialReliableMessages( target );
|
||
|
|
sdUserGroupManager::GetInstance().WriteNetworkData( target );
|
||
|
|
|
||
|
|
SendEndGameStats( target );
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
================
|
||
|
|
idGameLocal::ClientWriteGameState
|
||
|
|
================
|
||
|
|
*/
|
||
|
|
void idGameLocal::ClientWriteGameState( idFile* file ) {
|
||
|
|
file->WriteBool( isPaused );
|
||
|
|
file->WriteInt( time );
|
||
|
|
file->WriteInt( timeOffset );
|
||
|
|
|
||
|
|
assert( rules != NULL );
|
||
|
|
file->WriteInt( rules->GetType()->typeNum );
|
||
|
|
|
||
|
|
file->WriteInt( targetTimers.Num() );
|
||
|
|
for ( int i = 0; i < targetTimers.Num(); i++ ) {
|
||
|
|
file->WriteString( targetTimers[ i ].name );
|
||
|
|
file->WriteInt( targetTimers[ i ].serverHandle );
|
||
|
|
if ( localClientNum != ASYNC_DEMO_CLIENT_INDEX ) {
|
||
|
|
file->WriteInt( targetTimers[ i ].endTimes[ localClientNum ] );
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
file->WriteInt( networkedEntities.Num() );
|
||
|
|
for ( idEntity* ent = networkedEntities.Next(); ent; ent = ent->networkNode.Next() ) {
|
||
|
|
ent->WriteCreationData( file );
|
||
|
|
ASYNC_SECURITY_WRITE_FILE( file )
|
||
|
|
}
|
||
|
|
|
||
|
|
// Gordon: now seperate so the client can create all entities before reading this data
|
||
|
|
for ( idEntity* ent = networkedEntities.Next(); ent; ent = ent->networkNode.Next() ) {
|
||
|
|
ent->WriteDemoBaseData( file );
|
||
|
|
ASYNC_SECURITY_WRITE_FILE( file )
|
||
|
|
}
|
||
|
|
|
||
|
|
file->WriteInt( entityNetEventQueue.Num() );
|
||
|
|
for ( sdEntityNetEvent* event = entityNetEventQueue.Next(); event; event = event->GetNode().Next() ) {
|
||
|
|
event->Write( file );
|
||
|
|
ASYNC_SECURITY_WRITE_FILE( file )
|
||
|
|
}
|
||
|
|
|
||
|
|
for ( int i = 0; i < NUM_DEPLOY_REQUESTS; i++ ) {
|
||
|
|
if ( !deployRequests[ i ] ) {
|
||
|
|
file->WriteBool( false );
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
file->WriteBool( true );
|
||
|
|
deployRequests[ i ]->Write( file );
|
||
|
|
}
|
||
|
|
|
||
|
|
sdTaskManager::GetInstance().Write( file );
|
||
|
|
sdFireTeamManager::GetInstance().Write( file );
|
||
|
|
sdUserGroupManager::GetInstance().Write( file );
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
================
|
||
|
|
idGameLocal::ClientReadGameState
|
||
|
|
================
|
||
|
|
*/
|
||
|
|
void idGameLocal::ClientReadGameState( idFile* file ) {
|
||
|
|
file->ReadBool( isPaused );
|
||
|
|
file->ReadInt( time );
|
||
|
|
file->ReadInt( timeOffset );
|
||
|
|
|
||
|
|
int rulesTypeNum;
|
||
|
|
file->ReadInt( rulesTypeNum );
|
||
|
|
SetRules( idClass::GetType( rulesTypeNum ) );
|
||
|
|
|
||
|
|
ClearTargetTimers();
|
||
|
|
|
||
|
|
int count;
|
||
|
|
file->ReadInt( count );
|
||
|
|
|
||
|
|
targetTimers.SetNum( count );
|
||
|
|
numServerTimers = 0;
|
||
|
|
for ( int i = 0; i < count; i++ ) {
|
||
|
|
int serverHandle;
|
||
|
|
|
||
|
|
file->ReadString( targetTimers[ i ].name );
|
||
|
|
file->ReadInt( serverHandle );
|
||
|
|
targetTimers[ i ].serverHandle = serverHandle;
|
||
|
|
if ( localClientNum != ASYNC_DEMO_CLIENT_INDEX ) {
|
||
|
|
file->ReadInt( targetTimers[ i ].endTimes[ localClientNum ] );
|
||
|
|
}
|
||
|
|
|
||
|
|
if ( serverHandle != -1 ) {
|
||
|
|
numServerTimers = Max( serverHandle + 1, numServerTimers );
|
||
|
|
if ( numServerTimers > targetTimerLookup.Num() ) {
|
||
|
|
targetTimerLookup.AssureSize( numServerTimers, -1 );
|
||
|
|
}
|
||
|
|
targetTimerLookup[ serverHandle ] = i;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
idList< idEntity* > creationEnts;
|
||
|
|
|
||
|
|
file->ReadInt( count );
|
||
|
|
|
||
|
|
creationEnts.SetNum( count );
|
||
|
|
|
||
|
|
for ( int i = 0; i < count; i++ ) {
|
||
|
|
creationEnts[ i ] = idEntity::FromCreationData( file );
|
||
|
|
|
||
|
|
if ( !creationEnts[ i ] ) {
|
||
|
|
gameLocal.Error( "idGameLocal::ClientReadGameState Failed to spawn entity from demo" );
|
||
|
|
}
|
||
|
|
|
||
|
|
ASYNC_SECURITY_READ_FILE( file )
|
||
|
|
}
|
||
|
|
|
||
|
|
// Gordon: moved this out of the above loop so all entities are spawned before they read their creation data
|
||
|
|
// as they may want to link to an existing entity further down the chain
|
||
|
|
for ( int i = 0; i < count; i++ ) {
|
||
|
|
creationEnts[ i ]->LoadDemoBaseData( file );
|
||
|
|
|
||
|
|
ASYNC_SECURITY_READ_FILE( file )
|
||
|
|
}
|
||
|
|
|
||
|
|
file->ReadInt( count );
|
||
|
|
for ( int i = 0; i < count; i++ ) {
|
||
|
|
sdEntityNetEvent* event = entityNetEventAllocator.Alloc();
|
||
|
|
event->GetNode().AddToEnd( entityNetEventQueue );
|
||
|
|
event->Read( file );
|
||
|
|
|
||
|
|
ASYNC_SECURITY_READ_FILE( file )
|
||
|
|
}
|
||
|
|
|
||
|
|
ClearDeployRequests();
|
||
|
|
for ( int i = 0; i < NUM_DEPLOY_REQUESTS; i++ ) {
|
||
|
|
bool temp;
|
||
|
|
file->ReadBool( temp );
|
||
|
|
if ( !temp ) {
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
|
||
|
|
deployRequests[ i ] = new sdDeployRequest( file );
|
||
|
|
}
|
||
|
|
|
||
|
|
sdTaskManager::GetInstance().Read( file );
|
||
|
|
sdFireTeamManager::GetInstance().Read( file );
|
||
|
|
sdUserGroupManager::GetInstance().Read( file );
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
================
|
||
|
|
idGameLocal::FreeEntityNetworkEvents
|
||
|
|
================
|
||
|
|
*/
|
||
|
|
void idGameLocal::FreeEntityNetworkEvents( const idEntity *ent, int eventId ) {
|
||
|
|
|
||
|
|
sdEntityNetEvent* next;
|
||
|
|
for ( sdEntityNetEvent* event = savedEntityNetEventQueue.Next(); event; event = next ) {
|
||
|
|
next = event->GetNode().Next();
|
||
|
|
|
||
|
|
if ( eventId == -1 || event->GetEvent() == eventId ) {
|
||
|
|
|
||
|
|
idEntity* eventEnt = gameLocal.EntityForSpawnId( event->GetSpawnId() );
|
||
|
|
if ( eventEnt == ent ) {
|
||
|
|
event->GetNode().Remove();
|
||
|
|
entityNetEventAllocator.Free( event );
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
================
|
||
|
|
idGameLocal::SaveEntityNetworkEvent
|
||
|
|
================
|
||
|
|
*/
|
||
|
|
void idGameLocal::SaveEntityNetworkEvent( const sdEntityNetEvent& oldEvent ) {
|
||
|
|
sdEntityNetEvent* event;
|
||
|
|
event = entityNetEventAllocator.Alloc();
|
||
|
|
event->Create( oldEvent );
|
||
|
|
event->GetNode().AddToEnd( savedEntityNetEventQueue );
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
================
|
||
|
|
idGameLocal::SendUnreliableEntityNetworkEvent
|
||
|
|
================
|
||
|
|
*/
|
||
|
|
void idGameLocal::SendUnreliableEntityNetworkEvent( const idEntity *ent, int eventId, const idBitMsg *msg ) {
|
||
|
|
sdUnreliableEntityNetEvent* event;
|
||
|
|
event = unreliableEntityNetEventAllocator.Alloc();
|
||
|
|
event->Create( ent, eventId, false, msg );
|
||
|
|
event->ClearSent();
|
||
|
|
event->GetUnreliableNode().AddToEnd( unreliableEntityNetEventQueue );
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
================
|
||
|
|
idGameLocal::SendUnreliableEntityNetworkEvent
|
||
|
|
================
|
||
|
|
*/
|
||
|
|
void idGameLocal::SendUnreliableEntityNetworkEvent( const sdUnreliableEntityNetEvent& oldEvent ) {
|
||
|
|
sdUnreliableEntityNetEvent* event;
|
||
|
|
event = unreliableEntityNetEventAllocator.Alloc();
|
||
|
|
event->Create( oldEvent );
|
||
|
|
event->ClearSent();
|
||
|
|
event->GetUnreliableNode().AddToEnd( unreliableEntityNetEventQueue );
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
================
|
||
|
|
idGameLocal::WriteUnreliableEntityEvents
|
||
|
|
================
|
||
|
|
*/
|
||
|
|
void idGameLocal::WriteUnreliableEntityNetEvents( int clientNum, bool repeaterClient, idBitMsg &msg ) {
|
||
|
|
// write unreliable entity network events to the snapshot
|
||
|
|
// first count them up
|
||
|
|
int numEvents = 0;
|
||
|
|
sdUnreliableEntityNetEvent* event;
|
||
|
|
sdUnreliableEntityNetEvent* nextEvent;
|
||
|
|
for ( event = unreliableEntityNetEventQueue.Next(); event != NULL; event = nextEvent ) {
|
||
|
|
nextEvent = event->GetUnreliableNode().Next();
|
||
|
|
|
||
|
|
#ifdef SD_SUPPORT_REPEATER
|
||
|
|
if ( repeaterClient ) {
|
||
|
|
if ( !event->GetRepeaterSent( clientNum ) ) {
|
||
|
|
numEvents++;
|
||
|
|
}
|
||
|
|
} else
|
||
|
|
#endif // SD_SUPPORT_REPEATER
|
||
|
|
{
|
||
|
|
if ( !event->GetSent( clientNum ) ) {
|
||
|
|
numEvents++;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// now write them
|
||
|
|
msg.WriteLong( numEvents );
|
||
|
|
for ( event = unreliableEntityNetEventQueue.Next(); event != NULL; event = nextEvent ) {
|
||
|
|
nextEvent = event->GetUnreliableNode().Next();
|
||
|
|
|
||
|
|
#ifdef SD_SUPPORT_REPEATER
|
||
|
|
if ( repeaterClient ) {
|
||
|
|
if ( !event->GetRepeaterSent( clientNum ) ) {
|
||
|
|
event->Write( msg );
|
||
|
|
event->SetRepeaterSent( clientNum );
|
||
|
|
}
|
||
|
|
} else
|
||
|
|
#endif // SD_SUPPORT_REPEATER
|
||
|
|
{
|
||
|
|
if ( !event->GetSent( clientNum ) ) {
|
||
|
|
event->Write( msg );
|
||
|
|
event->SetSent( clientNum );
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// check if the event has expired
|
||
|
|
if ( event->HasExpired() ) {
|
||
|
|
event->GetUnreliableNode().Remove();
|
||
|
|
unreliableEntityNetEventAllocator.Free( event );
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
================
|
||
|
|
idGameLocal::FreeSnapshotsOlderThanSequence
|
||
|
|
================
|
||
|
|
*/
|
||
|
|
void idGameLocal::FreeSnapshotsOlderThanSequence( clientNetworkInfo_t& nwInfo, int sequence ) {
|
||
|
|
snapshot_t* nextSnapshot;
|
||
|
|
|
||
|
|
snapshot_t* lastSnapshot = NULL;
|
||
|
|
for ( snapshot_t* snapshot = nwInfo.snapshots; snapshot; snapshot = nextSnapshot ) {
|
||
|
|
nextSnapshot = snapshot->next;
|
||
|
|
if ( snapshot->sequence < sequence ) {
|
||
|
|
|
||
|
|
if ( lastSnapshot ) {
|
||
|
|
lastSnapshot->next = snapshot->next;
|
||
|
|
} else {
|
||
|
|
nwInfo.snapshots = snapshot->next;
|
||
|
|
}
|
||
|
|
|
||
|
|
for ( int i = 0; i < NSM_NUM_MODES; i++ ) {
|
||
|
|
sdEntityState* nextState;
|
||
|
|
for ( sdEntityState* state = snapshot->firstEntityState[ i ]; state; state = nextState ) {
|
||
|
|
nextState = state->next;
|
||
|
|
|
||
|
|
idEntity* ent = EntityForSpawnId( state->GetSpawnId() );
|
||
|
|
if ( ent ) {
|
||
|
|
state->next = ent->freeStates[ i ];
|
||
|
|
ent->freeStates[ i ] = state;
|
||
|
|
} else {
|
||
|
|
FreeNetworkState( state );
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
for ( int i = 0; i < ENSM_NUM_MODES; i++ ) {
|
||
|
|
if ( snapshot->gameStates[ i ] == NULL ) {
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
|
||
|
|
sdNetworkStateObject& obj = GetGameStateObject( ( extNetworkStateMode_t )i );
|
||
|
|
snapshot->gameStates[ i ]->next = obj.freeStates;
|
||
|
|
obj.freeStates = snapshot->gameStates[ i ];
|
||
|
|
}
|
||
|
|
|
||
|
|
snapshotAllocator.Free( snapshot );
|
||
|
|
} else {
|
||
|
|
lastSnapshot = snapshot;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
================
|
||
|
|
idGameLocal::ApplySnapshot
|
||
|
|
================
|
||
|
|
*/
|
||
|
|
bool idGameLocal::ApplySnapshot( clientNetworkInfo_t& nwInfo, int sequence ) {
|
||
|
|
snapshot_t *snapshot, *lastSnapshot, *nextSnapshot;
|
||
|
|
|
||
|
|
FreeSnapshotsOlderThanSequence( nwInfo, sequence );
|
||
|
|
|
||
|
|
for ( lastSnapshot = NULL, snapshot = nwInfo.snapshots; snapshot; snapshot = nextSnapshot ) {
|
||
|
|
nextSnapshot = snapshot->next;
|
||
|
|
if ( snapshot->sequence == sequence ) {
|
||
|
|
if ( lastSnapshot ) {
|
||
|
|
lastSnapshot->next = nextSnapshot;
|
||
|
|
} else {
|
||
|
|
nwInfo.snapshots = nextSnapshot;
|
||
|
|
}
|
||
|
|
|
||
|
|
for ( int i = 0; i < NSM_NUM_MODES; i++ ) {
|
||
|
|
sdEntityState* next;
|
||
|
|
for ( sdEntityState* state = snapshot->firstEntityState[ i ]; state; state = next ) {
|
||
|
|
next = state->next;
|
||
|
|
|
||
|
|
idEntity* ent = EntityForSpawnId( state->GetSpawnId() );
|
||
|
|
if ( ent ) {
|
||
|
|
sdEntityState* oldState = nwInfo.states[ ent->entityNumber ][ i ];
|
||
|
|
oldState->next = ent->freeStates[ i ];
|
||
|
|
ent->freeStates[ i ] = oldState;
|
||
|
|
|
||
|
|
nwInfo.states[ ent->entityNumber ][ i ] = state;
|
||
|
|
state->next = NULL;
|
||
|
|
} else {
|
||
|
|
FreeNetworkState( state );
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
for ( int i = 0; i < snapshot->visibleEntities.Num(); i++ ) {
|
||
|
|
nwInfo.lastMarker[ snapshot->visibleEntities[ i ] ] = snapshot->time;
|
||
|
|
}
|
||
|
|
|
||
|
|
for ( int i = 0; i < MAX_CLIENTS; i++ ) {
|
||
|
|
if ( snapshot->clientUserCommands.Get( i ) ) {
|
||
|
|
if ( nwInfo.lastUserCommand[ i ] != -1 ) {
|
||
|
|
nwInfo.lastUserCommandDelay[ i ] = snapshot->time - nwInfo.lastUserCommand[ i ];
|
||
|
|
} else {
|
||
|
|
nwInfo.lastUserCommandDelay[ i ] = 0;
|
||
|
|
}
|
||
|
|
nwInfo.lastUserCommand[ i ] = snapshot->time;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
for ( int i = 0; i < ENSM_NUM_MODES; i++ ) {
|
||
|
|
if ( !snapshot->gameStates[ i ] ) {
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
|
||
|
|
sdNetworkStateObject& object = GetGameStateObject( ( extNetworkStateMode_t )i );
|
||
|
|
|
||
|
|
sdGameState* oldState = nwInfo.gameStates[ i ];
|
||
|
|
oldState->next = object.freeStates;
|
||
|
|
object.freeStates = oldState;
|
||
|
|
|
||
|
|
nwInfo.gameStates[ i ] = snapshot->gameStates[ i ];
|
||
|
|
}
|
||
|
|
|
||
|
|
snapshotAllocator.Free( snapshot );
|
||
|
|
return true;
|
||
|
|
} else {
|
||
|
|
lastSnapshot = snapshot;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
================
|
||
|
|
idGameLocal::ServerWriteSnapshot
|
||
|
|
================
|
||
|
|
*/
|
||
|
|
snapshot_t* idGameLocal::AllocateSnapshot( int sequence, clientNetworkInfo_t& nwInfo ) {
|
||
|
|
// allocate new snapshot
|
||
|
|
snapshot_t* snapshot = snapshotAllocator.Alloc();
|
||
|
|
snapshot->Init( sequence, time );
|
||
|
|
snapshot->next = nwInfo.snapshots;
|
||
|
|
nwInfo.snapshots = snapshot;
|
||
|
|
activeSnapshot = snapshot;
|
||
|
|
snapshot->visibleEntities.SetNum( 0, false );
|
||
|
|
snapshot->clientUserCommands.Clear();
|
||
|
|
return snapshot;
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
================
|
||
|
|
idGameLocal::WriteSnapshotGameStates
|
||
|
|
================
|
||
|
|
*/
|
||
|
|
void idGameLocal::WriteSnapshotGameStates( snapshot_t* snapshot, clientNetworkInfo_t& nwInfo, idBitMsg& msg ) {
|
||
|
|
// ASYNC_SECURITY_WRITE( msg )
|
||
|
|
WriteGameState( ENSM_TEAM, snapshot, nwInfo, msg );
|
||
|
|
// ASYNC_SECURITY_WRITE( msg )
|
||
|
|
|
||
|
|
// ASYNC_SECURITY_WRITE( msg )
|
||
|
|
WriteGameState( ENSM_RULES, snapshot, nwInfo, msg );
|
||
|
|
// ASYNC_SECURITY_WRITE( msg )
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
================
|
||
|
|
idGameLocal::WriteSnapshotEntityStates
|
||
|
|
================
|
||
|
|
*/
|
||
|
|
void idGameLocal::WriteSnapshotEntityStates( snapshot_t* snapshot, clientNetworkInfo_t& nwInfo, int clientNum, idBitMsg& msg, bool useAOR ) {
|
||
|
|
idStaticList< idEntity*, MAX_GENTITIES > visibleEntities;
|
||
|
|
idStaticList< idEntity*, MAX_GENTITIES > broadcastEntities;
|
||
|
|
|
||
|
|
idEntity* ent = NULL;
|
||
|
|
if ( useAOR ) {
|
||
|
|
for ( ent = networkedEntities.Next(); ent != NULL; ent = ent->networkNode.Next() ) {
|
||
|
|
ent->snapshotPVSFlags = PVS_VISIBLE;
|
||
|
|
|
||
|
|
bool update = true;
|
||
|
|
aorManager.UpdateEntityAORFlags( ent, ent->GetPhysics()->GetOrigin(), update );
|
||
|
|
|
||
|
|
sdEntityState* baseState;
|
||
|
|
if ( ent != snapShotPlayer && ent->entityNumber != clientNum && !update ) {
|
||
|
|
ent->snapshotPVSFlags &= ~( PVS_VISIBLE );
|
||
|
|
} else {
|
||
|
|
baseState = nwInfo.states[ ent->entityNumber ][ NSM_VISIBLE ];
|
||
|
|
if ( ent->CheckNetworkStateChanges( NSM_VISIBLE, *baseState->data ) ) {
|
||
|
|
*visibleEntities.Alloc() = ent;
|
||
|
|
} else {
|
||
|
|
ent->snapshotPVSFlags &= ~( PVS_VISIBLE );
|
||
|
|
}
|
||
|
|
|
||
|
|
snapshot->visibleEntities.Alloc() = ent->entityNumber;
|
||
|
|
}
|
||
|
|
|
||
|
|
baseState = nwInfo.states[ ent->entityNumber ][ NSM_BROADCAST ];
|
||
|
|
if ( ent->CheckNetworkStateChanges( NSM_BROADCAST, *baseState->data ) ) {
|
||
|
|
*broadcastEntities.Alloc() = ent;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
for( ent = networkedEntities.Next(); ent != NULL; ent = ent->networkNode.Next() ) {
|
||
|
|
ent->snapshotPVSFlags = PVS_VISIBLE;
|
||
|
|
snapshot->visibleEntities.Alloc() = ent->entityNumber;
|
||
|
|
|
||
|
|
sdEntityState* baseState;
|
||
|
|
|
||
|
|
baseState = nwInfo.states[ ent->entityNumber ][ NSM_VISIBLE ];
|
||
|
|
if ( ent->CheckNetworkStateChanges( NSM_VISIBLE, *baseState->data ) ) {
|
||
|
|
*visibleEntities.Alloc() = ent;
|
||
|
|
} else {
|
||
|
|
ent->snapshotPVSFlags &= ~( PVS_VISIBLE );
|
||
|
|
}
|
||
|
|
|
||
|
|
baseState = nwInfo.states[ ent->entityNumber ][ NSM_BROADCAST ];
|
||
|
|
if ( ent->CheckNetworkStateChanges( NSM_BROADCAST, *baseState->data ) ) {
|
||
|
|
*broadcastEntities.Alloc() = ent;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
for ( int i = 0; i < visibleEntities.Num(); i++ ) {
|
||
|
|
idEntity* ent = visibleEntities[ i ];
|
||
|
|
|
||
|
|
int oldBits = msg.GetNumBitsWritten();
|
||
|
|
|
||
|
|
msg.WriteBits( ent->entityNumber, GENTITYNUM_BITS );
|
||
|
|
|
||
|
|
sdEntityState* baseState = nwInfo.states[ ent->entityNumber ][ NSM_VISIBLE ];
|
||
|
|
sdEntityState* newState = AllocEntityState( NSM_VISIBLE, ent );
|
||
|
|
|
||
|
|
// ASYNC_SECURITY_WRITE( msg )
|
||
|
|
ent->WriteNetworkState( NSM_VISIBLE, *baseState->data, *newState->data, msg );
|
||
|
|
// ASYNC_SECURITY_WRITE( msg )
|
||
|
|
|
||
|
|
if ( g_debugNetworkWrite.GetBool() ) {
|
||
|
|
int bitsWritten = msg.GetNumBitsWritten() - oldBits;
|
||
|
|
gameLocal.LogNetwork( va( "Writing Visible: '%s' '%s', %d bits\n", ent->GetType()->classname, ent->name.c_str(), bitsWritten ) );
|
||
|
|
}
|
||
|
|
|
||
|
|
newState->next = snapshot->firstEntityState[ NSM_VISIBLE ];
|
||
|
|
snapshot->firstEntityState[ NSM_VISIBLE ] = newState;
|
||
|
|
}
|
||
|
|
msg.WriteBits( ENTITYNUM_NONE, GENTITYNUM_BITS );
|
||
|
|
|
||
|
|
for ( int i = 0; i < broadcastEntities.Num(); i++ ) {
|
||
|
|
idEntity* ent = broadcastEntities[ i ];
|
||
|
|
|
||
|
|
int oldBits = msg.GetNumBitsWritten();
|
||
|
|
|
||
|
|
msg.WriteBits( ent->entityNumber, GENTITYNUM_BITS );
|
||
|
|
|
||
|
|
sdEntityState* baseState = nwInfo.states[ ent->entityNumber ][ NSM_BROADCAST ];
|
||
|
|
sdEntityState* newState = AllocEntityState( NSM_BROADCAST, ent );
|
||
|
|
|
||
|
|
// ASYNC_SECURITY_WRITE( msg )
|
||
|
|
ent->WriteNetworkState( NSM_BROADCAST, *baseState->data, *newState->data, msg );
|
||
|
|
// ASYNC_SECURITY_WRITE( msg )
|
||
|
|
|
||
|
|
if ( g_debugNetworkWrite.GetBool() ) {
|
||
|
|
int bitsWritten = msg.GetNumBitsWritten() - oldBits;
|
||
|
|
gameLocal.LogNetwork( va( "Writing Broadcast: '%s' '%s', %d bits\n", ent->GetType()->classname, ent->name.c_str(), bitsWritten ) );
|
||
|
|
}
|
||
|
|
|
||
|
|
newState->next = snapshot->firstEntityState[ NSM_BROADCAST ];
|
||
|
|
snapshot->firstEntityState[ NSM_BROADCAST ] = newState;
|
||
|
|
}
|
||
|
|
msg.WriteBits( ENTITYNUM_NONE, GENTITYNUM_BITS );
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
================
|
||
|
|
idGameLocal::WriteSnapshotUserCmds
|
||
|
|
================
|
||
|
|
*/
|
||
|
|
void idGameLocal::WriteSnapshotUserCmds( snapshot_t* snapshot, idBitMsg& msg, int ignoreClientNum, bool useAOR ) {
|
||
|
|
// write the latest user commands from the other clients in the PVS to the snapshot
|
||
|
|
// written to a seperate idBitMsg, which uses a different compression strategy
|
||
|
|
for ( int i = 0; i < MAX_CLIENTS; i++ ) {
|
||
|
|
if ( i == ignoreClientNum ) {
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
|
||
|
|
idPlayer* otherPlayer = GetClient( i );
|
||
|
|
if ( !otherPlayer ) {
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
|
||
|
|
if ( useAOR && otherPlayer != snapShotPlayer ) {
|
||
|
|
if ( otherPlayer->GetProxyEntity() == NULL ) {
|
||
|
|
if ( otherPlayer->aorFlags & AOR_INHIBIT_USERCMDS ) {
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
if ( otherPlayer->GetProxyEntity()->aorFlags & AOR_INHIBIT_USERCMDS ) {
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
msg.WriteBits( i, CLIENTBITS );
|
||
|
|
networkSystem->WriteClientUserCmds( i, msg );
|
||
|
|
|
||
|
|
// record that this client had its user command's sent with this snapshot
|
||
|
|
snapshot->clientUserCommands.Set( i );
|
||
|
|
if ( !IsPaused() ) {
|
||
|
|
sdAntiLagManager::GetInstance().CreateUserCommandBranch( otherPlayer );
|
||
|
|
}
|
||
|
|
}
|
||
|
|
msg.WriteBits( MAX_CLIENTS, CLIENTBITS );
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
================
|
||
|
|
idGameLocal::ServerWriteSnapshot
|
||
|
|
|
||
|
|
Write a snapshot of the current game state for the given client.
|
||
|
|
================
|
||
|
|
*/
|
||
|
|
void idGameLocal::ServerWriteSnapshot( int clientNum, int sequence, idBitMsg &msg, idBitMsg &ucmdmsg ) {
|
||
|
|
int oldBitsMain = msg.GetNumBitsWritten();
|
||
|
|
if ( g_debugNetworkWrite.GetBool() ) {
|
||
|
|
gameLocal.LogNetwork( va( "Writing Network State for client %d\n\n", clientNum ) );
|
||
|
|
}
|
||
|
|
|
||
|
|
bool useAOR = net_useAOR.GetBool();
|
||
|
|
|
||
|
|
snapShotClientIsRepeater = false; // Gordon: Main server will never have repeaters connected to it
|
||
|
|
SetSnapShotClient( NULL );
|
||
|
|
SetSnapShotPlayer( NULL );
|
||
|
|
if ( clientNum != ASYNC_DEMO_CLIENT_INDEX ) {
|
||
|
|
idPlayer* player = GetClient( clientNum );
|
||
|
|
if ( !player ) {
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
SetSnapShotClient( player );
|
||
|
|
SetSnapShotPlayer( player->GetSpectateClient() );
|
||
|
|
|
||
|
|
aorManager.SetClient( snapShotPlayer );
|
||
|
|
} else {
|
||
|
|
useAOR = false;
|
||
|
|
}
|
||
|
|
|
||
|
|
clientNetworkInfo_t& nwInfo = GetNetworkInfo( clientNum );
|
||
|
|
|
||
|
|
// free too old snapshots
|
||
|
|
FreeSnapshotsOlderThanSequence( nwInfo, sequence - 64 );
|
||
|
|
|
||
|
|
snapshot_t* snapshot = AllocateSnapshot( sequence, nwInfo );
|
||
|
|
WriteSnapshotGameStates( snapshot, nwInfo, msg );
|
||
|
|
WriteSnapshotEntityStates( snapshot, nwInfo, clientNum, msg, useAOR );
|
||
|
|
WriteUnreliableEntityNetEvents( clientNum, false, msg );
|
||
|
|
WriteSnapshotUserCmds( snapshot, ucmdmsg, clientNum, useAOR );
|
||
|
|
|
||
|
|
snapShotClientIsRepeater = false;
|
||
|
|
SetSnapShotClient( NULL );
|
||
|
|
SetSnapShotPlayer( NULL );
|
||
|
|
|
||
|
|
if ( g_debugNetworkWrite.GetBool() ) {
|
||
|
|
int bitsWrittenMain = msg.GetNumBitsWritten() - oldBitsMain;
|
||
|
|
gameLocal.LogNetwork( va( "\nTotal Bits Written: %d\nFinished Writing Network State for client %d\n\n", bitsWrittenMain, clientNum ) );
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
================
|
||
|
|
idGameLocal::ServerApplySnapshot
|
||
|
|
================
|
||
|
|
*/
|
||
|
|
bool idGameLocal::ServerApplySnapshot( int clientNum, int sequence ) {
|
||
|
|
return ApplySnapshot( GetNetworkInfo( clientNum ), sequence );
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
================
|
||
|
|
idGameLocal::NetworkEventWarning
|
||
|
|
================
|
||
|
|
*/
|
||
|
|
void idGameLocal::NetworkEventWarning( const sdEntityNetEvent& event, const char *fmt, ... ) {
|
||
|
|
char buf[1024];
|
||
|
|
int length = 0;
|
||
|
|
va_list argptr;
|
||
|
|
|
||
|
|
length += idStr::snPrintf( buf+length, sizeof(buf)-1-length, "event %d for entity %d %d: ", event.GetEvent(), event.GetEntityNumber(), event.GetId() );
|
||
|
|
va_start( argptr, fmt );
|
||
|
|
length = idStr::vsnPrintf( buf+length, sizeof(buf)-1-length, fmt, argptr );
|
||
|
|
va_end( argptr );
|
||
|
|
// idStr::Append( buf, sizeof(buf), "\n" ); - warning puts a \n already
|
||
|
|
|
||
|
|
gameLocal.DWarning( buf );
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
================
|
||
|
|
idGameLocal::UnreliableNetworkEventWarning
|
||
|
|
================
|
||
|
|
*/
|
||
|
|
void idGameLocal::UnreliableNetworkEventWarning( const sdUnreliableEntityNetEvent& event, const char *fmt, ... ) {
|
||
|
|
char buf[1024];
|
||
|
|
int length = 0;
|
||
|
|
va_list argptr;
|
||
|
|
|
||
|
|
length += idStr::snPrintf( buf+length, sizeof(buf)-1-length, "unreliable event %d for entity %d %d: ", event.GetEvent(), event.GetEntityNumber(), event.GetId() );
|
||
|
|
va_start( argptr, fmt );
|
||
|
|
length = idStr::vsnPrintf( buf+length, sizeof(buf)-1-length, fmt, argptr );
|
||
|
|
va_end( argptr );
|
||
|
|
// idStr::Append( buf, sizeof(buf), "\n" ); - warning puts a \n already
|
||
|
|
|
||
|
|
gameLocal.DWarning( buf );
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
================
|
||
|
|
idGameLocal::ServerSendQuickChatMessage
|
||
|
|
================
|
||
|
|
*/
|
||
|
|
void idGameLocal::ServerSendQuickChatMessage( idPlayer* player, const sdDeclQuickChat* quickChat, idPlayer* recipient, idEntity* target ) {
|
||
|
|
if ( !quickChat ) {
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
if ( !isClient ) {
|
||
|
|
if ( player != NULL ) {
|
||
|
|
|
||
|
|
//mal: update this players chat time and what the chat was, so the bots can see it, and respond if needed.
|
||
|
|
if ( !botThreadData.GetGameWorldState()->clientInfo[ player->entityNumber ].isBot ) {
|
||
|
|
if ( quickChat->GetType() != NULL_CHAT ) {
|
||
|
|
botThreadData.UpdateChats( player->entityNumber, quickChat );
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
const char* callback = quickChat->GetCallback();
|
||
|
|
|
||
|
|
if ( *callback ) {
|
||
|
|
sdScriptHelper helper;
|
||
|
|
if ( target != NULL ) {
|
||
|
|
helper.Push( target->GetScriptObject() );
|
||
|
|
}
|
||
|
|
player->CallNonBlockingScriptEvent( player->scriptObject->GetFunction( callback ), helper );
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if ( player != NULL && recipient == NULL ) {
|
||
|
|
if ( gameLocal.rules->MuteStatus( player ) & MF_CHAT ) {
|
||
|
|
const sdUserGroup& userGroup = sdUserGroupManager::GetInstance().GetGroup( player->GetUserGroup() );
|
||
|
|
if ( !userGroup.HasPermission( PF_NO_MUTE ) ) {
|
||
|
|
player->SendLocalisedMessage( declHolder.declLocStrType[ "rules/messages/muted" ], idWStrList() );
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if ( !quickChat->IsTeam() ) {
|
||
|
|
if ( si_disableGlobalChat.GetBool() ) {
|
||
|
|
const sdUserGroup& userGroup = sdUserGroupManager::GetInstance().GetGroup( player->GetUserGroup() );
|
||
|
|
if ( !userGroup.HasPermission( PF_NO_MUTE ) ) {
|
||
|
|
player->SendLocalisedMessage( declHolder.declLocStrType[ "rules/messages/globalchatdisabled" ], idWStrList() );
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
int sendingClientNum = player == NULL ? -1 : player->entityNumber;
|
||
|
|
idVec3 location = player == NULL ? vec3_origin : player->GetPhysics()->GetOrigin();
|
||
|
|
|
||
|
|
for ( int i = 0; i < MAX_CLIENTS; i++ ) {
|
||
|
|
idPlayer* other = GetClient( i );
|
||
|
|
if ( !other ) {
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
|
||
|
|
if ( recipient && other != recipient ) {
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
|
||
|
|
if ( !quickChat->Check( other, player ) ) {
|
||
|
|
continue;
|
||
|
|
} else if ( quickChat->IsTeam() && player != NULL ) {
|
||
|
|
if ( player->GetEntityAllegiance( other ) != TA_FRIEND ) {
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
other->PlayQuickChat( location, sendingClientNum, quickChat, target );
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
================
|
||
|
|
idGameLocal::ServerProcessReliableMessage
|
||
|
|
================
|
||
|
|
*/
|
||
|
|
void idGameLocal::ServerProcessReliableMessage( int clientNum, const idBitMsg &msg ) {
|
||
|
|
gameReliableClientMessage_t id = static_cast< gameReliableClientMessage_t >( msg.ReadBits( idMath::BitsForInteger( GAME_RELIABLE_CMESSAGE_NUM_MESSAGES ) ) );
|
||
|
|
|
||
|
|
idPlayer* client = GetClient( clientNum );
|
||
|
|
if ( !client ) {
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
switch( id ) {
|
||
|
|
case GAME_RELIABLE_CMESSAGE_CHAT:
|
||
|
|
case GAME_RELIABLE_CMESSAGE_TEAM_CHAT: {
|
||
|
|
case GAME_RELIABLE_CMESSAGE_FIRETEAM_CHAT:
|
||
|
|
wchar_t text[ 128 ];
|
||
|
|
|
||
|
|
msg.ReadString( text, sizeof( text ) / sizeof( wchar_t ) );
|
||
|
|
|
||
|
|
rules->ProcessChatMessage( client, id, text );
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
case GAME_RELIABLE_CMESSAGE_QUICK_CHAT: {
|
||
|
|
const sdDeclQuickChat* quickChat = declQuickChatType.SafeIndex( msg.ReadLong() );
|
||
|
|
int spawnId = msg.ReadLong();
|
||
|
|
client->RequestQuickChat( quickChat, spawnId );
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
case GAME_RELIABLE_CMESSAGE_KILL: {
|
||
|
|
rules->WantKilled( client );
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
case GAME_RELIABLE_CMESSAGE_GOD: {
|
||
|
|
ToggleGodMode( client );
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
case GAME_RELIABLE_CMESSAGE_NOCLIP: {
|
||
|
|
ToggleNoclipMode( client );
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
case GAME_RELIABLE_CMESSAGE_NETWORKSPAWN: {
|
||
|
|
char classname[128];
|
||
|
|
|
||
|
|
msg.ReadString( classname, sizeof( classname ) );
|
||
|
|
|
||
|
|
NetworkSpawn( classname, client );
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
case GAME_RELIABLE_CMESSAGE_IMPULSE: {
|
||
|
|
client->PerformImpulse( msg.ReadBits( 6 ) );
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
case GAME_RELIABLE_CMESSAGE_GUISCRIPT: {
|
||
|
|
idEntity* entity = EntityForSpawnId( msg.ReadBits( 32 ) );
|
||
|
|
if ( !entity ) {
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
|
||
|
|
const int MAX_GUISCRIPT_STRING = 1024;
|
||
|
|
char buffer[ MAX_GUISCRIPT_STRING ];
|
||
|
|
msg.ReadString( buffer, MAX_GUISCRIPT_STRING );
|
||
|
|
|
||
|
|
HandleGuiScriptMessage( client, entity, buffer );
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
case GAME_RELIABLE_CMESSAGE_NETWORKCOMMAND: {
|
||
|
|
idEntity* entity = EntityForSpawnId( msg.ReadBits( 32 ) );
|
||
|
|
if ( !entity ) {
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
|
||
|
|
const int MAX_GUISCRIPT_STRING = 1024;
|
||
|
|
char buffer[ MAX_GUISCRIPT_STRING ];
|
||
|
|
msg.ReadString( buffer, MAX_GUISCRIPT_STRING );
|
||
|
|
|
||
|
|
HandleNetworkMessage( client, entity, buffer );
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
case GAME_RELIABLE_CMESSAGE_TEAMSWITCH: {
|
||
|
|
int index = msg.ReadLong( );
|
||
|
|
char buffer[ 256 ];
|
||
|
|
char buffer2[ 256 ];
|
||
|
|
msg.ReadString( buffer, sizeof( buffer ) );
|
||
|
|
|
||
|
|
bool useBuffer2 = false;
|
||
|
|
if ( index == sdTeamManager::GetInstance().GetNumTeams() + 1 ) {
|
||
|
|
msg.ReadString( buffer2, sizeof( buffer2 ) );
|
||
|
|
|
||
|
|
// auto join team with the least number of players
|
||
|
|
int lowest = -1;
|
||
|
|
int clientTeamIndex = client->GetTeam() != NULL ? client->GetTeam()->GetIndex() : -1;
|
||
|
|
for ( int i = 0; i < sdTeamManager::GetInstance().GetNumTeams(); i++ ) {
|
||
|
|
int num = sdTeamManager::GetInstance().GetTeamByIndex( i ).GetNumPlayers();
|
||
|
|
if ( clientTeamIndex == i ) {
|
||
|
|
num--;
|
||
|
|
}
|
||
|
|
if ( num < lowest || lowest == -1 ) {
|
||
|
|
lowest = num;
|
||
|
|
index = i + 1;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if ( index == 2 ) {
|
||
|
|
// use password for team 2
|
||
|
|
useBuffer2 = true;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
rules->SetClientTeam( client, index, false, useBuffer2 == false ? buffer : buffer2 );
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
case GAME_RELIABLE_CMESSAGE_CLASSSWITCH: {
|
||
|
|
int index = msg.ReadLong();
|
||
|
|
int classOption = msg.ReadLong();
|
||
|
|
const sdDeclPlayerClass* pc = declPlayerClassType.SafeIndex( index );
|
||
|
|
if ( pc != NULL ) {
|
||
|
|
client->ChangeClass( pc, classOption );
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
case GAME_RELIABLE_CMESSAGE_CHANGEWEAPON: {
|
||
|
|
int id = msg.ReadLong();
|
||
|
|
if ( client->GetInventory().CanEquip( id, true ) ) {
|
||
|
|
client->GetInventory().SetIdealWeapon( id );
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
case GAME_RELIABLE_CMESSAGE_DEFAULTSPAWN: {
|
||
|
|
client->SetSpawnPoint( NULL );
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
case GAME_RELIABLE_CMESSAGE_SETSPAWNPOINT: {
|
||
|
|
idEntity* ent = gameLocal.EntityForSpawnId( msg.ReadLong() );
|
||
|
|
client->SetSpawnPoint( ent );
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
case GAME_RELIABLE_CMESSAGE_GIVECLASS: {
|
||
|
|
char buffer[ 128 ];
|
||
|
|
msg.ReadString( buffer, sizeof( buffer ) );
|
||
|
|
|
||
|
|
const sdDeclPlayerClass* pc = declPlayerClassType[ buffer ];
|
||
|
|
if ( CheatsOk( false ) && pc ) {
|
||
|
|
client->GetInventory().GiveClass( pc, true );
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
case GAME_RELIABLE_CMESSAGE_RESPAWN: {
|
||
|
|
if ( !client->IsSpectating() && client->IsDead() ) {
|
||
|
|
client->ServerForceRespawn( false );
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
case GAME_RELIABLE_CMESSAGE_ADMIN: {
|
||
|
|
idCmdArgs args;
|
||
|
|
args.AppendArg( "admin" );
|
||
|
|
|
||
|
|
char buffer[ 256 ];
|
||
|
|
int numArgs = msg.ReadLong();
|
||
|
|
if ( numArgs > 8 ) { // Gordon: prevent evil people making us attempt to read a silly number of args
|
||
|
|
numArgs = 8;
|
||
|
|
}
|
||
|
|
for ( int i = 0; i < numArgs; i++ ) {
|
||
|
|
msg.ReadString( buffer, sizeof( buffer ) );
|
||
|
|
args.AppendArg( buffer );
|
||
|
|
}
|
||
|
|
sdAdminSystem::GetInstance().PerformCommand( args, client );
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
case GAME_RELIABLE_CMESSAGE_FIRETEAM: {
|
||
|
|
idCmdArgs args;
|
||
|
|
args.AppendArg( "fireteam" );
|
||
|
|
|
||
|
|
char buffer[ 256 ];
|
||
|
|
int numArgs = msg.ReadLong();
|
||
|
|
if ( numArgs > 8 ) { // Gordon: prevent evil people making us attempt to read a silly number of args
|
||
|
|
numArgs = 8;
|
||
|
|
}
|
||
|
|
for ( int i = 0; i < numArgs; i++ ) {
|
||
|
|
msg.ReadString( buffer, sizeof( buffer ) );
|
||
|
|
args.AppendArg( buffer );
|
||
|
|
}
|
||
|
|
sdFireTeamManager::GetInstance().PerformCommand( args, client );
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
case GAME_RELIABLE_CMESSAGE_TASK: {
|
||
|
|
qhandle_t handle = msg.ReadBits( sdPlayerTask::TASK_BITS + 1 ) - 1;
|
||
|
|
sdTaskManager::GetInstance().SelectTask( client, handle );
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
case GAME_RELIABLE_CMESSAGE_SELECTWEAPON: {
|
||
|
|
char buffer[ 256 ];
|
||
|
|
msg.ReadString( buffer, sizeof( buffer ) );
|
||
|
|
client->SelectWeaponByName( buffer );
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
case GAME_RELIABLE_CMESSAGE_VOTE: {
|
||
|
|
sdVoteManager::GetInstance().ServerReadNetworkMessage( client, msg );
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
case GAME_RELIABLE_CMESSAGE_CALLVOTE: {
|
||
|
|
idCmdArgs args;
|
||
|
|
args.AppendArg( "callvote" );
|
||
|
|
|
||
|
|
char buffer[ 256 ];
|
||
|
|
int numArgs = msg.ReadLong();
|
||
|
|
if ( numArgs > 8 ) { // Gordon: prevent evil people making us attempt to read a silly number of args
|
||
|
|
numArgs = 8;
|
||
|
|
}
|
||
|
|
for ( int i = 0; i < numArgs; i++ ) {
|
||
|
|
msg.ReadString( buffer, sizeof( buffer ) );
|
||
|
|
args.AppendArg( buffer );
|
||
|
|
}
|
||
|
|
sdVoteManager::GetInstance().PerformCommand( args, client );
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
case GAME_RELIABLE_CMESSAGE_RESERVECLIENTSLOT: {
|
||
|
|
sdNetClientId netClientId;
|
||
|
|
|
||
|
|
netClientId.id[0] = msg.ReadLong();
|
||
|
|
netClientId.id[1] = msg.ReadLong();
|
||
|
|
|
||
|
|
ReserveClientSlot( netClientId );
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
case GAME_RELIABLE_CMESSAGE_REQUESTSTATS: {
|
||
|
|
sdGlobalStatsTracker::GetInstance().AddStatsRequest( client->entityNumber );
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
case GAME_RELIABLE_CMESSAGE_ACKNOWLEDGESTATS: {
|
||
|
|
sdGlobalStatsTracker::GetInstance().AcknowledgeStatsReponse( client->entityNumber );
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
case GAME_RELIABLE_CMESSAGE_SETMUTESTATUS: {
|
||
|
|
bool muteState = msg.ReadBool();
|
||
|
|
int clientIndex = msg.ReadByte();
|
||
|
|
if ( muteState ) {
|
||
|
|
MutePlayerLocal( client, clientIndex );
|
||
|
|
} else {
|
||
|
|
UnMutePlayerLocal( client, clientIndex );
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
case GAME_RELIABLE_CMESSAGE_SETSPECTATECLIENT: {
|
||
|
|
int entityNum = msg.ReadByte();
|
||
|
|
if ( entityNum >= 0 && entityNum < MAX_CLIENTS ) {
|
||
|
|
client->OnSetClientSpectatee( gameLocal.GetClient( entityNum ) );
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
case GAME_RELIABLE_CMESSAGE_ANTILAGDEBUG: {
|
||
|
|
sdAntiLagManager::GetInstance().OnNetworkEvent( clientNum, msg );
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
case GAME_RELIABLE_CMESSAGE_ACKNOWLEDGEBANLIST: {
|
||
|
|
if ( clientLastBanIndexReceived[ clientNum ] != -1 ) {
|
||
|
|
SendBanList( client );
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
case GAME_RELIABLE_CMESSAGE_REPEATERSTATUS: {
|
||
|
|
sdReliableServerMessage msg( GAME_RELIABLE_SMESSAGE_REPEATERSTATUS );
|
||
|
|
msg.WriteBool( gameLocal.isRepeater );
|
||
|
|
msg.Send( sdReliableMessageClientInfo( clientNum ) );
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
case GAME_RELIABLE_CMESSAGE_SPECTATECOMMAND: {
|
||
|
|
int command = msg.ReadBits( idMath::BitsForInteger( idPlayer::SPECTATE_MAX ) );
|
||
|
|
|
||
|
|
idVec3 origin = vec3_origin;
|
||
|
|
idAngles angles = ang_zero;
|
||
|
|
if ( command == idPlayer::SPECTATE_POSITION ) {
|
||
|
|
origin = msg.ReadVector();
|
||
|
|
angles.pitch = msg.ReadFloat();
|
||
|
|
angles.yaw = msg.ReadFloat();
|
||
|
|
angles.roll = msg.ReadFloat();
|
||
|
|
}
|
||
|
|
|
||
|
|
if ( client->IsSpectator() ) {
|
||
|
|
client->SpectateCommand( ( idPlayer::spectateCommand_t )command, origin, angles );
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
default: {
|
||
|
|
Warning( "Unknown client->server reliable message: %d", id );
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
================
|
||
|
|
idGameLocal::ClientShowAOR
|
||
|
|
================
|
||
|
|
*/
|
||
|
|
void idGameLocal::ClientShowAOR( int clientNum ) const {
|
||
|
|
if ( !net_clientShowAOR.GetInteger() ) {
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
if ( net_clientShowAOR.GetInteger() & 1 ) {
|
||
|
|
gameLocal.aorManager.DebugDraw( clientNum );
|
||
|
|
}
|
||
|
|
|
||
|
|
if ( net_clientShowAOR.GetInteger() & 2 ) {
|
||
|
|
gameLocal.aorManager.DebugDrawEntities( clientNum );
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
================
|
||
|
|
idGameLocal::ClientShowSnapshot
|
||
|
|
================
|
||
|
|
*/
|
||
|
|
void idGameLocal::ClientShowSnapshot( int clientNum ) const {
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
// Gordon: FIXME: This is a maintenance nightmare
|
||
|
|
/*
|
||
|
|
================
|
||
|
|
idGameLocal::ResetGameState
|
||
|
|
================
|
||
|
|
*/
|
||
|
|
void idGameLocal::ResetGameState( extNetworkStateMode_t mode ) {
|
||
|
|
sdNetworkStateObject& object = GetGameStateObject( mode );
|
||
|
|
|
||
|
|
for ( int i = 0; i < MAX_CLIENTS; i++ ) {
|
||
|
|
FreeGameState( clientNetworkInfo[ i ].gameStates[ mode ] );
|
||
|
|
}
|
||
|
|
FreeGameState( demoClientNetworkInfo.gameStates[ mode ] );
|
||
|
|
#ifdef SD_SUPPORT_REPEATER
|
||
|
|
FreeGameState( repeaterClientNetworkInfo.gameStates[ mode ] );
|
||
|
|
for ( int i = 0; i < repeaterNetworkInfo.Num(); i++ ) {
|
||
|
|
if ( repeaterNetworkInfo[ i ] == NULL ) {
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
FreeGameState( repeaterNetworkInfo[ i ]->gameStates[ mode ] );
|
||
|
|
}
|
||
|
|
#endif // SD_SUPPORT_REPEATER
|
||
|
|
|
||
|
|
while ( object.freeStates ) {
|
||
|
|
sdGameState* nextState = object.freeStates->next;
|
||
|
|
FreeGameState( object.freeStates );
|
||
|
|
object.freeStates = nextState;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
for ( int i = 0; i < MAX_CLIENTS; i++ ) {
|
||
|
|
sdGameState* newState = AllocGameState( object );
|
||
|
|
if ( newState->data ) {
|
||
|
|
newState->data->MakeDefault();
|
||
|
|
}
|
||
|
|
clientNetworkInfo[ i ].gameStates[ mode ] = newState;
|
||
|
|
}
|
||
|
|
|
||
|
|
sdGameState* newState = AllocGameState( object );
|
||
|
|
if ( newState->data ) {
|
||
|
|
newState->data->MakeDefault();
|
||
|
|
}
|
||
|
|
demoClientNetworkInfo.gameStates[ mode ] = newState;
|
||
|
|
|
||
|
|
#ifdef SD_SUPPORT_REPEATER
|
||
|
|
newState = AllocGameState( object );
|
||
|
|
if ( newState->data ) {
|
||
|
|
newState->data->MakeDefault();
|
||
|
|
}
|
||
|
|
repeaterClientNetworkInfo.gameStates[ mode ] = newState;
|
||
|
|
|
||
|
|
for ( int i = 0; i < repeaterNetworkInfo.Num(); i++ ) {
|
||
|
|
if ( repeaterNetworkInfo[ i ] == NULL ) {
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
sdGameState* newState = AllocGameState( object );
|
||
|
|
if ( newState->data ) {
|
||
|
|
newState->data->MakeDefault();
|
||
|
|
}
|
||
|
|
( *repeaterNetworkInfo[ i ] ).gameStates[ mode ] = newState;
|
||
|
|
}
|
||
|
|
#endif // SD_SUPPORT_REPEATER
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
================
|
||
|
|
idGameLocal::GetGameStateObject
|
||
|
|
================
|
||
|
|
*/
|
||
|
|
sdNetworkStateObject& idGameLocal::GetGameStateObject( extNetworkStateMode_t mode ) {
|
||
|
|
switch ( mode ) {
|
||
|
|
case ENSM_TEAM:
|
||
|
|
return sdTeamManager::GetInstance().GetStateObject();
|
||
|
|
case ENSM_RULES:
|
||
|
|
return rulesStateObject;
|
||
|
|
}
|
||
|
|
|
||
|
|
Error( "idGameLocal::GetGameStateObject Invalid Mode" );
|
||
|
|
|
||
|
|
return *( sdNetworkStateObject* )( NULL );
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
================
|
||
|
|
idGameLocal::WriteGameState
|
||
|
|
================
|
||
|
|
*/
|
||
|
|
void idGameLocal::WriteGameState( extNetworkStateMode_t mode, snapshot_t* snapshot, clientNetworkInfo_t& nwInfo, idBitMsg& msg ) {
|
||
|
|
sdGameState* baseState = nwInfo.gameStates[ mode ];
|
||
|
|
|
||
|
|
const sdNetworkStateObject& object = GetGameStateObject( mode );
|
||
|
|
if ( !object.CheckNetworkStateChanges( *baseState->data ) ) {
|
||
|
|
msg.WriteBool( false );
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
msg.WriteBool( true );
|
||
|
|
snapshot->gameStates[ mode ] = AllocGameState( object );
|
||
|
|
object.WriteNetworkState( *baseState->data, *snapshot->gameStates[ mode ]->data, msg );
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
================
|
||
|
|
idGameLocal::ReadGameState
|
||
|
|
================
|
||
|
|
*/
|
||
|
|
void idGameLocal::ReadGameState( extNetworkStateMode_t mode, snapshot_t* snapshot, const idBitMsg& msg ) {
|
||
|
|
if ( !msg.ReadBool() ) {
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
sdGameState* baseState = GetNetworkInfo( localClientNum ).gameStates[ mode ];
|
||
|
|
|
||
|
|
sdNetworkStateObject& object = GetGameStateObject( mode );
|
||
|
|
snapshot->gameStates[ mode ] = AllocGameState( object );
|
||
|
|
object.ReadNetworkState( *baseState->data, *snapshot->gameStates[ mode ]->data, msg );
|
||
|
|
object.ApplyNetworkState( *snapshot->gameStates[ mode ]->data );
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
================
|
||
|
|
idGameLocal::EnsureAlloced
|
||
|
|
================
|
||
|
|
*/
|
||
|
|
void idGameLocal::EnsureAlloced( int entityNum, idEntity* ent, const char* oldState, const char* currentState ) {
|
||
|
|
if ( entityNum < 0 || entityNum >= MAX_GENTITIES ) {
|
||
|
|
Error( "Entitynum (%i) out of range", entityNum );
|
||
|
|
}
|
||
|
|
|
||
|
|
if ( !entities[ entityNum ] ) {
|
||
|
|
Printf( "Current Entity (%s)\n", currentState );
|
||
|
|
Printf( "=======================================\n" );
|
||
|
|
entityDebugInfo[ entityNum ].PrintStatus( entityNum );
|
||
|
|
|
||
|
|
if ( ent ) {
|
||
|
|
Printf( "Previous Entity To Blame (%s)\n", oldState );
|
||
|
|
Printf( "=======================================\n" );
|
||
|
|
entityDebugInfo[ ent->entityNumber ].PrintStatus( ent->entityNumber );
|
||
|
|
} else {
|
||
|
|
Printf( "No Previous Entity To Blame\n" );
|
||
|
|
}
|
||
|
|
|
||
|
|
Error( "idGameLocal::EnsureAlloced State Received For Entity With No Header" );
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
================
|
||
|
|
idGameLocal::UpdateLagometer
|
||
|
|
================
|
||
|
|
*/
|
||
|
|
void idGameLocal::UpdateLagometer( int aheadOfServer, int numDuplicatedUsercmds ) {
|
||
|
|
int i, j, ahead;
|
||
|
|
for ( i = 0; i < LAGO_HEIGHT; i++ ) {
|
||
|
|
memmove( (byte *)lagometer + LAGO_WIDTH * 4 * i, (byte *)lagometer + LAGO_WIDTH * 4 * i + 4, ( LAGO_WIDTH - 1 ) * 4 );
|
||
|
|
}
|
||
|
|
j = LAGO_WIDTH - 1;
|
||
|
|
for ( i = 0; i < LAGO_HEIGHT; i++ ) {
|
||
|
|
lagometer[i][j][0] = lagometer[i][j][1] = lagometer[i][j][2] = lagometer[i][j][3] = 0;
|
||
|
|
}
|
||
|
|
ahead = idMath::Rint( (float)aheadOfServer / (float)USERCMD_MSEC );
|
||
|
|
if ( ahead >= 0 ) {
|
||
|
|
for ( i = 2 * Max( 0, 5 - ahead ); i < 2 * 5; i++ ) {
|
||
|
|
lagometer[i][j][1] = 255;
|
||
|
|
lagometer[i][j][3] = 255;
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
for ( i = 2 * 5; i < 2 * ( 5 + Min( 10, -ahead ) ); i++ ) {
|
||
|
|
lagometer[i][j][0] = 255;
|
||
|
|
lagometer[i][j][1] = 255;
|
||
|
|
lagometer[i][j][3] = 255;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
for ( i = LAGO_HEIGHT - 2 * Min( 6, numDuplicatedUsercmds ); i < LAGO_HEIGHT; i++ ) {
|
||
|
|
lagometer[i][j][0] = 255;
|
||
|
|
if ( numDuplicatedUsercmds <= 2 ) {
|
||
|
|
lagometer[i][j][1] = 255;
|
||
|
|
}
|
||
|
|
lagometer[i][j][3] = 255;
|
||
|
|
}
|
||
|
|
|
||
|
|
if ( renderSystem && !renderSystem->UploadImage( LAGO_IMAGE, (byte *)lagometer, LAGO_IMG_WIDTH, LAGO_IMG_HEIGHT, false, false ) ) {
|
||
|
|
common->Printf( "lagometer: UploadImage failed. turning off net_clientLagOMeter\n" );
|
||
|
|
net_clientLagOMeter.SetBool( false );
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
================
|
||
|
|
idGameLocal::ClientReadSnapshot
|
||
|
|
================
|
||
|
|
*/
|
||
|
|
bool idGameLocal::ClientReadSnapshot( int sequence, const int gameFrame, const int gameTime, const int numDuplicatedUsercmds, const int aheadOfServer, const idBitMsg &msg, const idBitMsg &ucmdmsg ) {
|
||
|
|
snapshot_t* snapshot;
|
||
|
|
clientNetworkInfo_t& nwInfo = GetNetworkInfo( localClientNum );
|
||
|
|
|
||
|
|
g_trainingMode.SetBool( false );
|
||
|
|
|
||
|
|
sdPhysicsEvent* physicsEvent;
|
||
|
|
sdPhysicsEvent* nextPhysicsEvent;
|
||
|
|
for ( physicsEvent = physicsEvents.Next(); physicsEvent; physicsEvent = nextPhysicsEvent ) {
|
||
|
|
nextPhysicsEvent = physicsEvent->GetNode().Next();
|
||
|
|
if ( gameTime > physicsEvent->GetCreationTime() ) {
|
||
|
|
delete physicsEvent;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if ( net_clientLagOMeter.GetBool() ) {
|
||
|
|
UpdateLagometer( aheadOfServer, numDuplicatedUsercmds );
|
||
|
|
}
|
||
|
|
|
||
|
|
// clear any debug lines from a previous frame
|
||
|
|
gameRenderWorld->DebugClearLines( time );
|
||
|
|
|
||
|
|
// clear any debug polygons from a previous frame
|
||
|
|
gameRenderWorld->DebugClearPolygons( time );
|
||
|
|
|
||
|
|
idEntity* ent = NULL;
|
||
|
|
for( ent = networkedEntities.Next(); ent != NULL; ent = ent->networkNode.Next() ) {
|
||
|
|
ent->snapshotPVSFlags = PVS_DEFERRED_VISIBLE;
|
||
|
|
|
||
|
|
sdEntityState* state = nwInfo.states[ ent->entityNumber ][ NSM_VISIBLE ];
|
||
|
|
if ( state == NULL ) {
|
||
|
|
gameLocal.Warning( "idGameLocal::ClientReadSnapshot Entity '%s' has no Visible State, Likely a Client Spawned Entity", ent->name.c_str() );
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
|
||
|
|
if ( state->data == NULL ) {
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
|
||
|
|
// reset back to the old visible state
|
||
|
|
ent->ResetNetworkState( NSM_VISIBLE, *state->data );
|
||
|
|
}
|
||
|
|
for( ent = networkedEntities.Next(); ent != NULL; ent = ent->networkNode.Next() ) {
|
||
|
|
ent->snapshotPVSFlags = PVS_DEFERRED_VISIBLE;
|
||
|
|
|
||
|
|
sdEntityState* state = nwInfo.states[ ent->entityNumber ][ NSM_BROADCAST ];
|
||
|
|
if ( state == NULL ) {
|
||
|
|
gameLocal.Warning( "idGameLocal::ClientReadSnapshot Entity '%s' has no Broadcast State, Likely a Client Spawned Entity", ent->name.c_str() );
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
|
||
|
|
if ( state->data == NULL ) {
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
|
||
|
|
// reset back to the old broadcast state
|
||
|
|
ent->ResetNetworkState( NSM_BROADCAST, *state->data );
|
||
|
|
}
|
||
|
|
|
||
|
|
// update the game time
|
||
|
|
framenum = gameFrame;
|
||
|
|
if ( !IsPaused() ) {
|
||
|
|
time = gameTime - timeOffset;
|
||
|
|
previousTime = time - networkSystem->ClientGetFrameTime();
|
||
|
|
} else {
|
||
|
|
timeOffset = gameTime - time;
|
||
|
|
previousTime = time;
|
||
|
|
}
|
||
|
|
isNewFrame = true;
|
||
|
|
predictionUpdateRequired = true;
|
||
|
|
|
||
|
|
// clear the snapshot entity list
|
||
|
|
snapshotEntities.Clear();
|
||
|
|
snapshotVisbileEntities.Clear();
|
||
|
|
|
||
|
|
// allocate new snapshot
|
||
|
|
snapshot = snapshotAllocator.Alloc();
|
||
|
|
snapshot->Init( sequence, gameTime );
|
||
|
|
snapshot->next = nwInfo.snapshots;
|
||
|
|
nwInfo.snapshots = snapshot;
|
||
|
|
|
||
|
|
activeSnapshot = snapshot;
|
||
|
|
|
||
|
|
int followPlayer = 0;
|
||
|
|
if ( serverIsRepeater ) {
|
||
|
|
followPlayer = msg.ReadByte() - 1;
|
||
|
|
}
|
||
|
|
|
||
|
|
// ASYNC_SECURITY_READ( msg )
|
||
|
|
ReadGameState( ENSM_TEAM, snapshot, msg );
|
||
|
|
// ASYNC_SECURITY_READ( msg )
|
||
|
|
|
||
|
|
// ASYNC_SECURITY_READ( msg )
|
||
|
|
ReadGameState( ENSM_RULES, snapshot, msg );
|
||
|
|
// ASYNC_SECURITY_READ( msg )
|
||
|
|
|
||
|
|
ent = NULL;
|
||
|
|
|
||
|
|
const char* oldState = NULL;
|
||
|
|
|
||
|
|
// process entity events
|
||
|
|
ClientProcessEntityNetworkEventQueue();
|
||
|
|
|
||
|
|
if ( serverIsRepeater ) {
|
||
|
|
SetSnapShotClient( NULL );
|
||
|
|
SetSnapShotPlayer( followPlayer == -1 ? NULL : GetClient( followPlayer ) );
|
||
|
|
} else {
|
||
|
|
idPlayer* localPlayer = GetLocalPlayer();
|
||
|
|
if ( localPlayer ) {
|
||
|
|
SetSnapShotClient( localPlayer );
|
||
|
|
SetSnapShotPlayer( localPlayer->GetSpectateClient() );
|
||
|
|
} else {
|
||
|
|
SetSnapShotClient( NULL );
|
||
|
|
SetSnapShotPlayer( NULL );
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// read visible states
|
||
|
|
for ( int i = msg.ReadBits( GENTITYNUM_BITS ); i != ENTITYNUM_NONE; i = msg.ReadBits( GENTITYNUM_BITS ) ) {
|
||
|
|
EnsureAlloced( i, ent, oldState, "Visible" );
|
||
|
|
|
||
|
|
ent = entities[ i ];
|
||
|
|
|
||
|
|
ent->snapshotPVSFlags &= ~( PVS_DEFERRED_VISIBLE );
|
||
|
|
ent->snapshotPVSFlags |= PVS_VISIBLE;
|
||
|
|
|
||
|
|
sdEntityState* newState = AllocEntityState( NSM_VISIBLE, ent );
|
||
|
|
sdEntityState* baseState = nwInfo.states[ i ][ NSM_VISIBLE ];
|
||
|
|
|
||
|
|
// ASYNC_SECURITY_READ( msg )
|
||
|
|
ent->ReadNetworkState( NSM_VISIBLE, *baseState->data, *newState->data, msg );
|
||
|
|
// ASYNC_SECURITY_READ( msg )
|
||
|
|
|
||
|
|
ent->ApplyNetworkState( NSM_VISIBLE, *newState->data );
|
||
|
|
|
||
|
|
newState->next = snapshot->firstEntityState[ NSM_VISIBLE ];
|
||
|
|
snapshot->firstEntityState[ NSM_VISIBLE ] = newState;
|
||
|
|
|
||
|
|
oldState = "Visible";
|
||
|
|
}
|
||
|
|
|
||
|
|
// read broadcast states
|
||
|
|
for ( int i = msg.ReadBits( GENTITYNUM_BITS ); i != ENTITYNUM_NONE; i = msg.ReadBits( GENTITYNUM_BITS ) ) {
|
||
|
|
EnsureAlloced( i, ent, oldState, "Broadcast" );
|
||
|
|
|
||
|
|
ent = entities[ i ];
|
||
|
|
|
||
|
|
ent->snapshotPVSFlags |= PVS_BROADCAST;
|
||
|
|
|
||
|
|
sdEntityState* newState = AllocEntityState( NSM_BROADCAST, ent );
|
||
|
|
sdEntityState* baseState = nwInfo.states[ i ][ NSM_BROADCAST ];
|
||
|
|
|
||
|
|
// ASYNC_SECURITY_READ( msg )
|
||
|
|
ent->ReadNetworkState( NSM_BROADCAST, *baseState->data, *newState->data, msg );
|
||
|
|
// ASYNC_SECURITY_READ( msg )
|
||
|
|
|
||
|
|
ent->ApplyNetworkState( NSM_BROADCAST, *newState->data );
|
||
|
|
|
||
|
|
newState->next = snapshot->firstEntityState[ NSM_BROADCAST ];
|
||
|
|
snapshot->firstEntityState[ NSM_BROADCAST ] = newState;
|
||
|
|
|
||
|
|
oldState = "Broadcast";
|
||
|
|
}
|
||
|
|
|
||
|
|
if ( snapShotPlayer ) {
|
||
|
|
|
||
|
|
// show AOR
|
||
|
|
ClientShowAOR( localClientNum );
|
||
|
|
|
||
|
|
// visualize the snapshot
|
||
|
|
ClientShowSnapshot( localClientNum );
|
||
|
|
}
|
||
|
|
|
||
|
|
if ( SetupClientAoR() ) {
|
||
|
|
for ( ent = networkedEntities.Next(); ent != NULL; ent = ent->networkNode.Next() ) {
|
||
|
|
// Gordon: Use evaluate position here, which for some fully predictable physics classes
|
||
|
|
// will return a newly evaluated positon, and not the currently last updated one
|
||
|
|
idPhysics* physics = ent->GetPhysics();
|
||
|
|
bool update = false;
|
||
|
|
aorManager.UpdateEntityAORFlags( ent, physics->EvaluatePosition(), update );
|
||
|
|
if ( !physics->AllowInhibit() ) {
|
||
|
|
ent->aorFlags &= ~AOR_INHIBIT_PHYSICS;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
for ( ent = networkedEntities.Next(); ent != NULL; ent = ent->networkNode.Next() ) {
|
||
|
|
ent->aorFlags = 0;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// read the unreliable entity network events
|
||
|
|
int numUnreliableEvents = msg.ReadLong();
|
||
|
|
for ( int i = 0; i < numUnreliableEvents; i++ ) {
|
||
|
|
sdUnreliableEntityNetEvent* event = unreliableEntityNetEventAllocator.Alloc();
|
||
|
|
event->GetUnreliableNode().AddToEnd( unreliableEntityNetEventQueue );
|
||
|
|
event->Read( msg );
|
||
|
|
|
||
|
|
if ( gameLocal.isRepeater ) {
|
||
|
|
gameLocal.SendUnreliableEntityNetworkEvent( *event );
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// read user commands
|
||
|
|
while ( true ) {
|
||
|
|
int clientNum = ucmdmsg.ReadBits( CLIENTBITS );
|
||
|
|
|
||
|
|
if ( clientNum == MAX_CLIENTS ) {
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
|
||
|
|
networkSystem->ReadClientUserCmds( clientNum, ucmdmsg );
|
||
|
|
}
|
||
|
|
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
/*
|
||
|
|
================
|
||
|
|
idGameLocal::SetupClientAoR
|
||
|
|
================
|
||
|
|
*/
|
||
|
|
bool idGameLocal::SetupClientAoR( void ) {
|
||
|
|
if ( !net_useAOR.GetBool() ) {
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
renderView_t view;
|
||
|
|
if ( sdDemoManager::GetInstance().CalculateRenderView( &view ) ) {
|
||
|
|
aorManager.SetPosition( view.vieworg );
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
idPlayer* viewer = GetActiveViewer();
|
||
|
|
if ( viewer != NULL ) {
|
||
|
|
aorManager.SetClient( viewer );
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
if ( serverIsRepeater ) {
|
||
|
|
playerView.CalculateRepeaterView( view );
|
||
|
|
aorManager.SetPosition( view.vieworg );
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
================
|
||
|
|
idGameLocal::ClientApplySnapshot
|
||
|
|
================
|
||
|
|
*/
|
||
|
|
bool idGameLocal::ClientApplySnapshot( int sequence ) {
|
||
|
|
return ApplySnapshot( GetNetworkInfo( localClientNum ), sequence );
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
================
|
||
|
|
idGameLocal::WriteClientNetworkInfo
|
||
|
|
================
|
||
|
|
*/
|
||
|
|
void idGameLocal::WriteClientNetworkInfo( idFile* file ) {
|
||
|
|
ClientWriteGameState( file );
|
||
|
|
|
||
|
|
clientNetworkInfo_t& nwInfo = GetNetworkInfo( localClientNum );
|
||
|
|
|
||
|
|
SetSnapShotClient( GetLocalPlayer() );
|
||
|
|
SetSnapShotPlayer( GetLocalPlayer() );
|
||
|
|
|
||
|
|
for ( idEntity* ent = networkedEntities.Next(); ent; ent = ent->networkNode.Next() ) {
|
||
|
|
file->WriteInt( ent->entityNumber );
|
||
|
|
|
||
|
|
int num = ent->entityNumber;
|
||
|
|
|
||
|
|
for ( int j = 0; j < NSM_NUM_MODES; j++ ) {
|
||
|
|
if ( nwInfo.states[ num ][ j ] == NULL || nwInfo.states[ num ][ j ]->data == NULL ) {
|
||
|
|
file->WriteBool( false );
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
|
||
|
|
file->WriteBool( true );
|
||
|
|
nwInfo.states[ num ][ j ]->data->Write( file );
|
||
|
|
ASYNC_SECURITY_WRITE_FILE( file )
|
||
|
|
}
|
||
|
|
ASYNC_SECURITY_WRITE_FILE( file )
|
||
|
|
|
||
|
|
for ( int j = 0; j < NSM_NUM_MODES; j++ ) {
|
||
|
|
networkStateMode_t mode = ( networkStateMode_t )j;
|
||
|
|
|
||
|
|
sdEntityState* state = AllocEntityState( mode, ent );
|
||
|
|
if ( state->data != NULL ) {
|
||
|
|
file->WriteBool( true );
|
||
|
|
|
||
|
|
idBitMsg temp;
|
||
|
|
byte buffer[ 2048 ];
|
||
|
|
temp.InitWrite( buffer, sizeof( buffer ) );
|
||
|
|
|
||
|
|
sdEntityState* defaultState = AllocEntityState( mode, ent );
|
||
|
|
defaultState->data->MakeDefault();
|
||
|
|
|
||
|
|
ent->WriteNetworkState( mode, *defaultState->data, *state->data, temp );
|
||
|
|
|
||
|
|
FreeNetworkState( defaultState );
|
||
|
|
|
||
|
|
state->data->Write( file );
|
||
|
|
} else {
|
||
|
|
file->WriteBool( false );
|
||
|
|
}
|
||
|
|
|
||
|
|
FreeNetworkState( state );
|
||
|
|
}
|
||
|
|
ASYNC_SECURITY_WRITE_FILE( file )
|
||
|
|
}
|
||
|
|
file->WriteInt( MAX_GENTITIES );
|
||
|
|
|
||
|
|
for ( int i = 0; i < ENSM_NUM_MODES; i++ ) {
|
||
|
|
if ( nwInfo.gameStates[ i ] == NULL || nwInfo.gameStates[ i ]->data == NULL ) {
|
||
|
|
file->WriteBool( false );
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
|
||
|
|
file->WriteBool( true );
|
||
|
|
nwInfo.gameStates[ i ]->data->Write( file );
|
||
|
|
}
|
||
|
|
|
||
|
|
ASYNC_SECURITY_WRITE_FILE( file )
|
||
|
|
|
||
|
|
for ( int i = 0; i < ENSM_NUM_MODES; i++ ) {
|
||
|
|
extNetworkStateMode_t mode = ( extNetworkStateMode_t )i;
|
||
|
|
|
||
|
|
sdNetworkStateObject& obj = GetGameStateObject( mode );
|
||
|
|
sdGameState* state = AllocGameState( obj );
|
||
|
|
if ( state->data != NULL ) {
|
||
|
|
file->WriteBool( true );
|
||
|
|
|
||
|
|
idBitMsg temp;
|
||
|
|
byte buffer[ 2048 ];
|
||
|
|
temp.InitWrite( buffer, sizeof( buffer ) );
|
||
|
|
|
||
|
|
sdGameState* defaultState = AllocGameState( obj );
|
||
|
|
defaultState->data->MakeDefault();
|
||
|
|
|
||
|
|
obj.WriteNetworkState( *defaultState->data, *state->data, temp );
|
||
|
|
|
||
|
|
FreeGameState( defaultState );
|
||
|
|
|
||
|
|
state->data->Write( file );
|
||
|
|
} else {
|
||
|
|
file->WriteBool( false );
|
||
|
|
}
|
||
|
|
|
||
|
|
FreeGameState( state );
|
||
|
|
}
|
||
|
|
|
||
|
|
ASYNC_SECURITY_WRITE_FILE( file )
|
||
|
|
|
||
|
|
// write number of snapshots so on readback we know how many to allocate
|
||
|
|
int snapCount = 0;
|
||
|
|
for ( snapshot_t* snapshot = nwInfo.snapshots; snapshot; snapshot = snapshot->next ) {
|
||
|
|
snapCount++;
|
||
|
|
}
|
||
|
|
file->WriteInt( snapCount );
|
||
|
|
|
||
|
|
|
||
|
|
for ( snapshot_t* snapshot = nwInfo.snapshots; snapshot; snapshot = snapshot->next ) {
|
||
|
|
file->WriteInt( snapshot->sequence );
|
||
|
|
|
||
|
|
for ( int i = 0; i < NSM_NUM_MODES; i++ ) {
|
||
|
|
int stateCount = 0;
|
||
|
|
for ( sdEntityState* state = snapshot->firstEntityState[ i ]; state; state = state->next ) {
|
||
|
|
stateCount++;
|
||
|
|
}
|
||
|
|
file->WriteInt( stateCount );
|
||
|
|
|
||
|
|
for ( sdEntityState* state = snapshot->firstEntityState[ i ]; state; state = state->next ) {
|
||
|
|
file->WriteInt( state->spawnId );
|
||
|
|
state->data->Write( file );
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
for ( int i = 0; i < ENSM_NUM_MODES; i++ ) {
|
||
|
|
if ( !snapshot->gameStates[ i ] ) {
|
||
|
|
file->WriteBool( false );
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
file->WriteBool( true );
|
||
|
|
snapshot->gameStates[ i ]->data->Write( file );
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
SetSnapShotClient( NULL );
|
||
|
|
SetSnapShotPlayer( NULL );
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
================
|
||
|
|
idGameLocal::ReadClientNetworkInfo
|
||
|
|
================
|
||
|
|
*/
|
||
|
|
void idGameLocal::ReadClientNetworkInfo( idFile* file ) {
|
||
|
|
ClientReadGameState( file );
|
||
|
|
|
||
|
|
// force new frame
|
||
|
|
realClientTime = 0;
|
||
|
|
isNewFrame = true;
|
||
|
|
|
||
|
|
SetSnapShotClient( GetLocalPlayer() );
|
||
|
|
SetSnapShotPlayer( GetLocalPlayer() );
|
||
|
|
|
||
|
|
clientNetworkInfo_t& nwInfo = GetNetworkInfo( localClientNum );
|
||
|
|
|
||
|
|
while ( true ) {
|
||
|
|
int num;
|
||
|
|
file->ReadInt( num );
|
||
|
|
if ( num == MAX_GENTITIES ) {
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
|
||
|
|
if ( num < 0 || num >= MAX_GENTITIES ) {
|
||
|
|
Error( "idGameLocal::ReadClientNetworkInfo Tried to read out of bounds entity" );
|
||
|
|
}
|
||
|
|
|
||
|
|
idEntity* ent = entities[ num ];
|
||
|
|
if ( ent == NULL ) {
|
||
|
|
Error( "idGameLocal::ReadClientNetworkInfo Tried to Read State For Missing Entity" );
|
||
|
|
}
|
||
|
|
|
||
|
|
for ( int j = 0; j < NSM_NUM_MODES; j++ ) {
|
||
|
|
bool temp;
|
||
|
|
file->ReadBool( temp );
|
||
|
|
if ( !temp ) {
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
|
||
|
|
FreeNetworkState( nwInfo.states[ num ][ j ] );
|
||
|
|
|
||
|
|
networkStateMode_t mode = ( networkStateMode_t )j;
|
||
|
|
|
||
|
|
sdEntityState& newState = *AllocEntityState( mode, ent );
|
||
|
|
if ( newState.data == NULL ) {
|
||
|
|
Error( "idGameLocal::ReadClientNetworkInfo Failed to Alloc Network State" );
|
||
|
|
}
|
||
|
|
|
||
|
|
newState.data->Read( file );
|
||
|
|
|
||
|
|
ASYNC_SECURITY_READ_FILE( file )
|
||
|
|
nwInfo.states[ num ][ j ] = &newState;
|
||
|
|
}
|
||
|
|
|
||
|
|
ASYNC_SECURITY_READ_FILE( file )
|
||
|
|
|
||
|
|
for ( int j = 0; j < NSM_NUM_MODES; j++ ) {
|
||
|
|
bool temp;
|
||
|
|
file->ReadBool( temp );
|
||
|
|
if ( !temp ) {
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
|
||
|
|
networkStateMode_t mode = ( networkStateMode_t )j;
|
||
|
|
|
||
|
|
sdEntityState* state = AllocEntityState( mode, ent );
|
||
|
|
assert( state->data != NULL );
|
||
|
|
state->data->Read( file );
|
||
|
|
|
||
|
|
ent->ApplyNetworkState( mode, *state->data );
|
||
|
|
|
||
|
|
FreeNetworkState( state );
|
||
|
|
}
|
||
|
|
|
||
|
|
ASYNC_SECURITY_READ_FILE( file )
|
||
|
|
}
|
||
|
|
|
||
|
|
for ( int i = 0; i < ENSM_NUM_MODES; i++ ) {
|
||
|
|
FreeGameState( nwInfo.gameStates[ i ] );
|
||
|
|
|
||
|
|
extNetworkStateMode_t mode = ( extNetworkStateMode_t )i;
|
||
|
|
sdNetworkStateObject& stateObject = GetGameStateObject( mode );
|
||
|
|
|
||
|
|
bool temp;
|
||
|
|
file->ReadBool( temp );
|
||
|
|
if ( !temp ) {
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
|
||
|
|
nwInfo.gameStates[ i ] = AllocGameState( stateObject );
|
||
|
|
nwInfo.gameStates[ i ]->data->Read( file );
|
||
|
|
}
|
||
|
|
|
||
|
|
ASYNC_SECURITY_READ_FILE( file )
|
||
|
|
|
||
|
|
for ( int i = 0; i < ENSM_NUM_MODES; i++ ) {
|
||
|
|
extNetworkStateMode_t mode = ( extNetworkStateMode_t )i;
|
||
|
|
sdNetworkStateObject& stateObject = GetGameStateObject( mode );
|
||
|
|
|
||
|
|
bool temp;
|
||
|
|
file->ReadBool( temp );
|
||
|
|
if ( !temp ) {
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
|
||
|
|
sdGameState* state = AllocGameState( stateObject );
|
||
|
|
assert( state->data != NULL );
|
||
|
|
state->data->Read( file );
|
||
|
|
|
||
|
|
stateObject.ApplyNetworkState( *state->data );
|
||
|
|
|
||
|
|
FreeGameState( state );
|
||
|
|
}
|
||
|
|
|
||
|
|
ASYNC_SECURITY_READ_FILE( file )
|
||
|
|
|
||
|
|
FreeSnapshotsOlderThanSequence( nwInfo, 0x7FFFFFFF );
|
||
|
|
|
||
|
|
int count;
|
||
|
|
file->ReadInt( count );
|
||
|
|
|
||
|
|
snapshot_t** lastSnapshot = &nwInfo.snapshots;
|
||
|
|
|
||
|
|
for ( int i = 0; i < count; i++ ) {
|
||
|
|
snapshot_t* snapshot = snapshotAllocator.Alloc();
|
||
|
|
|
||
|
|
int sequence;
|
||
|
|
file->ReadInt( sequence );
|
||
|
|
|
||
|
|
snapshot->Init( sequence, -1 /* FIXME: Gordon: Clients don't use this atm, and i don't want to break demos right now */ );
|
||
|
|
|
||
|
|
for ( int j = 0; j < NSM_NUM_MODES; j++ ) {
|
||
|
|
int numStates;
|
||
|
|
file->ReadInt( numStates );
|
||
|
|
|
||
|
|
for ( int k = 0; k < numStates; k++ ) {
|
||
|
|
int spawnId;
|
||
|
|
file->ReadInt( spawnId );
|
||
|
|
|
||
|
|
idEntity* ent = EntityForSpawnId( spawnId );
|
||
|
|
if ( !ent ) {
|
||
|
|
Error( "idGameLocal::ReadClientNetworkInfo Missing Entity for Snapshot State" );
|
||
|
|
}
|
||
|
|
|
||
|
|
sdEntityState* state = AllocEntityState( ( networkStateMode_t )j, ent );
|
||
|
|
state->next = snapshot->firstEntityState[ j ];
|
||
|
|
snapshot->firstEntityState[ j ] = state;
|
||
|
|
|
||
|
|
if ( state->data ) {
|
||
|
|
state->data->Read( file );
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
for ( int j = 0; j < ENSM_NUM_MODES; j++ ) {
|
||
|
|
bool temp;
|
||
|
|
file->ReadBool( temp );
|
||
|
|
if ( !temp ) {
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
snapshot->gameStates[ j ] = AllocGameState( GetGameStateObject( ( extNetworkStateMode_t )j ) );
|
||
|
|
snapshot->gameStates[ j ]->data->Read( file );
|
||
|
|
}
|
||
|
|
|
||
|
|
*lastSnapshot = snapshot;
|
||
|
|
lastSnapshot = &snapshot->next;
|
||
|
|
}
|
||
|
|
|
||
|
|
SetSnapShotClient( NULL );
|
||
|
|
SetSnapShotPlayer( NULL );
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
================
|
||
|
|
userInfo_t::ToDict
|
||
|
|
================
|
||
|
|
*/
|
||
|
|
void userInfo_t::ToDict( idDict& info ) const {
|
||
|
|
info.Set( "ui_name", baseName.c_str() );
|
||
|
|
info.Set( "ui_realname", rawName.c_str() );
|
||
|
|
info.SetBool( "ui_showGun", showGun );
|
||
|
|
info.SetBool( "ui_ignoreExplosiveWeapons", ignoreExplosiveWeapons );
|
||
|
|
info.SetBool( "ui_autoSwitchEmptyWeapons", autoSwitchEmptyWeapons );
|
||
|
|
info.SetBool( "ui_postArmFindBestWeapon", postArmFindBestWeapon );
|
||
|
|
info.SetBool( "ui_advancedFlightControls", advancedFlightControls );
|
||
|
|
info.SetBool( "ui_rememberCameraMode", rememberCameraMode );
|
||
|
|
info.SetBool( "ui_drivingCameraFreelook", drivingCameraFreelook );
|
||
|
|
info.SetBool( "ui_bot", isBot );
|
||
|
|
info.SetBool( "ui_swapFlightYawAndRoll", swapFlightYawAndRoll );
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
================
|
||
|
|
userInfo_t::FromDict
|
||
|
|
================
|
||
|
|
*/
|
||
|
|
void userInfo_t::FromDict( const idDict& info ) {
|
||
|
|
baseName = info.GetString( "ui_name" ); // doesn't include clan tag
|
||
|
|
rawName = info.GetString( "ui_realname" );
|
||
|
|
name = rawName + "^0";
|
||
|
|
cleanName = rawName;
|
||
|
|
idGameLocal::CleanName( cleanName );
|
||
|
|
wideName = va( L"%hs", name.c_str() );
|
||
|
|
showGun = info.GetBool( "ui_showGun" );
|
||
|
|
ignoreExplosiveWeapons = info.GetBool( "ui_ignoreExplosiveWeapons" );
|
||
|
|
autoSwitchEmptyWeapons = info.GetBool( "ui_autoSwitchEmptyWeapons" );
|
||
|
|
postArmFindBestWeapon = info.GetBool( "ui_postArmFindBestWeapon" );
|
||
|
|
advancedFlightControls = info.GetBool( "ui_advancedFlightControls" );
|
||
|
|
rememberCameraMode = info.GetBool( "ui_rememberCameraMode" );
|
||
|
|
drivingCameraFreelook = info.GetBool( "ui_drivingCameraFreelook" );
|
||
|
|
isBot = info.GetBool( "ui_bot" );
|
||
|
|
voipReceiveGlobal = info.GetBool( "ui_voipReceiveGlobal" );
|
||
|
|
voipReceiveTeam = info.GetBool( "ui_voipReceiveTeam" );
|
||
|
|
voipReceiveFireTeam = info.GetBool( "ui_voipReceiveFireTeam" );
|
||
|
|
showComplaints = info.GetBool( "ui_showComplaints" );
|
||
|
|
swapFlightYawAndRoll = info.GetBool( "ui_swapFlightYawAndRoll" );
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
================
|
||
|
|
idGameLocal::WriteUserInfo
|
||
|
|
================
|
||
|
|
*/
|
||
|
|
void idGameLocal::WriteUserInfo( idBitMsg& msg, const idDict& info ) {
|
||
|
|
userInfo_t userInfo;
|
||
|
|
userInfo.FromDict( info );
|
||
|
|
|
||
|
|
msg.WriteString( userInfo.baseName.c_str() );
|
||
|
|
msg.WriteString( userInfo.rawName.c_str() );
|
||
|
|
msg.WriteBool( userInfo.showGun );
|
||
|
|
msg.WriteBool( userInfo.ignoreExplosiveWeapons );
|
||
|
|
msg.WriteBool( userInfo.autoSwitchEmptyWeapons );
|
||
|
|
msg.WriteBool( userInfo.postArmFindBestWeapon );
|
||
|
|
msg.WriteBool( userInfo.advancedFlightControls );
|
||
|
|
msg.WriteBool( userInfo.rememberCameraMode );
|
||
|
|
msg.WriteBool( userInfo.drivingCameraFreelook );
|
||
|
|
msg.WriteBool( userInfo.isBot );
|
||
|
|
msg.WriteBool( userInfo.swapFlightYawAndRoll );
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
================
|
||
|
|
idGameLocal::ReadUserInfo
|
||
|
|
================
|
||
|
|
*/
|
||
|
|
void idGameLocal::ReadUserInfo( const idBitMsg& msg, idDict& info ) {
|
||
|
|
char buffer[ 256 ];
|
||
|
|
userInfo_t userInfo;
|
||
|
|
|
||
|
|
msg.ReadString( buffer, sizeof( buffer ) );
|
||
|
|
userInfo.baseName = buffer;
|
||
|
|
msg.ReadString( buffer, sizeof( buffer ) );
|
||
|
|
userInfo.rawName = buffer;
|
||
|
|
|
||
|
|
userInfo.showGun = msg.ReadBool();
|
||
|
|
userInfo.ignoreExplosiveWeapons = msg.ReadBool();
|
||
|
|
userInfo.autoSwitchEmptyWeapons = msg.ReadBool();
|
||
|
|
userInfo.postArmFindBestWeapon = msg.ReadBool();
|
||
|
|
userInfo.advancedFlightControls = msg.ReadBool();
|
||
|
|
userInfo.rememberCameraMode = msg.ReadBool();
|
||
|
|
userInfo.drivingCameraFreelook = msg.ReadBool();
|
||
|
|
userInfo.isBot = msg.ReadBool();
|
||
|
|
userInfo.swapFlightYawAndRoll = msg.ReadBool();
|
||
|
|
|
||
|
|
userInfo.ToDict( info );
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
================
|
||
|
|
idGameLocal::ClientProcessEntityNetworkEventQueue
|
||
|
|
================
|
||
|
|
*/
|
||
|
|
void idGameLocal::ClientProcessEntityNetworkEventQueue( void ) {
|
||
|
|
sdEntityNetEvent* next;
|
||
|
|
for ( sdEntityNetEvent* event = entityNetEventQueue.Next(); event; event = next ) {
|
||
|
|
next = event->GetNode().Next();
|
||
|
|
|
||
|
|
// only process forward, in order
|
||
|
|
if ( event->GetTime() > time ) {
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
|
||
|
|
idEntity* entity = gameLocal.EntityForSpawnId( event->GetSpawnId() );
|
||
|
|
|
||
|
|
if( !entity ) {
|
||
|
|
NetworkEventWarning( *event, "unknown entity" );
|
||
|
|
} else {
|
||
|
|
if ( gameLocal.isRepeater ) { // Gordon: Save any off that we need to send to clients which connect later
|
||
|
|
gameLocal.FreeEntityNetworkEvents( entity, event->GetEvent() );
|
||
|
|
if ( event->ShouldSaveEvent() ) {
|
||
|
|
gameLocal.SaveEntityNetworkEvent( *event );
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
idBitMsg eventMsg;
|
||
|
|
event->OutputParms( eventMsg );
|
||
|
|
|
||
|
|
if ( !entity->ClientReceiveEvent( event->GetEvent(), event->GetTime(), eventMsg ) ) {
|
||
|
|
NetworkEventWarning( *event, "unknown event" );
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
event->GetNode().Remove();
|
||
|
|
entityNetEventAllocator.Free( event );
|
||
|
|
}
|
||
|
|
|
||
|
|
// process unreliable events
|
||
|
|
sdUnreliableEntityNetEvent* unreliableNext;
|
||
|
|
for ( sdUnreliableEntityNetEvent* event = unreliableEntityNetEventQueue.Next(); event; event = unreliableNext ) {
|
||
|
|
unreliableNext = event->GetUnreliableNode().Next();
|
||
|
|
|
||
|
|
// only process forward, in order
|
||
|
|
if ( event->GetTime() > time ) {
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
|
||
|
|
idEntity* entity = gameLocal.EntityForSpawnId( event->GetSpawnId() );
|
||
|
|
|
||
|
|
if( !entity ) {
|
||
|
|
UnreliableNetworkEventWarning( *event, "unknown entity" );
|
||
|
|
} else {
|
||
|
|
idBitMsg eventMsg;
|
||
|
|
event->OutputParms( eventMsg );
|
||
|
|
|
||
|
|
if ( !entity->ClientReceiveUnreliableEvent( event->GetEvent(), event->GetTime(), eventMsg ) ) {
|
||
|
|
UnreliableNetworkEventWarning( *event, "unknown event" );
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
event->GetUnreliableNode().Remove();
|
||
|
|
unreliableEntityNetEventAllocator.Free( event );
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
================
|
||
|
|
idGameLocal::ClientReceiveEvent
|
||
|
|
================
|
||
|
|
*/
|
||
|
|
bool idGameLocal::ClientReceiveEvent( const idVec3& origin, int event, int time, const idBitMsg &msg ) {
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
================
|
||
|
|
idGameLocal::FreeNetworkState
|
||
|
|
================
|
||
|
|
*/
|
||
|
|
void idGameLocal::FreeNetworkState( sdEntityState* state ) {
|
||
|
|
delete state;
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
================
|
||
|
|
idGameLocal::FreeGameState
|
||
|
|
================
|
||
|
|
*/
|
||
|
|
void idGameLocal::FreeGameState( sdGameState* state ) {
|
||
|
|
delete state;
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
================
|
||
|
|
idGameLocal::CreateNetworkState
|
||
|
|
================
|
||
|
|
*/
|
||
|
|
void idGameLocal::CreateNetworkState( clientNetworkInfo_t& networkInfo, int entityNum ) {
|
||
|
|
idEntity* entity = entities[ entityNum ];
|
||
|
|
|
||
|
|
for ( int i = 0; i < NSM_NUM_MODES; i++ ) {
|
||
|
|
if ( !networkInfo.states[ entityNum ][ i ] ) {
|
||
|
|
networkInfo.states[ entityNum ][ i ] = AllocEntityState( ( networkStateMode_t )i, entity );
|
||
|
|
if ( networkInfo.states[ entityNum ][ i ]->data ) {
|
||
|
|
networkInfo.states[ entityNum ][ i ]->data->MakeDefault();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
================
|
||
|
|
idGameLocal::CreateNetworkState
|
||
|
|
================
|
||
|
|
*/
|
||
|
|
void idGameLocal::CreateNetworkState( int entityNum ) {
|
||
|
|
if ( isClient ) {
|
||
|
|
CreateNetworkState( GetNetworkInfo( localClientNum ), entityNum );
|
||
|
|
} else {
|
||
|
|
for ( int i = 0; i < MAX_CLIENTS; i++ ) {
|
||
|
|
if ( !entities[ i ] ) {
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
CreateNetworkState( GetNetworkInfo( i ), entityNum );
|
||
|
|
}
|
||
|
|
CreateNetworkState( demoClientNetworkInfo, entityNum );
|
||
|
|
}
|
||
|
|
|
||
|
|
#ifdef SD_SUPPORT_REPEATER
|
||
|
|
for ( int i = 0; i < repeaterNetworkInfo.Num(); i++ ) {
|
||
|
|
if ( repeaterNetworkInfo[ i ] == NULL ) {
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
|
||
|
|
CreateNetworkState( *repeaterNetworkInfo[ i ], entityNum );
|
||
|
|
}
|
||
|
|
#endif // SD_SUPPORT_REPEATER
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
================
|
||
|
|
idGameLocal::FreeNetworkState
|
||
|
|
================
|
||
|
|
*/
|
||
|
|
void idGameLocal::FreeNetworkState( clientNetworkInfo_t& networkInfo, int entityNum ) {
|
||
|
|
for ( int i = 0; i < NSM_NUM_MODES; i++ ) {
|
||
|
|
FreeNetworkState( networkInfo.states[ entityNum ][ i ] );
|
||
|
|
networkInfo.states[ entityNum ][ i ] = NULL;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
================
|
||
|
|
idGameLocal::FreeNetworkState
|
||
|
|
================
|
||
|
|
*/
|
||
|
|
void idGameLocal::FreeNetworkState( int entityNum ) {
|
||
|
|
if ( isClient ) {
|
||
|
|
FreeNetworkState( GetNetworkInfo( localClientNum ), entityNum );
|
||
|
|
|
||
|
|
// Gordon: Clear any pending events that we may have just caught this frame
|
||
|
|
sdEntityNetEvent* next = NULL;
|
||
|
|
for ( sdEntityNetEvent* evt = entityNetEventQueue.Next(); evt != NULL; evt = next ) {
|
||
|
|
next = evt->GetNode().Next();
|
||
|
|
|
||
|
|
if ( evt->GetEntityNumber() == entityNum ) {
|
||
|
|
evt->GetNode().Remove();
|
||
|
|
entityNetEventAllocator.Free( evt );
|
||
|
|
}
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
for ( int i = 0; i < MAX_CLIENTS; i++ ) {
|
||
|
|
FreeNetworkState( GetNetworkInfo( i ), entityNum );
|
||
|
|
}
|
||
|
|
FreeNetworkState( demoClientNetworkInfo, entityNum );
|
||
|
|
}
|
||
|
|
|
||
|
|
#ifdef SD_SUPPORT_REPEATER
|
||
|
|
for ( int i = 0; i < repeaterNetworkInfo.Num(); i++ ) {
|
||
|
|
if ( repeaterNetworkInfo[ i ] == NULL ) {
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
|
||
|
|
FreeNetworkState( *repeaterNetworkInfo[ i ], entityNum );
|
||
|
|
}
|
||
|
|
#endif // SD_SUPPORT_REPEATER
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
================
|
||
|
|
idGameLocal::ClientSpawn
|
||
|
|
================
|
||
|
|
*/
|
||
|
|
void idGameLocal::ClientSpawn( int entityNum, int spawnId, int typeNum, int entityDefNumber, int mapSpawnId ) {
|
||
|
|
idTypeInfo* typeInfo = NULL;
|
||
|
|
|
||
|
|
// if there is no entity or an entity of the wrong type
|
||
|
|
|
||
|
|
if ( entities[ entityNum ] ) {
|
||
|
|
// Warning( "idGameLocal::ClientSpawn: New Entity Spawned In Already Occupied Position" );
|
||
|
|
entities[ entityNum ]->ProcessEvent( &EV_Remove );
|
||
|
|
assert( !entities[ entityNum ] );
|
||
|
|
}
|
||
|
|
|
||
|
|
spawnCount = spawnId; // Makes the spawn func set up the spawnId properly
|
||
|
|
|
||
|
|
idDict args;
|
||
|
|
args.SetInt( "spawn_entnum", entityNum );
|
||
|
|
args.Set( "name", va( "entity%d", entityNum ) );
|
||
|
|
|
||
|
|
idEntity* ent = NULL;
|
||
|
|
|
||
|
|
if ( mapSpawnId != -1 ) {
|
||
|
|
if ( mapSpawnId > mapFile->GetNumEntities() ) {
|
||
|
|
Error( "Tried to spawn out of bounds entity number '%i' from map", mapSpawnId );
|
||
|
|
}
|
||
|
|
idMapEntity* mapEnt = mapFile->GetEntity( mapSpawnId );
|
||
|
|
|
||
|
|
args.Copy( mapEnt->epairs );
|
||
|
|
|
||
|
|
// precache any media specified in the map entity
|
||
|
|
CacheDictionaryMedia( args );
|
||
|
|
|
||
|
|
SpawnEntityDef( args, true, &ent, -1, mapSpawnId );
|
||
|
|
assert( ent );
|
||
|
|
} else if ( entityDefNumber >= 0 ) {
|
||
|
|
if ( entityDefNumber >= declHolder.declEntityDefType.Num() ) {
|
||
|
|
Error( "server has %d entityDefs instead of %d", entityDefNumber, declHolder.declEntityDefType.Num() );
|
||
|
|
}
|
||
|
|
const char* classname = declHolder.declEntityDefType.LocalFindByIndex( entityDefNumber, false )->GetName();
|
||
|
|
args.Set( "classname", classname );
|
||
|
|
|
||
|
|
if ( !SpawnEntityDef( args, true, &ent ) ) {
|
||
|
|
Error( "Failed to spawn entity with classname '%s'", classname );
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
idTypeInfo* t = idClass::GetType( typeNum );
|
||
|
|
if ( !t ) {
|
||
|
|
Error( "Unknown type number %d for entity %d with class number %d", typeNum, entityNum, entityDefNumber );
|
||
|
|
}
|
||
|
|
|
||
|
|
ent = CreateEntityType( *t );
|
||
|
|
CallSpawnFuncs( ent, &args );
|
||
|
|
if ( !entities[ entityNum ] ) {
|
||
|
|
Error( "Failed to spawn entity of type '%s'", t->classname );
|
||
|
|
}
|
||
|
|
ent->PostMapSpawn();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
================
|
||
|
|
idGameLocal::SetupGameStateBase
|
||
|
|
================
|
||
|
|
*/
|
||
|
|
void idGameLocal::SetupGameStateBase( clientNetworkInfo_t& networkInfo ) {
|
||
|
|
for ( int i = 0; i < ENSM_NUM_MODES; i++ ) {
|
||
|
|
FreeGameState( networkInfo.gameStates[ i ] );
|
||
|
|
|
||
|
|
sdGameState* state = AllocGameState( GetGameStateObject( ( extNetworkStateMode_t )i ) );
|
||
|
|
if ( state->data ) {
|
||
|
|
state->data->MakeDefault();
|
||
|
|
}
|
||
|
|
|
||
|
|
networkInfo.gameStates[ i ] = state;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
================
|
||
|
|
idGameLocal::SetupEntityStateBase
|
||
|
|
================
|
||
|
|
*/
|
||
|
|
void idGameLocal::SetupEntityStateBase( clientNetworkInfo_t& networkInfo ) {
|
||
|
|
idEntity* ent;
|
||
|
|
for ( ent = networkedEntities.Next(); ent; ent = ent->networkNode.Next() ) {
|
||
|
|
for ( int i = 0; i < NSM_NUM_MODES; i++ ) {
|
||
|
|
FreeNetworkState( networkInfo.states[ ent->entityNumber ][ i ] );
|
||
|
|
|
||
|
|
sdEntityState* state = AllocEntityState( ( networkStateMode_t )i, ent );
|
||
|
|
if ( state->data ) {
|
||
|
|
state->data->MakeDefault();
|
||
|
|
}
|
||
|
|
|
||
|
|
networkInfo.states[ ent->entityNumber ][ i ] = state;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
================
|
||
|
|
idGameLocal::OnEntityCreateMessage
|
||
|
|
================
|
||
|
|
*/
|
||
|
|
void idGameLocal::OnEntityCreateMessage( const idBitMsg& msg ) {
|
||
|
|
int temp = msg.ReadBits( 32 );
|
||
|
|
int entityNum = EntityNumForSpawnId( temp );
|
||
|
|
int spawnId = SpawnNumForSpawnId( temp );
|
||
|
|
|
||
|
|
int createType = msg.ReadBits( 2 );
|
||
|
|
switch ( createType ) {
|
||
|
|
case 0: {
|
||
|
|
int mapSpawnId = msg.ReadBits( idMath::BitsForInteger( GetNumMapEntities() ) );
|
||
|
|
ClientSpawn( entityNum, spawnId, -1, -1, mapSpawnId );
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
case 1: {
|
||
|
|
int entityDefNumber = msg.ReadBits( GetNumEntityDefBits() ) - 1;
|
||
|
|
ClientSpawn( entityNum, spawnId, -1, entityDefNumber, -1 );
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
case 2: {
|
||
|
|
int typeNum = msg.ReadBits( idClass::GetTypeNumBits() );
|
||
|
|
ClientSpawn( entityNum, spawnId, typeNum, -1, -1 );
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
default:
|
||
|
|
Error( "idGameLocal::OnEntityCreateMessage Unknown Create Type: '%d'", createType );
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
|
||
|
|
if ( entities[ entityNum ] == NULL ) {
|
||
|
|
Error( "idGameLocal::OnEntityCreateMessage Failed To Create Entity" );
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
entities[ entityNum ]->networkNode.AddToEnd( networkedEntities );
|
||
|
|
CreateNetworkState( entityNum );
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
================
|
||
|
|
idGameLocal::HandleNewEntityEvent
|
||
|
|
================
|
||
|
|
*/
|
||
|
|
void idGameLocal::HandleNewEntityEvent( const idBitMsg &msg ) {
|
||
|
|
sdEntityNetEvent* event = entityNetEventAllocator.Alloc();
|
||
|
|
event->GetNode().AddToEnd( entityNetEventQueue );
|
||
|
|
event->Read( msg );
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
================
|
||
|
|
idGameLocal::ClientProcessReliableMessage
|
||
|
|
================
|
||
|
|
*/
|
||
|
|
void idGameLocal::ClientProcessReliableMessage( const idBitMsg &msg ) {
|
||
|
|
gameLocal.isNewFrame = true;
|
||
|
|
|
||
|
|
idPlayer* localPlayer = GetLocalPlayer();
|
||
|
|
|
||
|
|
gameReliableServerMessage_t id = static_cast< gameReliableServerMessage_t >( msg.ReadBits( idMath::BitsForInteger( GAME_RELIABLE_SMESSAGE_NUM_MESSAGES ) ) );
|
||
|
|
|
||
|
|
switch( id ) {
|
||
|
|
case GAME_RELIABLE_SMESSAGE_DELETE_ENT: {
|
||
|
|
int spawnId = msg.ReadBits( 32 );
|
||
|
|
idEntity* ent = EntityForSpawnId( spawnId );
|
||
|
|
if ( ent ) {
|
||
|
|
ent->ProcessEvent( &EV_Remove );
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
case GAME_RELIABLE_SMESSAGE_MULTI_CREATE_ENT: {
|
||
|
|
int count = msg.ReadLong();
|
||
|
|
for ( int i = 0; i < count; i++ ) {
|
||
|
|
OnEntityCreateMessage( msg );
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
case GAME_RELIABLE_SMESSAGE_CREATE_ENT: {
|
||
|
|
OnEntityCreateMessage( msg );
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
case GAME_RELIABLE_SMESSAGE_CHAT:
|
||
|
|
case GAME_RELIABLE_SMESSAGE_FIRETEAM_CHAT:
|
||
|
|
case GAME_RELIABLE_SMESSAGE_TEAM_CHAT: {
|
||
|
|
sdGameRules::chatMode_t chatMode;
|
||
|
|
switch ( id ) {
|
||
|
|
case GAME_RELIABLE_SMESSAGE_CHAT:
|
||
|
|
chatMode = sdGameRules::CHAT_MODE_SAY;
|
||
|
|
break;
|
||
|
|
case GAME_RELIABLE_SMESSAGE_FIRETEAM_CHAT:
|
||
|
|
chatMode = sdGameRules::CHAT_MODE_SAY_FIRETEAM;
|
||
|
|
break;
|
||
|
|
case GAME_RELIABLE_SMESSAGE_TEAM_CHAT:
|
||
|
|
chatMode = sdGameRules::CHAT_MODE_SAY_TEAM;
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
wchar_t text[ 128 ];
|
||
|
|
idVec3 location = msg.ReadVector();
|
||
|
|
int clientNum = msg.ReadChar();
|
||
|
|
msg.ReadString( text, sizeof( text ) / sizeof( wchar_t ) );
|
||
|
|
rules->AddChatLine( location, chatMode, clientNum, text );
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
case GAME_RELIABLE_SMESSAGE_QUICK_CHAT: {
|
||
|
|
idVec3 location = msg.ReadVector();
|
||
|
|
int clientNum = msg.ReadChar();
|
||
|
|
int index = msg.ReadLong();
|
||
|
|
int spawnID = msg.ReadLong();
|
||
|
|
|
||
|
|
idEntity* target = NULL;
|
||
|
|
if ( spawnID != -1 ) {
|
||
|
|
target = gameLocal.EntityForSpawnId( spawnID );
|
||
|
|
}
|
||
|
|
|
||
|
|
localPlayer->PlayQuickChat( location, clientNum, declQuickChatType.SafeIndex( index ), target );
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
case GAME_RELIABLE_SMESSAGE_MULTI_ENTITY_EVENT: {
|
||
|
|
int count = msg.ReadLong();
|
||
|
|
for ( int i = 0; i < count; i++ ) {
|
||
|
|
HandleNewEntityEvent( msg );
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
case GAME_RELIABLE_SMESSAGE_ENTITY_EVENT: {
|
||
|
|
HandleNewEntityEvent( msg );
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
case GAME_RELIABLE_SMESSAGE_TOOLTIP: {
|
||
|
|
const sdDeclToolTip* toolTip = declToolTipType.SafeIndex( msg.ReadLong() );
|
||
|
|
if ( toolTip == NULL ) {
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
int numParms = msg.ReadLong();
|
||
|
|
sdToolTipParms* parms = new sdToolTipParms();
|
||
|
|
|
||
|
|
wchar_t buffer[ 128 ];
|
||
|
|
for ( int i = 0; i < numParms; i++ ) {
|
||
|
|
msg.ReadString( buffer, sizeof( buffer ) );
|
||
|
|
parms->Add( buffer );
|
||
|
|
}
|
||
|
|
localPlayer->SpawnToolTip( toolTip, parms );
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
|
||
|
|
case GAME_RELIABLE_SMESSAGE_TASK: {
|
||
|
|
sdPlayerTask::HandleMessage( msg );
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
case GAME_RELIABLE_SMESSAGE_FIRETEAM: {
|
||
|
|
sdFireTeam::HandleMessage( msg );
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
case GAME_RELIABLE_SMESSAGE_CREATEPLAYERTARGETTIMER: {
|
||
|
|
if ( isServer ) {
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
char buffer[ 256 ];
|
||
|
|
msg.ReadString( buffer, sizeof( buffer ) );
|
||
|
|
qhandle_t serverHandle = msg.ReadShort();
|
||
|
|
|
||
|
|
qhandle_t handle = AllocTargetTimer( buffer );
|
||
|
|
if ( targetTimers[ handle ].serverHandle == -1 ) {
|
||
|
|
targetTimers[ handle ].serverHandle = serverHandle;
|
||
|
|
if ( serverHandle >= targetTimerLookup.Num() ) {
|
||
|
|
targetTimerLookup.AssureSize( serverHandle + 1, -1 );
|
||
|
|
}
|
||
|
|
targetTimerLookup[ serverHandle ] = handle;
|
||
|
|
numServerTimers++;
|
||
|
|
|
||
|
|
// assert( targetTimerLookup.Num() == numServerTimers );
|
||
|
|
} else {
|
||
|
|
assert( targetTimers[ handle ].serverHandle == serverHandle );
|
||
|
|
}
|
||
|
|
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
case GAME_RELIABLE_SMESSAGE_NETWORKEVENT: {
|
||
|
|
int entityId = msg.ReadLong();
|
||
|
|
|
||
|
|
char buffer[ 512 ];
|
||
|
|
msg.ReadString( buffer, sizeof( buffer ) );
|
||
|
|
|
||
|
|
if ( entityId == NETWORKEVENT_RULES_ID ) {
|
||
|
|
rules->OnNetworkEvent( buffer );
|
||
|
|
} else if ( entityId == NETWORKEVENT_OBJECTIVE_ID ) {
|
||
|
|
sdObjectiveManager::GetInstance().OnNetworkEvent( buffer );
|
||
|
|
} else {
|
||
|
|
HandleNetworkEvent( EntityForSpawnId( entityId ), buffer );
|
||
|
|
}
|
||
|
|
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
case GAME_RELIABLE_SMESSAGE_CREATEDEPLOYREQUEST: {
|
||
|
|
int index = msg.ReadLong();
|
||
|
|
|
||
|
|
float rotation = msg.ReadFloat();
|
||
|
|
idPlayer* owner = EntityForSpawnId( msg.ReadLong() )->Cast< idPlayer >();
|
||
|
|
const sdDeclDeployableObject* object = declDeployableObjectType[ msg.ReadBits( GetNumDeployObjectBits() ) - 1 ];
|
||
|
|
idVec3 position = msg.ReadVector();
|
||
|
|
sdTeamInfo* team = sdTeamManager::GetInstance().ReadTeamFromStream( msg );
|
||
|
|
|
||
|
|
if ( deployRequests[ index ] ) {
|
||
|
|
assert( false );
|
||
|
|
delete deployRequests[ index ];
|
||
|
|
}
|
||
|
|
|
||
|
|
deployRequests[ index ] = new sdDeployRequest( object, owner, position, rotation, team, 0 );
|
||
|
|
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
|
||
|
|
case GAME_RELIABLE_SMESSAGE_DELETEDEPLOYREQUEST: {
|
||
|
|
int index = msg.ReadLong();
|
||
|
|
|
||
|
|
assert( deployRequests[ index ] );
|
||
|
|
|
||
|
|
delete deployRequests[ index ];
|
||
|
|
deployRequests[ index ] = NULL;
|
||
|
|
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
|
||
|
|
case GAME_RELIABLE_SMESSAGE_USERGROUPS: {
|
||
|
|
sdUserGroupManager::GetInstance().ReadNetworkData( msg );
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
|
||
|
|
case GAME_RELIABLE_SMESSAGE_OBITUARY: {
|
||
|
|
int clientIndex = msg.ReadBits( idMath::BitsForInteger( MAX_CLIENTS ) );
|
||
|
|
int attackerIndex = msg.ReadLong();
|
||
|
|
int damageDeclIndex = msg.ReadBits( gameLocal.GetNumDamageDeclBits() ) - 1;
|
||
|
|
|
||
|
|
idPlayer* player = GetClient( clientIndex );
|
||
|
|
idEntity* killer = EntityForSpawnId( attackerIndex );
|
||
|
|
const sdDeclDamage* damageDecl = declDamageType[ damageDeclIndex ];
|
||
|
|
|
||
|
|
if ( player != NULL ) {
|
||
|
|
player->Obituary( killer, damageDecl );
|
||
|
|
}
|
||
|
|
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
|
||
|
|
case GAME_RELIABLE_SMESSAGE_VOTE: {
|
||
|
|
sdVoteManager::GetInstance().ClientReadNetworkMessage( msg );
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
|
||
|
|
case GAME_RELIABLE_SMESSAGE_SETNEXTOBJECTIVE: {
|
||
|
|
sdTeamInfo* team = sdTeamManager::GetInstance().ReadTeamFromStream( msg );
|
||
|
|
int index = msg.ReadLong();
|
||
|
|
sdObjectiveManager::GetInstance().SetNextObjective( team, index );
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
|
||
|
|
case GAME_RELIABLE_SMESSAGE_RECORD_DEMO: {
|
||
|
|
StartRecordingDemo();
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
case GAME_RELIABLE_SMESSAGE_RULES_DATA: {
|
||
|
|
sdGameRules::ParseNetworkMessage( msg );
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
case GAME_RELIABLE_SMESSAGE_SETSPAWNPOINT: {
|
||
|
|
int spawnId = msg.ReadLong();
|
||
|
|
localPlayer->SetSpawnPoint( gameLocal.EntityForSpawnId( spawnId ) );
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
case GAME_RELIABLE_SMESSAGE_FIRETEAM_DISBAND: {
|
||
|
|
localPlayer->OnFireTeamDisbanded();
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
case GAME_RELIABLE_SMESSAGE_SESSION_ID: {
|
||
|
|
sdnet.ProcessSessionId( msg );
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
|
||
|
|
case GAME_RELIABLE_SMESSAGE_STATSMESSAGE: {
|
||
|
|
sdGlobalStatsTracker::GetInstance().OnServerStatsRequestMessage( msg );
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
|
||
|
|
case GAME_RELIABLE_SMESSAGE_STATSFINIHED: {
|
||
|
|
bool completed = msg.ReadBool();
|
||
|
|
if ( completed ) {
|
||
|
|
sdGlobalStatsTracker::GetInstance().OnServerStatsRequestCompleted();
|
||
|
|
} else {
|
||
|
|
sdGlobalStatsTracker::GetInstance().OnServerStatsRequestCancelled();
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
|
||
|
|
case GAME_RELIABLE_SMESSAGE_LOCALISEDMESSAGE: {
|
||
|
|
idVec3 location = msg.ReadVector();
|
||
|
|
const sdDeclLocStr* locStr = declHolder.declLocStrType.SafeIndex( msg.ReadLong() );
|
||
|
|
|
||
|
|
wchar_t buffer[ 256 ];
|
||
|
|
|
||
|
|
int parmCount = msg.ReadLong();
|
||
|
|
idWStrList strings;
|
||
|
|
strings.SetNum( parmCount );
|
||
|
|
for ( int i = 0; i < parmCount; i++ ) {
|
||
|
|
msg.ReadString( buffer, sizeof( buffer ) );
|
||
|
|
strings[ i ] = buffer;
|
||
|
|
}
|
||
|
|
|
||
|
|
localPlayer->SendLocalisedMessage( locStr, strings );
|
||
|
|
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
|
||
|
|
case GAME_RELIABLE_SMESSAGE_ENDGAMESTATS: {
|
||
|
|
int count = msg.ReadLong();
|
||
|
|
endGameStats.SetNum( count, false );
|
||
|
|
for ( int i = 0; i < count; i++ ) {
|
||
|
|
int rankIndex = msg.ReadLong();
|
||
|
|
endGameStats[ i ].rank = rankIndex == -1 ? NULL : gameLocal.declRankType.SafeIndex( rankIndex );
|
||
|
|
|
||
|
|
char buffer[ 256 ];
|
||
|
|
msg.ReadString( buffer, sizeof( buffer ) );
|
||
|
|
endGameStats[ i ].name = buffer;
|
||
|
|
|
||
|
|
endGameStats[ i ].value = msg.ReadFloat();
|
||
|
|
float localValue = msg.ReadFloat();
|
||
|
|
if ( localClientNum >= 0 && localClientNum < MAX_CLIENTS ) {
|
||
|
|
endGameStats[ i ].data[ localClientNum ] = localValue;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
OnEndGameStatsReceived();
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
case GAME_RELIABLE_SMESSAGE_ADMINFEEDBACK: {
|
||
|
|
bool success = msg.ReadBool();
|
||
|
|
sdAdminSystem::GetInstance().SetCommandState( success ? sdAdminSystemLocal::CS_SUCCESS : sdAdminSystemLocal::CS_FAILED );
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
case GAME_RELIABLE_SMESSAGE_SETCRITICALCLASS: {
|
||
|
|
playerTeamTypes_t playerTeam = static_cast< playerTeamTypes_t >( msg.ReadChar() );
|
||
|
|
playerClassTypes_t criticalClass = static_cast< playerClassTypes_t >( msg.ReadChar() );
|
||
|
|
sdObjectiveManager::GetInstance().SetCriticalClass( playerTeam, criticalClass );
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
case GAME_RELIABLE_SMESSAGE_MAP_RESTART: {
|
||
|
|
OnLocalMapRestart();
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
case GAME_RELIABLE_SMESSAGE_PAUSEINFO: {
|
||
|
|
bool paused = msg.ReadBool();
|
||
|
|
int newTime = msg.ReadLong();
|
||
|
|
int newTimeOffset = msg.ReadLong();
|
||
|
|
|
||
|
|
isPaused = paused;
|
||
|
|
time = newTime;
|
||
|
|
timeOffset = newTimeOffset;
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
#ifdef SD_SUPPORT_REPEATER
|
||
|
|
case GAME_RELIABLE_SMESSAGE_REPEATER_CHAT: {
|
||
|
|
char playerName[ 128 ];
|
||
|
|
msg.ReadString( playerName, sizeof( playerName ) );
|
||
|
|
|
||
|
|
int clientIndex = msg.ReadLong();
|
||
|
|
|
||
|
|
wchar_t textBuffer[ 128 ];
|
||
|
|
msg.ReadString( textBuffer, sizeof( textBuffer ) / sizeof( textBuffer[ 0 ] ) );
|
||
|
|
|
||
|
|
rules->AddRepeaterChatLine( playerName, clientIndex, textBuffer );
|
||
|
|
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
#endif // SD_SUPPORT_REPEATER
|
||
|
|
case GAME_RELIABLE_SMESSAGE_BANLISTMESSAGE: {
|
||
|
|
sdReliableClientMessage outMsg( GAME_RELIABLE_CMESSAGE_ACKNOWLEDGEBANLIST );
|
||
|
|
outMsg.Send();
|
||
|
|
|
||
|
|
guidFile.ListBans( msg );
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
case GAME_RELIABLE_SMESSAGE_BANLISTFINISHED: {
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
case GAME_RELIABLE_SMESSAGE_REPEATERSTATUS: {
|
||
|
|
bool repeaterActive = msg.ReadBool();
|
||
|
|
if ( repeaterActive ) {
|
||
|
|
gameLocal.Printf( "Repeater is running on this server\n" );
|
||
|
|
} else {
|
||
|
|
gameLocal.Printf( "Repeater is not running on this server\n" );
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
default: {
|
||
|
|
Warning( "idGameLocal::ClientProcessReliableMessage: Unknown reliable message: %d", id );
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
ID_INLINE bool ThinkNow( idEntity* ent, bool newFrame ) {
|
||
|
|
return !( ent->snapshotPVSFlags & PVS_DEFERRED_VISIBLE ) || newFrame;
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
================
|
||
|
|
idGameLocal::OnSnapshotHitch
|
||
|
|
================
|
||
|
|
*/
|
||
|
|
void idGameLocal::OnSnapshotHitch( int snapshotTime ) {
|
||
|
|
if ( realClientTime != 0 ) {
|
||
|
|
uiManager->OnSnapshotHitch( realClientTime - snapshotTime );
|
||
|
|
}
|
||
|
|
realClientTime = snapshotTime;
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
================
|
||
|
|
idGameLocal::OnClientDisconnected
|
||
|
|
================
|
||
|
|
*/
|
||
|
|
void idGameLocal::OnClientDisconnected( void ) {
|
||
|
|
isClient = false;
|
||
|
|
realClientTime = 0;
|
||
|
|
time = 0;
|
||
|
|
|
||
|
|
for ( int i = 0; i < MAX_CLIENTS; i++ ) {
|
||
|
|
GetProficiencyTable( i ).Clear( true );
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
================
|
||
|
|
idGameLocal::ClientPrediction
|
||
|
|
================
|
||
|
|
*/
|
||
|
|
void idGameLocal::ClientPrediction( const usercmd_t* clientCmds, const usercmd_t* demoCmd ) {
|
||
|
|
|
||
|
|
idPlayer* localPlayer = GetLocalPlayer();
|
||
|
|
if ( localPlayer != NULL ) {
|
||
|
|
unlock.canUnlockFrames = localPlayer->IsFPSUnlock();
|
||
|
|
} else {
|
||
|
|
unlock.canUnlockFrames = false;
|
||
|
|
}
|
||
|
|
|
||
|
|
unlock.unlockedDraw = false;
|
||
|
|
interpolateEntities.Clear();
|
||
|
|
|
||
|
|
idEntity* ent;
|
||
|
|
|
||
|
|
idPlayer* player = GetLocalPlayer();
|
||
|
|
|
||
|
|
sdDemoManagerLocal& demoManager = sdDemoManager::GetInstance();
|
||
|
|
if ( demoManager.GetState() == sdDemoManagerLocal::DS_PAUSED ) {
|
||
|
|
gameRenderWorld->DebugClearLines( 0 );
|
||
|
|
}
|
||
|
|
|
||
|
|
if ( serverIsRepeater && demoCmd != NULL ) {
|
||
|
|
playerView.SetRepeaterUserCmd( *demoCmd );
|
||
|
|
}
|
||
|
|
|
||
|
|
framenum++;
|
||
|
|
|
||
|
|
int frameTime = networkSystem->ClientGetFrameTime();
|
||
|
|
|
||
|
|
if ( IsPaused() ) {
|
||
|
|
msec = 0;
|
||
|
|
previousTime = time;
|
||
|
|
time += 0;
|
||
|
|
timeOffset += frameTime;
|
||
|
|
} else {
|
||
|
|
msec = frameTime;
|
||
|
|
previousTime = time;
|
||
|
|
time += frameTime;
|
||
|
|
timeOffset += 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
int now = gameLocal.ToGuiTime( time );
|
||
|
|
// update the real client time and the new frame flag
|
||
|
|
if ( now > realClientTime ) {
|
||
|
|
realClientTime = now;
|
||
|
|
isNewFrame = true;
|
||
|
|
|
||
|
|
if ( predictionUpdateRequired ) {
|
||
|
|
for ( idEntity* ent = networkedEntities.Next(); ent; ent = ent->networkNode.Next() ) {
|
||
|
|
ent->UpdatePredictionErrorDecay();
|
||
|
|
}
|
||
|
|
predictionUpdateRequired = false;
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
isNewFrame = false;
|
||
|
|
}
|
||
|
|
|
||
|
|
UpdateDeploymentRequests();
|
||
|
|
|
||
|
|
// check for local client lag
|
||
|
|
if ( player ) {
|
||
|
|
player->SetLagged( networkSystem->ClientGetTimeSinceLastPacket() >= net_clientMaxPrediction.GetInteger() );
|
||
|
|
}
|
||
|
|
|
||
|
|
gameRenderWorld->DebugClearLines( time );
|
||
|
|
gameRenderWorld->DebugClearPolygons( time );
|
||
|
|
|
||
|
|
#ifdef CLIP_DEBUG_EXTREME
|
||
|
|
clip.UpdateTraceLogging();
|
||
|
|
#endif
|
||
|
|
sdProfileHelperManager::GetInstance().Update();
|
||
|
|
|
||
|
|
if ( isNewFrame ) {
|
||
|
|
bse->StartFrame();
|
||
|
|
}
|
||
|
|
|
||
|
|
// set the user commands for this frame
|
||
|
|
memcpy( usercmds, clientCmds, numClients * sizeof( usercmds[ 0 ] ) );
|
||
|
|
|
||
|
|
// update demo state
|
||
|
|
demoManager.RunDemoFrame( demoCmd );
|
||
|
|
|
||
|
|
if ( !isRepeater ) {
|
||
|
|
sdPhysicsEvent* physicsEvent;
|
||
|
|
for ( physicsEvent = physicsEvents.Next(); physicsEvent; physicsEvent = physicsEvent->GetNode().Next() ) {
|
||
|
|
if ( physicsEvent->GetCreationTime() != time ) {
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
physicsEvent->Apply();
|
||
|
|
}
|
||
|
|
|
||
|
|
for ( int i = 0; i < changedEntities.Num(); i++ ) {
|
||
|
|
idEntity* ent = changedEntities[ i ];
|
||
|
|
if ( !ent ) {
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
|
||
|
|
if ( !ent->thinkFlags || ent->NoThink() ) {
|
||
|
|
ent->activeNode.Remove();
|
||
|
|
ent->activeNetworkNode.Remove();
|
||
|
|
} else {
|
||
|
|
if ( ent->IsNetSynced() ) {
|
||
|
|
if ( !ent->activeNetworkNode.InList() ) {
|
||
|
|
ent->activeNetworkNode.AddToEnd( gameLocal.activeNetworkEntities );
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if ( !ent->activeNode.InList() ) {
|
||
|
|
ent->activeNode.AddToEnd( gameLocal.activeEntities );
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
changedEntities.Clear();
|
||
|
|
|
||
|
|
idEntity::ClearEntityCaches();
|
||
|
|
|
||
|
|
if ( !isNewFrame ) {
|
||
|
|
idEntity* nextEnt;
|
||
|
|
for( ent = activeNetworkEntities.Next(); ent != NULL; ent = nextEnt ) {
|
||
|
|
nextEnt = ent->activeNetworkNode.Next();
|
||
|
|
if ( ( ent->snapshotPVSFlags & PVS_DEFERRED_VISIBLE ) == 0 ) {
|
||
|
|
sdProfileHelper_ScopeTimer( "EntityThink", ent->spawnArgs.GetString( "classname" ), g_profileEntityThink.GetBool() );
|
||
|
|
ent->Think();
|
||
|
|
} else {
|
||
|
|
ent->UpdateVisuals();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
// sort the active entity list
|
||
|
|
SortActiveEntityList();
|
||
|
|
|
||
|
|
idEntity* nextEnt;
|
||
|
|
for( ent = activeEntities.Next(); ent != NULL; ent = nextEnt ) {
|
||
|
|
sdProfileHelper_ScopeTimer( "EntityThink", ent->spawnArgs.GetString( "classname" ), g_profileEntityThink.GetBool() );
|
||
|
|
nextEnt = ent->activeNode.Next();
|
||
|
|
ent->Think();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
idPlayer* viewPlayer = GetLocalViewPlayer();
|
||
|
|
if ( viewPlayer != gameLocal.localPlayerProperties.GetActivePlayer() ) {
|
||
|
|
gameLocal.OnLocalViewPlayerChanged();
|
||
|
|
}
|
||
|
|
playerView.UpdateProxyView( viewPlayer, false );
|
||
|
|
|
||
|
|
if ( isNewFrame || demoManager.GetState() == sdDemoManagerLocal::DS_PAUSED ) {
|
||
|
|
for( ent = postThinkEntities.Next(); ent; ent = ent->GetPostThinkNode()->Next() ) {
|
||
|
|
ent->PostThink();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
{
|
||
|
|
if ( isNewFrame ) {
|
||
|
|
rvClientEntity* cent;
|
||
|
|
for( cent = clientSpawnedEntities.Next(); cent != NULL; cent = cent->spawnNode.Next() ) {
|
||
|
|
cent->Think();
|
||
|
|
}
|
||
|
|
|
||
|
|
localPlayerProperties.UpdateHudModules();
|
||
|
|
|
||
|
|
// Some will remove themselves
|
||
|
|
sdEffect::UpdateDeadEffects();
|
||
|
|
|
||
|
|
// service any pending events
|
||
|
|
idEvent::ServiceEvents();
|
||
|
|
|
||
|
|
sdTeamManager::GetInstance().Think();
|
||
|
|
sdTaskManager::GetInstance().Think();
|
||
|
|
sdObjectiveManager::GetInstance().Think();
|
||
|
|
sdWayPointManager::GetInstance().Think();
|
||
|
|
sdWakeManager::GetInstance().Think();
|
||
|
|
sdAntiLagManager::GetInstance().Think();
|
||
|
|
tireTreadManager->Think();
|
||
|
|
footPrintManager->Think();
|
||
|
|
sdGlobalStatsTracker::GetInstance().UpdateStatsRequests();
|
||
|
|
|
||
|
|
if ( gameLocal.serverIsRepeater ) {
|
||
|
|
playerView.UpdateRepeaterView();
|
||
|
|
}
|
||
|
|
|
||
|
|
idPlayer* viewPlayer = GetLocalViewPlayer();
|
||
|
|
if ( viewPlayer != NULL ) {
|
||
|
|
playerView.CalculateShake( viewPlayer );
|
||
|
|
|
||
|
|
// fps unlock: record view position
|
||
|
|
int index = framenum & 1;
|
||
|
|
unlock.originlog[ index ] = viewPlayer->GetRenderView()->vieworg;
|
||
|
|
}
|
||
|
|
|
||
|
|
bse->EndFrame();
|
||
|
|
|
||
|
|
UpdateLoggedDecals();
|
||
|
|
|
||
|
|
// Run multiplayer game rules
|
||
|
|
if ( rules ) {
|
||
|
|
rules->Run();
|
||
|
|
}
|
||
|
|
|
||
|
|
// decrease deleted clip model reference counts
|
||
|
|
clip.ThreadDeleteClipModels();
|
||
|
|
|
||
|
|
// delete clip models without references for real
|
||
|
|
clip.ActuallyDeleteClipModels();
|
||
|
|
}
|
||
|
|
|
||
|
|
demoManager.EndDemoFrame();
|
||
|
|
|
||
|
|
if ( isNewFrame || demoManager.GetState() == sdDemoManagerLocal::DS_PAUSED ) {
|
||
|
|
// show any debug info for this frame
|
||
|
|
RunDebugInfo();
|
||
|
|
D_DrawDebugLines();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
#ifndef _XENON
|
||
|
|
UpdateGameSession();
|
||
|
|
#endif // _XENON
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
================
|
||
|
|
idGameLocal::ApplyRulesData
|
||
|
|
================
|
||
|
|
*/
|
||
|
|
void idGameLocal::ApplyRulesData( const sdEntityStateNetworkData& newState ) {
|
||
|
|
rules->ApplyNetworkState( newState );
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
================
|
||
|
|
idGameLocal::ReadRulesData
|
||
|
|
================
|
||
|
|
*/
|
||
|
|
void idGameLocal::ReadRulesData( const sdEntityStateNetworkData& baseState, sdEntityStateNetworkData& newState, const idBitMsg& msg ) const {
|
||
|
|
rules->ReadNetworkState( baseState, newState, msg );
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
================
|
||
|
|
idGameLocal::WriteRulesData
|
||
|
|
================
|
||
|
|
*/
|
||
|
|
void idGameLocal::WriteRulesData( const sdEntityStateNetworkData& baseState, sdEntityStateNetworkData& newState, idBitMsg& msg ) const {
|
||
|
|
rules->WriteNetworkState( baseState, newState, msg );
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
================
|
||
|
|
idGameLocal::CheckRulesData
|
||
|
|
================
|
||
|
|
*/
|
||
|
|
bool idGameLocal::CheckRulesData( const sdEntityStateNetworkData& baseState ) const {
|
||
|
|
return rules->CheckNetworkStateChanges( baseState );
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
================
|
||
|
|
idGameLocal::CreateRulesData
|
||
|
|
================
|
||
|
|
*/
|
||
|
|
sdEntityStateNetworkData* idGameLocal::CreateRulesData( void ) const {
|
||
|
|
if ( !rules ) {
|
||
|
|
return NULL;
|
||
|
|
}
|
||
|
|
return rules->CreateNetworkStructure();
|
||
|
|
}
|