mirror of
https://github.com/ptitSeb/Serious-Engine
synced 2024-11-22 18:30:27 +01:00
2533 lines
84 KiB
C++
2533 lines
84 KiB
C++
/* Copyright (c) 2002-2012 Croteam Ltd.
|
|
This program is free software; you can redistribute it and/or modify
|
|
it under the terms of version 2 of the GNU General Public License as published by
|
|
the Free Software Foundation
|
|
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License along
|
|
with this program; if not, write to the Free Software Foundation, Inc.,
|
|
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */
|
|
|
|
#include <Engine/StdH.h>
|
|
|
|
#include <Engine/Build.h>
|
|
#include <Engine/Base/Console.h>
|
|
#include <Engine/Base/CRCTable.h>
|
|
#include <Engine/Base/Shell.h>
|
|
#include <Engine/Base/ProgressHook.h>
|
|
#include <Engine/Network/Server.h>
|
|
#include <Engine/Network/SessionState.h>
|
|
#include <Engine/Network/Network.h>
|
|
#include <Engine/Network/PlayerSource.h>
|
|
#include <Engine/Network/PlayerBuffer.h>
|
|
#include <Engine/Network/PlayerTarget.h>
|
|
#include <Engine/Entities/InternalClasses.h>
|
|
#include <Engine/Entities/Precaching.h>
|
|
#include <Engine/Network/CommunicationInterface.h>
|
|
#include <Engine/Templates/Stock_CModelData.h>
|
|
#include <Engine/Templates/Stock_CAnimData.h>
|
|
#include <Engine/Templates/Stock_CTextureData.h>
|
|
#include <Engine/Templates/Stock_CSoundData.h>
|
|
#include <Engine/Templates/Stock_CEntityClass.h>
|
|
|
|
|
|
#include <Engine/Base/Statistics_Internal.h>
|
|
#include <Engine/Graphics/DrawPort.h>
|
|
#include <Engine/Sound/SoundLibrary.h>
|
|
#include <Engine/Sound/SoundListener.h>
|
|
#include <Engine/Rendering/Render.h>
|
|
#include <Engine/Rendering/Render_internal.h>
|
|
#include <Engine/Base/ListIterator.inl>
|
|
#include <Engine/Math/Float.h>
|
|
|
|
#include <Engine/Rendering/RenderProfile.h>
|
|
#include <Engine/Network/NetworkProfile.h>
|
|
#include <Engine/Network/LevelChange.h>
|
|
#include <Engine/Brushes/BrushArchive.h>
|
|
#include <Engine/Entities/Entity.h>
|
|
#include <Engine/Models/ModelObject.h>
|
|
#include <Engine/Ska/ModelInstance.h>
|
|
#include <Engine/Entities/ShadingInfo.h>
|
|
#include <Engine/Entities/EntityCollision.h>
|
|
#include <Engine/Entities/LastPositions.h>
|
|
|
|
#include <Engine/Templates/DynamicContainer.cpp>
|
|
#include <Engine/Templates/DynamicArray.cpp>
|
|
#include <Engine/Templates/StaticArray.cpp>
|
|
#include <Engine/Templates/StaticStackArray.cpp>
|
|
|
|
#include <Engine/Templates/Stock_CAnimData.h>
|
|
#include <Engine/Templates/Stock_CTextureData.h>
|
|
#include <Engine/Templates/Stock_CSoundData.h>
|
|
#include <Engine/Templates/Stock_CEntityClass.h>
|
|
#include <Engine/Templates/Stock_CModelData.h>
|
|
#include <Engine/Templates/Stock_CAnimSet.h>
|
|
#include <Engine/Templates/Stock_CMesh.h>
|
|
#include <Engine/Templates/Stock_CShader.h>
|
|
#include <Engine/Templates/Stock_CSkeleton.h>
|
|
|
|
#include <Engine/GameAgent/GameAgent.h>
|
|
|
|
|
|
// pointer to global instance of the only game object in the application
|
|
CNetworkLibrary *_pNetwork= NULL;
|
|
|
|
extern BOOL _bNeedPretouch;
|
|
BOOL _bMultiPlayer = FALSE;
|
|
INDEX _ctEntities = 0;
|
|
INDEX _ctPredictorEntities = 0;
|
|
LevelChangePhase _lphCurrent = LCP_NOCHANGE;
|
|
BOOL _bTempNetwork = FALSE; // set while using temporary second network object
|
|
extern BOOL con_bCapture;
|
|
extern CTString con_strCapture;
|
|
|
|
static FLOAT _bStartDemoRecordingNextTime = FALSE;
|
|
static FLOAT _bStopDemoRecordingNextTime = FALSE;
|
|
static INDEX dem_iRecordedNumber = 0;
|
|
|
|
// network control
|
|
INDEX ser_bReportSyncOK = FALSE;
|
|
INDEX ser_bReportSyncBad = TRUE;
|
|
INDEX ser_bReportSyncLate = FALSE;
|
|
INDEX ser_bReportSyncEarly = FALSE;
|
|
INDEX ser_bPauseOnSyncBad = FALSE;
|
|
INDEX ser_iKickOnSyncBad = 10;
|
|
INDEX ser_bKickOnSyncLate = 1;
|
|
INDEX ser_iRememberBehind = 3000;
|
|
INDEX ser_iExtensiveSyncCheck = 0;
|
|
INDEX ser_bClientsMayPause = TRUE;
|
|
FLOAT ser_tmSyncCheckFrequency = 1.0f;
|
|
INDEX ser_iSyncCheckBuffer = 60;
|
|
INDEX ser_bEnumeration = TRUE;
|
|
INDEX ser_bPingGameAgent = TRUE;
|
|
FLOAT ser_tmKeepAlive = 0.1f;
|
|
FLOAT ser_tmPingUpdate = 3.0f;
|
|
INDEX ser_bWaitFirstPlayer = 0;
|
|
INDEX ser_iMaxAllowedBPS = 8000;
|
|
CTString ser_strIPMask = "";
|
|
CTString ser_strNameMask = "";
|
|
INDEX ser_bInverseBanning = FALSE;
|
|
CTString ser_strMOTD = "";
|
|
|
|
INDEX cli_bEmulateDesync = FALSE;
|
|
INDEX cli_bDumpSync = FALSE;
|
|
INDEX cli_bDumpSyncEachTick = FALSE;
|
|
INDEX cli_bAutoAdjustSettings = FALSE;
|
|
FLOAT cli_tmAutoAdjustThreshold = 2.0f;
|
|
INDEX cli_bPrediction = FALSE;
|
|
INDEX cli_iMaxPredictionSteps = 10;
|
|
INDEX cli_bPredictIfServer = FALSE;
|
|
INDEX cli_bPredictLocalPlayers = TRUE;
|
|
INDEX cli_bPredictRemotePlayers = FALSE;
|
|
FLOAT cli_fPredictEntitiesRange = 20.0f;
|
|
INDEX cli_bLerpActions = FALSE;
|
|
INDEX cli_bReportPredicted = FALSE;
|
|
INDEX cli_iSendBehind = 3;
|
|
INDEX cli_iPredictionFlushing = 1;
|
|
|
|
INDEX cli_iBufferActions = 1;
|
|
INDEX cli_iMaxBPS = 4000;
|
|
INDEX cli_iMinBPS = 0;
|
|
|
|
INDEX net_iCompression = 1;
|
|
INDEX net_bLookupHostNames = FALSE;
|
|
INDEX net_bReportPackets = FALSE;
|
|
INDEX net_iMaxSendRetries = 10;
|
|
FLOAT net_fSendRetryWait = 0.5f;
|
|
INDEX net_bReportTraffic = FALSE;
|
|
INDEX net_bReportICMPErrors = FALSE;
|
|
INDEX net_bReportMiscErrors = FALSE;
|
|
INDEX net_bLerping = TRUE;
|
|
INDEX net_iGraphBuffer = 100;
|
|
INDEX net_iExactTimer = 2;
|
|
INDEX net_bDumpStreamBlocks = 0;
|
|
INDEX net_bDumpConnectionInfo = 0;
|
|
INDEX net_iPort = 25600;
|
|
CTString net_strLocalHost = "";
|
|
CTString net_strLocationCode = "";
|
|
CTString net_strConnectPassword = "";
|
|
CTString net_strAdminPassword = "";
|
|
CTString net_strVIPPassword = "";
|
|
CTString net_strObserverPassword = "";
|
|
INDEX net_iVIPReserve = 0;
|
|
INDEX net_iMaxObservers = 16;
|
|
INDEX net_iMaxClients = 0;
|
|
FLOAT net_tmConnectionTimeout = 30.0f;
|
|
FLOAT net_tmProblemsTimeout = 5.0f;
|
|
FLOAT net_tmDisconnectTimeout = 300.0f; // must be higher for level changing
|
|
INDEX net_bReportCRC = FALSE;
|
|
FLOAT net_fDropPackets = 0.0f;
|
|
FLOAT net_tmLatency = 0.0f;
|
|
|
|
INDEX ent_bReportSpawnInWall = FALSE;
|
|
|
|
FLOAT cmd_tmTick = 0.0f;
|
|
CTString cmd_cmdOnTick = "";
|
|
CTString cmd_strChatSender = "";
|
|
CTString cmd_strChatMessage = "";
|
|
CTString cmd_cmdOnChat = "";
|
|
INDEX net_ctChatMessages = 0; // counter for incoming chat messages
|
|
|
|
extern CPacketBufferStats _pbsSend;
|
|
extern CPacketBufferStats _pbsRecv;
|
|
|
|
BOOL _bPredictionActive = FALSE;
|
|
|
|
class CGatherCRC {
|
|
public:
|
|
BOOL bOld;
|
|
CGatherCRC();
|
|
~CGatherCRC();
|
|
};
|
|
|
|
CGatherCRC::CGatherCRC(): bOld(CRCT_bGatherCRCs){}
|
|
CGatherCRC::~CGatherCRC() {
|
|
CRCT_bGatherCRCs = bOld;
|
|
}
|
|
|
|
// precache control
|
|
INDEX _precache_NONE = PRECACHE_NONE;
|
|
INDEX _precache_SMART = PRECACHE_SMART;
|
|
INDEX _precache_ALL = PRECACHE_ALL;
|
|
INDEX _precache_PARANOIA = PRECACHE_PARANOIA;
|
|
INDEX gam_iPrecachePolicy = _precache_SMART;
|
|
INDEX _precache_bNowPrecaching = FALSE;
|
|
|
|
INDEX dbg_bBreak = FALSE;
|
|
INDEX gam_bPretouch = FALSE;
|
|
|
|
FLOAT phy_fCollisionCacheAhead = 5.0f;
|
|
FLOAT phy_fCollisionCacheAround = 1.5f;
|
|
FLOAT cli_fPredictionFilter = 0.5f;
|
|
|
|
extern INDEX shd_bCacheAll;
|
|
|
|
|
|
// input
|
|
INDEX inp_iKeyboardReadingMethod = 2; // 0=getasynckey, 1=virtkeytrap, 2=scancodetrap
|
|
INDEX inp_bAllowMouseAcceleration = TRUE;
|
|
FLOAT inp_fMouseSensitivity = 1.0f;
|
|
INDEX inp_bMousePrecision = FALSE;
|
|
FLOAT inp_fMousePrecisionFactor = 4.0f;
|
|
FLOAT inp_fMousePrecisionThreshold = 10.0f;
|
|
FLOAT inp_fMousePrecisionTimeout = 0.25f;
|
|
FLOAT inp_bInvertMouse = FALSE;
|
|
INDEX inp_bFilterMouse = FALSE;
|
|
INDEX inp_bAllowPrescan = TRUE;
|
|
|
|
INDEX inp_i2ndMousePort = 0; // COM no (0=disable)
|
|
FLOAT inp_f2ndMouseSensitivity = 1.0f;
|
|
INDEX inp_b2ndMousePrecision = FALSE;
|
|
FLOAT inp_f2ndMousePrecisionFactor = 4.0f;
|
|
FLOAT inp_f2ndMousePrecisionThreshold = 10.0f;
|
|
FLOAT inp_f2ndMousePrecisionTimeout = 0.25f;
|
|
INDEX inp_bInvert2ndMouse = FALSE;
|
|
INDEX inp_bFilter2ndMouse = FALSE;
|
|
|
|
extern INDEX inp_iMButton4Up;
|
|
extern INDEX inp_iMButton4Dn;
|
|
extern INDEX inp_iMButton5Up;
|
|
extern INDEX inp_iMButton5Dn;
|
|
extern INDEX inp_bMsgDebugger;
|
|
extern INDEX inp_ctJoysticksAllowed;
|
|
extern INDEX inp_bForceJoystickPolling;
|
|
extern INDEX inp_bAutoDisableJoysticks;
|
|
|
|
INDEX wed_bUseGenericTextureReplacement = FALSE;
|
|
|
|
|
|
extern void RendererInfo(void);
|
|
extern void ClearRenderer(void);
|
|
|
|
|
|
// cache all shadowmaps now
|
|
extern void CacheShadows(void)
|
|
{
|
|
// mute all sounds
|
|
_pSound->Mute();
|
|
CWorld *pwo = _pShell->GetCurrentWorld();
|
|
if( pwo!=NULL) {
|
|
pwo->wo_baBrushes.CacheAllShadowmaps();
|
|
CPrintF( TRANS("All shadows recached"));
|
|
if( shd_bCacheAll) CPrintF(".\n");
|
|
else CPrintF( TRANS(", but not for long.\n(precache all shadows function is disabled)\n"));
|
|
}
|
|
// mark that we need pretouching
|
|
_bNeedPretouch = TRUE;
|
|
}
|
|
|
|
// check if a name or IP matches a mask
|
|
extern BOOL MatchesBanMask(const CTString &strString, const CTString &strMask)
|
|
{
|
|
CTString strRest = strMask;
|
|
CTString strLine;
|
|
|
|
while(strRest!="") {
|
|
strLine = strRest;
|
|
strLine.OnlyFirstLine();
|
|
strRest.RemovePrefix(strLine);
|
|
strRest.DeleteChar(0);
|
|
|
|
if (strString.Matches(strLine)) {
|
|
return TRUE;
|
|
}
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
extern CTString RemoveSubstring(const CTString &strFull, const CTString &strSub);
|
|
|
|
static void AddIPMask(void* pArgs)
|
|
{
|
|
CTString strIP = *NEXTARGUMENT(CTString*);
|
|
ser_strIPMask+= strIP+"\n";
|
|
}
|
|
static void RemIPMask(void* pArgs)
|
|
{
|
|
CTString strIP = *NEXTARGUMENT(CTString*);
|
|
ser_strIPMask = RemoveSubstring(ser_strIPMask, strIP+"\n");
|
|
}
|
|
static void AddNameMask(void* pArgs)
|
|
{
|
|
CTString strName = *NEXTARGUMENT(CTString*);
|
|
ser_strNameMask += strName+"\n";
|
|
}
|
|
static void RemNameMask(void* pArgs)
|
|
{
|
|
CTString strName = *NEXTARGUMENT(CTString*);
|
|
ser_strNameMask = RemoveSubstring(ser_strNameMask, strName+"\n");
|
|
}
|
|
|
|
static void StartDemoRecording(void)
|
|
{
|
|
_bStartDemoRecordingNextTime = TRUE;
|
|
}
|
|
|
|
|
|
static void StopDemoRecording(void)
|
|
{
|
|
_bStopDemoRecordingNextTime = TRUE;
|
|
}
|
|
|
|
|
|
static void NetworkInfo(void)
|
|
{
|
|
CPrintF("*Network library information:\n");
|
|
CPrintF("Entities existing: %d\n", _ctEntities);
|
|
CPrintF("Predictor entities existing: %d\n", _ctPredictorEntities);
|
|
CPrintF("Server:\n");
|
|
if (_pNetwork->ga_srvServer.srv_bActive) {
|
|
CPrintF(" last processed tick: %g\n", _pNetwork->ga_srvServer.srv_tmLastProcessedTick);
|
|
CPrintF(" last processed sequence: %d\n", _pNetwork->ga_srvServer.srv_iLastProcessedSequence);
|
|
CPrintF(" players:\n");
|
|
for(INDEX iplb=0; iplb<_pNetwork->ga_srvServer.srv_aplbPlayers.Count(); iplb++) {
|
|
CPlayerBuffer &plb = _pNetwork->ga_srvServer.srv_aplbPlayers[iplb];
|
|
if (plb.plb_Active) {
|
|
CPrintF(" %2d(%2d):'%s'@client%2d: (%dact)\n",
|
|
iplb, plb.plb_Index, (const char *) plb.plb_pcCharacter.GetNameForPrinting(),
|
|
plb.plb_iClient, plb.plb_abReceived.GetCount());
|
|
}
|
|
}
|
|
CPrintF(" clients:\n");
|
|
for(INDEX iSession=0; iSession<_pNetwork->ga_srvServer.srv_assoSessions.Count(); iSession++) {
|
|
CSessionSocket &sso = _pNetwork->ga_srvServer.srv_assoSessions[iSession];
|
|
if (sso.sso_bActive) {
|
|
CPrintF(" %2d:'%s'\n", iSession, (const char *) _cmiComm.Server_GetClientName(iSession)),
|
|
CPrintF(" buffer: %dblk=%dk\n",
|
|
sso.sso_nsBuffer.GetUsedBlocks(),
|
|
sso.sso_nsBuffer.GetUsedMemory()/1024);
|
|
CPrintF(" state:");
|
|
if (sso.sso_iDisconnectedState>0) {
|
|
CPrintF(" disconnecting");
|
|
} else if (sso.sso_bSendStream) {
|
|
CPrintF(" connected");
|
|
} else {
|
|
CPrintF(" connecting");
|
|
}
|
|
CPrintF("\n");
|
|
}
|
|
}
|
|
} else {
|
|
CPrintF(" not a server\n");
|
|
}
|
|
CPrintF("Session state:\n");
|
|
CPrintF(" buffer: (%dblk)%dk\n",
|
|
_pNetwork->ga_sesSessionState.ses_nsGameStream.GetUsedBlocks(),
|
|
_pNetwork->ga_sesSessionState.ses_nsGameStream.GetUsedMemory()/1024);
|
|
CPrintF(" last processed tick: %g\n", _pNetwork->ga_sesSessionState.ses_tmLastProcessedTick);
|
|
CPrintF(" last processed sequence: %d\n", _pNetwork->ga_sesSessionState.ses_iLastProcessedSequence);
|
|
CPrintF(" level change: %d\n", _pNetwork->ga_sesSessionState.ses_iLevel);
|
|
for(INDEX iplt=0; iplt<_pNetwork->ga_sesSessionState.ses_apltPlayers.Count(); iplt++) {
|
|
CPlayerTarget &plt = _pNetwork->ga_sesSessionState.ses_apltPlayers[iplt];
|
|
if (plt.plt_bActive) {
|
|
ULONG ulID = (ULONG) -1;
|
|
if (plt.plt_penPlayerEntity!=NULL) {
|
|
ulID = plt.plt_penPlayerEntity->en_ulID;
|
|
}
|
|
CPrintF(" player %2d (ID:%d): (%dact)\n", iplt, ulID, plt.plt_abPrediction.GetCount());
|
|
}
|
|
}
|
|
|
|
|
|
if (TIMER_PROFILING) {
|
|
CTString strNetProfile;
|
|
_pfNetworkProfile.Report(strNetProfile);
|
|
CPrintF(strNetProfile);
|
|
}
|
|
}
|
|
|
|
static void ListPlayers(void)
|
|
{
|
|
CPrintF("player list:\n");
|
|
if (!_pNetwork->ga_srvServer.srv_bActive) {
|
|
CPrintF(" <not a server>\n");
|
|
return;
|
|
}
|
|
|
|
CPrintF(" client# name\n");
|
|
CPrintF(" ----------------------\n");
|
|
for(INDEX iplb=0; iplb<_pNetwork->ga_srvServer.srv_aplbPlayers.Count(); iplb++) {
|
|
CPlayerBuffer &plb = _pNetwork->ga_srvServer.srv_aplbPlayers[iplb];
|
|
if (plb.plb_Active) {
|
|
CPrintF(" %-2d %s\n", plb.plb_iClient, (const char *) plb.plb_pcCharacter.GetNameForPrinting());
|
|
}
|
|
}
|
|
CPrintF(" ----------------------\n");
|
|
}
|
|
|
|
static void KickClient(INDEX iClient, const CTString &strReason)
|
|
{
|
|
if (!_pNetwork->IsServer()) {
|
|
CPrintF( TRANS("Only server can kick people!\n"));
|
|
return;
|
|
}
|
|
iClient = Clamp(iClient, INDEX(0), INDEX(NET_MAXGAMECOMPUTERS));
|
|
if (!_pNetwork->ga_srvServer.srv_assoSessions[iClient].IsActive()) {
|
|
CPrintF(TRANSV("Client not connected!\n"));
|
|
return;
|
|
}
|
|
if (iClient == 0) {
|
|
CPrintF(TRANSV("Can't kick local client!\n"));
|
|
return;
|
|
}
|
|
CPrintF( TRANS("Kicking %d with explanation '%s'...\n"), iClient, (const char *) strReason);
|
|
_pNetwork->ga_srvServer.SendDisconnectMessage(iClient, "Admin: "+strReason);
|
|
}
|
|
static void KickClientCfunc(void* pArgs)
|
|
{
|
|
INDEX iClient = NEXTARGUMENT(INDEX);
|
|
CTString strReason = *NEXTARGUMENT(CTString*);
|
|
KickClient(iClient, strReason);
|
|
}
|
|
static void KickByName(const CTString &strName, const CTString &strReason)
|
|
{
|
|
if (!_pNetwork->IsServer()) {
|
|
CPrintF( TRANS("Only server can kick people!\n"));
|
|
return;
|
|
}
|
|
for(INDEX iplb=0; iplb<_pNetwork->ga_srvServer.srv_aplbPlayers.Count(); iplb++) {
|
|
CPlayerBuffer &plb = _pNetwork->ga_srvServer.srv_aplbPlayers[iplb];
|
|
if (plb.plb_Active && plb.plb_pcCharacter.GetNameForPrinting().Undecorated().Matches(strName)) {
|
|
KickClient(plb.plb_iClient, strReason);
|
|
}
|
|
}
|
|
}
|
|
static void KickByNameCfunc(void* pArgs)
|
|
{
|
|
CTString strName = *NEXTARGUMENT(CTString*);
|
|
CTString strReason = *NEXTARGUMENT(CTString*);
|
|
KickByName(strName, strReason);
|
|
}
|
|
|
|
static void Admin(void* pArgs)
|
|
{
|
|
CTString strCommand = *NEXTARGUMENT(CTString*);
|
|
|
|
CNetworkMessage nm(MSG_ADMIN_COMMAND);
|
|
nm<<net_strAdminPassword<<strCommand;
|
|
_pNetwork->SendToServerReliable(nm);
|
|
}
|
|
|
|
static void StockInfo(void)
|
|
{
|
|
// find memory used by shadowmap (both cached and uploaded)
|
|
INDEX ctCachedShadows=0, ctDynamicShadows=0, ctFlatShadows=0;
|
|
SLONG slStaticMemory=0, slDynamicMemory=0, slUploadMemory=0;
|
|
SLONG slShdBytes=0, slSlackMemory=0, slFlatMemory=0;
|
|
INDEX ct256=0, ct128=0, ct64=0, ct32=0, ct16=0;
|
|
SLONG sl256Memory=0, sl128Memory=0, sl64Memory=0, sl32Memory=0, sl16Memory=0;
|
|
|
|
if( _pGfx!=NULL)
|
|
{
|
|
FLOAT fSlackRatio;
|
|
FOREACHINLIST( CShadowMap, sm_lnInGfx, _pGfx->gl_lhCachedShadows, itsm)
|
|
{ // get polygon size in pixels (used portion of shadowmap)
|
|
SLONG slStaticSize, slDynamicSize, slUploadSize;
|
|
BOOL bIsFlat = itsm->GetUsedMemory( slStaticSize, slDynamicSize, slUploadSize, fSlackRatio);
|
|
SLONG slTotalSize = slDynamicSize+slUploadSize;
|
|
if( bIsFlat) {
|
|
slStaticMemory += 4;
|
|
slTotalSize += 4;
|
|
slFlatMemory += slStaticSize;
|
|
ctFlatShadows++;
|
|
} else {
|
|
slStaticMemory += slStaticSize;
|
|
slTotalSize += slStaticSize;
|
|
if( slTotalSize>0) ctCachedShadows++;
|
|
}
|
|
if( slDynamicSize>0) {
|
|
slDynamicMemory += slDynamicSize;
|
|
ctDynamicShadows++;
|
|
}
|
|
slUploadMemory += slUploadSize;
|
|
slShdBytes += slTotalSize + sizeof(CShadowMap);
|
|
slSlackMemory += (SLONG) (slTotalSize*fSlackRatio);
|
|
|
|
if( !bIsFlat) { // by size ...
|
|
if( slStaticSize>128*1024) { ct256++; sl256Memory+=slTotalSize; }
|
|
else if( slStaticSize> 64*1024) { ct128++; sl128Memory+=slTotalSize; }
|
|
else if( slStaticSize> 32*1024) { ct64++; sl64Memory +=slTotalSize; }
|
|
else if( slStaticSize> 16*1024) { ct32++; sl32Memory +=slTotalSize; }
|
|
else if( slStaticSize> 0) { ct16++; sl16Memory +=slTotalSize; }
|
|
}
|
|
}
|
|
// report shadowmap memory usage (if any)
|
|
if( slShdBytes>0) {
|
|
CPrintF( "\nCached shadowmaps:\n");
|
|
CPrintF( " Total: %d in %d KB with %d%% (%d KB) of slack space\n", ctCachedShadows, slShdBytes/1024, slSlackMemory*100/slShdBytes, slSlackMemory/1024);
|
|
CPrintF( " Static: %d KB\n", slStaticMemory/1024);
|
|
CPrintF( " Upload: %d KB\n", slUploadMemory/1024);
|
|
CPrintF( " Dynamic: %d in %d KB\n", ctDynamicShadows, slDynamicMemory/1024);
|
|
if( ctCachedShadows<1) ctCachedShadows=1; // for percentage calc
|
|
CPrintF( " Flats: %d (%d%%) with %d KB saved\n", ctFlatShadows, ctFlatShadows*100/ctCachedShadows, slFlatMemory/1024);
|
|
CPrintF("of size:\n");
|
|
CPrintF( " >128K: %4d in %d KB\n", ct256, sl256Memory/1024);
|
|
CPrintF( " 128-64K: %4d in %d KB\n", ct128, sl128Memory/1024);
|
|
CPrintF( " 64-32K: %4d in %d KB\n", ct64, sl64Memory /1024);
|
|
CPrintF( " 32-16K: %4d in %d KB\n", ct32, sl32Memory /1024);
|
|
CPrintF( " <=16K: %4d in %d KB\n", ct16, sl16Memory /1024);
|
|
}
|
|
}
|
|
|
|
// report world stats
|
|
INDEX ctEntities=0, ctShadowLayers=0, ctPolys=0, ctPlanes=0, ctEdges=0, ctVertices=0, ctSectors=0;
|
|
SLONG slEntBytes=0, slLyrBytes=0, slPlyBytes=0, slPlnBytes=0, slEdgBytes=0, slVtxBytes=0, slSecBytes=0;
|
|
SLONG slCgrBytes=0;
|
|
CWorld *pwo = _pShell->GetCurrentWorld();
|
|
|
|
if( pwo!=NULL)
|
|
{
|
|
// report count of and memory used by entities
|
|
FOREACHINDYNAMICCONTAINER( pwo->wo_cenEntities, CEntity, iten) {
|
|
ctEntities++;
|
|
slEntBytes += iten->GetUsedMemory();
|
|
}
|
|
|
|
// report shadow layers and world geometry memory usage
|
|
FOREACHINDYNAMICARRAY( pwo->wo_baBrushes.ba_abrBrushes, CBrush3D, itbr) // for all brush entities in the world
|
|
{
|
|
// skip brush without entity
|
|
if( itbr->br_penEntity==NULL) continue;
|
|
|
|
// for each mip
|
|
FOREACHINLIST( CBrushMip, bm_lnInBrush, itbr->br_lhBrushMips, itbm)
|
|
{
|
|
// for each sector in the brush mip
|
|
FOREACHINDYNAMICARRAY( itbm->bm_abscSectors, CBrushSector, itbsc)
|
|
{
|
|
// add sector class memory usage to polygons memory
|
|
ctSectors++;
|
|
slSecBytes += itbsc->GetUsedMemory();
|
|
|
|
// add each vertex and working vertex in sector
|
|
ctVertices += itbsc->bsc_abvxVertices.Count();
|
|
FOREACHINSTATICARRAY( itbsc->bsc_abvxVertices, CBrushVertex, itbvx) slVtxBytes += itbvx->GetUsedMemory();
|
|
FOREACHINSTATICARRAY( itbsc->bsc_awvxVertices, CWorkingVertex, itwvx) slVtxBytes += 32; // aligned to 32 bytes!
|
|
|
|
// add each plane and working plane in sector
|
|
ctPlanes += itbsc->bsc_abplPlanes.Count();
|
|
FOREACHINSTATICARRAY( itbsc->bsc_abplPlanes, CBrushPlane, itbpl) slPlnBytes += itbpl->GetUsedMemory();
|
|
FOREACHINSTATICARRAY( itbsc->bsc_awplPlanes, CWorkingPlane, itwpl) slPlnBytes += sizeof(CWorkingPlane);
|
|
|
|
// add each edge and working edge in sector
|
|
ctEdges += itbsc->bsc_abedEdges.Count();
|
|
FOREACHINSTATICARRAY( itbsc->bsc_abedEdges, CBrushEdge, itbed) slEdgBytes += itbed->GetUsedMemory();
|
|
FOREACHINSTATICARRAY( itbsc->bsc_awedEdges, CWorkingEdge, itwed) slEdgBytes += sizeof(CWorkingEdge);
|
|
|
|
// for each polygon in sector
|
|
ctPolys += itbsc->bsc_abpoPolygons.Count();
|
|
FOREACHINSTATICARRAY( itbsc->bsc_abpoPolygons, CBrushPolygon, itbpo) {
|
|
CBrushPolygon &bpo = *itbpo;
|
|
slPlyBytes += bpo.GetUsedMemory();
|
|
// count in the shadow layers (if any)
|
|
if( bpo.bpo_smShadowMap.bsm_lhLayers.IsEmpty()) continue; // skip polygon without shadowmap
|
|
ctShadowLayers += bpo.bpo_smShadowMap.GetShadowLayersCount();
|
|
slLyrBytes += bpo.bpo_smShadowMap.GetUsedMemory();
|
|
}
|
|
}
|
|
}
|
|
} // add in memory used by collision grid
|
|
extern SLONG GetCollisionGridMemory( CCollisionGrid *pcg);
|
|
slCgrBytes += GetCollisionGridMemory( pwo->wo_pcgCollisionGrid);
|
|
}
|
|
|
|
// stock info
|
|
const DOUBLE dToMB = 1.0/1024.0/1024.0;
|
|
const FLOAT fTexBytes = dToMB * _pTextureStock->CalculateUsedMemory();
|
|
const FLOAT fMdlBytes = dToMB * _pModelStock->CalculateUsedMemory();
|
|
const FLOAT fSndBytes = dToMB * _pSoundStock->CalculateUsedMemory();
|
|
const FLOAT fMshBytes = dToMB * _pMeshStock->CalculateUsedMemory();
|
|
const FLOAT fAstBytes = dToMB * _pAnimSetStock->CalculateUsedMemory();
|
|
const FLOAT fShaBytes = dToMB * _pShaderStock->CalculateUsedMemory();
|
|
const FLOAT fSkaBytes = dToMB * _pSkeletonStock->CalculateUsedMemory();
|
|
|
|
CPrintF("\nStock information:\n");
|
|
CPrintF(" Textures: %5d (%5.2f MB)\n", _pTextureStock->GetTotalCount(), fTexBytes);
|
|
CPrintF(" ShadowMaps: %5d (%5.2f MB)\n", ctCachedShadows, slShdBytes*dToMB);
|
|
CPrintF(" Entities: %5d (%5.2f MB)\n", ctEntities, slEntBytes*dToMB);
|
|
CPrintF(" Sounds: %5d (%5.2f MB)\n", _pSoundStock->GetTotalCount(), fSndBytes);
|
|
CPrintF("\n");
|
|
CPrintF(" Sectors: %5d (%5.2f MB)\n", ctSectors, slSecBytes*dToMB);
|
|
CPrintF(" Planes: %5d (%5.2f MB)\n", ctPlanes, slPlnBytes*dToMB);
|
|
CPrintF(" Edges: %5d (%5.2f MB)\n", ctEdges, slEdgBytes*dToMB);
|
|
CPrintF(" Polygons: %5d (%5.2f MB)\n", ctPolys, slPlyBytes*dToMB);
|
|
CPrintF(" Vertices: %5d (%5.2f MB)\n", ctVertices, slVtxBytes*dToMB);
|
|
CPrintF(" ShadowLayers: %5d (%5.2f MB)\n", ctShadowLayers, slLyrBytes*dToMB);
|
|
CPrintF("\n");
|
|
CPrintF(" Models: %5d (%5.2f MB)\n", _pModelStock->GetTotalCount(), fMdlBytes);
|
|
CPrintF(" Meshes: %5d (%5.2f MB)\n", _pMeshStock->GetTotalCount(), fMshBytes);
|
|
CPrintF(" Skeletons: %5d (%5.2f MB)\n", _pSkeletonStock->GetTotalCount(), fSkaBytes);
|
|
CPrintF(" AnimSets: %5d (%5.2f MB)\n", _pAnimSetStock->GetTotalCount(), fAstBytes);
|
|
CPrintF(" Shaders: %5d (%5.2f MB)\n", _pShaderStock->GetTotalCount(), fShaBytes);
|
|
CPrintF("\n");
|
|
CPrintF("CollisionGrid: %.2f MB\n", slCgrBytes*dToMB);
|
|
CPrintF("--------------\n");
|
|
CPrintF(" Total: %.2f MB\n", fTexBytes+fSndBytes+fMdlBytes+fMshBytes+fSkaBytes+fAstBytes+fShaBytes
|
|
+ (slShdBytes+slEntBytes+slSecBytes+slPlnBytes+slEdgBytes+slPlyBytes+slVtxBytes+slLyrBytes+slCgrBytes)*dToMB);
|
|
CPrintF("\n");
|
|
}
|
|
|
|
|
|
static void StockDump(void)
|
|
{
|
|
try {
|
|
CTFileStream strm;
|
|
CTFileName fnm = CTString("Temp\\StockDump.txt");
|
|
strm.Create_t(fnm);
|
|
strm.PutLine_t("Animations:");
|
|
_pAnimStock->DumpMemoryUsage_t(strm);
|
|
strm.PutLine_t("Textures:");
|
|
_pTextureStock->DumpMemoryUsage_t(strm);
|
|
strm.PutLine_t("Models:");
|
|
_pModelStock->DumpMemoryUsage_t(strm);
|
|
strm.PutLine_t("Sounds:");
|
|
_pSoundStock->DumpMemoryUsage_t(strm);
|
|
strm.PutLine_t("Classes:");
|
|
_pEntityClassStock->DumpMemoryUsage_t(strm);
|
|
CPrintF("Dumped to '%s'\n", (const char *) CTString(fnm));
|
|
} catch (char *strError) {
|
|
CPrintF("Error: %s\n", strError);
|
|
}
|
|
}
|
|
|
|
|
|
// free all unused stocks
|
|
extern void FreeUnusedStock(void)
|
|
{
|
|
// free all unused stocks
|
|
_pEntityClassStock->FreeUnused();
|
|
_pModelStock->FreeUnused();
|
|
_pSoundStock->FreeUnused();
|
|
_pTextureStock->FreeUnused();
|
|
_pAnimStock->FreeUnused();
|
|
}
|
|
|
|
|
|
/*
|
|
* This is called every TickQuantum seconds.
|
|
*/
|
|
void CNetworkTimerHandler::HandleTimer(void)
|
|
{
|
|
ASSERT(this!=NULL);
|
|
if (_bTempNetwork) {
|
|
return; // this can happen during NET_MakeDefaultState_t()!
|
|
}
|
|
// enable stream handling during timer
|
|
#if (!defined SINGLE_THREADED)
|
|
CTSTREAM_BEGIN {
|
|
#endif
|
|
|
|
// do the timer loop
|
|
_pNetwork->TimerLoop();
|
|
|
|
#if (!defined SINGLE_THREADED)
|
|
} CTSTREAM_END;
|
|
#endif
|
|
}
|
|
|
|
/*
|
|
* Default constructor.
|
|
*/
|
|
CNetworkLibrary::CNetworkLibrary(void) :
|
|
ga_IsServer(FALSE), // is not server
|
|
ga_srvServer(*new CServer),
|
|
ga_sesSessionState(*new CSessionState),
|
|
ga_bDemoRec(FALSE), // not recording demo
|
|
ga_bDemoPlay(FALSE), // not playing demo
|
|
ga_bDemoPlayFinished(FALSE) // demo not finished
|
|
{
|
|
ga_aplsPlayers.New(NET_MAXLOCALPLAYERS);
|
|
|
|
// default demo syncronization is real-time, with 1:1 playback speed
|
|
ga_fDemoSyncRate = DEMOSYNC_REALTIME;
|
|
ga_fDemoRealTimeFactor = 1.0f;
|
|
ga_fGameRealTimeFactor = 1.0f;
|
|
ga_pubDefaultState = NULL;
|
|
ga_slDefaultStateSize = 0;
|
|
memset(ga_aubDefaultProperties, 0, sizeof(ga_aubDefaultProperties));
|
|
ga_pubCRCList = NULL;
|
|
ga_slCRCList = 0;
|
|
ga_ulDemoMinorVersion = _SE_BUILD_MINOR;
|
|
|
|
ga_csNetwork.cs_iIndex = 2000;
|
|
ga_ctTimersPending = -1;
|
|
|
|
ga_fEnumerationProgress = 0;
|
|
ga_bEnumerationChange = FALSE;
|
|
}
|
|
|
|
/*
|
|
* Destructor.
|
|
*/
|
|
CNetworkLibrary::~CNetworkLibrary(void)
|
|
{
|
|
// clear the global world
|
|
ga_World.DeletePredictors();
|
|
ga_World.Clear();
|
|
|
|
// free renderer info to free pointers to entities etc.
|
|
if (!_bTempNetwork) {
|
|
extern void ClearRenderer(void);
|
|
ClearRenderer();
|
|
}
|
|
|
|
delete &ga_sesSessionState;
|
|
delete &ga_srvServer;
|
|
}
|
|
|
|
|
|
/*
|
|
* Initialize game management.
|
|
*/
|
|
void CNetworkLibrary::Init(const CTString &strGameID)
|
|
{
|
|
// remember the game ID
|
|
CMessageDispatcher::Init(strGameID);
|
|
|
|
// add shell symbols
|
|
_pShell->DeclareSymbol("user INDEX dbg_bBreak;", (void *)&dbg_bBreak);
|
|
_pShell->DeclareSymbol("persistent user INDEX gam_bPretouch;", (void *)&gam_bPretouch);
|
|
|
|
_pShell->DeclareSymbol("user INDEX dem_iRecordedNumber;", (void *)&dem_iRecordedNumber);
|
|
_pShell->DeclareSymbol("user void StartDemoRecording(void);", (void *)&StartDemoRecording);
|
|
_pShell->DeclareSymbol("user void StopDemoRecording(void);", (void *)&StopDemoRecording);
|
|
_pShell->DeclareSymbol("user void NetworkInfo(void);", (void *)&NetworkInfo);
|
|
_pShell->DeclareSymbol("user void StockInfo(void);", (void *)&StockInfo);
|
|
_pShell->DeclareSymbol("user void StockDump(void);", (void *)&StockDump);
|
|
_pShell->DeclareSymbol("user void RendererInfo(void);", (void *)&RendererInfo);
|
|
_pShell->DeclareSymbol("user void ClearRenderer(void);", (void *)&ClearRenderer);
|
|
_pShell->DeclareSymbol("user void CacheShadows(void);", (void *)&CacheShadows);
|
|
_pShell->DeclareSymbol("user void KickClient(INDEX, CTString);", (void *)&KickClientCfunc);
|
|
_pShell->DeclareSymbol("user void KickByName(CTString, CTString);", (void *)&KickByNameCfunc);
|
|
_pShell->DeclareSymbol("user void ListPlayers(void);", (void *)&ListPlayers);
|
|
_pShell->DeclareSymbol("user void Admin(CTString);", (void *)&Admin);
|
|
|
|
_pShell->DeclareSymbol("user void AddIPMask(CTString);", (void *)&AddIPMask);
|
|
_pShell->DeclareSymbol("user void RemIPMask(CTString);", (void *)&RemIPMask);
|
|
_pShell->DeclareSymbol("user void AddNameMask(CTString);", (void *)&AddNameMask);
|
|
_pShell->DeclareSymbol("user void RemNameMask(CTString);", (void *)&RemNameMask);
|
|
|
|
_pShell->DeclareSymbol("user FLOAT dem_tmTimer;", (void *)&ga_fDemoTimer);
|
|
_pShell->DeclareSymbol("user FLOAT dem_fSyncRate;", (void *)&ga_fDemoSyncRate);
|
|
_pShell->DeclareSymbol("user FLOAT dem_fRealTimeFactor;", (void *)&ga_fDemoRealTimeFactor);
|
|
_pShell->DeclareSymbol("user FLOAT gam_fRealTimeFactor;", (void *)&ga_fGameRealTimeFactor);
|
|
|
|
_pShell->DeclareSymbol("user const FLOAT net_tmLatency;", (void *)&net_tmLatency);
|
|
_pShell->DeclareSymbol("user const FLOAT cmd_tmTick;", (void *)&cmd_tmTick);
|
|
_pShell->DeclareSymbol("persistent user CTString cmd_cmdOnTick;", (void *)&cmd_cmdOnTick);
|
|
_pShell->DeclareSymbol("user CTString cmd_strChatSender ;", (void *)&cmd_strChatSender );
|
|
_pShell->DeclareSymbol("user CTString cmd_strChatMessage;", (void *)&cmd_strChatMessage);
|
|
_pShell->DeclareSymbol("persistent user CTString cmd_cmdOnChat;", (void *)&cmd_cmdOnChat);
|
|
|
|
_pShell->DeclareSymbol("user INDEX net_ctChatMessages;", (void *)&net_ctChatMessages);
|
|
|
|
_pShell->DeclareSymbol("persistent user INDEX ent_bReportSpawnInWall;", (void *)&ent_bReportSpawnInWall);
|
|
|
|
_pShell->DeclareSymbol("user INDEX ser_bReportSyncOK;", (void *)&ser_bReportSyncOK);
|
|
_pShell->DeclareSymbol("user INDEX ser_bReportSyncBad;", (void *)&ser_bReportSyncBad);
|
|
_pShell->DeclareSymbol("user INDEX ser_bReportSyncLate;", (void *)&ser_bReportSyncLate);
|
|
_pShell->DeclareSymbol("user INDEX ser_bReportSyncEarly;", (void *)&ser_bReportSyncEarly);
|
|
_pShell->DeclareSymbol("user INDEX ser_bPauseOnSyncBad;", (void *)&ser_bPauseOnSyncBad);
|
|
_pShell->DeclareSymbol("user INDEX ser_iKickOnSyncBad;", (void *)&ser_iKickOnSyncBad);
|
|
_pShell->DeclareSymbol("user INDEX ser_bKickOnSyncLate;", (void *)&ser_bKickOnSyncLate);
|
|
_pShell->DeclareSymbol("persistent user FLOAT ser_tmSyncCheckFrequency;", (void *)&ser_tmSyncCheckFrequency);
|
|
_pShell->DeclareSymbol("persistent user INDEX ser_iSyncCheckBuffer;", (void *)&ser_iSyncCheckBuffer);
|
|
_pShell->DeclareSymbol("persistent user INDEX cli_bLerpActions;", (void *)&cli_bLerpActions);
|
|
_pShell->DeclareSymbol("persistent user INDEX cli_bReportPredicted;", (void *)&cli_bReportPredicted);
|
|
_pShell->DeclareSymbol("persistent user INDEX net_iExactTimer;", (void *)&net_iExactTimer);
|
|
_pShell->DeclareSymbol("user INDEX net_bDumpStreamBlocks;", (void *)&net_bDumpStreamBlocks);
|
|
_pShell->DeclareSymbol("user INDEX net_bDumpConnectionInfo;", (void *)&net_bDumpConnectionInfo);
|
|
_pShell->DeclareSymbol("user INDEX net_iPort;", (void *)&net_iPort);
|
|
_pShell->DeclareSymbol("persistent user CTString net_strLocalHost;", (void *)&net_strLocalHost);
|
|
_pShell->DeclareSymbol("persistent user CTString net_strLocationCode;", (void *)&net_strLocationCode);
|
|
_pShell->DeclareSymbol("user CTString net_strVIPPassword;", (void *)&net_strVIPPassword);
|
|
_pShell->DeclareSymbol("user CTString net_strObserverPassword;", (void *)&net_strObserverPassword);
|
|
_pShell->DeclareSymbol("user INDEX net_iVIPReserve;", (void *)&net_iVIPReserve);
|
|
_pShell->DeclareSymbol("user INDEX net_iMaxObservers;", (void *)&net_iMaxObservers);
|
|
_pShell->DeclareSymbol("user INDEX net_iMaxClients;", (void *)&net_iMaxClients);
|
|
_pShell->DeclareSymbol("user CTString net_strConnectPassword;", (void *)&net_strConnectPassword);
|
|
_pShell->DeclareSymbol("user CTString net_strAdminPassword;", (void *)&net_strAdminPassword);
|
|
_pShell->DeclareSymbol("user FLOAT net_tmConnectionTimeout;", (void *)&net_tmConnectionTimeout);
|
|
_pShell->DeclareSymbol("user FLOAT net_tmProblemsTimeout;", (void *)&net_tmProblemsTimeout);
|
|
_pShell->DeclareSymbol("user FLOAT net_tmDisconnectTimeout;", (void *)&net_tmDisconnectTimeout);
|
|
_pShell->DeclareSymbol("user INDEX net_bReportCRC;", (void *)&net_bReportCRC);
|
|
_pShell->DeclareSymbol("user INDEX ser_iRememberBehind;", (void *)&ser_iRememberBehind);
|
|
_pShell->DeclareSymbol("user INDEX cli_bEmulateDesync;", (void *)&cli_bEmulateDesync);
|
|
_pShell->DeclareSymbol("user INDEX cli_bDumpSync;", (void *)&cli_bDumpSync);
|
|
_pShell->DeclareSymbol("user INDEX cli_bDumpSyncEachTick;", (void *)&cli_bDumpSyncEachTick);
|
|
|
|
_pShell->DeclareSymbol("persistent user INDEX ser_iExtensiveSyncCheck;", (void *)&ser_iExtensiveSyncCheck);
|
|
_pShell->DeclareSymbol("persistent user INDEX net_bLookupHostNames;", (void *)&net_bLookupHostNames);
|
|
_pShell->DeclareSymbol("persistent user INDEX net_iCompression ;", (void *)&net_iCompression);
|
|
_pShell->DeclareSymbol("persistent user INDEX net_bReportPackets;", (void *)&net_bReportPackets);
|
|
_pShell->DeclareSymbol("persistent user INDEX net_iMaxSendRetries;", (void *)&net_iMaxSendRetries);
|
|
_pShell->DeclareSymbol("persistent user FLOAT net_fSendRetryWait;", (void *)&net_fSendRetryWait);
|
|
_pShell->DeclareSymbol("persistent user INDEX net_bReportTraffic;", (void *)&net_bReportTraffic);
|
|
_pShell->DeclareSymbol("persistent user INDEX net_bReportICMPErrors;", (void *)&net_bReportICMPErrors);
|
|
_pShell->DeclareSymbol("persistent user INDEX net_bReportMiscErrors;", (void *)&net_bReportMiscErrors);
|
|
_pShell->DeclareSymbol("persistent user INDEX net_bLerping;", (void *)&net_bLerping);
|
|
_pShell->DeclareSymbol("persistent user INDEX ser_bClientsMayPause;", (void *)&ser_bClientsMayPause);
|
|
_pShell->DeclareSymbol("persistent user INDEX ser_bEnumeration;", (void *)&ser_bEnumeration);
|
|
_pShell->DeclareSymbol("persistent user INDEX ser_bPingGameAgent;", (void *)&ser_bPingGameAgent);
|
|
_pShell->DeclareSymbol("persistent user FLOAT ser_tmKeepAlive;", (void *)&ser_tmKeepAlive);
|
|
_pShell->DeclareSymbol("persistent user FLOAT ser_tmPingUpdate;", (void *)&ser_tmPingUpdate);
|
|
_pShell->DeclareSymbol("persistent user INDEX ser_bWaitFirstPlayer;", (void *)&ser_bWaitFirstPlayer);
|
|
_pShell->DeclareSymbol("persistent user INDEX ser_iMaxAllowedBPS;", (void *)&ser_iMaxAllowedBPS);
|
|
_pShell->DeclareSymbol("persistent user INDEX ser_iMaxAllowedBPS;", (void *)&ser_iMaxAllowedBPS);
|
|
_pShell->DeclareSymbol("persistent user CTString ser_strIPMask;", (void *)&ser_strIPMask);
|
|
_pShell->DeclareSymbol("persistent user CTString ser_strNameMask;", (void *)&ser_strNameMask);
|
|
_pShell->DeclareSymbol("persistent user INDEX ser_bInverseBanning;", (void *)&ser_bInverseBanning);
|
|
_pShell->DeclareSymbol("persistent user CTString ser_strMOTD;", (void *)&ser_strMOTD);
|
|
|
|
_pShell->DeclareSymbol("persistent user INDEX cli_bAutoAdjustSettings;", (void *)&cli_bAutoAdjustSettings);
|
|
_pShell->DeclareSymbol("persistent user FLOAT cli_tmAutoAdjustThreshold;", (void *)&cli_tmAutoAdjustThreshold);
|
|
_pShell->DeclareSymbol("persistent user INDEX cli_bPrediction;", (void *)&cli_bPrediction);
|
|
_pShell->DeclareSymbol("persistent user INDEX cli_iMaxPredictionSteps;", (void *)&cli_iMaxPredictionSteps);
|
|
_pShell->DeclareSymbol("persistent user INDEX cli_bPredictIfServer;", (void *)&cli_bPredictIfServer);
|
|
_pShell->DeclareSymbol("persistent user INDEX cli_bPredictLocalPlayers;", (void *)&cli_bPredictLocalPlayers);
|
|
_pShell->DeclareSymbol("persistent user INDEX cli_bPredictRemotePlayers;", (void *)&cli_bPredictRemotePlayers);
|
|
_pShell->DeclareSymbol("persistent user FLOAT cli_fPredictEntitiesRange;", (void *)&cli_fPredictEntitiesRange);
|
|
_pShell->DeclareSymbol("persistent user FLOAT cli_fPredictionFilter;", (void *)&cli_fPredictionFilter);
|
|
_pShell->DeclareSymbol("persistent user INDEX cli_iSendBehind;", (void *)&cli_iSendBehind);
|
|
_pShell->DeclareSymbol("persistent user INDEX cli_iPredictionFlushing;", (void *)&cli_iPredictionFlushing);
|
|
|
|
_pShell->DeclareSymbol("persistent user INDEX cli_iBufferActions;", (void *)&cli_iBufferActions);
|
|
_pShell->DeclareSymbol("persistent user INDEX cli_iMaxBPS;", (void *)&cli_iMaxBPS);
|
|
_pShell->DeclareSymbol("persistent user INDEX cli_iMinBPS;", (void *)&cli_iMinBPS);
|
|
|
|
_pShell->DeclareSymbol("user FLOAT net_fLimitLatencySend;", (void *)&_pbsSend.pbs_fLatencyLimit);
|
|
_pShell->DeclareSymbol("user FLOAT net_fLimitLatencyRecv;", (void *)&_pbsRecv.pbs_fLatencyLimit);
|
|
_pShell->DeclareSymbol("user FLOAT net_fLatencyVariationSend;", (void *)&_pbsSend.pbs_fLatencyVariation);
|
|
_pShell->DeclareSymbol("user FLOAT net_fLatencyVariationRecv;", (void *)&_pbsRecv.pbs_fLatencyVariation);
|
|
_pShell->DeclareSymbol("user FLOAT net_fLimitBandwidthSend;", (void *)&_pbsSend.pbs_fBandwidthLimit);
|
|
_pShell->DeclareSymbol("user FLOAT net_fLimitBandwidthRecv;", (void *)&_pbsRecv.pbs_fBandwidthLimit);
|
|
_pShell->DeclareSymbol("user FLOAT net_fDropPackets;", (void *)&net_fDropPackets);
|
|
|
|
_pShell->DeclareSymbol("persistent user INDEX net_iGraphBuffer;", (void *)&net_iGraphBuffer);
|
|
|
|
_pShell->DeclareSymbol("user const INDEX precache_NONE;", (void *)&_precache_NONE);
|
|
_pShell->DeclareSymbol("user const INDEX precache_SMART;", (void *)&_precache_SMART);
|
|
_pShell->DeclareSymbol("user const INDEX precache_ALL;", (void *)&_precache_ALL);
|
|
_pShell->DeclareSymbol("user const INDEX precache_PARANOIA;", (void *)&_precache_PARANOIA);
|
|
_pShell->DeclareSymbol("persistent user INDEX gam_iPrecachePolicy;", (void *)&gam_iPrecachePolicy);
|
|
|
|
_pShell->DeclareSymbol("user FLOAT phy_fCollisionCacheAhead;", (void *)&phy_fCollisionCacheAhead);
|
|
_pShell->DeclareSymbol("user FLOAT phy_fCollisionCacheAround;", (void *)&phy_fCollisionCacheAround);
|
|
|
|
_pShell->DeclareSymbol("persistent user INDEX inp_iKeyboardReadingMethod;", (void *)&inp_iKeyboardReadingMethod);
|
|
_pShell->DeclareSymbol("persistent user INDEX inp_bAllowMouseAcceleration;", (void *)&inp_bAllowMouseAcceleration);
|
|
_pShell->DeclareSymbol("persistent user FLOAT inp_fMouseSensitivity;", (void *)&inp_fMouseSensitivity);
|
|
_pShell->DeclareSymbol("persistent user INDEX inp_bMousePrecision;", (void *)&inp_bMousePrecision);
|
|
_pShell->DeclareSymbol("persistent user FLOAT inp_fMousePrecisionFactor;", (void *)&inp_fMousePrecisionFactor);
|
|
_pShell->DeclareSymbol("persistent user FLOAT inp_fMousePrecisionThreshold;", (void *)&inp_fMousePrecisionThreshold);
|
|
_pShell->DeclareSymbol("persistent user FLOAT inp_fMousePrecisionTimeout;", (void *)&inp_fMousePrecisionTimeout);
|
|
_pShell->DeclareSymbol("persistent user INDEX inp_bInvertMouse;", (void *)&inp_bInvertMouse);
|
|
_pShell->DeclareSymbol("persistent user INDEX inp_bFilterMouse;", (void *)&inp_bFilterMouse);
|
|
_pShell->DeclareSymbol("persistent user INDEX inp_bAllowPrescan;", (void *)&inp_bAllowPrescan);
|
|
|
|
_pShell->DeclareSymbol("persistent user INDEX inp_i2ndMousePort;", (void *)&inp_i2ndMousePort);
|
|
_pShell->DeclareSymbol("persistent user INDEX inp_bInvert2ndMouse;", (void *)&inp_bInvert2ndMouse);
|
|
_pShell->DeclareSymbol("persistent user INDEX inp_bFilter2ndMouse;", (void *)&inp_bFilter2ndMouse);
|
|
_pShell->DeclareSymbol("persistent user FLOAT inp_f2ndMouseSensitivity;", (void *)&inp_f2ndMouseSensitivity);
|
|
_pShell->DeclareSymbol("persistent user INDEX inp_b2ndMousePrecision;", (void *)&inp_b2ndMousePrecision);
|
|
_pShell->DeclareSymbol("persistent user FLOAT inp_f2ndMousePrecisionFactor;", (void *)&inp_f2ndMousePrecisionFactor);
|
|
_pShell->DeclareSymbol("persistent user FLOAT inp_f2ndMousePrecisionThreshold;", (void *)&inp_f2ndMousePrecisionThreshold);
|
|
_pShell->DeclareSymbol("persistent user FLOAT inp_f2ndMousePrecisionTimeout;", (void *)&inp_f2ndMousePrecisionTimeout);
|
|
|
|
_pShell->DeclareSymbol("persistent user INDEX inp_bMsgDebugger;", (void *)&inp_bMsgDebugger);
|
|
_pShell->DeclareSymbol("persistent user INDEX inp_iMButton4Up;", (void *)&inp_iMButton4Up);
|
|
_pShell->DeclareSymbol("persistent user INDEX inp_iMButton4Dn;", (void *)&inp_iMButton4Dn);
|
|
_pShell->DeclareSymbol("persistent user INDEX inp_iMButton5Up;", (void *)&inp_iMButton5Up);
|
|
_pShell->DeclareSymbol("persistent user INDEX inp_iMButton5Dn;", (void *)&inp_iMButton5Dn);
|
|
_pShell->DeclareSymbol("persistent user INDEX inp_ctJoysticksAllowed;", (void *)&inp_ctJoysticksAllowed);
|
|
_pShell->DeclareSymbol("persistent user INDEX inp_bForceJoystickPolling;", (void *)&inp_bForceJoystickPolling);
|
|
_pShell->DeclareSymbol("persistent user INDEX inp_bAutoDisableJoysticks;", (void *)&inp_bAutoDisableJoysticks);
|
|
|
|
_pShell->DeclareSymbol("persistent user INDEX wed_bUseGenericTextureReplacement;", (void *)&wed_bUseGenericTextureReplacement);
|
|
|
|
_pShell->DeclareSymbol("persistent user CTString ga_strServer;", (void *)&ga_strServer);
|
|
_pShell->DeclareSymbol("persistent user CTString ga_strMSLegacy;", (void *)&ga_strMSLegacy);
|
|
_pShell->DeclareSymbol("persistent user INDEX ga_bMSLegacy;", (void *)&ga_bMSLegacy);
|
|
|
|
}
|
|
|
|
/*
|
|
* Add the timer handler.
|
|
*/
|
|
void CNetworkLibrary::AddTimerHandler(void)
|
|
{
|
|
ASSERT(this!=NULL);
|
|
if (_bTempNetwork) {
|
|
return; // this can happen during NET_MakeDefaultState_t()!
|
|
}
|
|
_pTimer->AddHandler(&ga_thTimerHandler);
|
|
}
|
|
/*
|
|
* Remove the timer handler.
|
|
*/
|
|
void CNetworkLibrary::RemoveTimerHandler(void)
|
|
{
|
|
ASSERT(this!=NULL);
|
|
if (_bTempNetwork) {
|
|
return; // this can happen during NET_MakeDefaultState_t()!
|
|
}
|
|
_pTimer->RemHandler(&ga_thTimerHandler);
|
|
}
|
|
|
|
/*
|
|
// set settings to prediction-off
|
|
void AdjustPredictionOff(void)
|
|
{
|
|
if (!cli_bAutoAdjustSettings) {
|
|
return;
|
|
}
|
|
if (cli_bPrediction) {
|
|
CPrintF("AutoAdjustment: prediction off, buffer 1\n");
|
|
}
|
|
cli_bPrediction = 0;
|
|
cli_iBufferActions = 1;
|
|
}
|
|
// set settings to prediction-on
|
|
void AdjustPredictionOn(void)
|
|
{
|
|
if (!cli_bAutoAdjustSettings) {
|
|
return;
|
|
}
|
|
if (!cli_bPrediction) {
|
|
CPrintF("AutoAdjustment: prediction on, buffer 3\n");
|
|
}
|
|
cli_bPrediction = 1;
|
|
cli_iBufferActions = 3;
|
|
}
|
|
|
|
// automatically adjust network settings
|
|
void CNetworkLibrary::AutoAdjustSettings(void)
|
|
{
|
|
// if server and not debugging prediction
|
|
if (IsServer() && !cli_bPredictIfServer) {
|
|
// just turn it all off
|
|
AdjustPredictionOff();
|
|
return;
|
|
}
|
|
|
|
static TIME _tmLastTimeNoPredictionSteps = -1;
|
|
// get network lag in terms of ticks
|
|
INDEX ctLagTicks = ga_sesSessionState.GetPredictionStepsCount()-(cli_iBufferActions-1);
|
|
|
|
// if no significant lag
|
|
if (ctLagTicks<=1) {
|
|
// set settings to prediction-off
|
|
AdjustPredictionOff();
|
|
_tmLastTimeNoPredictionSteps = _pTimer->CurrentTick();
|
|
// if there is lag now for some time
|
|
} else if (_pTimer->CurrentTick()-_tmLastTimeNoPredictionSteps>=cli_tmAutoAdjustThreshold) {
|
|
// set settings to prediction-on
|
|
AdjustPredictionOn();
|
|
}
|
|
}
|
|
*/
|
|
|
|
/*
|
|
* Start a peer-to-peer game session.
|
|
*
|
|
* remember to keep this routine up to date with CNetworkLibrary::Read()
|
|
*/
|
|
void CNetworkLibrary::StartPeerToPeer_t(const CTString &strSessionName,
|
|
const CTFileName &fnmWorld, ULONG ulSpawnFlags,
|
|
INDEX ctMaxPlayers, BOOL bWaitAllPlayers,
|
|
void *pvSessionProperties) // throw char *
|
|
{
|
|
// mute all sounds
|
|
_pSound->Mute();
|
|
|
|
// go on
|
|
CPrintF( TRANS("Starting session: '%s'\n"), (const char *) strSessionName);
|
|
CPrintF( TRANS(" level: '%s'\n"), (const char*) fnmWorld);
|
|
CPrintF( TRANS(" spawnflags: %08x\n"), ulSpawnFlags);
|
|
CPrintF( TRANS(" max players: %d\n"), ctMaxPlayers);
|
|
CPrintF( TRANS(" waiting: %d\n"), bWaitAllPlayers);
|
|
|
|
CGatherCRC gc;
|
|
|
|
// if starting in network
|
|
if (_cmiComm.IsNetworkEnabled()) {
|
|
CPrintF( TRANS(" network is on\n"));
|
|
// start gathering CRCs
|
|
InitCRCGather();
|
|
|
|
// make default state data for creating deltas
|
|
MakeDefaultState(fnmWorld, ulSpawnFlags, pvSessionProperties);
|
|
} else {
|
|
CPrintF( TRANS(" network is off\n"));
|
|
}
|
|
|
|
// access to the list of handlers must be locked
|
|
CTSingleLock slHooks(&_pTimer->tm_csHooks, TRUE);
|
|
// synchronize access to network
|
|
CTSingleLock slNetwork(&ga_csNetwork, TRUE);
|
|
ga_ctTimersPending = -1; // disable timer pending
|
|
|
|
ga_strSessionName = strSessionName;
|
|
ga_bLocalPause = FALSE;
|
|
ga_sesSessionState.ses_iLevel+=1;
|
|
ga_sesSessionState.ses_ulSpawnFlags = ulSpawnFlags;
|
|
ga_sesSessionState.ses_tmSyncCheckFrequency = ser_tmSyncCheckFrequency;
|
|
ga_sesSessionState.ses_iExtensiveSyncCheck = ser_iExtensiveSyncCheck;
|
|
|
|
memcpy(ga_aubProperties, pvSessionProperties, NET_MAXSESSIONPROPERTIES);
|
|
|
|
// remember the world filename
|
|
ga_fnmWorld = fnmWorld;
|
|
ga_fnmNextLevel = CTString("");
|
|
try {
|
|
// load the world
|
|
_pTimer->SetCurrentTick(0.0f); // must have timer at 0 while loading
|
|
ga_World.Load_t(fnmWorld);
|
|
// delete all entities that don't fit given spawn flags
|
|
ga_World.FilterEntitiesBySpawnFlags(ga_sesSessionState.ses_ulSpawnFlags);
|
|
} catch(char *) {
|
|
ga_fnmWorld = CTString("");
|
|
_cmiComm.Server_Close();
|
|
_cmiComm.Client_Close();
|
|
throw;
|
|
}
|
|
// remember the world pointer
|
|
_pShell->SetCurrentWorld(&ga_World);
|
|
|
|
SetProgressDescription(TRANS("starting server"));
|
|
CallProgressHook_t(0.0f);
|
|
// initialize server
|
|
try {
|
|
ga_srvServer.Start_t();
|
|
} catch (char *) {
|
|
ga_World.DeletePredictors();
|
|
ga_World.Clear();
|
|
throw;
|
|
}
|
|
ga_IsServer = TRUE;
|
|
ga_ulDemoMinorVersion = _SE_BUILD_MINOR;
|
|
CallProgressHook_t(1.0f);
|
|
|
|
// start the timer loop
|
|
AddTimerHandler();
|
|
|
|
SetProgressDescription(TRANS("starting session"));
|
|
CallProgressHook_t(0.0f);
|
|
// initialize session state
|
|
try {
|
|
ga_sesSessionState.Start_t(-1);
|
|
} catch (char *strError) {
|
|
(void)strError;
|
|
RemoveTimerHandler();
|
|
ga_srvServer.Stop();
|
|
ga_World.DeletePredictors();
|
|
ga_World.Clear();
|
|
throw;
|
|
}
|
|
CallProgressHook_t(1.0f);
|
|
|
|
// remember maximum number of players
|
|
ga_sesSessionState.ses_ctMaxPlayers = ctMaxPlayers;
|
|
ga_sesSessionState.ses_bWaitAllPlayers = bWaitAllPlayers;
|
|
|
|
// time speed is normal by default
|
|
ga_sesSessionState.ses_fRealTimeFactor = 1.0f;
|
|
|
|
// eventually cache all shadowmaps in world (memory eater!)
|
|
if( shd_bCacheAll) ga_World.wo_baBrushes.CacheAllShadowmaps();
|
|
// flush stale caches
|
|
FreeUnusedStock();
|
|
// mark that pretouching is required
|
|
_bNeedPretouch = TRUE;
|
|
|
|
// start timer sync anew
|
|
ga_ctTimersPending = 0;
|
|
FinishCRCGather();
|
|
CPrintF( TRANS(" started.\n"));
|
|
}
|
|
|
|
/*
|
|
* Save the game.
|
|
*/
|
|
void CNetworkLibrary::Save_t(const CTFileName &fnmGame) // throw char *
|
|
{
|
|
// synchronize access to network
|
|
CTSingleLock slNetwork(&ga_csNetwork, TRUE);
|
|
|
|
// must be server
|
|
if (!ga_IsServer) {
|
|
throw TRANS("Cannot save game - not a server!\n");
|
|
}
|
|
|
|
// create the file
|
|
CTFileStream strmFile;
|
|
strmFile.Create_t(fnmGame);
|
|
|
|
// write game to stream
|
|
strmFile.WriteID_t("GAME");
|
|
ga_sesSessionState.Write_t(&strmFile);
|
|
strmFile.WriteID_t("GEND"); // game end
|
|
}
|
|
|
|
/*
|
|
* Load the game.
|
|
*
|
|
* remember to keep this routine up to date with CNetworkLibrary::StartPeerToPeer()
|
|
*/
|
|
void CNetworkLibrary::Load_t(const CTFileName &fnmGame) // throw char *
|
|
{
|
|
// mute all sounds
|
|
_pSound->Mute();
|
|
|
|
// access to the list of handlers must be locked
|
|
CTSingleLock slHooks(&_pTimer->tm_csHooks, TRUE);
|
|
// synchronize access to network
|
|
CTSingleLock slNetwork(&ga_csNetwork, TRUE);
|
|
ga_ctTimersPending = -1; // disable timer pending
|
|
CGatherCRC gc;
|
|
|
|
ga_bLocalPause = FALSE;
|
|
|
|
// open the file
|
|
CTFileStream strmFile;
|
|
strmFile.Open_t(fnmGame);
|
|
|
|
// if starting in network
|
|
if (_cmiComm.IsNetworkEnabled()) {
|
|
// start gathering CRCs
|
|
InitCRCGather();
|
|
}
|
|
|
|
// initialize server
|
|
ga_srvServer.Start_t();
|
|
ga_IsServer = TRUE;
|
|
ga_ulDemoMinorVersion = _SE_BUILD_MINOR;
|
|
ga_fnmNextLevel = CTString("");
|
|
memset(ga_aubProperties, 0, NET_MAXSESSIONPROPERTIES);
|
|
|
|
// start the timer loop
|
|
AddTimerHandler();
|
|
|
|
strmFile.ExpectID_t("GAME");
|
|
// read session state
|
|
try {
|
|
ga_sesSessionState.Start_t(-1);
|
|
ga_sesSessionState.Read_t(&strmFile);
|
|
// if starting in network
|
|
if (_cmiComm.IsNetworkEnabled()) {
|
|
// make default state data for creating deltas
|
|
MakeDefaultState(ga_fnmWorld, ga_sesSessionState.ses_ulSpawnFlags,
|
|
ga_aubProperties);
|
|
}
|
|
// players will be connected later
|
|
ga_sesSessionState.ses_apltPlayers.Clear();
|
|
ga_sesSessionState.ses_apltPlayers.New(NET_MAXGAMEPLAYERS);
|
|
strmFile.ExpectID_t("GEND"); // game end
|
|
} catch(char *) {
|
|
RemoveTimerHandler();
|
|
ga_srvServer.Stop();
|
|
ga_IsServer = FALSE;
|
|
throw;
|
|
}
|
|
|
|
// set time and pause for server from the saved game
|
|
ga_sesSessionState.ses_iLevel+=1;
|
|
ga_srvServer.srv_tmLastProcessedTick = ga_sesSessionState.ses_tmLastProcessedTick;
|
|
ga_srvServer.srv_iLastProcessedSequence = ga_sesSessionState.ses_iLastProcessedSequence;
|
|
ga_srvServer.srv_bPause = ga_sesSessionState.ses_bPause;
|
|
ga_srvServer.srv_bGameFinished = ga_sesSessionState.ses_bGameFinished;
|
|
ga_sesSessionState.ses_tmPredictionHeadTick = ga_sesSessionState.ses_tmLastProcessedTick;
|
|
// start sending stream to local state
|
|
ga_srvServer.srv_assoSessions[0].sso_bSendStream = TRUE;
|
|
ga_srvServer.srv_assoSessions[0].sso_iLastSentSequence = ga_srvServer.srv_iLastProcessedSequence;
|
|
|
|
// eventually cache all shadowmaps in world (memory eater!)
|
|
if( shd_bCacheAll) ga_World.wo_baBrushes.CacheAllShadowmaps();
|
|
// flush stale caches
|
|
FreeUnusedStock();
|
|
// mark that pretouching is required
|
|
_bNeedPretouch = TRUE;
|
|
|
|
// start timer sync anew
|
|
ga_ctTimersPending = 0;
|
|
FinishCRCGather();
|
|
}
|
|
|
|
/*
|
|
* Save a debugging game.
|
|
*/
|
|
void CNetworkLibrary::DebugSave(void)
|
|
{
|
|
// try to save game
|
|
try {
|
|
Save_t(CTString("Save\\Debug.sav"));
|
|
// if not successful
|
|
} catch (char *strError){
|
|
FatalError("Cannot save debug game:\n%s", strError);
|
|
}
|
|
}
|
|
|
|
/* Enumerate existing sessions. */
|
|
void CNetworkLibrary::EnumSessions(BOOL bInternet)
|
|
{
|
|
// clear old list
|
|
FORDELETELIST(CNetworkSession, ns_lnNode, ga_lhEnumeratedSessions, itns) {
|
|
delete &*itns;
|
|
}
|
|
|
|
// make sure network is on
|
|
if (!_cmiComm.IsNetworkEnabled()) {
|
|
_cmiComm.PrepareForUse(/*network*/TRUE, /*client*/FALSE); // have to enumerate as server
|
|
}
|
|
|
|
// request enumeration
|
|
GameAgent_EnumTrigger(bInternet);
|
|
}
|
|
|
|
/*
|
|
* Join a running multi-player game.
|
|
*/
|
|
void CNetworkLibrary::JoinSession_t(const CNetworkSession &nsSesssion, INDEX ctLocalPlayers) // throw char *
|
|
{
|
|
// mute all sounds
|
|
_pSound->Mute();
|
|
|
|
// report session addres
|
|
CPrintF( TRANS("Joining session at: '%s'\n"), (const char *) nsSesssion.ns_strAddress);
|
|
|
|
ga_bLocalPause = FALSE;
|
|
|
|
// access to the list of handlers must be locked
|
|
CTSingleLock slHooks(&_pTimer->tm_csHooks, TRUE);
|
|
// synchronize access to network
|
|
CTSingleLock slNetwork(&ga_csNetwork, TRUE);
|
|
ga_ctTimersPending = -1; // disable timer pending
|
|
// start gathering CRCs
|
|
CGatherCRC gc;
|
|
InitCRCGather();
|
|
|
|
// set session name and server address
|
|
ga_strSessionName = nsSesssion.ns_strSession;
|
|
ga_strServerAddress = nsSesssion.ns_strAddress;
|
|
ga_fnmNextLevel = CTString("");
|
|
ga_fnmWorld = CTString("");
|
|
memset(ga_aubProperties, 0, NET_MAXSESSIONPROPERTIES);
|
|
|
|
ga_IsServer = FALSE;
|
|
ga_ulDemoMinorVersion = _SE_BUILD_MINOR;
|
|
// start the timer loop
|
|
AddTimerHandler();
|
|
|
|
SetProgressDescription(TRANS("connecting"));
|
|
CallProgressHook_t(0.0f);
|
|
// initialize session state
|
|
try {
|
|
ga_sesSessionState.Start_t(ctLocalPlayers);
|
|
} catch(char *) {
|
|
RemoveTimerHandler();
|
|
throw;
|
|
}
|
|
|
|
// remember the world pointer
|
|
_pShell->SetCurrentWorld(&ga_World);
|
|
|
|
// eventually cache all shadowmaps in world (memory eater!)
|
|
if( shd_bCacheAll) ga_World.wo_baBrushes.CacheAllShadowmaps();
|
|
// flush stale caches
|
|
FreeUnusedStock();
|
|
// mark that pretouching is required
|
|
_bNeedPretouch = TRUE;
|
|
|
|
// run main loop to let session state process messages from server
|
|
MainLoop();
|
|
// start timer sync anew
|
|
ga_ctTimersPending = 0;
|
|
|
|
// initially auto adjust prediction on
|
|
// AdjustPredictionOn();
|
|
CPrintF(" joined\n");
|
|
}
|
|
|
|
/* Start playing a demo. */
|
|
void CNetworkLibrary::StartDemoPlay_t(const CTFileName &fnDemo) // throw char *
|
|
{
|
|
// mute all sounds
|
|
_pSound->Mute();
|
|
|
|
// access to the list of handlers must be locked
|
|
CTSingleLock slHooks(&_pTimer->tm_csHooks, TRUE);
|
|
// synchronize access to network
|
|
CTSingleLock slNetwork(&ga_csNetwork, TRUE);
|
|
ga_ctTimersPending = -1; // disable timer pending
|
|
ga_bLocalPause = FALSE;
|
|
|
|
// open the file
|
|
ga_strmDemoPlay.Open_t(fnDemo);
|
|
|
|
// remember that playing demo
|
|
ga_bDemoPlay = TRUE;
|
|
ga_bDemoPlayFinished = FALSE;
|
|
|
|
// create session name from demo name
|
|
CTString strSessionName = CTString("Demo: ")+fnDemo;
|
|
ga_strSessionName = strSessionName;
|
|
|
|
ga_IsServer = FALSE;
|
|
// start the timer loop
|
|
AddTimerHandler();
|
|
// initialize server
|
|
try {
|
|
// read initial info to stream
|
|
ga_strmDemoPlay.ExpectID_t("DEMO");
|
|
if (ga_strmDemoPlay.PeekID_t()==CChunkID("MVER")) {
|
|
ga_strmDemoPlay.ExpectID_t("MVER");
|
|
ga_strmDemoPlay>>ga_ulDemoMinorVersion;
|
|
} else {
|
|
ga_ulDemoMinorVersion = 2;
|
|
}
|
|
ga_sesSessionState.Read_t(&ga_strmDemoPlay);
|
|
} catch(char *) {
|
|
RemoveTimerHandler();
|
|
ga_strmDemoPlay.Close();
|
|
ga_bDemoPlay = FALSE;
|
|
throw;
|
|
}
|
|
|
|
// eventually cache all shadowmaps in world (memory eater!)
|
|
if( shd_bCacheAll) ga_World.wo_baBrushes.CacheAllShadowmaps();
|
|
// flush stale caches
|
|
FreeUnusedStock();
|
|
// mark that pretouching is required
|
|
_bNeedPretouch = TRUE;
|
|
|
|
// remember the world pointer
|
|
_pShell->SetCurrentWorld(&ga_World);
|
|
|
|
// demo synchronization starts at the beginning initially
|
|
ga_fDemoTimer = 0.0f;
|
|
ga_tvDemoTimerLastTime = _pTimer->GetHighPrecisionTimer();
|
|
|
|
// demo sync seuqence must be initialized first time in ProcessGameStream()
|
|
ga_sesSessionState.ses_tmLastDemoSequence = -1.0f;
|
|
|
|
// run main loop to let server process messages from host
|
|
MainLoop();
|
|
// start timer sync anew
|
|
ga_ctTimersPending = 0;
|
|
}
|
|
|
|
/* Test if currently playing demo has finished. */
|
|
BOOL CNetworkLibrary::IsDemoPlayFinished(void)
|
|
{
|
|
return ga_bDemoPlay && ga_bDemoPlayFinished;
|
|
}
|
|
|
|
/* Test if currently playing a demo. */
|
|
BOOL CNetworkLibrary::IsPlayingDemo(void)
|
|
{
|
|
return ga_bDemoPlay;
|
|
}
|
|
|
|
/* Test if currently recording a demo. */
|
|
BOOL CNetworkLibrary::IsRecordingDemo(void)
|
|
{
|
|
return ga_bDemoRec;
|
|
}
|
|
BOOL CNetworkLibrary::IsNetworkEnabled(void)
|
|
{
|
|
return _cmiComm.IsNetworkEnabled();
|
|
}
|
|
// pause/unpause game
|
|
void CNetworkLibrary::TogglePause(void)
|
|
{
|
|
ga_sesSessionState.ses_bWantPause = !ga_sesSessionState.ses_bWantPause;
|
|
}
|
|
|
|
// test if game is paused
|
|
BOOL CNetworkLibrary::IsPaused(void)
|
|
{
|
|
ASSERT(this!=NULL);
|
|
if (_bTempNetwork) {
|
|
return TRUE; // this can happen during NET_MakeDefaultState_t()!
|
|
}
|
|
return ga_sesSessionState.ses_bPause;
|
|
}
|
|
|
|
// test if having connnection problems (not getting messages from server regulary)
|
|
BOOL CNetworkLibrary::IsConnectionStable(void)
|
|
{
|
|
// if network is not enabled
|
|
if (!_cmiComm.IsNetworkEnabled()) {
|
|
// it is always stable
|
|
return TRUE;
|
|
}
|
|
|
|
// check when last message was received.
|
|
return (_pTimer->GetHighPrecisionTimer()-ga_sesSessionState.ses_tvMessageReceived).GetSeconds()<net_tmProblemsTimeout;
|
|
}
|
|
// test if completely disconnected and why
|
|
BOOL CNetworkLibrary::IsDisconnected(void)
|
|
{
|
|
return ga_sesSessionState.ses_strDisconnected!="";
|
|
}
|
|
|
|
const CTString &CNetworkLibrary::WhyDisconnected(void)
|
|
{
|
|
return ga_sesSessionState.ses_strDisconnected;
|
|
}
|
|
|
|
// set/get server side pause (for single player only)
|
|
void CNetworkLibrary::SetLocalPause(BOOL bPause)
|
|
{
|
|
ga_bLocalPause = bPause;
|
|
}
|
|
|
|
BOOL CNetworkLibrary::GetLocalPause(void)
|
|
{
|
|
ASSERT(this!=NULL);
|
|
if (_bTempNetwork) {
|
|
return TRUE; // this can happen during NET_MakeDefaultState_t()!
|
|
}
|
|
return ga_bLocalPause;
|
|
}
|
|
|
|
// get server/client name and address
|
|
void CNetworkLibrary::GetHostName(CTString &strName, CTString &strAddress)
|
|
{
|
|
_cmiComm.GetHostName(strName, strAddress);
|
|
}
|
|
|
|
// mark that the game has finished -- called from AI
|
|
void CNetworkLibrary::SetGameFinished(void)
|
|
{
|
|
ga_sesSessionState.ses_bGameFinished = TRUE;
|
|
if (IsServer()) {
|
|
ga_srvServer.srv_bGameFinished = TRUE;
|
|
}
|
|
}
|
|
BOOL CNetworkLibrary::IsGameFinished(void)
|
|
{
|
|
return ga_sesSessionState.ses_bGameFinished;
|
|
}
|
|
|
|
// manipulation with realtime factor for slower/faster time -- called from AI
|
|
void CNetworkLibrary::SetRealTimeFactor(FLOAT fSpeed)
|
|
{
|
|
ga_sesSessionState.ses_fRealTimeFactor = fSpeed;
|
|
}
|
|
|
|
FLOAT CNetworkLibrary::GetRealTimeFactor(void)
|
|
{
|
|
return ga_sesSessionState.ses_fRealTimeFactor;
|
|
}
|
|
|
|
// test if game is waiting for more players to connect
|
|
BOOL CNetworkLibrary::IsWaitingForPlayers(void)
|
|
{
|
|
// if game mode does not include waiting for players
|
|
if (!ga_sesSessionState.ses_bWaitAllPlayers) {
|
|
// not waiting
|
|
return FALSE;
|
|
}
|
|
// if server
|
|
if (IsServer()) {
|
|
// check number of players on server
|
|
return ga_srvServer.GetPlayersCount()<ga_sesSessionState.ses_ctMaxPlayers;
|
|
// if not server
|
|
} else {
|
|
// check number of players in session
|
|
return ga_sesSessionState.GetPlayersCount()<ga_sesSessionState.ses_ctMaxPlayers;
|
|
}
|
|
}
|
|
// test if game is waiting for server
|
|
BOOL CNetworkLibrary::IsWaitingForServer(void)
|
|
{
|
|
return ga_sesSessionState.ses_bWaitingForServer;
|
|
}
|
|
|
|
// test if game session is currently doing prediction
|
|
BOOL CNetworkLibrary::IsPredicting(void)
|
|
{
|
|
return ga_sesSessionState.ses_bPredicting;
|
|
}
|
|
|
|
/*
|
|
* Stop currently running game.
|
|
*/
|
|
void CNetworkLibrary::StopGame(void)
|
|
{
|
|
// mute all sounds
|
|
_pSound->Mute();
|
|
|
|
CPrintF( TRANS("stopping game.\n"));
|
|
// access to the list of handlers must be locked
|
|
CTSingleLock slHooks(&_pTimer->tm_csHooks, TRUE);
|
|
// synchronize access to network
|
|
CTSingleLock slNetwork(&ga_csNetwork, TRUE);
|
|
ga_ctTimersPending = -1; // disable timer pending
|
|
|
|
// stop demo recording if active
|
|
StopDemoRec();
|
|
|
|
// if playing demo
|
|
if (ga_bDemoPlay) {
|
|
// close the demo file
|
|
ga_strmDemoPlay.Close();
|
|
// remember that not playing demo
|
|
ga_bDemoPlay = FALSE;
|
|
ga_bDemoPlayFinished = FALSE;
|
|
}
|
|
|
|
// stop the timer loop
|
|
RemoveTimerHandler();
|
|
|
|
// stop session
|
|
ga_sesSessionState.Stop();
|
|
|
|
// stop server
|
|
if (ga_IsServer) {
|
|
ga_srvServer.Stop();
|
|
ga_IsServer = FALSE;
|
|
}
|
|
ga_ulDemoMinorVersion = _SE_BUILD_MINOR;
|
|
|
|
ga_strSessionName = "";
|
|
|
|
ga_World.DeletePredictors();
|
|
ga_World.Clear();
|
|
|
|
// free default state if existing
|
|
if (ga_pubDefaultState!=NULL) {
|
|
FreeMemory(ga_pubDefaultState);
|
|
ga_pubDefaultState = NULL;
|
|
ga_slDefaultStateSize = 0;
|
|
memset(ga_aubDefaultProperties, 0, sizeof(ga_aubDefaultProperties));
|
|
}
|
|
if (ga_pubCRCList!=NULL) {
|
|
FreeMemory(ga_pubCRCList);
|
|
ga_pubCRCList = NULL;
|
|
ga_slCRCList = 0;
|
|
}
|
|
|
|
ga_aplsPlayers.Clear();
|
|
ga_aplsPlayers.New(NET_MAXLOCALPLAYERS);
|
|
// remember the world pointer
|
|
_pShell->SetCurrentWorld(NULL);
|
|
|
|
// rewind the timer
|
|
_pTimer->SetCurrentTick(0.0f);
|
|
}
|
|
|
|
// initiate level change
|
|
void CNetworkLibrary::ChangeLevel(
|
|
const CTFileName &fnmNextLevel, BOOL bRemember, INDEX iUserData)
|
|
{
|
|
// synchronize access to network
|
|
CTSingleLock slNetwork(&ga_csNetwork, TRUE);
|
|
|
|
ASSERT(!IsPredicting());
|
|
|
|
// if not currently changing
|
|
if (_lphCurrent==LCP_NOCHANGE) {
|
|
// initiate change
|
|
ga_fnmNextLevel = fnmNextLevel;
|
|
ga_bNextRemember = bRemember;
|
|
ga_iNextLevelUserData = iUserData;
|
|
_lphCurrent = LCP_INITIATED;
|
|
}
|
|
}
|
|
|
|
// really do the level change
|
|
void CNetworkLibrary::ChangeLevel_internal(void)
|
|
{
|
|
CSetFPUPrecision FPUPrecision(FPT_24BIT);
|
|
|
|
extern BOOL _bReinitEntitiesWhileCopying;
|
|
_bReinitEntitiesWhileCopying = FALSE;
|
|
|
|
// mute all sounds
|
|
_pSound->Mute();
|
|
|
|
// cancel all predictions before crossing levels
|
|
_pNetwork->ga_World.DeletePredictors();
|
|
|
|
// find all entities that are to cross to next level
|
|
CEntitySelection senToCross;
|
|
{FOREACHINDYNAMICCONTAINER(ga_World.wo_cenEntities, CEntity, iten) {
|
|
if (iten->en_ulFlags&ENF_CROSSESLEVELS) {
|
|
senToCross.Select(*iten);
|
|
}
|
|
}}
|
|
|
|
// copy them to a temporary world
|
|
CWorld wldTemp;
|
|
CEntitySelection senInTemp;
|
|
wldTemp.CopyEntities(ga_World, senToCross,
|
|
senInTemp, CPlacement3D(FLOAT3D(0,0,0), ANGLE3D(0,0,0)));
|
|
|
|
// remember characters for all player targets and disable them
|
|
CPlayerCharacter apc[NET_MAXGAMEPLAYERS];
|
|
BOOL abWasActive[NET_MAXGAMEPLAYERS];
|
|
CPlayerAction apaActions[NET_MAXGAMEPLAYERS][2];
|
|
{for(INDEX i=0; i<NET_MAXGAMEPLAYERS; i++) {
|
|
CPlayerTarget &plt = ga_sesSessionState.ses_apltPlayers[i];
|
|
abWasActive[i] = plt.IsActive();
|
|
if (plt.IsActive()) {
|
|
apc[i] = plt.plt_penPlayerEntity->en_pcCharacter;
|
|
apaActions[i][0] = plt.plt_paLastAction;
|
|
apaActions[i][1] = plt.plt_paPreLastAction;
|
|
plt.plt_penPlayerEntity = NULL;
|
|
plt.Deactivate();
|
|
}
|
|
}}
|
|
|
|
// destroy all entities that will cross level
|
|
ga_World.DestroyEntities(senToCross);
|
|
|
|
// if should remember old levels
|
|
if (ga_bNextRemember) {
|
|
// remember current level
|
|
ga_sesSessionState.RememberCurrentLevel(ga_fnmWorld);
|
|
}
|
|
|
|
CGatherCRC gc;
|
|
|
|
// if starting in network
|
|
if (_cmiComm.IsNetworkEnabled()) {
|
|
// start gathering CRCs
|
|
InitCRCGather();
|
|
|
|
// make default state data for creating deltas
|
|
MakeDefaultState(ga_fnmNextLevel, ga_sesSessionState.ses_ulSpawnFlags, ga_aubProperties);
|
|
}
|
|
|
|
// if the new level is not remembered
|
|
if (ga_sesSessionState.FindRememberedLevel(ga_fnmNextLevel)==NULL) {
|
|
// remember original world filename
|
|
CTFileName fnmOldWorld = ga_fnmWorld;
|
|
|
|
// try to
|
|
try {
|
|
// load the new world
|
|
_pTimer->SetCurrentTick(0.0f); // must have timer at 0 while loading
|
|
ga_World.Load_t(ga_fnmNextLevel);
|
|
// delete all entities that don't fit given spawn flags
|
|
ga_World.FilterEntitiesBySpawnFlags(ga_sesSessionState.ses_ulSpawnFlags);
|
|
// if failed
|
|
} catch(char *strError) {
|
|
// report error
|
|
CPrintF(TRANSV("Cannot change level:\n%s"), strError);
|
|
// try to
|
|
try {
|
|
// load the old world
|
|
ga_fnmNextLevel = fnmOldWorld;
|
|
ga_World.Load_t(ga_fnmNextLevel);
|
|
// delete all entities that don't fit given spawn flags
|
|
ga_World.FilterEntitiesBySpawnFlags(ga_sesSessionState.ses_ulSpawnFlags);
|
|
// if that fails
|
|
} catch (char *strError2) {
|
|
// fatal error
|
|
FatalError(
|
|
TRANS("Cannot change level because:\n%s\n"
|
|
"and cannot go back to original one because:\n%s"), strError, strError2);
|
|
return;
|
|
}
|
|
}
|
|
// remember the world filename
|
|
ga_fnmWorld = ga_fnmNextLevel;
|
|
// remember the world pointer
|
|
_pShell->SetCurrentWorld(&ga_World);
|
|
// if there is remembered level
|
|
} else {
|
|
// restore it
|
|
ga_sesSessionState.RestoreOldLevel(ga_fnmNextLevel);
|
|
}
|
|
|
|
// set overdue timers in just loaded world to be due in current time
|
|
ga_World.AdjustLateTimers(ga_sesSessionState.ses_tmLastProcessedTick);
|
|
|
|
// copy entities from temporary world into new one
|
|
CEntitySelection senCrossed;
|
|
ga_World.CopyEntities(wldTemp, senInTemp,
|
|
senCrossed, CPlacement3D(FLOAT3D(0,0,0), ANGLE3D(0,0,0)));
|
|
|
|
// restore pointers to entities for all active player targets
|
|
{for(INDEX i=0; i<NET_MAXGAMEPLAYERS; i++) {
|
|
CPlayerTarget &plt = ga_sesSessionState.ses_apltPlayers[i];
|
|
if (abWasActive[i]) {
|
|
plt.Activate();
|
|
plt.plt_paLastAction = apaActions[i][0];
|
|
plt.plt_paPreLastAction = apaActions[i][1];
|
|
plt.AttachEntity(ga_World.FindEntityWithCharacter(apc[i]));
|
|
}
|
|
}}
|
|
|
|
_bReinitEntitiesWhileCopying = TRUE;
|
|
|
|
// if should not remember old levels
|
|
if (!ga_bNextRemember) {
|
|
// clear them all
|
|
ga_sesSessionState.ForgetOldLevels();
|
|
}
|
|
|
|
// if not server
|
|
if (!IsServer()) {
|
|
// start waiting for server
|
|
ga_sesSessionState.ses_bWaitingForServer = TRUE;
|
|
// if server
|
|
} else {
|
|
// flush sync check buffer
|
|
ga_srvServer.srv_ascChecks.Clear();
|
|
|
|
// for each client
|
|
{for( INDEX iClient=0; iClient<NET_MAXGAMECOMPUTERS; iClient++) {
|
|
CSessionSocket &sso = ga_srvServer.srv_assoSessions[iClient];
|
|
// reset message timer
|
|
sso.sso_tvMessageReceived = (__int64) -1;
|
|
// reset sync timer
|
|
sso.sso_tmLastSyncReceived = -1.0f;
|
|
}}
|
|
// for each player
|
|
{for( INDEX iPlayer=0; iPlayer<NET_MAXGAMEPLAYERS; iPlayer++) {
|
|
CPlayerBuffer &plb = _pNetwork->ga_srvServer.srv_aplbPlayers[iPlayer];
|
|
if (plb.plb_Active) {
|
|
// add one dummy action
|
|
CPlayerAction pa;
|
|
pa.Clear();
|
|
pa.pa_aRotation = plb.plb_paLastAction.pa_aRotation;
|
|
pa.pa_aViewRotation = plb.plb_paLastAction.pa_aViewRotation;
|
|
plb.plb_abReceived.AddAction(pa);
|
|
}
|
|
}}
|
|
}
|
|
ga_sesSessionState.ses_iLevel+=1;
|
|
|
|
// flush stale caches
|
|
FreeUnusedStock();
|
|
// mark that pretouching is required
|
|
_bNeedPretouch = TRUE;
|
|
|
|
// start timer sync anew
|
|
ga_ctTimersPending = 0;
|
|
FinishCRCGather();
|
|
}
|
|
|
|
/* Start recording a demo. */
|
|
void CNetworkLibrary::StartDemoRec_t(const CTFileName &fnDemo) // throw char *
|
|
{
|
|
// synchronize access to network
|
|
CTSingleLock slNetwork(&ga_csNetwork, TRUE);
|
|
|
|
// if already recording
|
|
if (ga_bDemoRec) {
|
|
// error
|
|
throw TRANS("Already recording a demo!");
|
|
}
|
|
|
|
// create the file
|
|
ga_strmDemoRec.Create_t(fnDemo);
|
|
|
|
// write initial info to stream
|
|
ga_strmDemoRec.WriteID_t("DEMO");
|
|
ga_strmDemoRec.WriteID_t("MVER");
|
|
ga_strmDemoRec<<ULONG(_SE_BUILD_MINOR);
|
|
ga_sesSessionState.Write_t(&ga_strmDemoRec);
|
|
|
|
// remember that recording demo
|
|
ga_bDemoRec = TRUE;
|
|
}
|
|
|
|
/* Stop recording a demo. */
|
|
void CNetworkLibrary::StopDemoRec(void)
|
|
{
|
|
// synchronize access to network
|
|
CTSingleLock slNetwork(&ga_csNetwork, TRUE);
|
|
|
|
// if not recording
|
|
if (!ga_bDemoRec) {
|
|
// do nothing
|
|
return;
|
|
}
|
|
// write terminal info to the stream
|
|
ga_strmDemoRec.WriteID_t("DEND"); // game end
|
|
// close the file
|
|
ga_strmDemoRec.Close();
|
|
// remember that not recording demo
|
|
ga_bDemoRec = FALSE;
|
|
}
|
|
|
|
// split the rcon response string into lines and send one by one to the client
|
|
static void SendAdminResponse(ULONG ulAdr, UWORD uwPort, ULONG ulCode, const CTString &strResponse)
|
|
{
|
|
CTString str = strResponse;
|
|
INDEX iLineCt = 0;
|
|
|
|
while (str!="") {
|
|
CTString strLine = str;
|
|
strLine.OnlyFirstLine();
|
|
str.RemovePrefix(strLine);
|
|
str.DeleteChar(0);
|
|
if (strLine.Length()>0) {
|
|
CNetworkMessage nm(MSG_EXTRA);
|
|
nm<<CTString(0, "log %u %d %s\n", ulCode, iLineCt++, (const char *) strLine);
|
|
_pNetwork->SendBroadcast(nm, ulAdr, uwPort);
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Main loop.
|
|
*/
|
|
void CNetworkLibrary::MainLoop(void)
|
|
{
|
|
// synchronize access to network
|
|
CTSingleLock slNetwork(&ga_csNetwork, TRUE);
|
|
|
|
// update network state variable (to control usage of some cvars that cannot be altered in mulit-player mode)
|
|
_bMultiPlayer = (_pNetwork->ga_sesSessionState.GetPlayersCount() > 1);
|
|
|
|
// if should change world
|
|
if (_lphCurrent==LCP_SIGNALLED) {
|
|
// really do the level change here
|
|
ChangeLevel_internal();
|
|
_lphCurrent=LCP_CHANGED;
|
|
}
|
|
|
|
if (_bStartDemoRecordingNextTime) {
|
|
_bStartDemoRecordingNextTime = 0.0f;
|
|
if (!ga_bDemoRec) {
|
|
try {
|
|
CTString strName;
|
|
strName.PrintF("Temp\\Recorded%02d.dem", (INDEX)dem_iRecordedNumber);
|
|
StartDemoRec_t(strName);
|
|
dem_iRecordedNumber+=1;
|
|
} catch(char *strError) {
|
|
CPrintF(TRANSV("Demo recording error: %s\n"), strError);
|
|
}
|
|
}
|
|
}
|
|
if (_bStopDemoRecordingNextTime) {
|
|
_bStopDemoRecordingNextTime = 0.0f;
|
|
if (ga_bDemoRec) {
|
|
StopDemoRec();
|
|
}
|
|
}
|
|
|
|
_sfStats.StartTimer(CStatForm::STI_MAINLOOP);
|
|
_pfNetworkProfile.StartTimer(CNetworkProfile::PTI_MAINLOOP);
|
|
|
|
// handle messages for session state
|
|
if (!ga_bDemoPlay) {
|
|
if (_cmiComm.Client_Update() == FALSE) {
|
|
ga_sesSessionState.Stop();
|
|
return;
|
|
}
|
|
ga_sesSessionState.SessionStateLoop();
|
|
if (_cmiComm.Client_Update() == FALSE) {
|
|
ga_sesSessionState.Stop();
|
|
return;
|
|
}
|
|
}
|
|
// if this is server computer
|
|
if (ga_IsServer) {
|
|
// handle server messages
|
|
_cmiComm.Server_Update();
|
|
}
|
|
|
|
// let server process game stream
|
|
TIME tmBefore = _pTimer->GetRealTimeTick();
|
|
_pTimer->SetLerp(0.0f);
|
|
|
|
|
|
/*
|
|
// automatically adjust network settings
|
|
if (cli_bAutoAdjustSettings) {
|
|
AutoAdjustSettings();
|
|
}
|
|
*/
|
|
|
|
// determine whether to use prediction
|
|
BOOL bUsePrediction = cli_bPrediction && (cli_bPredictIfServer || !IsServer());
|
|
_bPredictionActive = bUsePrediction; // memeber this for other misc code
|
|
|
|
// mark all predictable entities that will be predicted using user-set criterions
|
|
if (bUsePrediction) {
|
|
ga_World.MarkForPrediction();
|
|
}
|
|
// process the game stream coming from the server
|
|
ga_sesSessionState.ProcessGameStream();
|
|
// flush actions that don't need to be predicted any more
|
|
ga_sesSessionState.FlushProcessedPredictions();
|
|
// process additional prediction steps
|
|
if (bUsePrediction) {
|
|
// mark all new predictable entities that might have been spawned
|
|
ga_World.UnmarkForPrediction();
|
|
ga_World.MarkForPrediction();
|
|
ga_sesSessionState.ProcessPrediction();
|
|
// unmark all predictable entities marked for prediction
|
|
ga_World.UnmarkForPrediction();
|
|
}
|
|
|
|
ga_sesSessionState.ses_tmLastUpdated = _pTimer->GetRealTimeTick();
|
|
|
|
TIME tmAfter = _pTimer->GetRealTimeTick();
|
|
ga_sesSessionState.ses_bKeepingUpWithTime = (tmAfter-tmBefore)<=_pTimer->TickQuantum*2.01f;
|
|
|
|
CTimerValue tvNow = _pTimer->GetHighPrecisionTimer();
|
|
// set the lerping factor for current frame
|
|
if (!ga_bDemoPlay) {
|
|
ga_sesSessionState.SetLerpFactor(tvNow);
|
|
} else {
|
|
ga_sesSessionState.SetLerpFactor(CTimerValue(ga_fDemoTimer));
|
|
}
|
|
|
|
// if playing a demo
|
|
if (ga_bDemoPlay) {
|
|
// if synchronizing by real time
|
|
if (ga_fDemoSyncRate==DEMOSYNC_REALTIME) {
|
|
// if server is keeping up
|
|
if (ga_sesSessionState.ses_bKeepingUpWithTime) {
|
|
// add passed time with slow/fast factor
|
|
ga_fDemoTimer += FLOAT((tvNow-ga_tvDemoTimerLastTime).GetSeconds())
|
|
*ga_fDemoRealTimeFactor*ga_sesSessionState.ses_fRealTimeFactor;
|
|
}
|
|
// if synchronizing is stopped
|
|
} else if (ga_fDemoSyncRate==DEMOSYNC_STOP) {
|
|
// don't step
|
|
NOTHING;
|
|
// if synchronizing by given steps
|
|
} else {
|
|
// just add the step
|
|
ga_fDemoTimer += 1.0f/ga_fDemoSyncRate;
|
|
}
|
|
}
|
|
// remember the demo timer
|
|
ga_tvDemoTimerLastTime = tvNow;
|
|
|
|
// if network
|
|
if (_cmiComm.IsNetworkEnabled()) {
|
|
|
|
// do services for gameagent querying
|
|
GameAgent_ServerUpdate();
|
|
|
|
// _cmiComm.Broadcast_Update();
|
|
|
|
// repeat
|
|
FOREVER {
|
|
CNetworkMessage nmReceived;
|
|
|
|
// _cmiComm.Broadcast_Update();
|
|
ULONG ulFrom;
|
|
UWORD uwPort;
|
|
BOOL bHasMsg = ReceiveBroadcast(nmReceived, ulFrom, uwPort);
|
|
// if there are no more messages
|
|
if (!bHasMsg) {
|
|
// finish
|
|
break;
|
|
}
|
|
|
|
// if this message is not valid rcon message
|
|
if (nmReceived.GetType()!=MSG_EXTRA) {
|
|
// skip it
|
|
continue;
|
|
}
|
|
// get the string from the message
|
|
CTString strMsg;
|
|
nmReceived>>strMsg;
|
|
|
|
// if this is server
|
|
if (IsServer()) {
|
|
// accept requests
|
|
if (!strMsg.RemovePrefix("rcmd ")) {
|
|
continue;
|
|
}
|
|
ULONG ulCode;
|
|
char strPass[80];
|
|
char strCmd[256];
|
|
strMsg.ScanF("%u \"%80[^\"]\"%256[^\n]", &ulCode, strPass, strCmd);
|
|
CTString strAdr = AddressToString(ulFrom);
|
|
|
|
if (net_strAdminPassword=="" || net_strAdminPassword!=strPass) {
|
|
CPrintF(TRANSV("Server: Client '%s', Wrong password for remote administration.\n"), (const char*)strAdr);
|
|
continue;
|
|
}
|
|
|
|
CPrintF(TRANSV("Server: Client '%s', Admin cmd: %s\n"), (const char*)strAdr, strCmd);
|
|
|
|
con_bCapture = TRUE;
|
|
con_strCapture = "";
|
|
_pShell->Execute(CTString(strCmd)+";");
|
|
|
|
CTString strResponse = CTString(">")+strCmd+"\n"+con_strCapture;
|
|
SendAdminResponse(ulFrom, uwPort, ulCode, strResponse);
|
|
con_bCapture = FALSE;
|
|
con_strCapture = "";
|
|
}
|
|
}
|
|
}
|
|
|
|
_pfNetworkProfile.StopTimer(CNetworkProfile::PTI_MAINLOOP);
|
|
_sfStats.StopTimer(CStatForm::STI_MAINLOOP);
|
|
}
|
|
|
|
// make actions packet for local players and send to server
|
|
void CNetworkLibrary::SendActionsToServer(void)
|
|
{
|
|
// make the packet
|
|
CNetworkMessage nmAction(MSG_ACTION);
|
|
|
|
// for all local players on this machine
|
|
for(INDEX ipls=0; ipls<ga_aplsPlayers.Count(); ipls++) {
|
|
CPlayerSource &pls = ga_aplsPlayers[ipls];
|
|
// create action packet if the player exists
|
|
pls.WriteActionPacket(nmAction);
|
|
}
|
|
// send the packet
|
|
SendToServer(nmAction);
|
|
}
|
|
|
|
/*
|
|
* Client loop.
|
|
*/
|
|
void CNetworkLibrary::TimerLoop(void)
|
|
{
|
|
ASSERT(this!=NULL);
|
|
if (_bTempNetwork) {
|
|
return; // this can happen during NET_MakeDefaultState_t()!
|
|
}
|
|
_pfNetworkProfile.StartTimer(CNetworkProfile::PTI_TIMERLOOP);
|
|
|
|
// count number of timer interrupts that happened
|
|
if (ga_ctTimersPending>=0) {
|
|
ga_ctTimersPending++;
|
|
}
|
|
|
|
// if can synchronize access to network
|
|
CTSingleLock slNetwork(&ga_csNetwork, FALSE);
|
|
// initially, no timer functions needed
|
|
INDEX ct = 0;
|
|
// if timer exactness level is full
|
|
if (net_iExactTimer==2) {
|
|
// lock network mutex
|
|
slNetwork.Lock();
|
|
// execute exactly one
|
|
ct = 1;
|
|
// if timer exactness level is partial
|
|
} else if (net_iExactTimer==1) {
|
|
// if network mutex can be locked
|
|
if (slNetwork.TryToLock()) {
|
|
// execute all pending
|
|
ct = ga_ctTimersPending;
|
|
}
|
|
// if timer exactness level is low
|
|
} else if (net_iExactTimer==0) {
|
|
// if network mutex can be locked
|
|
if (slNetwork.TryToLock()) {
|
|
// execute exactly one
|
|
ct = 1;
|
|
}
|
|
}
|
|
// for each pending interrupt
|
|
while(ct) {
|
|
ct--;
|
|
ga_ctTimersPending--;
|
|
// if not disconnected
|
|
// if (!IsDisconnected()) {
|
|
if (_cmiComm.cci_bClientInitialized) {
|
|
// make actions packet for all local players and send to server
|
|
SendActionsToServer();
|
|
_cmiComm.Client_Update();
|
|
}
|
|
|
|
// if this is server computer
|
|
if (ga_IsServer) {
|
|
// handle server messages
|
|
_cmiComm.Server_Update();
|
|
ga_srvServer.ServerLoop();
|
|
_cmiComm.Server_Update();
|
|
}
|
|
}
|
|
|
|
_pfNetworkProfile.StopTimer(CNetworkProfile::PTI_TIMERLOOP);
|
|
}
|
|
|
|
/* Get player entity for a given local player. */
|
|
CEntity *CNetworkLibrary::GetLocalPlayerEntity(CPlayerSource *ppls)
|
|
{
|
|
// synchronize access to network
|
|
CTSingleLock slNetwork(&ga_csNetwork, TRUE);
|
|
|
|
// get the index of the player target in game state
|
|
INDEX iPlayerTarget = ppls->pls_Index;
|
|
// if player is not added
|
|
if (iPlayerTarget<0) {
|
|
// no entity
|
|
return NULL;
|
|
// if player is added
|
|
} else {
|
|
// get the entity from player target
|
|
CPlayerTarget &plt = ga_sesSessionState.ses_apltPlayers[iPlayerTarget];
|
|
CPlayerEntity *pen = plt.plt_penPlayerEntity;
|
|
return pen;
|
|
}
|
|
}
|
|
|
|
/* Get player entity for a given player by name. */
|
|
CEntity *CNetworkLibrary::GetPlayerEntityByName(const CTString &strName)
|
|
{
|
|
// synchronize access to network
|
|
CTSingleLock slNetwork(&ga_csNetwork, TRUE);
|
|
|
|
// for each player in game
|
|
CStaticArray<CPlayerTarget> &aplt = ga_sesSessionState.ses_apltPlayers;
|
|
for(INDEX iplt = 0; iplt<aplt.Count(); iplt++) {
|
|
// if it is active and has that name
|
|
if (aplt[iplt].IsActive()
|
|
&&aplt[iplt].plt_penPlayerEntity->en_pcCharacter.GetName()==strName) {
|
|
// return it
|
|
return aplt[iplt].plt_penPlayerEntity;
|
|
}
|
|
}
|
|
// else not found
|
|
return NULL;
|
|
}
|
|
|
|
/* Get number of entities with given name. */
|
|
INDEX CNetworkLibrary::GetNumberOfEntitiesWithName(const CTString &strName)
|
|
{
|
|
INDEX ctEntities = 0;
|
|
{FOREACHINDYNAMICCONTAINER(ga_World.wo_cenEntities, CEntity, iten) {
|
|
if (iten->GetName()==strName) {
|
|
ctEntities++;
|
|
}
|
|
}}
|
|
return ctEntities;
|
|
}
|
|
|
|
/* Get n-th entity with given name. */
|
|
CEntity *CNetworkLibrary::GetEntityWithName(const CTString &strName, INDEX iEntityWithThatName)
|
|
{
|
|
INDEX ctEntities = 0;
|
|
CEntity *pen = NULL;
|
|
{FOREACHINDYNAMICCONTAINER(ga_World.wo_cenEntities, CEntity, iten) {
|
|
if (iten->GetName()==strName) {
|
|
pen = iten;
|
|
if (ctEntities==iEntityWithThatName) {
|
|
break;
|
|
}
|
|
ctEntities++;
|
|
}
|
|
}}
|
|
return pen;
|
|
}
|
|
/* Test if a given player is local to this computer. */
|
|
BOOL CNetworkLibrary::IsPlayerLocal(CEntity *pen)
|
|
{
|
|
return GetPlayerSource(pen)!=NULL;
|
|
}
|
|
// get player source for a given player if it is local to this computer
|
|
CPlayerSource *CNetworkLibrary::GetPlayerSource(CEntity *pen)
|
|
{
|
|
// synchronize access to network
|
|
CTSingleLock slNetwork(&ga_csNetwork, TRUE);
|
|
|
|
// for all local player on this machine
|
|
{FOREACHINSTATICARRAY(ga_aplsPlayers, CPlayerSource, itpls) {
|
|
// get the index of the player target in game state
|
|
INDEX iPlayerTarget = itpls->pls_Index;
|
|
// if player is added
|
|
if (iPlayerTarget>=0) {
|
|
// get the player target
|
|
CPlayerTarget &plt = ga_sesSessionState.ses_apltPlayers[iPlayerTarget];
|
|
// if it is that one
|
|
if (plt.plt_penPlayerEntity == pen) {
|
|
// return it
|
|
return itpls;
|
|
}
|
|
}
|
|
}}
|
|
|
|
// if not found, it is not local
|
|
return NULL;
|
|
}
|
|
|
|
// get game time in currently running game
|
|
TIME CNetworkLibrary::GetGameTime(void)
|
|
{
|
|
return ga_sesSessionState.ses_tmLastProcessedTick;
|
|
}
|
|
|
|
/*
|
|
* Add a new client to game.
|
|
*/
|
|
CPlayerSource *CNetworkLibrary::AddPlayer_t(CPlayerCharacter &pcCharacter) // throw char *
|
|
{
|
|
// synchronize access to network
|
|
CTSingleLock slNetwork(&ga_csNetwork, TRUE);
|
|
CPrintF( TRANS("Adding player: '%s'\n"), (const char *) pcCharacter.GetNameForPrinting());
|
|
|
|
// for all local clients on this machine
|
|
FOREACHINSTATICARRAY(ga_aplsPlayers, CPlayerSource, itcls) {
|
|
// if client is not active
|
|
if (!itcls->IsActive()) {
|
|
// activate it
|
|
itcls->Start_t(pcCharacter);
|
|
CPrintF( TRANS(" done.\n"));
|
|
return &itcls.Current();
|
|
}
|
|
}
|
|
// number of local clients is limited with NET_MAXLOCALCLIENTS
|
|
ASSERTALWAYS("Adding too much local clients!");
|
|
throw TRANS("Cannot add more local clients");
|
|
return NULL;
|
|
}
|
|
|
|
/* Get session properties for current game. */
|
|
void *CNetworkLibrary::GetSessionProperties(void)
|
|
{
|
|
// synchronize access to network
|
|
CTSingleLock slNetwork(&ga_csNetwork, TRUE);
|
|
|
|
return ga_aubProperties;
|
|
}
|
|
|
|
/* Send chat message from some players to some other players. */
|
|
void CNetworkLibrary::SendChat(ULONG ulFrom, ULONG ulTo, const CTString &strMessage)
|
|
{
|
|
// if the string is too long and we're not server
|
|
if (strlen(strMessage)>256 && !_pNetwork->IsServer()) {
|
|
// refuse it
|
|
return;
|
|
}
|
|
|
|
// just make the message and send it to server
|
|
CNetworkMessage nm(MSG_CHAT_IN);
|
|
nm<<ulFrom;
|
|
nm<<ulTo;
|
|
nm<<strMessage;
|
|
SendToServer(nm);
|
|
}
|
|
|
|
// save current version of engine
|
|
void CNetworkLibrary::WriteVersion_t(CTStream &strm)
|
|
{
|
|
strm.WriteID_t("BUIV"); // build version
|
|
strm<<INDEX(_SE_BUILD_MAJOR);
|
|
}
|
|
// load version of engine saved in file and check against current
|
|
void CNetworkLibrary::CheckVersion_t(CTStream &strm, BOOL bAllowReinit, BOOL &bNeedsReinit)
|
|
{
|
|
// if not saved
|
|
if (strm.PeekID_t()!=CChunkID("BUIV")) { // build version
|
|
// behave as if everything is ok (for old versions)
|
|
bNeedsReinit = FALSE;
|
|
return;
|
|
}
|
|
strm.ExpectID_t("BUIV"); // build version
|
|
// read the saved one
|
|
INDEX iSaved;
|
|
strm>>iSaved;
|
|
// get current one
|
|
INDEX iCurrent = _SE_BUILD_MAJOR;
|
|
// if current version is an internal build
|
|
if (iCurrent==0) {
|
|
// it is never forced to reinit
|
|
bNeedsReinit = FALSE;
|
|
return;
|
|
}
|
|
|
|
// if current version is older than the saved one
|
|
if (iCurrent<iSaved) {
|
|
// it cannot be reinitialized
|
|
ThrowF_t(TRANS("File '%s' was saved by a newer version of engine, it cannot be loaded"),
|
|
(const char *) strm.GetDescription());
|
|
return;
|
|
}
|
|
|
|
// if current version is same as the saved one
|
|
if (iCurrent==iSaved) {
|
|
// all ok
|
|
bNeedsReinit = FALSE;
|
|
return;
|
|
}
|
|
|
|
// if current version is newer than the saved one
|
|
if (iCurrent>iSaved) {
|
|
// it should be reinitialized
|
|
bNeedsReinit = TRUE;
|
|
|
|
// if it may not be reinitialized
|
|
if (!bAllowReinit) {
|
|
ThrowF_t(TRANS("File '%s' was saved by an older version of engine, it cannot be loaded"),
|
|
(const char *) strm.GetDescription());
|
|
}
|
|
return;
|
|
}
|
|
// this should not happen
|
|
ASSERT(FALSE);
|
|
bNeedsReinit = FALSE;
|
|
return;
|
|
}
|
|
|
|
// add a value to the netgraph
|
|
void CNetworkLibrary::AddNetGraphValue(enum NetGraphEntryType nget, FLOAT fLatency)
|
|
{
|
|
net_iGraphBuffer = Clamp(net_iGraphBuffer, INDEX(20), INDEX(1000));
|
|
|
|
// make sure the netgraph has wanted number of values
|
|
if (ga_angeNetGraph.Count()!=net_iGraphBuffer) {
|
|
ga_angeNetGraph.Clear();
|
|
ga_angeNetGraph.New(net_iGraphBuffer);
|
|
memset(&ga_angeNetGraph[0], 0, ga_angeNetGraph.Count()*sizeof(ga_angeNetGraph[0]));
|
|
}
|
|
|
|
// scroll the values in the netgraph by one value
|
|
memmove(&ga_angeNetGraph[1], &ga_angeNetGraph[0], (ga_angeNetGraph.Count()-1)*sizeof(ga_angeNetGraph[0]));
|
|
|
|
// add the new value
|
|
ga_angeNetGraph[0].nge_ngetType = nget;
|
|
ga_angeNetGraph[0].nge_fLatency = fLatency;
|
|
}
|
|
|
|
// make default state for a network game
|
|
extern void NET_MakeDefaultState_t(
|
|
const CTFileName &fnmWorld, ULONG ulSpawnFlags, void *pvSessionProperties,
|
|
CTStream &strmState) // throw char *
|
|
{
|
|
// mute all sounds
|
|
_pSound->Mute();
|
|
|
|
// first off - mark that we are in the special state
|
|
_bTempNetwork = TRUE;
|
|
|
|
// make sure that current network object gets locked
|
|
CTSingleLock slNetwork(&_pNetwork->ga_csNetwork, TRUE);
|
|
|
|
// remember original network pointer and clear it
|
|
CNetworkLibrary *pnlOld = _pNetwork;
|
|
_pNetwork = NULL;
|
|
|
|
// try to
|
|
try {
|
|
// create new network object
|
|
CNetworkLibrary *pNewNet = new CNetworkLibrary;
|
|
// it must have new mutex index since both will be locked
|
|
pNewNet->ga_csNetwork.cs_iIndex = 2001;
|
|
|
|
// lock the new network access
|
|
CTSingleLock slNetwork(&pNewNet->ga_csNetwork, TRUE);
|
|
pNewNet->ga_ctTimersPending = -1; // disable timer pending
|
|
// only after locking it, we may allow the new pointer to be remembered
|
|
// otherwise, the other thread can jump in between
|
|
_pNetwork = pNewNet;
|
|
|
|
// remember settings
|
|
_pNetwork->ga_sesSessionState.ses_ulSpawnFlags = ulSpawnFlags;
|
|
_pNetwork->ga_sesSessionState.ses_tmSyncCheckFrequency = 10.0f;
|
|
_pNetwork->ga_sesSessionState.ses_iExtensiveSyncCheck = 0;
|
|
memcpy(_pNetwork->ga_aubProperties, pvSessionProperties, NET_MAXSESSIONPROPERTIES);
|
|
_pNetwork->ga_fnmWorld = fnmWorld;
|
|
_pNetwork->ga_fnmNextLevel = CTString("");
|
|
|
|
try {
|
|
// load the world
|
|
_pTimer->SetCurrentTick(0.0f); // must have timer at 0 while loading
|
|
_pNetwork->ga_World.Load_t(fnmWorld);
|
|
// delete all entities that don't fit given spawn flags
|
|
_pNetwork->ga_World.FilterEntitiesBySpawnFlags(_pNetwork->ga_sesSessionState.ses_ulSpawnFlags);
|
|
} catch(char *) {
|
|
throw;
|
|
}
|
|
// remember the world filename
|
|
_pNetwork->ga_fnmWorld = fnmWorld;
|
|
_pNetwork->ga_fnmNextLevel = CTString("");
|
|
// remember the world pointer
|
|
_pShell->SetCurrentWorld(&_pNetwork->ga_World);
|
|
|
|
// reset random number generator
|
|
_pNetwork->ga_sesSessionState.ResetRND();
|
|
// flush stale caches
|
|
FreeUnusedStock();
|
|
|
|
// warmup the world
|
|
_pNetwork->ga_sesSessionState.WarmUpWorld();
|
|
|
|
// save the session state to the stream
|
|
_pNetwork->ga_sesSessionState.Write_t(&strmState);
|
|
|
|
// if any error
|
|
} catch (char *) {
|
|
// restore original network pointer
|
|
CNetworkLibrary *pnlTemp = _pNetwork;
|
|
_pNetwork = pnlOld;
|
|
if (pnlTemp!=NULL) {
|
|
delete pnlTemp;
|
|
}
|
|
_bTempNetwork = FALSE;
|
|
// fail
|
|
throw;
|
|
}
|
|
|
|
// restore original network pointer
|
|
CNetworkLibrary *pnlTemp = _pNetwork;
|
|
_pNetwork = pnlOld;
|
|
delete pnlTemp;
|
|
_bTempNetwork = FALSE;
|
|
}
|
|
|
|
// handle broadcast messages (server enumeration)
|
|
void CNetworkLibrary::GameInactive(void)
|
|
{
|
|
GameAgent_EnumUpdate();
|
|
|
|
// if no network
|
|
if (!_cmiComm.IsNetworkEnabled()) {
|
|
// do not handle
|
|
return;
|
|
}
|
|
|
|
// _cmiComm.Broadcast_Update();
|
|
|
|
// repeat
|
|
FOREVER {
|
|
CNetworkMessage nmReceived;
|
|
|
|
// _cmiComm.Broadcast_Update();
|
|
ULONG ulFrom;
|
|
UWORD uwPort;
|
|
BOOL bHasMsg = ReceiveBroadcast(nmReceived, ulFrom, uwPort);
|
|
// if there are no more messages
|
|
if (!bHasMsg) {
|
|
// finish
|
|
break;
|
|
}
|
|
|
|
/* This is handled by GameAgent.
|
|
|
|
// if requesting enumeration and this is server and enumeration is allowed
|
|
if (nmReceived.GetType()==MSG_REQ_ENUMSERVERS
|
|
&& IsServer()
|
|
&& (ser_bEnumeration && ga_sesSessionState.ses_ctMaxPlayers>1)) {
|
|
// create response
|
|
CNetworkMessage nmEnum(MSG_SERVERINFO);
|
|
nmEnum<<ga_strSessionName;
|
|
nmEnum<<ga_World.wo_strName;
|
|
nmEnum<<ga_srvServer.GetPlayersCount();
|
|
nmEnum<<ga_sesSessionState.ses_ctMaxPlayers;
|
|
|
|
// send it
|
|
SendBroadcast(nmEnum, ulFrom, uwPort);
|
|
// if receiving enumeration
|
|
} else if (nmReceived.GetType()==MSG_SERVERINFO) {
|
|
// create a new session
|
|
CNetworkSession &ns = *new CNetworkSession;
|
|
ga_lhEnumeratedSessions.AddTail(ns.ns_lnNode);
|
|
// read it
|
|
nmReceived>>ns.ns_strSession;
|
|
nmReceived>>ns.ns_strWorld;
|
|
nmReceived>>ns.ns_ctPlayers;
|
|
nmReceived>>ns.ns_ctMaxPlayers;
|
|
ns.ns_strAddress = AddressToString(ulFrom);
|
|
}*/
|
|
}
|
|
}
|
|
|
|
void CNetworkLibrary::InitCRCGather(void)
|
|
{
|
|
CRCT_ResetActiveList();
|
|
CRCT_bGatherCRCs = TRUE;
|
|
CRCT_AddFile_t(CTString("Classes\\Player.ecl"));
|
|
}
|
|
|
|
// finish gathering of file CRCs to CRC table (call for server only!)
|
|
void CNetworkLibrary::FinishCRCGather(void)
|
|
{
|
|
try {
|
|
// make the list
|
|
CTMemoryStream strmCRC;
|
|
CRCT_MakeFileList_t(strmCRC);
|
|
|
|
// remember it
|
|
strmCRC.SetPos_t(0);
|
|
ga_slCRCList = strmCRC.GetStreamSize();
|
|
ga_pubCRCList = (UBYTE*)AllocMemory(ga_slCRCList);
|
|
strmCRC.Read_t(ga_pubCRCList, ga_slCRCList);
|
|
|
|
// remember its CRC
|
|
strmCRC.SetPos_t(0);
|
|
ga_ulCRC = CRCT_MakeCRCForFiles_t(strmCRC);
|
|
|
|
} catch (char *strError) {
|
|
CPrintF(TRANSV("Warning, cannot get CRCs: %s\n"), strError);
|
|
}
|
|
}
|
|
|
|
// make default state data for creating deltas
|
|
void CNetworkLibrary::MakeDefaultState(const CTFileName &fnmWorld,
|
|
ULONG ulSpawnFlags, void *pvSessionProperties)
|
|
{
|
|
// prepare file or memory stream for state
|
|
CTFileStream strmStateFile; CTMemoryStream strmStateMem;
|
|
CTStream *pstrmState;
|
|
extern INDEX net_bDumpConnectionInfo;
|
|
if (net_bDumpConnectionInfo) {
|
|
strmStateFile.Create_t(CTString("Temp\\DefaultState.bin"));
|
|
pstrmState = &strmStateFile;
|
|
} else {
|
|
pstrmState = &strmStateMem;
|
|
}
|
|
// make default state for a network game
|
|
NET_MakeDefaultState_t(fnmWorld, ulSpawnFlags, pvSessionProperties, *pstrmState);
|
|
pstrmState->SetPos_t(0);
|
|
|
|
ga_slDefaultStateSize = pstrmState->GetStreamSize();
|
|
ga_pubDefaultState = (UBYTE*)AllocMemory(ga_slDefaultStateSize);
|
|
pstrmState->Read_t(ga_pubDefaultState, ga_slDefaultStateSize);
|
|
memcpy(ga_aubDefaultProperties, pvSessionProperties, sizeof(ga_aubDefaultProperties));
|
|
}
|