aleajactaest/khanat-code-old
1
0
Fork 0
mirror of https://port.numenaute.org/aleajactaest/khanat-code-old.git synced 2024-11-27 09:16:18 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions
khanat-code-old/code/ryzom/client/src/network_connection.cpp
kaetemi 9c1d333924 More of the VS2015 stuff
2016-01-15 12:29:05 +01:00

3199 lines
87 KiB
C++
Raw Blame History

// Ryzom - MMORPG Framework <http://dev.ryzom.com/projects/ryzom/>
// Copyright (C) 2010 Winch Gate Property Limited
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU Affero General Public License as
// published by the Free Software Foundation, either version 3 of the
// License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
#include "stdpch.h"
#ifdef NL_OS_WINDOWS
#include <process.h>
#endif
#include "network_connection.h"
#include "client_cfg.h"
#include "game_share/action_factory.h"
#include "game_share/action.h"
#include "game_share/action_disconnection.h"
#include "game_share/action_position.h"
#include "game_share/action_sync.h"
#include "game_share/action_association.h"
#include "game_share/action_dummy.h"
#include "game_share/action_login.h"
#include "game_share/action_sint64.h"
#include "game_share/action_target_slot.h"
#include "game_share/action_generic.h"
#include "game_share/action_generic_multi_part.h"
#include "game_share/mode_and_behaviour.h"
#include "game_share/simlag.h"
#include "nel/misc/cdb.h"
#include "nel/misc/cdb_leaf.h"
#include "nel/misc/cdb_branch.h"
#include "cdb_synchronised.h"
#include "nel/misc/variable.h"
#include "nel/misc/algo.h"
#include "nel/3d/u_driver.h"
#include "game_share/system_message.h"
#include "game_share/entity_types.h" // required for ifdef
#include "graph.h"
#include "global.h"
#include "far_tp.h"
#ifdef DISPLAY_ENTITIES
#include "../../../test/network/sb5000/client/graph.h"
#endif
// ***************************************************************************
// Smooth ServerTick setup
// The numner of Smooth Tick per Server Tick
#define SMOOTH_SERVER_TICK_PER_TICK 100
// The possible not corrected error between actual ServerTick and estimated one (NB: equal to packet sent frequency)
#define SMOOTH_SERVER_TICK_WINDOW 100
// The min Difference between the estimated and the actual one. If <=, the estimation is reseted.
#define SMOOTH_SERVER_TICK_DIFF_MIN -1000
// The max Difference between the estimated and the actual one. If >=, clamp
#define SMOOTH_SERVER_TICK_DIFF_MAX 500
// When the estimation is late, the Max Acceleration factor
#define SMOOTH_SERVER_TICK_ACCEL 4.0f
const char * ConnectionStateCStr [9] = { "NotInitialised", "NotConnected", "Authenticate", "Login", "Synchronize", "Connected", "Probe", "Stalled", "Disconnect" };
// ***************************************************************************
using namespace std;
using namespace NLMISC;
using namespace NLNET;
using namespace CLFECOMMON;
#undef MEASURE_RECEIVE_DATES
//#define SHOW_PROPERTIES_RECEIVED
#ifdef MEASURE_RECEIVE_DATES
#include <nel/misc/config_file.h>
#include <nel/misc/displayer.h>
#include <nel/misc/log.h>
#include <nel/misc/path.h>
#include <nel/misc/time_nl.h>
#include <nel/misc/command.h>
// Stat: array of vectors of cycles when a pos is received, indexed by TCLEntityId
struct TRDateState
{
TRDateState( TGameCycle gc, TGameCycle pdit, TTime ct ) : ServerCycle(gc), PredictedInterval(pdit), LocalTime(ct) {}
TGameCycle ServerCycle, PredictedInterval;
TTicks LocalTime;
};
extern CLFECOMMON::TCLEntityId WatchedEntitySlot;
////////////
// GLOBAL //
////////////
typedef vector<TRDateState> TReceiveDateLog;
TReceiveDateLog ReceivePosDateLog [256];
bool LogReceiveEnabled = false;
CConfigFile NCConfigFile;
CFileDisplayer *ReceiveLogDisp;
CLog ReceiveLogger;
/*
* initReceiveLog
*/
void initReceiveLog()
{
try
{
ReceiveLogDisp = new CFileDisplayer( getLogDirectory() + "ReceiveLog.log" );
ReceiveLogger.addDisplayer( ReceiveLogDisp );
//ReceiveLogger.displayNL( "Searching for param LogReceive in the config file..." );
NCConfigFile.load( string( "client.cfg" ) );
int slot = NCConfigFile.getVar( "LogReceive" ).asInt();
if ( slot != 0 )
{
LogReceiveEnabled = true;
ReceiveLogger.displayNL( "LogReceive is on" ); // only when enabled
}
}
catch (const EConfigFile&)
{}
}
/*
* startReceiveLog (the slots logged are all if no selection, or only the selected slots (one at a time)
*/
void startReceiveLog()
{
sint i;
for ( i=0; i!=256; ++i )
{
ReceivePosDateLog[i].clear();
}
LogReceiveEnabled = true;
}
/*
* stopReceiveLog
*/
void stopReceiveLog()
{
LogReceiveEnabled = false;
}
/*
* displayReceiveLog
*/
void displayReceiveLog()
{
if ( ! LogReceiveEnabled )
return;
nlinfo( "Dumping ReceiveLog" );
ReceiveLogger.displayNL( "ReceiveLog (ServerCycle, PredictedInterval, LocalTime(ms)):" );
// Display receive dates for all slots for which vector is not empty
// (allows to trace several selected slots one after one, or all slots at the same time)
sint i;
for ( i=0; i!=256; ++i )
{
if ( ! ReceivePosDateLog[i].empty() )
{
ReceiveLogger.displayRawNL( "Entity %d: %u updates", i, ReceivePosDateLog[i].size() );
TReceiveDateLog::iterator idl;
for ( idl=ReceivePosDateLog[i].begin(); idl!=ReceivePosDateLog[i].end(); ++idl )
{
ReceiveLogger.displayRawNL( "%u\t%u\t%" NL_I64 "u", (*idl).ServerCycle, (*idl).PredictedInterval, (*idl).LocalTime );
}
}
}
ReceiveLogger.displayRawNL( "ReceiveLog completed" );
}
NLMISC_COMMAND( startReceiveLog, "Starts logging the position receives (for all or only the watched entities when selected)", "" )
{
nlinfo( "Starting ReceiveLog" );
startReceiveLog();
return true;
}
NLMISC_COMMAND( stopReceiveLog, "Stops logging the position receives", "" )
{
stopReceiveLog();
return true;
}
NLMISC_COMMAND( displayReceiveLog, "Flush the receive log into ReceiveLog.log", "" )
{
displayReceiveLog();
return true;
}
#endif // MEASURE_RECEIVE_DATES
extern NL3D::UDriver *Driver;
CVariable<bool> CheckXMLSignature("client", "CheckXMLSignature", "enable client to check msg/database.xml signature", true, 0, true);
CSlotGraph *PosUpdateIntervalGraph = NULL;
CSlotGraph *PosUpdatePredictionGraph = NULL;
CGraph MsPerTickGraph ("mspertick (ms)", 10.0f, 570.0f, 400.0f, 100.0f, CRGBA(0,0,128,128), 1000, 400.0f, 2);
CGraph PingGraph ("ping (ms)", 10.0f, 460.0f, 400.0f, 100.0f, CRGBA(128,0,0,128), 100000, 1000.0f, 2);
CGraph PacketLossGraph ("PacketLoss (pc)", 10.0f, 350.0f, 200.0f, 100.0f, CRGBA(0,128,0,128), 100000, 100.0f, 2);
CGraph UploadGraph ("upload (byps)", 10.0f, 240.0f, 200.0f, 100.0f, CRGBA(0,128,128,128), 1000, 3000.0f, 2);
CGraph DownloadGraph ("download (byps)", 10.0f, 130.0f, 200.0f, 100.0f, CRGBA(0,0,128,128), 1000, 3000.0f, 2);
//#define A a() !!!
//#define B b() !!! SO DANGEROUS !!!
//#define Parent parent() !!!
bool CNetworkConnection::_Registered = false;
/*
* Percentile (in fact, quantile) function
* Freely adapted from the Goose Library (http://www.gnu.org/software/goose)
* at http://cvs.gnome.org/lxr/source/goose/src/stats/descriptive.cpp#90
*/
// Normal quantile function (see also percentilRev below)
/*float percentile( const multiset<uint32>& dataset, float p )
{
//nlassert( ! dataset.empty() );
//nlassert( (p >= 0) && (p <= 1) );
uint ds = dataset.size();
if ( ds == 1 )
return (float)(*dataset.begin());
float fpIndex = p * (float)(ds-1);
sint ipIndex = (sint)fpIndex;
multiset<uint32>::iterator it = dataset.begin(), itnext;
for ( sint i=0; i!=ipIndex; ++i, ++it );
itnext = it; ++itnext;
return ((float)(ipIndex+1)-fpIndex)*(float)(*it) + (fpIndex-(float)ipIndex)*(float)(*itnext);
}*/
// Reversed quantile function = percentile(dataset, 1-p) (optimized for p>0.5 i.e. rp<=0.5)
float percentileRev( const multiset<uint32>& dataset, float rp )
{
//nlassert( ! dataset.empty() );
//nlassert( (rp >= 0) && (rp <= 1) );
uint ds = (uint)dataset.size();
if ( ds == 1 )
return (float)(*dataset.begin());
float fpIndex = rp * (float)(ds-1);
sint ipIndex = (sint)fpIndex;
multiset<uint32>::const_reverse_iterator it = dataset.rbegin(), itnext;
for ( sint i=0; i!=ipIndex; ++i, ++it );
itnext = it; ++itnext;
return ((float)(ipIndex+1)-fpIndex)*(float)(*it) + (fpIndex-(float)ipIndex)*(float)(*itnext);
}
//
const uint MAX_POSUPDATETICKQUEUE_SIZE = 25;
const float PREDICTION_REV_PERCENTILE = 0.2f; // (1 - 0.8)
//
bool CNetworkConnection::LoggingMode = false;
/*
* Constructor
*/
#ifdef ENABLE_INCOMING_MSG_RECORDER
CNetworkConnection::CNetworkConnection() : _NextMessageToReplay(true)
#else
CNetworkConnection::CNetworkConnection()
#endif
{
_ConnectionState = NotInitialised;
_ImpulseCallback = NULL;
_ImpulseArg = NULL;
_DataBase = NULL;
reset();
_QuitId = 0;
initTicks();
}
/*
* Destructor
*/
CNetworkConnection::~CNetworkConnection()
{
#ifdef MEASURE_RECEIVE_DATES
delete ReceiveLogDisp;
#endif
if ( _VisualPropertyTreeRoot ) // not allocated in local mode
{
_VisualPropertyTreeRoot->deleteBranches();
delete _VisualPropertyTreeRoot;
_VisualPropertyTreeRoot = NULL;
}
#ifdef ENABLE_INCOMING_MSG_RECORDER
if ( _RecordIncomingMessagesOn )
_RecordedMessagesOut.close();
else if ( _ReplayIncomingMessagesOn )
_RecordedMessagesIn.close();
#endif
}
NLMISC::CHashKeyMD5 getTextMD5(const std::string& filename)
{
CIFile fi;
if (!fi.open(CPath::lookup(filename, false)))
return NLMISC::CHashKeyMD5();
std::vector<uint8> buffer(fi.getFileSize());
fi.serialBuffer(&(buffer[0]), (uint)buffer.size());
std::vector<uint8>::iterator it = buffer.begin();
do
{
while (it != buffer.end() && *it != '\015')
++it;
if (it != buffer.end())
it = buffer.erase(it);
}
while (it != buffer.end());
return NLMISC::getMD5((&buffer[0]), (uint32)buffer.size());
}
/*
* Init
*/
void CNetworkConnection::init(const string &cookie, const string &addr)
{
if (_ConnectionState != NotInitialised &&
_ConnectionState != Disconnect)
{
nlwarning("Unable to init(): connection not properly closed yet.");
return;
}
if (!_Registered)
{
CActionFactory::getInstance ()->registerAction (ACTION_POSITION_CODE, CActionPosition::create);
CActionFactory::getInstance ()->registerAction (ACTION_SYNC_CODE, CActionSync::create);
CActionFactory::getInstance ()->registerAction (ACTION_DISCONNECTION_CODE, CActionDisconnection::create);
CActionFactory::getInstance ()->registerAction (ACTION_ASSOCIATION_CODE, CActionAssociation::create);
CActionFactory::getInstance ()->registerAction (ACTION_DUMMY_CODE, CActionDummy::create);
CActionFactory::getInstance ()->registerAction (ACTION_LOGIN_CODE, CActionLogin::create);
CActionFactory::getInstance ()->registerAction (ACTION_TARGET_SLOT_CODE, CActionTargetSlot::create);
CActionFactory::getInstance ()->registerAction (ACTION_GENERIC_CODE, CActionGeneric::create);
CActionFactory::getInstance ()->registerAction (ACTION_GENERIC_MULTI_PART_CODE, CActionGenericMultiPart::create);
CActionFactory::getInstance ()->registerAction (ACTION_SINT64, CActionSint64::create);
_Registered = true;
}
initCookie(cookie, addr);
#ifdef HALF_FREQUENCY_SENDING_TO_CLIENT
nlinfo( "Half-frequency mode" );
#else
nlinfo( "Full-frequency mode" );
#endif
#ifdef MEASURE_RECEIVE_DATES
initReceiveLog();
#endif
// Register property nbbits
CActionSint64::registerNumericPropertiesRyzom();
// Init visual property tree
_VisualPropertyTreeRoot = new TVPNodeClient();
_VisualPropertyTreeRoot->buildTree();
#ifdef ENABLE_INCOMING_MSG_RECORDER
_RecordIncomingMessagesOn = false;
_ReplayIncomingMessagesOn = false;
_NextClientTickToReplay = 0;
#endif
// If the server run on window, those are the one to test
_AltMsgXmlMD5 = NLMISC::getMD5("msg.xml");
_AltDatabaseXmlMD5 = NLMISC::getMD5("database.xml");
// If the server run on UNIX, those are the one to test
_MsgXmlMD5 = getTextMD5("msg.xml");
_DatabaseXmlMD5 = getTextMD5("database.xml");
}
/*
* Sets the cookie and front-end address, resets the connection state.
*/
void CNetworkConnection::initCookie(const string &cookie, const string &addr)
{
#ifdef ENABLE_INCOMING_MSG_RECORDER
if ( ! ClientCfg.Local )
#endif
{
// set values of simulation for the udp socket
CUdpSimSock::setSimValues(ClientCfg.ConfigFile);
_FrontendAddress = addr;
if (!cookie.empty ())
_LoginCookie.setFromString (cookie);
else if (ClientCfg.ConfigFile.exists ("UserId"))
{
uint32 uid = ClientCfg.ConfigFile.getVar ("UserId").asInt();
_LoginCookie.set(0, 0, uid);
Cookie = _LoginCookie.toString(); // to be able to do '/reconnect'
nlinfo ("Set the cookie with the UserId %d set in config file", uid);
}
nlinfo ("Network initialisation with front end '%s' and cookie %s",_FrontendAddress.c_str(), _LoginCookie.toString().c_str ());
}
_ConnectionState = NotConnected;
}
namespace CLFECOMMON
{
// Factory for TVPNodeBase::buildTree()
TVPNodeBase *NewNode()
{
return (TVPNodeBase*) new CNetworkConnection::TVPNodeClient();
}
};
#ifdef ENABLE_INCOMING_MSG_RECORDER
/*
* Start/stop recording the incoming messages (in online mode)
*/
void CNetworkConnection::setRecordingMode( bool onOff, const std::string& filename )
{
nlassert( ! ClientCfg.Local );
if ( onOff )
{
if ( ! _RecordIncomingMessagesOn )
{
if ( _RecordedMessagesOut.open( filename ) )
{
nlinfo( "Beginning recording to %s", filename.c_str() );
_RecordedMessagesOut.serialEnum( _ConnectionState );
_RecordedMessagesOut.serial( _CurrentReceivedNumber );
_RecordedMessagesOut.serial( _LastReceivedNumber );
_RecordedMessagesOut.serial( _LastAckInLongAck );
_RecordIncomingMessagesOn = true;
}
else
{
nlwarning( "Cannot open %s for recording", filename.c_str() );
}
}
}
else
{
if ( _RecordIncomingMessagesOn )
_RecordedMessagesOut.close();
_RecordIncomingMessagesOn = false;
}
}
/*
* Start/stop replaying the incoming messages (in offline mode)
*/
void CNetworkConnection::setReplayingMode( bool onOff, const std::string& filename )
{
nlassert( ClientCfg.Local );
if ( onOff )
{
if ( ! _ReplayIncomingMessagesOn )
{
if ( _RecordedMessagesIn.open( filename ) )
{
nlinfo( "Beginning replaying of %s", filename.c_str() );
_RecordedMessagesIn.serialEnum( _ConnectionState );
_RecordedMessagesIn.serial( _CurrentReceivedNumber );
_RecordedMessagesIn.serial( _LastReceivedNumber );
_RecordedMessagesIn.serial( _LastAckInLongAck );
// Preload first message
if ( _RecordedMessagesIn.eof() )
{
// Nothing to load
nlinfo( "Nothing to replay" );
_RecordedMessagesIn.close();
return;
}
else
{
_RecordedMessagesIn.serial( _NextClientTickToReplay );
_RecordedMessagesIn.serialMemStream( _NextMessageToReplay );
_CurrentClientTick = _NextClientTickToReplay;
_CurrentServerTick = _CurrentClientTick + 10;
nlinfo( "Setting initial replay tick: %u", _CurrentClientTick );
_ReplayIncomingMessagesOn = true;
}
}
else
{
nlwarning( "File %s for replay not found", filename.c_str() );
}
}
}
else
{
if ( _RecordIncomingMessagesOn )
_RecordedMessagesIn.close();
_ReplayIncomingMessagesOn = false;
}
}
#endif
bool CNetworkConnection::connect(string &result)
{
if (_ConnectionState != NotConnected)
{
nlwarning("Unable to connect(): connection not properly initialised (maybe connection not closed).");
return false;
}
// try to find where common data are located depending to where we'll connect
// the goal is to use the same database.txt as the server one
try
{
CConfigFile cfg;
cfg.load (CPath::lookup("shards.cfg"));
// do this process only if Use == 1
if (cfg.getVar("Use").asInt() == 1)
{
CInetAddress fsaddr (_FrontendAddress);
fsaddr.setPort(0);
nlinfo ("Try to find a shard that have fsaddr = '%s'", fsaddr.asString().c_str());
CConfigFile::CVar &shards = cfg.getVar("Shards");
CInetAddress net;
uint i;
for (i = 0; i < shards.size(); i+=2)
{
try
{
net.setNameAndPort (shards.asString(i));
nlinfo ("testAddr = '%s'", net.asString().c_str());
if (net == fsaddr)
{
// ok, we found it, now overwrite files
string srcPath = CPath::standardizeDosPath(CPath::getFullPath(shards.asString(i+1)));
nlinfo ("srcPath = '%s'", srcPath.c_str());
CConfigFile::CVar &needToCopy = cfg.getVar("NeedToCopy");
for (uint j = 0; j < needToCopy.size(); j++)
{
string arg1 = srcPath + needToCopy.asString(j);
string dstPath = CPath::standardizeDosPath(CPath::getFullPath(CPath::lookup (CFile::getFilename (needToCopy.asString(j))), false));
try
{
if(arg1.empty () || dstPath.empty ())
{
nlinfo ("Can't copy, src or dst is empty");
}
if(arg1 != dstPath)
{
nlinfo ("Copying '%s' into '%s'", arg1.c_str(), dstPath.c_str());
nlinfo ("executing 'copy /Y %s %s", arg1.c_str(), dstPath.c_str());
string str = "copy /Y " + arg1 + " " + dstPath;
int ret = system (str.c_str ());
//int ret = _spawnlp (_P_WAIT, "copy", "copy", "/Y", arg1.c_str(), dstPath.c_str(), NULL);
if (ret != 0)
{
nlwarning ("the copy command seems failed with the error code %d, errno %d: %s", ret, errno, strerror(errno));
}
}
else
{
nlinfo ("Can't copy, same path '%s'", arg1.c_str());
}
}
catch (const Exception &)
{
nlwarning ("Can't copy '%s' '%s', try the next file", arg1.c_str(), dstPath.c_str());
}
}
break;
}
}
catch (const Exception &e)
{
nlwarning (e.what ());
}
}
if (i == shards.size())
{
nlwarning ("the fsaddr '%s' is not in the shards.cfg, can't copy data_common files", fsaddr.asString().c_str());
}
}
}
catch (const Exception &)
{
nlinfo ("There's no shards.cfg, or bad file format, can't copy common files");
}
nlinfo ("CNET[%p]: Connecting to '%s' with cookie '%s'", this, _FrontendAddress.c_str(), _LoginCookie.toString().c_str ());
// then connect to the frontend using the udp sock
//ace faut faire la nouveau login client result = CLoginClient::connectToShard (_FrontendAddress, _Connection);
nlassert (!_Connection.connected());
try
{
//
// S12: connect to the FES. Note: In UDP mode, it's the user that have to send the cookie to the front end
//
_Connection.connect (CInetAddress(_FrontendAddress));
}
catch (const ESocket &e)
{
result = toString ("FS refused the connection (%s)", e.what());
return false;
}
_ConnectionState = Login;
_LatestLoginTime = ryzomGetLocalTime ();
_LatestSyncTime = _LatestLoginTime;
_LatestProbeTime = _LatestLoginTime;
nlinfo("CNET[%p]: Client connected to shard, attempting login", this);
return true;
}
void CNetworkConnection::setImpulseCallback(TImpulseCallback callback, void *argument)
{
_ImpulseCallback = callback;
_ImpulseArg = argument;
}
//
bool CNetworkConnection::isConnected()
{
return _ConnectionState == Connected;
}
#ifdef ENABLE_INCOMING_MSG_RECORDER
/*
* Return true if there is some messages to replay (in replay mode)
*/
bool CNetworkConnection::dataToReplayAvailable()
{
// Test the next tick loaded with the curent client tick (set externally)
//nldebug( "current=%u nextToReplay=%u", _CurrentClientTick, _NextClientTickToReplay );
return ( _CurrentClientTick >= _NextClientTickToReplay ); // when true => authorize entering buildStream()...
}
#endif
/*
* Set MsPerTick value
*/
void CNetworkConnection::setMsPerTick(sint32 msPerTick)
{
_MsPerTick = msPerTick;
}
//
//
//
bool CNetworkConnection::update()
{
#ifdef ENABLE_INCOMING_MSG_RECORDER
if ( _NextClientTickToReplay == std::numeric_limits<uint32>::max() )
{
setReplayingMode( false );
return false;
}
#endif
_UpdateTime = ryzomGetLocalTime ();
_UpdateTicks = ryzomGetPerformanceTime();
_ReceivedSync = false;
_NormalPacketsReceived = 0;
_TotalMessages = 0;
//nldebug("CNET[%d]: begin update()", this);
// If we are disconnected, bypass the real network update
if ( _ConnectionState == Disconnect )
{
_ConnectionQuality = false; // to block the user entity
return false;
}
// Yoyo. Update the Smooth ServerTick.
updateSmoothServerTick();
////// MEASURE_FE_SENDING (special test mode, not used in normal mode)
#ifdef MEASURE_FE_SENDING
if ( _ConnectionState == Login )
{
//_Connection.setNonBlockingMode( true );
sendSystemLogin();
_ConnectionState = Connected;
}
// Receive
CBitMemStream msgin( true );
bool res = buildStream( msgin );
if ( res )
{
static sint32 loopcount = 0;
++loopcount;
static TTicks lastdisplay = CTime::getPerformanceTime();
TTicks tn = CTime::getPerformanceTime();
TTime diff = CTime::ticksToSecond(tn - lastdisplay) * 1000.0;
if ( diff > 2000 )
{
nlinfo("Reads by second: %.1f => LoopTime = %.2f ms LoopCount = %u Diff = %u ms",(float)loopcount * 1000.0f / (float)diff, (float)diff / loopcount, loopcount, diff);
loopcount = 0;
lastdisplay = tn;
}
}
return res;
#endif
if (!_Connection.connected())
{
//if(!ClientCfg.Local)
// nlwarning("CNET[%p]: update() attempted whereas socket is not connected !", this);
return false;
}
try
{
// State automaton
bool stateBroke = false;
do
{
switch (_ConnectionState)
{
case Login:
// if receives System SYNC
// immediate state Synchronize
// else
// sends System LoginCookie
stateBroke = stateLogin();
break;
case Synchronize:
// if receives System PROBE
// immediate state Probe
// else if receives Normal
// immediate state Connected
// else
// sends System ACK_SYNC
stateBroke = stateSynchronize();
break;
case Connected:
// if receives System PROBE
// immediate state Probe
// else if receives Normal
// sends Normal data
stateBroke = stateConnected();
break;
case Probe:
// if receives System SYNC
// immediate state SYNC
// else if receives System PROBE
// decode PROBE
// sends System ACK_PROBE
stateBroke = stateProbe();
break;
case Stalled:
// if receives System SYNC
// immediate state SYNC
// else if receives System STALLED
// decode STALLED (nothing to do)
// else if receives System PROBE
// immediate state PROBE
stateBroke = stateStalled();
break;
case Quit:
// if receives System SYNC
// immediate state Synchronize
// else
// sends System LoginCookie
stateBroke = stateQuit();
break;
default:
// Nothing here !
stateBroke = false; // will come here if a disconnection action is received inside a method that returns true
break;
}
}
while (stateBroke);// && _TotalMessages<5);
}
catch (const ESocket &)
{
_ConnectionState = Disconnect;
}
//updateBufferizedPackets ();
PacketLossGraph.addOneValue (getMeanPacketLoss ());
_ConnectionQuality = (getConnectionState() == Connected &&
_UpdateTime - _LastReceivedNormalTime < 2000 && _CurrentClientTick < _CurrentServerTick);
return (_TotalMessages!=0);
}
/*
* Receive available data and convert it to a bitmemstream
*/
bool CNetworkConnection::buildStream( CBitMemStream &msgin )
{
#ifdef ENABLE_INCOMING_MSG_RECORDER
if ( _ReplayIncomingMessagesOn )
{
// Replay message
statsReceive( _NextMessageToReplay.length() );
msgin.clear();
memcpy( msgin.bufferToFill( _NextMessageToReplay.length() ), _NextMessageToReplay.buffer(), _NextMessageToReplay.length() );
//nldebug( "Reading message for tick %u (size %u)", _NextClientTickToReplay, msgin.length() );
// Preload next message
if ( _RecordedMessagesIn.eof() )
{
// Nothing more to load
_NextClientTickToReplay = std::numeric_limits<uint32>::max();
nlinfo( "Nothing more to replay, end of replaying" );
}
else
{
_RecordedMessagesIn.serial( _NextClientTickToReplay );
_NextMessageToReplay.clear();
_RecordedMessagesIn.serialMemStream( _NextMessageToReplay );
}
return true;
}
#endif
uint32 len = 65536;
if ( _Connection.receive( (uint8*)_ReceiveBuffer, len, false ) )
{
// Compute some statistics
statsReceive( len );
// Fill the message
msgin.clear();
memcpy( msgin.bufferToFill( len ), _ReceiveBuffer, len );
#ifdef ENABLE_INCOMING_MSG_RECORDER
if ( _RecordIncomingMessagesOn )
{
_RecordedMessagesOut.serial( _CurrentClientTick );
_RecordedMessagesOut.serialMemStream( msgin ); // shouldn't msgin's bufpos be resetted?
}
#endif
return true;
}
else
{
// A receiving error means the front-end is down
_ConnectionState = Disconnect;
disconnect(); // won't send a disconnection msg because state is already Disconnect
nlwarning( "DISCONNECTION" );
return false;
}
}
//
// Client automaton states methods
//
//
// Login state
//
// sends system login cookie
void CNetworkConnection::sendSystemLogin()
{
CBitMemStream message;
buildSystemHeader(message);
uint8 login = SYSTEM_LOGIN_CODE;
message.serial(login);
if (_LoginCookie.isValid())
message.serial(_LoginCookie);
else
{
uint32 fakeCookie = 0xDEADBEEF;
message.serial(fakeCookie);
message.serial(fakeCookie);
message.serial(fakeCookie);
}
message.serial( ClientCfg.LanguageCode );
// Try to send login, and handle the case when a firewall blocks the sending
uint32 length = message.length();
static TTime attemptStartTime = CTime::getLocalTime();
try
{
//sendUDP (&(_Connection), message.buffer(), length);
_Connection.send( message.buffer(), length );
}
catch (const ESocket &e)
{
#ifdef NL_OS_WINDOWS
// An exception (10004: Blocking operation interrupted) may occur if a firewall such as Kerio is
// running (note: ZoneAlarm blocks connect() until a decision is made by the user).
// Handle true network errors with a nlerror dialog box
if ( string(e.what()).find( "10004:" ) == string::npos ) // Code of WSAEINTR
{
// nlerror( "Cannot login: %s", e.what() );
}
#endif
// The first time, display info for the user to configure his personal firewall
static bool exceptionThrown = false;
if ( ! exceptionThrown )
{
exceptionThrown = true;
throw EBlockedByFirewall();
}
// Next time, disconnect if the time-out expired
//nldebug( "Attempt interrupted at %u ms", (uint32)(CTime::getLocalTime()-attemptStartTime) );
TTime currentTime = CTime::getLocalTime();
if ( currentTime - attemptStartTime > 15000 ) // let 15 seconds for the user to allow the connection
{
nldebug( "Login failed at %u ms", (uint32)(CTime::getLocalTime()-attemptStartTime) );
//nlerror( "Cannot login (check your firewall's settings?): %s", e.what() );
throw EBlockedByFirewall();
}
}
statsSend( length );
nlinfo( "CNET[%p]: sent LOGIN cookie=%s", this, _LoginCookie.toString().c_str() );
//nlinfo( "CNET[%p]: sent LOGIN cookie=%s at attempt %u at %u ms", this, _LoginCookie.toString().c_str(), nbAttempts, (uint32)(CTime::getLocalTime()-attemptStartTime) );
}
bool CNetworkConnection::stateLogin()
{
// if receives System SYNC
// immediate state Synchronize
// else
// sends System LoginCookie
#ifdef ENABLE_INCOMING_MSG_RECORDER
if ( ClientCfg.Local && !_ReplayIncomingMessagesOn )
return false;
while ( (_ReplayIncomingMessagesOn && dataToReplayAvailable()) ||
_Connection.dataAvailable() )
#else
while ( _Connection.dataAvailable() )// && _TotalMessages<5)
#endif
{
_DecodedHeader = false;
CBitMemStream msgin (true);
if (buildStream(msgin) && decodeHeader(msgin))
{
if (_SystemMode)
{
uint8 message = 0;
msgin.serial(message);
switch (message)
{
case SYSTEM_SYNC_CODE:
// receive sync, decode sync
_ConnectionState = Synchronize;
nldebug("CNET[%p]: login->synchronize", this);
receiveSystemSync(msgin);
return true;
break;
case SYSTEM_STALLED_CODE:
// receive stalled, decode stalled and state stalled
_ConnectionState = Stalled;
nldebug("CNET[%p]: login->stalled", this);
receiveSystemStalled(msgin);
return true;
break;
case SYSTEM_PROBE_CODE:
// receive probe, decode probe and state probe
_ConnectionState = Probe;
_Changes.push_back(CChange(0, ProbeReceived));
nldebug("CNET[%p]: login->probe", this);
receiveSystemProbe(msgin);
return true;
break;
case SYSTEM_SERVER_DOWN_CODE:
disconnect(); // will send disconnection message
nlwarning( "BACK-END DOWN" );
return false; // exit now from loop, don't expect a new state
break;
default:
//msgin.displayStream("DBG:BEN:stateLogin:msgin");
nlwarning("CNET[%p]: received system %d in state Login", this, message);
break;
}
}
else
{
//msgin.displayStream("DBG:BEN:stateLogin:msgin");
nlwarning("CNET[%p]: received normal in state Login", this);
}
}
}
// send ack sync if received sync or last sync timed out
if (_UpdateTime-_LatestLoginTime > 300)
{
sendSystemLogin();
_LatestLoginTime = _UpdateTime;
}
return false;
}
//
// Sync state
//
void CNetworkConnection::receiveSystemSync(CBitMemStream &msgin)
{
#ifdef ENABLE_INCOMING_MSG_RECORDER
if ( _ReplayIncomingMessagesOn )
{
TGameCycle dummyTick;
TTime dummyTime;
msgin.serial( dummyTick );
msgin.serial( dummyTime );
return;
}
#endif
_LatestSyncTime = _UpdateTime;
TTime stime;
msgin.serial(_Synchronize);
msgin.serial(stime);
msgin.serial(_LatestSync);
if (CheckXMLSignature.get())
{
bool xmlInvalid = false;
CHashKeyMD5 checkMsgXml;
CHashKeyMD5 checkDatabaseXml;
try
{
msgin.serialBuffer(checkMsgXml.Data, sizeof(checkMsgXml.Data));
msgin.serialBuffer(checkDatabaseXml.Data, sizeof(checkDatabaseXml.Data));
// Since cannot now easily if the server run on Windows or unix, try the both methods
xmlInvalid = (checkMsgXml != _MsgXmlMD5 || checkDatabaseXml != _DatabaseXmlMD5);
if(xmlInvalid)
xmlInvalid = (checkMsgXml != _AltMsgXmlMD5 || checkDatabaseXml != _AltDatabaseXmlMD5);
}
catch (const NLMISC::Exception&)
{
}
static bool alreadyWarned = false;
if (xmlInvalid && !alreadyWarned)
{
alreadyWarned = true;
Driver->systemMessageBox("msg.xml and database.xml files are invalid (server version signature is different)", "XML files invalid");
nlwarning("XML signature is invalid:");
nlwarning("msg.xml client:%s,%s server:%s", _AltMsgXmlMD5.toString().c_str(), _MsgXmlMD5.toString().c_str(),
checkMsgXml.toString().c_str());
nlwarning("database.xml client:%s,%s server:%s", _AltDatabaseXmlMD5.toString().c_str(), _DatabaseXmlMD5.toString().c_str(),
checkDatabaseXml.toString().c_str());
}
}
_ReceivedSync = true;
setMsPerTick(100);
//_MsPerTick = 100; // initial values
#ifdef HALF_FREQUENCY_SENDING_TO_CLIENT
//#pragma message ("HALF_FREQUENCY_SENDING_TO_CLIENT")
_CurrentServerTick = _Synchronize+_CurrentReceivedNumber*2;
#else
//#pragma message ("FULL_FREQUENCY_SENDING_TO_CLIENT")
_CurrentServerTick = _Synchronize+_CurrentReceivedNumber;
#endif
_CurrentClientTick = uint32(_CurrentServerTick - (_LCT+_MsPerTick)/_MsPerTick);
_CurrentClientTime = _UpdateTime - (_LCT+_MsPerTick);
//nlinfo( "CNET[%p]: received SYNC %" NL_I64 "u %" NL_I64 "u - _CurrentReceivedNumber=%d _CurrentServerTick=%d", this, (uint64)_Synchronize, (uint64)stime, _CurrentReceivedNumber, _CurrentServerTick );
sendSystemAckSync();
}
// sends system sync acknowledge
void CNetworkConnection::sendSystemAckSync()
{
#ifdef ENABLE_INCOMING_MSG_RECORDER
if ( _ReplayIncomingMessagesOn )
return;
#endif
CBitMemStream message;
buildSystemHeader(message);
uint8 sync = SYSTEM_ACK_SYNC_CODE;
message.serial(sync);
message.serial(_LastReceivedNumber);
message.serial(_LastAckInLongAck);
message.serial(_LongAckBitField);
message.serial(_LatestSync);
uint32 length = message.length();
_Connection.send (message.buffer(), length);
//sendUDP (&(_Connection), message.buffer(), length);
statsSend(length);
_LatestSyncTime = _UpdateTime;
//nlinfo("CNET[%p]: sent ACK_SYNC, _LastReceivedNumber=%d _LastAckInLongAck=%d", this, _LastReceivedNumber, _LastAckInLongAck);
/* // display long ack
uint i;
uint bfsize = _LongAckBitField.size();
uint bbuffer = 0;
string buffer;
static const char htable[] = "0123456789ABCDEF";
for (i=0; i<bfsize; ++i)
{
if (i>0 && (i&3)==0)
{
buffer += htable[bbuffer];
bbuffer = 0;
}
bbuffer = bbuffer*2 + (_LongAckBitField.get((_LastReceivedNumber-i)&(bfsize-1)) ? 1 : 0);
}
buffer += htable[bbuffer];
nlinfo("CNET[%p]: ACK=%s", buffer.c_str());
*/}
bool CNetworkConnection::stateSynchronize()
{
// if receives System PROBE
// immediate state Probe
// else if receives Normal
// immediate state Connected
// sends System ACK_SYNC
#ifdef ENABLE_INCOMING_MSG_RECORDER
if ( ClientCfg.Local && !_ReplayIncomingMessagesOn )
return false;
while ( (_ReplayIncomingMessagesOn && dataToReplayAvailable()) ||
_Connection.dataAvailable() )
#else
while (_Connection.dataAvailable())// && _TotalMessages<5)
#endif
{
_DecodedHeader = false;
CBitMemStream msgin (true);
if (buildStream(msgin) && decodeHeader(msgin))
{
if (_SystemMode)
{
uint8 message = 0;
msgin.serial(message);
switch (message)
{
case SYSTEM_PROBE_CODE:
// receive probe, decode probe and state probe
_ConnectionState = Probe;
//nldebug("CNET[%p]: synchronize->probe", this);
_Changes.push_back(CChange(0, ProbeReceived));
receiveSystemProbe(msgin);
return true;
break;
case SYSTEM_STALLED_CODE:
// receive stalled, decode stalled and state stalled
_ConnectionState = Stalled;
//nldebug("CNET[%p]: synchronize->stalled", this);
receiveSystemStalled(msgin);
return true;
break;
case SYSTEM_SYNC_CODE:
// receive sync, decode sync
receiveSystemSync(msgin);
break;
case SYSTEM_SERVER_DOWN_CODE:
disconnect(); // will send disconnection message
nlwarning( "BACK-END DOWN" );
return false; // exit now from loop, don't expect a new state
break;
default:
nlwarning("CNET[%p]: received system %d in state Synchronize", this, message);
break;
}
}
else
{
_ConnectionState = Connected;
//nlwarning("CNET[%p]: synchronize->connected", this);
_Changes.push_back(CChange(0, ConnectionReady));
_ImpulseDecoder.reset();
receiveNormalMessage(msgin);
return true;
}
}
}
// send ack sync if received sync or last sync timed out
if (_UpdateTime-_LatestSyncTime > 300)
sendSystemAckSync();
return false;
}
#ifdef SHOW_PROPERTIES_RECEIVED
uint8 propReceived [18];
#endif
#ifdef MEASURE_RECEIVE_DATES
TTime currentTime;
#endif
//
// Connected state
//
void CNetworkConnection::receiveNormalMessage(CBitMemStream &msgin)
{
//nlinfo("CNET[%p]: received normal message Packet=%d Ack=%d", this, _LastReceivedNumber, _LastReceivedAck);
vector<CAction *> actions;
_ImpulseDecoder.decode(msgin, _CurrentReceivedNumber, _LastReceivedAck, _CurrentSendNumber, actions);
#ifdef SHOW_PROPERTIES_RECEIVED
for ( uint8 p=0; p!=18; ++p )
propReceived[p] = 0;
propReceived[2] = actions.size();
#endif
++_NormalPacketsReceived;
// we can now remove all old action that are acked
while (!_Actions.empty() && _Actions.front().FirstPacket != 0 && _Actions.front().FirstPacket <= _LastReceivedAck)
{
// warning, CActionBlock automatically remove() actions when deleted
_Actions.pop_front();
}
// now, read actions
/*vector<CAction *> commonActions;
CActionFactory::getInstance()->unpack (msgin, commonActions, getCurrentServerTick()+1 ); // +1 because the current tick is set a few lines further
actions.insert(actions.end(), commonActions.begin(), commonActions.end());*/
//_PropertyDecoder.ack(_LastReceivedNumber, _LastReceivedAck);
//
// update game time and ticks from network infos
//
#ifdef ENABLE_INCOMING_MSG_RECORDER
if ( ! _ReplayIncomingMessagesOn )
#endif
{
// convert the number of the packet that we just received into tick
#ifdef HALF_FREQUENCY_SENDING_TO_CLIENT
nlassert(_CurrentReceivedNumber*2+_Synchronize > _CurrentServerTick);
_CurrentServerTick = _CurrentReceivedNumber*2+_Synchronize;
#else
nlassert(_CurrentReceivedNumber+_Synchronize > _CurrentServerTick);
_CurrentServerTick = _CurrentReceivedNumber+_Synchronize;
#endif
//nldebug( "_CurrentServerTick=%d _CurrentReceivedNumber=%d _Synchronize=%d", _CurrentServerTick, _CurrentReceivedNumber, _Synchronize );
}
// remove useless stamps in queue
while (!_PacketStamps.empty() && _LastReceivedAck > _PacketStamps.front().first)
_PacketStamps.pop_front();
#ifdef ENABLE_INCOMING_MSG_RECORDER
if ( (! _ReplayIncomingMessagesOn) && (_PacketStamps.empty() || _PacketStamps.front().first > _LastReceivedAck) )
#else
if (_PacketStamps.empty() || _PacketStamps.front().first > _LastReceivedAck)
#endif
{
//nlwarning("Frontend ack'ed message %d not stamp dated", _LastReceivedAck);
}
else
{
// get the send time of the acknowledged packet
TTime ackedPacketTime = _PacketStamps.front().second;
// update ping
uint32 ping = (uint32)(_UpdateTime-ackedPacketTime);
_InstantPing = ping;
if (ping < _BestPing)
_BestPing = ping;
PingGraph.addOneValue (float(ping));
// earliest estimation of server packet send time and latest estimation (based on ping and acknowledge)
TTime earliest = ackedPacketTime + _BestPing/2,
latest = _UpdateTime - _BestPing/2;
// compute number of ticks between frame currently played by client and packet received from server
sint32 numStepTick = (sint32)(_CurrentServerTick-_CurrentClientTick);
// if enough steps and times are valid
if (numStepTick > 0 && earliest > _CurrentClientTime && latest > _CurrentClientTime)
{
// exact formula for _MsPerTick = (_CurrentServerTime-_CurrentClientTime)/numStepTick
// where _CurrentServerTime is the actual server packet send time
// but as the exact time is unknown, we use a predictive time window instead, based on
// the acknwoledged packet send time, the received packet time and the ping
// adjust if estimation of _MsPerTick is too small
if ((TTime)(_CurrentClientTime+_MsPerTick*numStepTick) < earliest)
setMsPerTick((sint32)(earliest-_CurrentClientTime)/numStepTick);
//_MsPerTick = (sint32)(earliest-_CurrentClientTime)/numStepTick;
// adjust if estimation of _MsPerTick is too large
if ((TTime)(_CurrentClientTime+_MsPerTick*numStepTick) > latest)
setMsPerTick((sint32)(latest-_CurrentClientTime)/numStepTick);
//_MsPerTick = (sint32)(latest-_CurrentClientTime)/numStepTick;
// _MsPerTick should be positive here -- seems to crash yet
/// \todo we should instead of putting 1, returning in probe mode because it means that we had a very big lag
if (_MsPerTick == 0)
{
nlwarning ("_MsPerTick is 0 because server tick is too big %d compare to the client tick is %d", _CurrentServerTick, _CurrentClientTick);
setMsPerTick(1);
//_MsPerTick = 1;
}
}
else if (numStepTick <= 0)
{
setMsPerTick((sint32)_LCT);
//_MsPerTick = (sint32)_LCT;
}
MsPerTickGraph.addOneValue (float(_MsPerTick));
}
#ifdef MEASURE_RECEIVE_DATES
currentTime = ryzomGetLocalTime ();
#endif
// Decode the actions received in the impulsions
uint i;
for (i = 0; i < actions.size (); i++)
{
switch (actions[i]->Code)
{
case ACTION_DISCONNECTION_CODE:
{
// Self disconnection
nlwarning( "You were disconnected by the server" );
disconnect(); // will send disconnection message
LoginSM.pushEvent( CLoginStateMachine::ev_conn_dropped );
}
break;
case ACTION_GENERIC_CODE:
{
genericAction((CActionGeneric *)actions[i]);
}
break;
case ACTION_GENERIC_MULTI_PART_CODE:
{
genericAction((CActionGenericMultiPart *)actions[i]);
}
break;
case ACTION_DUMMY_CODE:
{
CActionDummy *dummy = ((CActionDummy*)actions[i]);
nldebug("CNET[%d] Received Dummy %d", this, dummy->Dummy1);
// Nothing to do
}
break;
}
CActionFactory::getInstance()->remove(actions[i]);
}
// Decode the visual properties
decodeVisualProperties( msgin );
_LastReceivedNormalTime = _UpdateTime;
#ifdef DISPLAY_ENTITIES
DownloadGraph.addValue ((float)(msgin.length()));
DpfGraph.addValue ((float)(msgin.length()));
#endif
#ifdef SHOW_PROPERTIES_RECEIVED
string str = "Received: ";
// stringstream ss;
// ss << "Received: ";
if ( propReceived[2] != 0 )
str += NLMISC::toString(propReceived[2]) + " impuls. ";
// ss << propReceived[2] << " impuls. ";
if ( propReceived[0] != 0 )
str += NLMISC::toString(propReceived[0]) + " pos; ";
// ss << propReceived[0] << " pos; ";
if ( propReceived[3] != 0 )
str += NLMISC::toString(propReceived[3]) + " orient; ";
// ss << propReceived[3] << " orient; ";
uint sum = propReceived[4] + propReceived[5] + propReceived[6] + propReceived[7] + propReceived[8] + propReceived[9];
if ( sum != 0 )
str += NLMISC::toString(sum) + " discreet; ";
// ss << sum << " discreet; ";
if ( propReceived[16] != 0 )
str += NLMISC::toString(propReceived[16]) + "assoc; ";
// ss << propReceived[16] << "assoc; ";
if ( propReceived[17] != 0 )
str += NLMISC::toString(propReceived[17]) + "disac; ";
// ss << propReceived[17] << "disac; ";
str += "TOTAL: " + NLMISC::toString(propReceived[2]) + " + " + NLMISC::toString(propReceived[0] + propReceived[3] + sum);
//ss << "TOTAL: " << propReceived[2] << " + " << propReceived[0] + propReceived[3] + sum;
nlwarning( "%s", str.c_str() );
#endif
}
void CNetworkConnection::decodeVisualProperties( CBitMemStream& msgin )
{
try
{
//nldebug( "pos: %d len: %u", msgin.getPos(), msgin.length() );
while ( true )
{
//nlinfo( "Reading pass %u, BEFORE HEADER: pos: %d len: %u", ++i, msgin.getPosInBit(), msgin.length() * 8 );
// Check if there is a new block to read
if ( msgin.getPosInBit() + (sizeof(TCLEntityId)*8) > msgin.length()*8 )
return;
// Header
TCLEntityId slot;
msgin.serialAndLog1( slot );
uint32 associationBits;
msgin.serialAndLog2( associationBits, 2 );
//nlinfo( "slot %hu AB: %u", (uint16)slot, associationBits );
if ( associationBitsHaveChanged( slot, associationBits ) && (!IgnoreEntityDbUpdates || slot==0))
{
//displayBitStream( msgin, beginbitpos, msgin.getPosInBit() );
// nlinfo ("Disassociating S%hu (AB %u)", (uint16)slot, associationBits );
if ( _PropertyDecoder.isUsed( slot ) )
{
TSheetId sheet = _PropertyDecoder.sheet( slot );
TIdMap::iterator it = _IdMap.find( sheet );
if ( it != _IdMap.end() )
_IdMap.erase(it);
_PropertyDecoder.removeEntity( slot );
CChange theChange( slot, RemoveOldEntity );
_Changes.push_back( theChange );
}
else
{
// nlinfo( "Cannot disassociate slot %hu: sheet not received yet", (uint16)slot );
}
}
// Read the timestamp delta if there's one (otherwise take _CurrentServerTick)
TGameCycle timestamp;
bool timestampIsThere;
msgin.serialBitAndLog( timestampIsThere );
if ( timestampIsThere )
{
uint32 timestampDelta;
msgin.serialAndLog2( timestampDelta, 4 );
timestamp = _CurrentServerTick - timestampDelta;
//nldebug( "TD: %u (S%hu)", timestampDelta, (uint16)slot );
}
else
{
timestamp = _CurrentServerTick;
}
// Tree
//nlinfo( "AFTER HEADER: posBit: %d pos: %d len: %u", msgin.getPosInBit(), msgin.getPos(), msgin.length() );
TVPNodeClient *currentNode = _VisualPropertyTreeRoot;
msgin.serialBitAndLog( currentNode->a()->BranchHasPayload );
if ( currentNode->a()->BranchHasPayload )
{
CActionPosition *ap = (CActionPosition*)CActionFactory::getInstance()->create( slot, ACTION_POSITION_CODE );
ap->unpack( msgin );
_PropertyDecoder.receive( _CurrentReceivedNumber, ap );
#ifdef SHOW_PROPERTIES_RECEIVED
++propReceived[PROPERTY_POSITION];
#endif
/*
* Set into property database
*/
// TEMP
if ( ap->Position[0]==0 || ap->Position[1]==0 )
nlwarning( "S%hu: Receiving an invalid position", (uint16)slot );
if (_DataBase != NULL && (!IgnoreEntityDbUpdates || slot==0))
{
CCDBNodeBranch *nodeRoot;
nodeRoot = dynamic_cast<CCDBNodeBranch*>(_DataBase->getNode((uint16)0));
if(nodeRoot)
{
CCDBNodeLeaf *node;
node = dynamic_cast<CCDBNodeLeaf*>(nodeRoot->getNode(slot)->getNode(0));
nlassert(node != NULL);
node->setValue64(ap->Position[0]);
node = dynamic_cast<CCDBNodeLeaf*>(nodeRoot->getNode(slot)->getNode(1));
nlassert(node != NULL);
node->setValue64(ap->Position[1]);
node = dynamic_cast<CCDBNodeLeaf*>(nodeRoot->getNode(slot)->getNode(2));
nlassert(node != NULL);
node->setValue64(ap->Position[2]);
if ( LoggingMode )
{
nlinfo( "recvd position (%d,%d) for slot %hu, date %u", (sint32)(ap->Position[0]), (sint32)(ap->Position[1]), (uint16)slot, timestamp );
}
}
}
bool interior = ap->Interior;
CActionFactory::getInstance()->remove( (CAction*&)ap );
/*
* Statistical prediction of time before next position update: set PredictedInterval
*/
//nlassert( MAX_POSUPDATETICKQUEUE_SIZE > 1 );
deque<TGameCycle>& puTicks = _PosUpdateTicks[slot];
multiset<TGameCycle>& puIntervals = _PosUpdateIntervals[slot];
// Flush the old element of tick queue and of the interval sorted set
if ( puTicks.size() == MAX_POSUPDATETICKQUEUE_SIZE )
{
puIntervals.erase( puIntervals.find( puTicks[1] - puTicks[0] ) ); // erase only one element, not all corresponding to the value
puTicks.pop_front();
}
// Add a new element to the tick queue and possibly to the interval sorted set
// Still to choose: _CurrentServerTick or timestamp ?
TGameCycle latestInterval = 0;
if ( ! puTicks.empty() )
{
latestInterval = timestamp - puTicks.back();
puIntervals.insert( latestInterval );
if ( PosUpdateIntervalGraph )
PosUpdateIntervalGraph->addOneValue( slot, (float)latestInterval );
}
puTicks.push_back( timestamp );
nlassert( puTicks.size() == puIntervals.size()+1 );
// Prediction function : Percentile(25 last, 0.8) + 1
TGameCycle predictedInterval;
if ( puIntervals.empty() )
{
predictedInterval = 0;
}
else
{
predictedInterval = (TGameCycle)(percentileRev( puIntervals, PREDICTION_REV_PERCENTILE ) + 1);
//if ( predictedInterval > 100 )
// nlwarning( "Slot %hu: Predicted interval %u exceeds 100 ticks", (uint16)slot, predictedInterval );
if ( PosUpdatePredictionGraph )
PosUpdatePredictionGraph->addOneValue( slot, (float)predictedInterval );
}
//nlinfo( "Slot %hu: Interval=%u Predicted=%u", (uint16)slot, latestInterval, predictedInterval );
/*
* Add into the changes vector
*/
CChange thechange( slot, PROPERTY_POSITION, timestamp );
thechange.PositionInfo.PredictedInterval = predictedInterval;
thechange.PositionInfo.IsInterior = interior;
_Changes.push_back( thechange );
#ifdef MEASURE_RECEIVE_DATES
// Stat log
if ( LogReceiveEnabled && (WatchedEntitySlot == 256) || (WatchedEntitySlot == slot) )
{
TRDateState ds( timestamp, predictedInterval, currentTime );
ReceivePosDateLog[slot].push_back( ds );
}
#endif
}
currentNode = currentNode->b();
msgin.serialBitAndLog( currentNode->BranchHasPayload );
if ( currentNode->BranchHasPayload )
{
msgin.serialBitAndLog( currentNode->a()->BranchHasPayload );
if ( currentNode->a()->BranchHasPayload )
{
CActionSint64 *ac = (CActionSint64*)CActionFactory::getInstance()->createByPropIndex( slot, PROPERTY_ORIENTATION );
ac->unpack( msgin );
// Process orientation
CChange thechange(slot, PROPERTY_ORIENTATION, timestamp);
_Changes.push_back( thechange );
#ifdef SHOW_PROPERTIES_RECEIVED
++propReceived[PROPERTY_ORIENTATION];
#endif
if (_DataBase != NULL && (!IgnoreEntityDbUpdates || slot==0))
{
CCDBNodeBranch *nodeRoot;
nodeRoot = dynamic_cast<CCDBNodeBranch*>(_DataBase->getNode(0));
if ( nodeRoot )
{
CCDBNodeLeaf *node = dynamic_cast<CCDBNodeLeaf*>(nodeRoot->getNode(slot)->getNode( PROPERTY_ORIENTATION ));
nlassert(node != NULL);
node->setValue64(ac->getValue());
if ( LoggingMode )
{
nlinfo( "CLIENT: recvd property %hu (%s) for slot %hu, date %u", (uint16)PROPERTY_ORIENTATION, getPropText(PROPERTY_ORIENTATION), (uint16)slot, timestamp );
}
//nldebug("CLPROPNET[%p]: received property %d for entity %d: %" NL_I64 "u", this, action->PropIndex, action->CLEntityId, action->getValue());
}
}
CActionFactory::getInstance()->remove( (CAction*&)ac );
}
TVPNodeClient::SlotContext.NetworkConnection = this;
TVPNodeClient::SlotContext.Slot = slot;
TVPNodeClient::SlotContext.Timestamp = timestamp;
// Discreet properties
currentNode->b()->decodeDiscreetProperties( msgin );
}
}
}
catch (const EStreamOverflow&)
{
// End of stream (saves useless bits)
}
}
/*
*
*/
static vector<TCLEntityId> TargetSlotsList(256);
void CNetworkConnection::decodeDiscreetProperty( CBitMemStream& msgin, TPropIndex propIndex )
{
//nldebug( "Reading discreet property %hu at bitpos %d", (uint16)propIndex, msgin.getPosInBit() );
TCLEntityId slot = TVPNodeClient::SlotContext.Slot;
// \todo BEN this is temp, put it somewhere in database
if (propIndex == PROPERTY_TARGET_LIST)
{
uint8 listSize;
msgin.serial(listSize);
TargetSlotsList.resize(listSize);
if (listSize > 0)
msgin.serialBuffer(&(TargetSlotsList[0]), listSize);
// Set target list value in database
if (_DataBase != NULL && (!IgnoreEntityDbUpdates || slot==0))
{
CCDBNodeBranch *nodeRoot;
nodeRoot = dynamic_cast<CCDBNodeBranch*>(_DataBase->getNode(0));
if ( nodeRoot )
{
CCDBNodeBranch *nodeEntity = dynamic_cast<CCDBNodeBranch*>(nodeRoot->getNode(slot));
nlassert(nodeEntity != NULL);
uint writeProp = PROPERTY_TARGET_LIST;
uint place = 0;
if (listSize >= 32)
{
listSize = 32;
}
else
{
TargetSlotsList.push_back(INVALID_SLOT);
++listSize;
}
CCDBNodeLeaf *nodeProp = NULL;
uint i;
uint64 value = 0;
for (i=0; i<listSize; ++i)
{
if (place == 0)
value = 0;
value += (((uint64)TargetSlotsList[i]) << (place*8));
++place;
if (place == 8)
{
nodeProp = dynamic_cast<CCDBNodeLeaf*>(nodeEntity->getNode(writeProp));
nlassert(nodeProp != NULL);
nodeProp->setValue64(value);
++writeProp;
place = 0;
}
}
if (place != 0)
{
nodeProp = dynamic_cast<CCDBNodeLeaf*>(nodeEntity->getNode(writeProp));
nlassert(nodeProp != NULL);
nodeProp->setValue64(value);
}
}
if ( LoggingMode )
{
nlinfo( "CLIENT: recvd property %hu (%s) for slot %hu, date %u", (uint16)propIndex, getPropText(propIndex), (uint16)slot, TVPNodeClient::SlotContext.Timestamp );
}
}
CChange thechange( slot, propIndex, TVPNodeClient::SlotContext.Timestamp );
_Changes.push_back( thechange );
return;
}
CActionSint64 *ac = (CActionSint64*)CActionFactory::getInstance()->createByPropIndex( slot, propIndex );
ac->unpack( msgin );
#ifdef SHOW_PROPERTIES_RECEIVED
++propReceived[propIndex];
#endif
switch ( propIndex )
{
case PROPERTY_SHEET:
{
// Special case for sheet
// nlinfo ("Associating S%hu", (uint16)slot );
if ( _PropertyDecoder.isUsed( slot ) )
{
TSheetId sheet = _PropertyDecoder.sheet( slot );
TIdMap::iterator it = _IdMap.find(sheet);
if ( it != _IdMap.end() )
_IdMap.erase(it);
_PropertyDecoder.removeEntity( slot );
}
TSheetId newSheetId = (TSheetId)(ac->getValue() & 0xffffffff);
_IdMap.insert( make_pair( newSheetId, slot) );
_PropertyDecoder.addEntity( slot, newSheetId );
// Reset the position update statistical data
_PosUpdateTicks[slot].clear();
_PosUpdateIntervals[slot].clear();
// Read optional alias block
uint32 alias = 0;
bool aliasBit = false;
msgin.serialBitAndLog( aliasBit );
if ( aliasBit )
msgin.serialAndLog1( alias );
// Set information
CChange thechange( slot, AddNewEntity );
thechange.NewEntityInfo.DataSetIndex = (TClientDataSetIndex)((ac->getValue() >> 32) & 0xffffffff);
thechange.NewEntityInfo.Alias = alias;
_Changes.push_back( thechange );
break;
}
case PROPERTY_MODE:
{
// Special case for mode: push theta or pos, then mode
uint64 mode44 = ac->getValue();
uint32 modeTimestamp = _CurrentServerTick - (uint32)(((mode44 >> 8) & 0xF));
// Push the mode Before the position or the orientation
CChange thechangeMode( slot, PROPERTY_MODE, modeTimestamp );
_Changes.push_back( thechangeMode );
// Set mode value in database
if (_DataBase != NULL && (!IgnoreEntityDbUpdates || slot==0))
{
CCDBNodeBranch *nodeRoot;
nodeRoot = dynamic_cast<CCDBNodeBranch*>(_DataBase->getNode(0));
if ( nodeRoot )
{
CCDBNodeLeaf *node = dynamic_cast<CCDBNodeLeaf*>(nodeRoot->getNode(slot)->getNode( propIndex ));
nlassert(node != NULL);
node->setValue64(ac->getValue() & 0xFF); // (8 bits)
if ( LoggingMode )
{
nlinfo( "CLIENT: recvd property %hu (%s) for slot %hu, date %u", (uint16)propIndex, getPropText(propIndex), (uint16)slot, TVPNodeClient::SlotContext.Timestamp );
}
}
}
// Set the position or orientation received along with the mode in the database
uint8 modeEnum = (uint8)(mode44 & 0xFF);
if ( modeEnum == MBEHAV::COMBAT_FLOAT )
{
// Set theta
if (_DataBase != NULL && (!IgnoreEntityDbUpdates || slot==0))
{
CCDBNodeBranch *nodeRoot;
nodeRoot = dynamic_cast<CCDBNodeBranch*>(_DataBase->getNode(0));
if ( nodeRoot )
{
CCDBNodeLeaf *node = dynamic_cast<CCDBNodeLeaf*>(nodeRoot->getNode(slot)->getNode( PROPERTY_ORIENTATION ));
nlassert(node != NULL);
node->setValue64( (mode44 >> 12) /*&& 0xFFFFFFFF*/ );
}
}
}
else
{
// Set 2D position (the position at TVPNodeClient::SlotContext.Timestamp is not sent at the same time as the position for Mode)
if ( _DataBase != NULL && (!IgnoreEntityDbUpdates || slot==0))
{
uint16 x16 = (uint16)((ac->getValue() >> 12) & 0xFFFF);
uint16 y16 = (uint16)((ac->getValue() >> 28) & 0xFFFF);
if ( ! (x16==0 && y16==0) ) // don't set the position if it was not initialized yet
{
sint32 x, y;
_PropertyDecoder.decodeAbsPos2D( x, y, x16, y16 );
CCDBNodeBranch *nodeRoot;
nodeRoot = dynamic_cast<CCDBNodeBranch*>(_DataBase->getNode(0));
if ( nodeRoot )
{
CCDBNodeLeaf *node;
node = dynamic_cast<CCDBNodeLeaf*>(nodeRoot->getNode(slot)->getNode(0));
nlassert(node != NULL);
node->setValue64( x );
node = dynamic_cast<CCDBNodeLeaf*>(nodeRoot->getNode(slot)->getNode(1));
nlassert(node != NULL);
node->setValue64( y );
}
}
else
{
nldebug( "%u: S%hu: Received mode with null pos", _CurrentServerTick, (uint16)slot ); // TEMP
}
}
}
break;
}
/* case PROPERTY_GUILD_SYMBOL:
nlinfo("GuildSymbol received...");
*/
default:
{
// special for Bars, always take _CurrentServerTick timestamp (delta timestamp decoded is mainly for position purpose...)
NLMISC::TGameCycle timeStamp= TVPNodeClient::SlotContext.Timestamp;
/* YOYO: i don't know what to do with others property that really use the gamecycle and are maybe buggued:
ENTITY_MOUNTED_ID,RIDER_ENTITY_ID,BEHAVIOUR,TARGET_LIST,TARGET_ID,VISUAL_FX
But bars timestamp accuracy is very important (else could take DB property with falsly newer timestamp)
*/
if(propIndex== PROPERTY_BARS)
timeStamp= _CurrentServerTick;
// Process property
CChange thechange( slot, propIndex, timeStamp );
_Changes.push_back( thechange );
if (_DataBase != NULL && (!IgnoreEntityDbUpdates || slot==0) )
{
CCDBNodeBranch *nodeRoot;
nodeRoot = dynamic_cast<CCDBNodeBranch*>(_DataBase->getNode(0));
if ( nodeRoot )
{
CCDBNodeLeaf *node = dynamic_cast<CCDBNodeLeaf*>(nodeRoot->getNode(slot)->getNode( propIndex ));
nlassert(node != NULL);
node->setValue64(ac->getValue());
if ( LoggingMode )
{
nlinfo( "CLIENT: recvd property %hu (%s) for slot %hu, date %u", (uint16)propIndex, getPropText(propIndex), (uint16)slot, TVPNodeClient::SlotContext.Timestamp );
}
//nldebug("CLPROPNET[%p]: received property %d for entity %d: %" NL_I64 "u", this, action->PropIndex, action->CLEntityId, action->getValue());
}
}
}
}
CActionFactory::getInstance()->remove( (CAction*&)ac );
#ifdef SHOW_PROPERTIES_RECEIVED
// stringstream ss;
// ss << "Received: ";
// if ( propReceived[2] != 0 )
// ss << propReceived[2] << " impuls. ";
// if ( propReceived[0] != 0 )
// ss << propReceived[0] << " pos; ";
// if ( propReceived[3] != 0 )
// ss << propReceived[3] << " orient; ";
// uint sum = propReceived[4] + propReceived[5] + propReceived[6] + propReceived[7] + propReceived[8] + propReceived[9];
// if ( sum != 0 )
// ss << sum << " discreet; ";
// if ( propReceived[16] != 0 )
// ss << propReceived[16] << "assoc; ";
// if ( propReceived[17] != 0 )
// ss << propReceived[17] << "disac; ";
// ss << "TOTAL: " << propReceived[2] << " + " << propReceived[0] + propReceived[3] + sum;
string str = "Received: ";
if ( propReceived[2] != 0 )
str += NLMISC::toString(propReceived[2]) + " impuls. ";
if ( propReceived[0] != 0 )
str += NLMISC::toString(propReceived[0]) + " pos; ";
if ( propReceived[3] != 0 )
str += NLMISC::toString(propReceived[3]) + " orient; ";
uint sum = propReceived[4] + propReceived[5] + propReceived[6] + propReceived[7] + propReceived[8] + propReceived[9];
if ( sum != 0 )
str += NLMISC::toString(sum) + " discreet; ";
if ( propReceived[16] != 0 )
str += NLMISC::toString(propReceived[16]) + "assoc; ";
if ( propReceived[17] != 0 )
str += NLMISC::toString(propReceived[17]) + "disac; ";
str += "TOTAL: " + NLMISC::toString(propReceived[2]) + " + " + NLMISC::toString(propReceived[0] + propReceived[3] + sum);
nlwarning( "%s", str.c_str() );
#endif
}
void CNetworkConnection::sendNormalMessage()
{
//nlinfo("CNET[%p]: send normal message Packet=%d Ack=%d AckBits=%08X", this, _CurrentSendNumber, _LastReceivedNumber, _AckBitMask);
//
// Create the message to send to the server
//
CBitMemStream message;
bool systemMode = false;
message.serial (_CurrentSendNumber);
message.serial (systemMode);
message.serial (_LastReceivedNumber);
message.serial (_AckBitMask);
uint numPacked = 0;
// pack each block
TGameCycle lastPackedCycle = 0;
list<CActionBlock>::iterator itblock;
//nldebug("CNET[%p]: sending message %d", this, _CurrentSendNumber);
for (itblock=_Actions.begin(); itblock!=_Actions.end(); ++itblock)
{
CActionBlock &block = *itblock;
// if block contains action that are not already stamped, don't send it now
if (block.Cycle == 0)
break;
// Prevent to send a message too big
//if (message.getPosInBit() + (*itblock).bitSize() > FrontEndInputBufferSize) // hard version
// break;
if (block.FirstPacket == 0)
block.FirstPacket = _CurrentSendNumber;
//nlassertex((*itblock).Cycle > lastPackedCycle, ("(*itblock).Cycle=%d lastPackedCycle=%d", (*itblock).Cycle, lastPackedCycle));
lastPackedCycle = block.Cycle;
block.serial(message);
++numPacked;
//nldebug("CNET[%p]: packed block %d, message is currently %d bits long", this, block.Cycle, message.getPosInBit());
// Prevent to send a message too big
//if (message.getPosInBit() + (*itblock).bitSize() > FrontEndInputBufferSize) // hard version
if ( message.getPosInBit() > 480*8 ) // easy version
break;
}
//_PropertyDecoder.send (_CurrentSendNumber, _LastReceivedNumber);
uint32 length = message.length();
_Connection.send (message.buffer(), length);
//sendUDP (&(_Connection), message.buffer(), length);
statsSend(length);
// remember send time
_LastSendTime = CTime::getLocalTime();
_PacketStamps.push_back(make_pair(_CurrentSendNumber, _UpdateTime));
_CurrentSendNumber++;
}
bool CNetworkConnection::stateConnected()
{
// if receives System PROBE
// immediate state Probe
// else if receives Normal
// sends Normal data
#ifdef ENABLE_INCOMING_MSG_RECORDER
if ( ! _ReplayIncomingMessagesOn )
#endif
{
// Prevent to increment the client time when the front-end does not respond
static TTime previousTime = ryzomGetLocalTime ();
TTime now = ryzomGetLocalTime ();
TTime diff = now - previousTime;
previousTime = now;
if ( (diff > 3000) && (! _Connection.dataAvailable()) )
{
return false;
}
// update the current time;
while (_CurrentClientTime < (TTime)(_UpdateTime - _MsPerTick - _LCT) && _CurrentClientTick < _CurrentServerTick)
{
_CurrentClientTime += _MsPerTick;
_CurrentClientTick++;
_MachineTimeAtTick = _UpdateTime;
_MachineTicksAtTick = _UpdateTicks;
}
if (_CurrentClientTick >= _CurrentServerTick && !_Connection.dataAvailable())
{
return false;
}
}
#ifdef ENABLE_INCOMING_MSG_RECORDER
if ( ClientCfg.Local && !_ReplayIncomingMessagesOn )
return false;
while ( (_ReplayIncomingMessagesOn && dataToReplayAvailable()) ||
_Connection.dataAvailable() )
#else
while (_Connection.dataAvailable())// && _TotalMessages<5)
#endif
{
_DecodedHeader = false;
CBitMemStream msgin (true);
if (buildStream(msgin) && decodeHeader(msgin))
{
if (_SystemMode)
{
uint8 message = 0;
msgin.serial(message);
switch (message)
{
case SYSTEM_PROBE_CODE:
// receive probe, and goto state probe
_ConnectionState = Probe;
// reset client impulse & vars
/*
_ImpulseDecoder.reset();
_PropertyDecoder.clear();
_PacketStamps.clear();
// clears sent actions
while (!_Actions.empty())
CActionFactory::getInstance()->remove(_Actions.front().Actions),
_Actions.clear();
_AckBitMask = 0;
_LastReceivedNumber = 0xffffffff;
*/
//nldebug("CNET[%p]: connected->probe", this);
_Changes.push_back(CChange(0, ProbeReceived));
receiveSystemProbe(msgin);
return true;
break;
case SYSTEM_SYNC_CODE:
// receive stalled, decode stalled and state stalled
_ConnectionState = Synchronize;
//nldebug("CNET[%p]: connected->synchronize", this);
receiveSystemSync(msgin);
return true;
break;
case SYSTEM_STALLED_CODE:
// receive stalled, decode stalled and state stalled
_ConnectionState = Stalled;
//nldebug("CNET[%p]: connected->stalled", this);
receiveSystemStalled(msgin);
return true;
break;
case SYSTEM_SERVER_DOWN_CODE:
disconnect(); // will send disconnection message
nlwarning( "BACK-END DOWN" );
return false; // exit now from loop, don't expect a new state
break;
default:
nlwarning("CNET[%p]: received system %d in state Connected", this, message);
break;
}
}
else
{
receiveNormalMessage(msgin);
}
}
}
return false;
}
//
// Probe state
//
void CNetworkConnection::receiveSystemProbe(CBitMemStream &msgin)
{
_LatestProbeTime = _UpdateTime;
msgin.serial(_LatestProbe);
_LatestProbes.push_back(_LatestProbe);
//nldebug("CNET[%p]: received PROBE %d", this, _LatestProbe);
}
// sends system sync acknowledge
void CNetworkConnection::sendSystemAckProbe()
{
CBitMemStream message;
buildSystemHeader(message);
uint8 probe = SYSTEM_ACK_PROBE_CODE;
uint32 numprobes = (uint32)_LatestProbes.size();
message.serial(probe);
message.serial(numprobes);
uint i;
for (i=0; i<numprobes; ++i)
message.serial(_LatestProbes[i]);
_LatestProbes.clear();
uint32 length = message.length();
_Connection.send (message.buffer(), length);
//sendUDP (&(_Connection), message.buffer(), length);
statsSend(length);
//nlinfo("CNET[%p]: sent ACK_PROBE (%d probes)", this, numprobes);
}
bool CNetworkConnection::stateProbe()
{
// if receives System SYNC
// immediate state SYNC
// else if receives System PROBE
// decode PROBE
// sends System ACK_PROBE
#ifdef ENABLE_INCOMING_MSG_RECORDER
if ( ClientCfg.Local && !_ReplayIncomingMessagesOn )
return false;
while ( (_ReplayIncomingMessagesOn && dataToReplayAvailable()) ||
_Connection.dataAvailable() )
#else
while (_Connection.dataAvailable())// && _TotalMessages<5)
#endif
{
_DecodedHeader = false;
CBitMemStream msgin (true);
if (buildStream(msgin) && decodeHeader(msgin))
{
if (_SystemMode)
{
uint8 message = 0;
msgin.serial(message);
switch (message)
{
case SYSTEM_SYNC_CODE:
// receive sync, decode sync and state synchronize
_ConnectionState = Synchronize;
//nldebug("CNET[%p]: probe->synchronize", this);
receiveSystemSync(msgin);
return true;
break;
case SYSTEM_STALLED_CODE:
// receive sync, decode sync and state synchronize
_ConnectionState = Stalled;
//nldebug("CNET[%p]: probe->stalled", this);
receiveSystemStalled(msgin);
return true;
break;
case SYSTEM_PROBE_CODE:
// receive sync, decode sync
receiveSystemProbe(msgin);
break;
case SYSTEM_SERVER_DOWN_CODE:
disconnect(); // will send disconnection message
nlwarning( "BACK-END DOWN" );
return false; // exit now from loop, don't expect a new state
break;
default:
nlwarning("CNET[%p]: received system %d in state Probe", message);
break;
}
}
else
{
nlwarning("CNET[%p]: received normal in state Probe", this);
}
}
}
// send ack sync if received sync or last sync timed out
if (!_LatestProbes.empty() || _UpdateTime-_LatestProbeTime > 300)
{
sendSystemAckProbe();
_LatestProbeTime = _UpdateTime;
}
else
nlSleep(10);
return false;
}
//
// Stalled state
//
void CNetworkConnection::receiveSystemStalled(CBitMemStream &/* msgin */)
{
nldebug("CNET[%p]: received STALLED", this);
}
bool CNetworkConnection::stateStalled()
{
// if receives System SYNC
// immediate state SYNC
// else if receives System STALLED
// decode STALLED (nothing to do)
// else if receives System PROBE
// immediate state PROBE
#ifdef ENABLE_INCOMING_MSG_RECORDER
if ( ClientCfg.Local && !_ReplayIncomingMessagesOn )
return false;
while ( (_ReplayIncomingMessagesOn && dataToReplayAvailable()) ||
_Connection.dataAvailable() )
#else
while (_Connection.dataAvailable())// && _TotalMessages<5)
#endif
{
_DecodedHeader = false;
CBitMemStream msgin (true);
if (buildStream(msgin) && decodeHeader(msgin))
{
if (_SystemMode)
{
uint8 message = 0;
msgin.serial(message);
switch (message)
{
case SYSTEM_SYNC_CODE:
// receive sync, decode sync and state synchronize
_ConnectionState = Synchronize;
nldebug("CNET[%p]: stalled->synchronize", this);
receiveSystemSync(msgin);
return true;
break;
case SYSTEM_PROBE_CODE:
// receive sync, decode sync
_ConnectionState = Probe;
nldebug("CNET[%p]: stalled->probe", this);
receiveSystemProbe(msgin);
break;
case SYSTEM_STALLED_CODE:
// receive stalled, decode stalled
receiveSystemStalled(msgin);
break;
case SYSTEM_SERVER_DOWN_CODE:
disconnect(); // will send disconnection message
nlwarning( "BACK-END DOWN" );
return false; // exit now from loop, don't expect a new state
break;
default:
nlwarning("CNET[%p]: received system %d in state Stalled", message);
break;
}
}
else
{
nlwarning("CNET[%p]: received normal in state Stalled", this);
}
}
}
return false;
}
//
// encoding / decoding methods
//
bool CNetworkConnection::decodeHeader(CBitMemStream &msgin, bool checkMessageNumber)
{
if (_DecodedHeader)
return true;
// simulate packet loss
#if !FINAL_VERSION
if(uint((rand()%100)) < ClientCfg.SimulatePacketLossRatio)
return false;
#endif
++_TotalMessages;
_LastReceivedTime = _UpdateTime;
msgin.serial (_CurrentReceivedNumber);
msgin.serial (_SystemMode);
if ((sint)_CurrentReceivedNumber > (sint)_LastReceivedPacketInBothModes && checkMessageNumber)
{
_TotalLostPackets += (_CurrentReceivedNumber-_LastReceivedPacketInBothModes - 1);
_LastReceivedPacketInBothModes = _CurrentReceivedNumber;
}
_MeanPackets.update((float)_CurrentReceivedNumber, ryzomGetLocalTime ());
/// \todo remove
//nlinfo("DBG:BEN: decodeHeader, packet=%d, %s", _CurrentReceivedNumber, _SystemMode ? "SYSTEM" : "NORMAL");
///
if (_SystemMode)
{
}
else
{
msgin.serial (_LastReceivedAck);
#ifdef INCLUDE_FE_STATS_IN_PACKETS
// receive debug info in the message header
uint32 UserLWatch,
CycleWatch,
ReceiveWatch,
SendWatch;
float PriorityAmount;
uint16 SeenEntities;
//float HpT;
msgin.serial (UserLWatch);
msgin.serial (CycleWatch);
msgin.serial (ReceiveWatch);
msgin.serial (SendWatch);
msgin.serial (PriorityAmount);
msgin.serial (SeenEntities);
//msgin.serial (HpT);
#endif
#ifdef DISPLAY_ENTITIES
UserLWatchGraph.addOneValue ((float)UserLWatch);
CycleWatchGraph.addOneValue ((float)CycleWatch);
ReceiveWatchGraph.addOneValue ((float)ReceiveWatch);
SendWatchGraph.addOneValue ((float)SendWatch);
PriorityAmountGraph.addOneValue(PriorityAmount);
SeenEntitiesGraph.addOneValue(SeenEntities);
//HPThreshold = HpT;
#else
static sint counter = 128;
--counter;
if ( counter == 0 )
{
// nlinfo( "User:%u Cycle:%u Rcv:%u Snd:%u PrioAmount:%.2f",
// UserLWatch, CycleWatch, ReceiveWatch, SendWatch, PriorityAmount );
counter = 128;
}
#endif // DISPLAY_ENTITIES
}
if (!checkMessageNumber)
return true;
// display info on this packet
//nlinfo("CNET[%p] received packet %d, %s mode - LastReceivedAck=%d", this, _CurrentReceivedNumber, _SystemMode ? "SYTEM" : "NORMAL", _LastReceivedAck);
// todo doesn't work if we receive the packet in bad order or 2 same packet
if (_CurrentReceivedNumber > _LastReceivedNumber+1)
{
// we lost some messages...
nldebug ("CNET[%p] lost messages server->client [%d; %d]", this, _LastReceivedNumber+1, _CurrentReceivedNumber-1);
_MeanLoss.update((float)(_CurrentReceivedNumber-_LastReceivedNumber-1), ryzomGetLocalTime ());
}
else if (_CurrentReceivedNumber == _LastReceivedNumber)
{
// we receive the same packet that the last one
nldebug ("CNET[%p] awaiting packet %d, received packet %d", this, _LastReceivedNumber+1, _CurrentReceivedNumber);
return false;
}
else if (_CurrentReceivedNumber < _LastReceivedNumber)
{
// it's an older message than the current
nldebug ("CNET[%p] received an old message, awaiting packet %d, received packet %d", this, _LastReceivedNumber+1, _CurrentReceivedNumber);
return false;
}
// don't acknowledge system messages and normal messages in
// because this will disturb impulsion from frontend, that will interpret it as if previous messages were ok
bool ackBool = (!_SystemMode && (_ConnectionState == Connected || _ConnectionState == Synchronize));
uint ackBit = (ackBool ? 1 : 0);
if (_CurrentReceivedNumber - _LastReceivedNumber < 32)
{
_AckBitMask <<= _CurrentReceivedNumber - _LastReceivedNumber;
_AckBitMask |= _LastAckBit << (_CurrentReceivedNumber - _LastReceivedNumber - 1);
}
else
{
_AckBitMask = (_CurrentReceivedNumber - _LastReceivedNumber == 32 && _LastAckBit != 0) ? 0x80000000 : 0x00000000;
}
_LastAckBit = ackBit;
// encode long ack bitfield
TPacketNumber i;
for (i=_LastReceivedNumber+1; i<_CurrentReceivedNumber; ++i)
_LongAckBitField.clear(i&(NumBitsInLongAck-1));
_LongAckBitField.set(_CurrentReceivedNumber&(NumBitsInLongAck-1), ackBool);
// no more than NumBitsInLongAck ack in field
if ((TPacketNumber)_LastAckInLongAck <= (TPacketNumber)(_CurrentReceivedNumber-NumBitsInLongAck))
_LastAckInLongAck = _CurrentReceivedNumber-NumBitsInLongAck+1;
_LastReceivedNumber = _CurrentReceivedNumber;
_DecodedHeader = true;
return true;
}
void CNetworkConnection::buildSystemHeader(NLMISC::CBitMemStream &msgout)
{
msgout.serial (_CurrentSendNumber);
bool systemMode = true;
msgout.serial (systemMode);
_PacketStamps.push_back(make_pair(_CurrentSendNumber, _UpdateTime));
++_CurrentSendNumber;
}
//
//
//
void CNetworkConnection::setDataBase(CCDBNodeBranch *database)
{
_DataBase = database;
}
//
//
//
void CNetworkConnection::push(CBitMemStream &msg)
{
sint32 maxImpulseBitSize = 230*8;
CActionGeneric *ag = (CActionGeneric *)CActionFactory::getInstance ()->create (INVALID_SLOT, ACTION_GENERIC_CODE);
if( ag == NULL ) //TODO: see that with oliver...
return;
uint bytelen = msg.length();
sint32 impulseMinBitSize = (sint32)CActionFactory::getInstance ()->size( ag );
sint32 impulseBitSize = impulseMinBitSize + (4 + bytelen)*8;
if (impulseBitSize < maxImpulseBitSize)
{
ag->set(msg);
push(ag);
}
else
{
CAction *casted = ag;
CActionFactory::getInstance()->remove(casted);
ag = NULL;
// MultiPart impulsion
CActionGenericMultiPart *agmp = (CActionGenericMultiPart *)CActionFactory::getInstance ()->create (INVALID_SLOT, ACTION_GENERIC_MULTI_PART_CODE);
sint32 minimumBitSizeForMP = CActionFactory::getInstance ()->size (agmp);
sint32 availableSize = (maxImpulseBitSize - minimumBitSizeForMP) / 8; // (in bytes)
#ifdef NL_DEBUG
nlassert( availableSize > 0 ); // the available size must be larger than the 'empty' size
#endif
sint32 nbBlock = (bytelen + availableSize - 1) / availableSize;
uint8 num = _ImpulseMultiPartNumber++;
for (sint32 i = 0; i < nbBlock; i++)
{
if (i != 0)
agmp = (CActionGenericMultiPart *)CActionFactory::getInstance ()->create (INVALID_SLOT, ACTION_GENERIC_MULTI_PART_CODE);
agmp->set(num, (uint16)i, msg.buffer(), bytelen, availableSize, (uint16)nbBlock);
push(agmp);
}
}
}
void CNetworkConnection::pushTarget(TCLEntityId slot, LHSTATE::TLHState targetOrPickup )
{
CActionTargetSlot *ats = (CActionTargetSlot*)CActionFactory::getInstance ()->create (INVALID_SLOT, ACTION_TARGET_SLOT_CODE);
nlassert (ats != NULL);
ats->Slot = slot;
switch ( targetOrPickup ) // ensure the value is good for the FE
{
case LHSTATE::NONE: ats->TargetOrPickup = 0; break;
case LHSTATE::LOOTABLE: ats->TargetOrPickup = 1; break;
case LHSTATE::HARVESTABLE: ats->TargetOrPickup = 2; break;
default:
break;
}
ats->TargetOrPickup = (uint32)targetOrPickup;
push(ats);
}
void CNetworkConnection::push(CAction *action)
{
if (_Actions.empty() || _Actions.back().Cycle != 0)
{
//nlinfo("-BEEN- push back 2 [size=%d, cycle=%d]", _Actions.size(), _Actions.empty() ? 0 : _Actions.back().Cycle);
_Actions.push_back(CLFECOMMON::CActionBlock());
}
_Actions.back().Actions.push_back(action);
}
//
void CNetworkConnection::send(TGameCycle cycle)
{
try
{
// check the current game cycle was not already sent
nlassertex(_LastSentCycle < cycle, ("Client=%p, _LastSentCycle=%d, cycle=%d", this, _LastSentCycle, cycle));
/*
if (_LastSentCycle == cycle) // delay send till next tick
return;
*/
_LastSentCycle = cycle;
// if no actions were sent at this cyle, create a new block
if (_Actions.empty() || _Actions.back().Cycle != 0)
{
// nlinfo("-BEEN- push back 1 [size=%d, cycle=%d]", _Actions.size(), _Actions.empty() ? 0 : _Actions.back().Cycle);
// _Actions.push_back();
}
else
{
CActionBlock &block = _Actions.back();
/*
CAction *dummy = CActionFactory::getInstance()->create(INVALID_SLOT, ACTION_DUMMY_CODE);
((CActionDummy*)dummy)->Dummy1 = _DummySend++;
push(dummy);
*/
_Actions.back().Cycle = cycle;
// check last block isn't bigger than maximum allowed
uint i;
uint bitSize = 32+8; // block size is 32 (cycle) + 8 (number of actions
for (i=0; i<block.Actions.size(); ++i)
{
bitSize += CActionFactory::getInstance()->size(block.Actions[i]);
if (bitSize >= 480*8)
break;
}
if (i<block.Actions.size())
{
nldebug( "Postponing %u actions exceeding max size in block %d (block size is %d bits long)", block.Actions.size()-i, cycle, bitSize );
// last block is bigger than allowed
// allocate a new block
_Actions.push_back(CActionBlock());
CActionBlock &newBlock = _Actions.back();
// reset block stamp
newBlock.Cycle = 0;
// copy remaining actions in new block
newBlock.Actions.insert(newBlock.Actions.begin(),
block.Actions.begin()+i,
block.Actions.end());
// remove remaining actions of block
block.Actions.erase(block.Actions.begin()+i, block.Actions.end());
}
//nlinfo("-BEEN- setcycle [size=%d, cycle=%d]", _Actions.size(), _Actions.empty() ? 0 : _Actions.back().Cycle);
}
if (_ConnectionState == Connected)
{
sendNormalMessage();
}
}
catch (const ESocket &/*e*/)
{
_ConnectionState = Disconnect;
disconnect(); // won't send disconnection message as state is already Disconnect
}
}
void CNetworkConnection::send()
{
try
{
// Send is temporised, that is the packet may not be actually sent.
// We don't care, since:
// - this packet has no new data (not ticked send)
// - a next send() will send packet if time elapsed enough
// - a next send(tick) will really be sent
// This way, we can say that at most 15 packets will be delivered each second
// (5 send(tick), and 10 send() -- if you take getLocalTime() inaccuracy into account)
if (_ConnectionState == Connected && CTime::getLocalTime()-_LastSendTime > 100)
{
sendNormalMessage();
}
}
catch (const ESocket &/*e*/)
{
_ConnectionState = Disconnect;
}
}
//
//
//
// sends system sync acknowledge
void CNetworkConnection::sendSystemDisconnection()
{
CBitMemStream message;
buildSystemHeader(message);
uint8 disconnection = SYSTEM_DISCONNECTION_CODE;
message.serial(disconnection);
uint32 length = message.length();
if (_Connection.connected())
_Connection.send (message.buffer(), length);
//sendUDP (&(_Connection), message.buffer(), length);
statsSend(length);
updateBufferizedPackets ();
nlinfo("CNET[%p]: sent DISCONNECTION", this);
}
void CNetworkConnection::disconnect()
{
#ifdef MEASURE_RECEIVE_DATES
if ( LogReceiveEnabled )
{
displayReceiveLog();
}
#endif
if (_ConnectionState == NotInitialised ||
_ConnectionState == NotConnected ||
_ConnectionState == Authenticate ||
_ConnectionState == Disconnect)
{
//nlwarning("Unable to disconnect(): not connected yet, or already disconnected.");
return;
}
sendSystemDisconnection();
_Connection.close();
_ConnectionState = Disconnect;
}
//
// Quit state
//
void CNetworkConnection::receiveSystemAckQuit(CBitMemStream &/* msgin */)
{
nldebug("CNET[%p]: received ACK_QUIT", this);
_ReceivedAckQuit = true;
}
bool CNetworkConnection::stateQuit()
{
#ifdef ENABLE_INCOMING_MSG_RECORDER
if ( ClientCfg.Local && !_ReplayIncomingMessagesOn )
return false;
while ( (_ReplayIncomingMessagesOn && dataToReplayAvailable()) ||
_Connection.dataAvailable() )
#else
while (_Connection.dataAvailable())// && _TotalMessages<5)
#endif
{
_DecodedHeader = false;
CBitMemStream msgin (true);
if (buildStream(msgin) && decodeHeader(msgin, false))
{
if (_SystemMode)
{
uint8 message = 0;
msgin.serial(message);
switch (message)
{
case SYSTEM_SYNC_CODE:
// receive sync, decode sync and state synchronize
reset();
_ConnectionState = Synchronize;
nldebug("CNET[%p]: quit->synchronize", this);
receiveSystemSync(msgin);
return true;
break;
/*
case SYSTEM_PROBE_CODE:
// receive sync, decode sync
_ConnectionState = Probe;
nldebug("CNET[%p]: stalled->probe", this);
receiveSystemProbe(msgin);
break;
case SYSTEM_STALLED_CODE:
// receive stalled, decode stalled
_ConnectionState = Stalled;
receiveSystemStalled(msgin);
return true;
break;
*/
case SYSTEM_SERVER_DOWN_CODE:
disconnect(); // will send disconnection message
nlwarning( "BACK-END DOWN" );
return false; // exit now from loop, don't expect a new state
break;
case SYSTEM_ACK_QUIT_CODE:
// receive ack quit -> reset connection state
receiveSystemAckQuit(msgin);
break;
default:
nlwarning("CNET[%p]: received system %d in state Stalled", message);
break;
}
}
else
{
nlwarning("CNET[%p]: received normal in state Stalled", this);
}
}
}
// send quit if not yet received a ack quit
if (!_ReceivedAckQuit && _UpdateTime-_LatestQuitTime > 100)
{
sendSystemQuit();
_LatestQuitTime = _UpdateTime;
}
return false;
}
/*
* Quit the game till the connection is reset
*/
void CNetworkConnection::quit()
{
nlinfo("CNetworkConnection::quit() called, setting to quitting state.");
++_QuitId;
_ConnectionState = Quit;
_ReceivedAckQuit = false;
_LatestQuitTime = _UpdateTime;
sendSystemQuit();
}
void CNetworkConnection::reset()
{
_CurrentSendNumber = 0;
_LastReceivedNumber = 0;
_LastReceivedTime = 0;
_LastReceivedNormalTime = 0;
_AckBitMask = 0;
_LastAckBit = 0;
_Synchronize = 0;
_InstantPing = 10000;
_BestPing = 10000;
_LCT = 100;
_MachineTimeAtTick = ryzomGetLocalTime ();
_MachineTicksAtTick = CTime::getPerformanceTime();
_LastSentSync = 0;
_LatestSync = 0;
_PropertyDecoder.init (256);
_DummySend = 0;
_LongAckBitField.resize(1024);
_LastAckInLongAck = 0;
_LastSentCycle = 0;
_TotalReceivedBytes = 0;
_PartialReceivedBytes = 0;
_TotalSentBytes = 0;
_PartialSentBytes = 0;
_MeanPackets.MeanPeriod = 5000;
_MeanLoss.MeanPeriod = 5000;
_LastReceivedPacketInBothModes = 0;
_TotalLostPackets = 0;
_ConnectionQuality = false;
_CurrentSmoothServerTick= 0;
_SSTLastLocalTime= 0;
}
void CNetworkConnection::initTicks()
{
_CurrentClientTick = 0;
_CurrentServerTick = 0;
_MsPerTick = 100;
_LCT = LCT;
}
void CNetworkConnection::reinit()
{
// Reset data
_ImpulseDecoder.reset();
if (_DataBase)
_DataBase->resetData(_CurrentServerTick, true);
_LongAckBitField.clearAll();
_PacketStamps.clear();
_Actions.clear();
_Changes.clear();
_GenericMultiPartTemp.clear();
_IdMap.clear();
reset();
initTicks();
// Reuse the udp socket
_Connection.~CUdpSimSock();
new (&_Connection) CUdpSimSock();
}
// sends system sync acknowledge
void CNetworkConnection::sendSystemQuit()
{
CBitMemStream message;
buildSystemHeader(message);
uint8 quit = SYSTEM_QUIT_CODE;
message.serial(quit);
message.serial(_QuitId);
uint32 length = message.length();
_Connection.send (message.buffer(), length);
//sendUDP (&(_Connection), message.buffer(), length);
statsSend(length);
updateBufferizedPackets ();
nlinfo("CNET[%p]: sent QUIT", this);
}
//
void CNetworkConnection::displayAllocationStats()
{
nlinfo("CNET[%p]: %d queued blocks, %d changes", this, _Actions.size(), _Changes.size());
}
string CNetworkConnection::getAllocationStats()
{
char buf[128];
sprintf(buf, "CNET[%p]: %u queued blocks, %u changes", this, (uint)_Actions.size(), (uint)_Changes.size());
return string(buf);
}
//
//
//
void CNetworkConnection::genericAction (CActionGeneric *ag)
{
// manage a generic action
CBitMemStream &bms = ag->get ();
//nldebug("CNET: Calling impulsion callback (size %u) :'%s'", this, bms.length(), toHexaString(bms.bufferAsVector()).c_str());
//nldebug("CNET[%p]: Calling impulsion callback (size %u)", this, bms.length());
if (_ImpulseCallback != NULL)
_ImpulseCallback(bms, _LastReceivedNumber, _ImpulseArg);
}
void CNetworkConnection::CGenericMultiPartTemp::set (CActionGenericMultiPart *agmp, CNetworkConnection *parent)
{
if (NbBlock == 0xFFFFFFFF)
{
// new GenericMultiPart
NbBlock = agmp->NbBlock;
NbCurrentBlock = 0;
TempSize = 0;
Temp.clear();
Temp.resize(NbBlock);
BlockReceived.resize(NbBlock);
for (uint i = 0; i < NbBlock; i++)
BlockReceived[i] = false;
}
nlassert (NbBlock == agmp->NbBlock);
nlassert (NbBlock > agmp->Part);
// check if the block was already received
if (BlockReceived[agmp->Part])
{
nlwarning ("CLMPNET[%p]: This part is already received, discard it", this);
return;
}
Temp[agmp->Part] = agmp->PartCont;
BlockReceived[agmp->Part] = true;
NbCurrentBlock++;
TempSize += (uint32)agmp->PartCont.size();
if (NbCurrentBlock == NbBlock)
{
// reform the total action
//nldebug("CLMPNET[%p]: Received a TOTAL generic action MP size: number %d nbblock %d", this, agmp->Number, NbBlock);
CBitMemStream bms(true);
uint8 *ptr = bms.bufferToFill (TempSize);
for (uint i = 0; i < Temp.size (); i++)
{
memcpy (ptr, &(Temp[i][0]), Temp[i].size());
ptr += Temp[i].size();
}
NbBlock = 0xFFFFFFFF;
//nldebug("CLMPNET[%p]: Received a generic action size %d", this, bms.length());
// todo interface api, call a user callback
if (parent->_ImpulseCallback != NULL)
parent->_ImpulseCallback(bms, parent->_LastReceivedNumber, parent->_ImpulseArg);
}
}
void CNetworkConnection::genericAction (CActionGenericMultiPart *agmp)
{
// manage a generic action (big one that comes by blocks)
vector<uint8> &v = agmp->PartCont;
//nldebug("CLMPNET[%p]: Received a generic action MP size %d: number %d part %d nbblock %d", this, v.size(), agmp->Number, agmp->Part, agmp->NbBlock);
// add it
if (_GenericMultiPartTemp.size() <= agmp->Number)
{
_GenericMultiPartTemp.resize (agmp->Number+1);
}
_GenericMultiPartTemp[agmp->Number].set(agmp, this);
}
CNetworkConnection::TVPNodeClient::TSlotContext CNetworkConnection::TVPNodeClient::SlotContext;
/*
* Return the average billed upload rate in kbps, including all headers (UDP+IP+Ethernet)
*/
void CNetworkConnection::statsSend(uint32 bytes)
{
_TotalSentBytes += bytes;
_PartialSentBytes += bytes;
_MeanUpload.update((float)bytes, ryzomGetLocalTime ());
UploadGraph.addValue ((float)bytes);
}
/*
* Return the average billed download rate in kbps, including all headers (UDP+IP+Ethernet)
*/
void CNetworkConnection::statsReceive(uint32 bytes)
{
_TotalReceivedBytes += bytes;
_PartialReceivedBytes += bytes;
_MeanDownload.update((float)bytes, ryzomGetLocalTime ());
DownloadGraph.addValue ((float)bytes);
}
NLMISC_COMMAND( displayPosUpdateGraph, "Display position update interval graph", "0|<slot>" )
{
// Stop graph in all cases
if ( PosUpdateIntervalGraph )
{
delete PosUpdateIntervalGraph;
delete PosUpdatePredictionGraph;
PosUpdateIntervalGraph = NULL;
PosUpdatePredictionGraph = NULL;
}
// Start graph if argument is not 0
if ( (args.size() != 0) && (args[0] != "0") )
{
uint8 slot;
fromString(args[0], slot);
PosUpdateIntervalGraph = new CSlotGraph( "Interval", 350, 2, 100, 200, CRGBA(128,0,0,64), 1000, 20, true, slot );
PosUpdatePredictionGraph = new CSlotGraph( " Prediction", 350, 2, 100, 200, CRGBA(0,0,128,64), 1000, 20, true, slot );
}
return true;
}
// ***************************************************************************
sint64 CNetworkConnection::convertToSmoothServerTick(NLMISC::TGameCycle t) const
{
return t*SMOOTH_SERVER_TICK_PER_TICK;
}
// ***************************************************************************
void CNetworkConnection::updateSmoothServerTick()
{
// Get deltaT
NLMISC::TTime t= ryzomGetLocalTime ();
sint32 deltaT= (sint32)(t - _SSTLastLocalTime);
_SSTLastLocalTime= t;
// Get the actual ServerTick not smoothed value
sint64 actualST= _CurrentServerTick*SMOOTH_SERVER_TICK_PER_TICK;
// Special bound cases
if( _CurrentSmoothServerTick < actualST+SMOOTH_SERVER_TICK_DIFF_MIN )
{
// Reset (possible jump to future!)
_CurrentSmoothServerTick= actualST;
}
else if( _CurrentSmoothServerTick>= actualST+SMOOTH_SERVER_TICK_DIFF_MAX )
{
// Clamp (no reset, no back to past!)
_CurrentSmoothServerTick= actualST+SMOOTH_SERVER_TICK_DIFF_MAX;
}
else
{
// Compute the Factor of acceleration according to error difference (FIXED 16:16)
sint64 factor;
sint64 errorDiff= _CurrentSmoothServerTick-actualST;
// If the estimation is in the TimeWindow, no acceleration
if( errorDiff>=-SMOOTH_SERVER_TICK_WINDOW && errorDiff<=SMOOTH_SERVER_TICK_WINDOW)
{
factor= 65536;
}
// If the estimation is late, accelerate
else if( errorDiff<0 )
{
float f= (float)(errorDiff+SMOOTH_SERVER_TICK_WINDOW)/(SMOOTH_SERVER_TICK_DIFF_MIN+SMOOTH_SERVER_TICK_WINDOW);
f*= SMOOTH_SERVER_TICK_ACCEL;
factor= sint64(f*65536);
}
// Else the estimation is too early, slowDown
else
{
float f= (float)(errorDiff-SMOOTH_SERVER_TICK_WINDOW)/(SMOOTH_SERVER_TICK_DIFF_MAX-SMOOTH_SERVER_TICK_WINDOW);
f= 1-f;
factor= sint64(f*65536);
}
// Update the Smooth
_CurrentSmoothServerTick+= ((deltaT*SMOOTH_SERVER_TICK_PER_TICK*factor)/getMsPerTick()) >> 16;
}
}
Reference in a new issue View git blame Copy permalink