ryzom/client/src/network_connection.h

   1 // Ryzom - MMORPG Framework <http://dev.ryzom.com/projects/ryzom/>
   2 // Copyright (C) 2010  Winch Gate Property Limited
   3 //
   4 // This source file has been modified by the following contributors:
   5 // Copyright (C) 2013  Laszlo KIS-ADAM (dfighter) <dfighter1985@gmail.com>
   6 // Copyright (C) 2015-2020  Jan BOON (Kaetemi) <jan.boon@kaetemi.be>
   7 //
   8 // This program is free software: you can redistribute it and/or modify
   9 // it under the terms of the GNU Affero General Public License as
  10 // published by the Free Software Foundation, either version 3 of the
  11 // License, or (at your option) any later version.
  12 //
  13 // This program is distributed in the hope that it will be useful,
  14 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16 // GNU Affero General Public License for more details.
  17 //
  18 // You should have received a copy of the GNU Affero General Public License
  19 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
  20
  21
  22
  23 #ifndef NL_NETWORK_CONNECTION_H
  24 #define NL_NETWORK_CONNECTION_H
  25
  26 #include "nel/misc/types_nl.h"
  27 #include "nel/misc/bit_set.h"
  28
  29 #include <string>
  30 #include <vector>
  31 #include <list>
  32 #include <deque>
  33 #include <set>
  34
  35 #include <nel/misc/bit_mem_stream.h>
  36 #include <nel/net/inet_address.h>
  37 #include <nel/net/login_cookie.h>
  38 #include <nel/net/login_client.h>
  39 #include <nel/net/udp_sim_sock.h>
  40 #include <nel/misc/vectord.h>
  41 #include <nel/misc/md5.h>
  42
  43 #include "time_client.h"
  44 #include "game_share/entity_types.h"
  45 #include "property_decoder.h"
  46 #include "impulse_decoder.h"
  47 #include "game_share/action.h"
  48 #include "game_share/ryzom_entity_id.h"
  49 #include "game_share/action_block.h"
  50 #include "game_share/loot_harvest_state.h"
  51
  52 /*
  53  * ENABLE_INCOMING_MSG_RECORDER for recording/replaying incoming network messages
  54  */
  55 #undef ENABLE_INCOMING_MSG_RECORDER
  56
  57 #ifdef ENABLE_INCOMING_MSG_RECORDER
  58 #include <nel/misc/file.h>
  59 #endif
  60
  61 /*
  62 // UNUSED
  63 const uint              PropertiesPerEntity = 16;
  64 const uint              EntitiesPerClient = 256;
  65 */
  66
  67 namespace NLMISC{
  68 class CCDBNodeBranch;
  69 }
  70
  71 namespace CLFECOMMON
  72 {
  73         class CActionGeneric;
  74         class CActionGenericMultiPart;
  75 }
  76
  77 // Hierarchical timer
  78 H_AUTO_DECL ( RZ_Client_Network_Connection_Set_Reference_Position )
  79
  80 //#define MEASURE_FE_SENDING
  81
  82 extern const char * ConnectionStateCStr [9];
  83
  84
  85 /**
  86  * Exception thrown when the sending returns a "blocking operation interrupted".
  87  */
  88 class EBlockedByFirewall : public NLNET::ESocket
  89 {};
  90
  91
  92 struct TNewEntityInfo
  93 {
  94         void reset()
  95         {
  96                 DataSetIndex = CLFECOMMON::INVALID_CLIENT_DATASET_INDEX;
  97                 Alias = 0;
  98         }
  99
 100         /// Compressed dataset row
 101         CLFECOMMON::TClientDataSetIndex         DataSetIndex;
 102
 103         /// Alias (only for mission giver NPCs)
 104         uint32                                                          Alias;
 105 };
 106
 107
 108
 109 // ***************************************************************************
 110 /**
 111  * Abstracts the connection client towards front-end
 112  * \author Benjamin Legros, Olivier Cado
 113  * \author Nevrax France
 114  * \date 2001-2002
 115  */
 116 class CNetworkConnection
 117 {
 118 public:
 119         enum
 120         {
 121                 /*
 122                  * DO LEAVE ENOUGH ROOM FOR FUTURE PROPERTIES !
 123                  */
 124                 AddNewEntity = 32,
 125                 RemoveOldEntity,
 126                 ConnectionReady,
 127                 LagDetected,
 128                 ProbeReceived
 129         };
 130
 131
 132         struct TVPNodeClient : public CLFECOMMON::TVPNodeBase
 133         {
 134                 struct TSlotContext
 135                 {
 136                         CNetworkConnection                                              *NetworkConnection;
 137                         CLFECOMMON::TCLEntityId                                 Slot;
 138                         NLMISC::TGameCycle                                              Timestamp;
 139                 };
 140
 141                 // Static data
 142                 static TSlotContext                                                     SlotContext;
 143
 144                 ///
 145                 TVPNodeClient() : TVPNodeBase() {}
 146
 147                 TVPNodeClient   *a() { return (TVPNodeClient*)VPA; }
 148                 TVPNodeClient   *b() { return (TVPNodeClient*)VPB; }
 149                 TVPNodeClient   *parent() { return (TVPNodeClient*)VPParent; }
 150
 151                 ///
 152                 void                    decodeDiscreetProperties( NLMISC::CBitMemStream& msgin )
 153                 {
 154                         msgin.serialBitAndLog( BranchHasPayload );
 155                         if ( BranchHasPayload )
 156                         {
 157                                 if ( isLeaf() )
 158                                 {
 159                                         SlotContext.NetworkConnection->decodeDiscreetProperty( msgin, PropIndex );
 160                                 }
 161                                 else
 162                                 {
 163                                         if ( a() ) a()->decodeDiscreetProperties( msgin );
 164                                         if ( b() ) b()->decodeDiscreetProperties( msgin );
 165                                 }
 166                         }
 167                 }
 168
 169                 void            makeChildren()
 170                 {
 171                         VPA = new TVPNodeClient();
 172                         VPA->VPParent = this;
 173                         VPB = new TVPNodeClient();
 174                         VPB->VPParent = this;
 175                 }
 176
 177                 void            makeDescendants( uint nbLevels )
 178                 {
 179                         makeChildren();
 180                         if ( nbLevels > 1 )
 181                         {
 182                                 a()->makeDescendants( nbLevels-1 );
 183                                 b()->makeDescendants( nbLevels-1 );
 184                         }
 185                 }
 186
 187                 void            deleteBranches()
 188                 {
 189                         if ( a() )
 190                         {       a()->deleteBranches();
 191                                 delete a();
 192                         }
 193                         if ( b() )
 194                         {       b()->deleteBranches();
 195                                 delete b();
 196                         }
 197                 }
 198
 199                 void            deleteA()
 200                 {
 201                         if ( a() )
 202                         {       a()->deleteBranches();
 203                                 delete a();
 204                         }
 205                 }
 206
 207                 void            deleteB()
 208                 {
 209                         if ( b() )
 210                         {       b()->deleteBranches();
 211                                 delete b();
 212                         }
 213                 }
 214
 215         };
 216
 217         /// Additional info for position updates
 218         struct TPositionInfo
 219         {
 220                 /**
 221                  * Only for positions (property index 0): interval, in game cycle unit, between the current
 222                  * position update and the next predicted one. In most cases the next real position update
 223                  * will occur just before the predicted interval elapses.
 224                  *
 225                  * If the interval cannot be predicted yet (e.g. before having received two updates
 226                  * for the same entity), PredictedInterval is set to ~0.
 227                  */
 228                 NLMISC::TGameCycle                      PredictedInterval;
 229
 230                 /// Is position interior (only for position)
 231                 bool                                            IsInterior;
 232         };
 233
 234         /**
 235          * A property change
 236          */
 237         class CChange
 238         {
 239         public:
 240
 241                 /// Constructor
 242                 CChange( CLFECOMMON::TCLEntityId id = 0, uint8 prop = 255, NLMISC::TGameCycle gc = 0 ) :
 243                         ShortId(id), Property(prop), GameCycle(gc) {}
 244
 245                 /// Slot
 246                 CLFECOMMON::TCLEntityId         ShortId;
 247
 248                 /// Property index
 249                 uint8                                           Property;
 250
 251                 /// The tick when the property changed, in server time
 252                 NLMISC::TGameCycle                      GameCycle;
 253
 254                 // These contextual additional properties must be set by hand (not by constructor)
 255                 union
 256                 {
 257                         /// Position additional information (prediction & interior)
 258                         TPositionInfo                                           PositionInfo;
 259
 260                         /// Additional information when creating an entitys
 261                         TNewEntityInfo                                          NewEntityInfo;
 262                 };
 263         };
 264
 265
 266         /// The states of the connection to the server (if you change them, change ConnectionStateCStr)
 267         enum TConnectionState
 268         {
 269                 NotInitialised = 0,             // nothing happened yet
 270                 NotConnected,                   // init() called
 271                 Authenticate,                   // connect() called, identified by the login server
 272                 Login,                                  // connecting to the frontend, sending identification
 273                 Synchronize,                    // connection accepted by the frontend, synchronizing
 274                 Connected,                              // synchronized, connected, ready to work
 275                 Probe,                                  // connection lost by frontend, probing for response
 276                 Stalled,                                // server is stalled
 277                 Disconnect,                             // disconnect() called, or timeout, or connection closed by frontend
 278                 Quit                                    // quit() called
 279         };
 280
 281         typedef void    (*TImpulseCallback)(NLMISC::CBitMemStream &, CLFECOMMON::TPacketNumber packet, void *arg);
 282
 283         static bool                                     LoggingMode;
 284
 285 public:
 286
 287         /// Constructor
 288         CNetworkConnection();
 289
 290         /// Destructor
 291         virtual ~CNetworkConnection();
 292
 293         /// @name Connection initialisation
 294         //@{
 295
 296         /**
 297          * Inits the client connection to the front-end.
 298          * \param cookie it s the cookie in string format that was passed to the exe command line (given by the nel_launcher)
 299          * \param addr it s the front end address in string format that was passed to the exe command line (given by the nel_launcher)
 300          */
 301         void                    init(const std::string &cookie, const std::string &addr);
 302
 303         /**
 304          * Sets the cookie and front-end address, resets the connection state.
 305          */
 306         void                    initCookie(const std::string &cookie, const std::string &addr);
 307
 308         /**
 309          * Connects to the front-end (using or not the login system, depending on what was specified at init())
 310          * \param result the message returned in case of an error
 311          * Returns true if no error occurred.
 312          */
 313         bool                    connect(std::string &result);
 314
 315
 316         /**
 317          * Sets the callback called when        a generic impulse comes
 318          */
 319         void                    setImpulseCallback(TImpulseCallback callback, void *argument = NULL);
 320
 321         //@}
 322
 323
 324         /// @name Connection management
 325         //@{
 326
 327         /**
 328          * Tells if the client is yet connected or not
 329          */
 330         bool                    isConnected();
 331
 332
 333         /**
 334          * Gets the connection state
 335          */
 336         TConnectionState        getConnectionState() const { return _ConnectionState; }
 337
 338
 339         /**
 340          * Updates the whole connection with the frontend.
 341          *
 342          * Behaviour in login state when a firewall does not grant the sending:
 343          * - When a sending is refused (error "Blocking operation interrupted")
 344          * the exception EBlockedByFirewall in thrown. The first time, a time-out is armed.
 345          * - In a later attempt, if the time-out expired, the function sets state to
 346          * Disconnect, then throws EBlockedByFirewall.
 347          *
 348          * \return bool 'true' if data were sent/received.
 349          */
 350         bool                    update();
 351
 352
 353         /**
 354          * Disconnects the current connection
 355          */
 356         void                    disconnect();
 357
 358         //@}
 359
 360
 361         /**
 362          * Quit the game till the connection is reset
 363          */
 364         void                    quit();
 365
 366
 367         /// @name Database management
 368         //@{
 369
 370         /**
 371          * Set database entry point
 372          */
 373         void                    setDataBase(NLMISC::CCDBNodeBranch *database);
 374
 375         //@}
 376
 377
 378
 379         /// @name Push and Send
 380         //@{
 381
 382         /**
 383          * Buffers a bitmemstream, that will be converted into a generic action, to be sent later to the server (at next update).
 384          */
 385         void                    push (NLMISC::CBitMemStream &msg);
 386
 387         /**
 388          * Buffers an action to be sent at next update (or later updates if network overload occurs)
 389          */
 390         void                    push(CLFECOMMON::CAction *action);
 391
 392         /**
 393          * Buffers a target action (set targetOrPickup to true for target, false for pick-up
 394          */
 395         void                    pushTarget(CLFECOMMON::TCLEntityId slot, LHSTATE::TLHState targetOrPickup);
 396
 397         /**
 398          * Send
 399          */
 400         void                    send(NLMISC::TGameCycle);
 401
 402         /**
 403          * Send last information without changes (only acknowedges frontend)
 404          */
 405         void                    send();
 406
 407         /**
 408          * Clear not acknownledged actions in sending buffer
 409          */
 410         void                    flushSendBuffer() { _Actions.clear(); }
 411
 412         /**
 413          * Set player reference position
 414          */
 415 //      void                    setReferencePosition(const NLMISC::CVectorD &position) { _ImpulseDecoder.setReferencePosition(position); }
 416
 417         //@}
 418
 419
 420         /// @name Temp methods
 421         // @{
 422
 423         const std::vector<CChange>                      &getChanges() { return _Changes; }
 424
 425         void    clearChanges() { _Changes.clear(); }
 426
 427         // @}
 428
 429
 430         /// @name Client time hints
 431         // @{
 432         NLMISC::TTime           getCurrentClientTime() { return _CurrentClientTime; }           // the time currently played at this frame (in the past)
 433         NLMISC::TGameCycle      getCurrentClientTick() { return _CurrentClientTick; }           // the tick for the current frame (also in the past)
 434         NLMISC::TGameCycle      getCurrentServerTick() { return _CurrentServerTick; }           // the last tick sent by the server.
 435         NLMISC::TTime           getMachineTimeAtTick() { return  _MachineTimeAtTick; }          // the machine time at the beginning of the current tick
 436         NLMISC::TTicks          getMachineTicksAtTick() { return _MachineTicksAtTick; }
 437         sint32                          getMsPerTick() { return _MsPerTick; }
 438         NLMISC::TGameCycle      getSynchronize() { return _Synchronize; }
 439         uint32                          getBestPing() { return _BestPing; }
 440         uint32                          getPing() const { return _InstantPing; }
 441         NLMISC::TTime           getLCT() { return _LCT; }                                                                                       // Lag compensation time
 442         NLMISC::TTime           getUpdateTime() { return _UpdateTime; }
 443         NLMISC::TTicks          getUpdateTicks() { return _UpdateTicks; }
 444         // Return an estimated smooth server tick. Increment only and accelerate/decelerate according to network
 445         sint64                          getCurrentSmoothServerTick() const { return _CurrentSmoothServerTick; }
 446         // Convert a GameCycle to a SmoothServerTick
 447         sint64                          convertToSmoothServerTick(NLMISC::TGameCycle t) const;
 448         // @}
 449
 450
 451         /// Set the Lag Compensation Time in ms (default: 1000)
 452         void                            setLCT( NLMISC::TTime lct ) { _LCT = lct; }
 453
 454         /// Allocation statistics
 455         void                            displayAllocationStats();
 456
 457         /// Get Allocation statistics
 458         std::string                     getAllocationStats();
 459
 460         /// @name Network Stats Methods
 461         // @{
 462
 463         uint32                          getSentBytes()                                          { return _TotalSentBytes; }
 464         uint32                          getPartialSentBytes()                           { uint32 ret = _PartialSentBytes; _PartialSentBytes = 0; return ret; }
 465         uint32                          getReceivedBytes()                                      { return _TotalReceivedBytes; }
 466         uint32                          getPartialReceivedBytes()                       { uint32 ret = _PartialReceivedBytes; _PartialReceivedBytes = 0; return ret; }
 467         bool                            getConnectionQuality()                          { return _ConnectionQuality; }
 468         NLMISC::TTime           getTimeSinceLastReceivedPacket()        { return NLMISC::CTime::getLocalTime()-_LastReceivedNormalTime; }
 469
 470
 471         /// Return the average billed download rate in kbps, including all headers (UDP+IP+Ethernet)
 472         float                           getMeanDownload() { return (_MeanDownload.mean(ryzomGetLocalTime ())+20+8+14)*0.008f; }
 473
 474         /// Return the average billed upload rate in kbps, including all headers (UDP+IP+Ethernet)
 475         float                           getMeanUpload() { return (_MeanUpload.mean(ryzomGetLocalTime ())+20+8+14)*0.008f; }
 476
 477         /// Return the packet loss average
 478         float                           getMeanPacketLoss()
 479         {
 480                 NLMISC::TTime   time = ryzomGetLocalTime ();
 481                 _MeanPackets.check(time);
 482                 _MeanLoss.check(time);
 483                 float   dpk = _MeanPackets.Values.empty() ? 0.0f : _MeanPackets.Values.back().second-_MeanPackets.Values.front().second+1;
 484                 float   tloss = _MeanLoss.Content;
 485                 return (dpk > 0.0f) ? std::min(100.0f, tloss*100.0f/dpk) : 0.0f;
 486         }
 487
 488         /// Get total lost packets
 489         uint32                          getTotalLostPackets() const     { return _TotalLostPackets; }
 490
 491         // @}
 492
 493
 494         /// Get the NLMISC::CEntityId from the TCLEntityId
 495         CLFECOMMON::TSheetId    get(CLFECOMMON::TCLEntityId id) const   { return _PropertyDecoder.sheet(id); }
 496
 497         /// Get the TCLEntityId from the NLMISC::CEntityId
 498         sint                            get(CLFECOMMON::TSheetId id) const
 499         {
 500                 TIdMap::const_iterator  it = _IdMap.find(id);
 501                 return (it != _IdMap.end()) ? (*it).second : -1;
 502         }
 503
 504         /// Set player's reference position
 505         void    setReferencePosition(const NLMISC::CVectorD &position)
 506         {
 507                 H_AUTO_USE ( RZ_Client_Network_Connection_Set_Reference_Position )
 508                 _PropertyDecoder.setReferencePosition( position );
 509         }
 510
 511         /// Get local IP address
 512         const NLNET::CInetAddress&      getAddress()
 513         {
 514                 return _Connection.localAddr();
 515         }
 516
 517         /// Get socket
 518         NLNET::CUdpSock&                        getConnection()
 519         {
 520                 return _Connection.UdpSock;
 521         }
 522
 523         /// Get userId
 524         uint32                                          getUserId()
 525         {
 526                 if(_LoginCookie.isValid())
 527                         return _LoginCookie.getUserId();
 528                 else
 529                         return 0xFFFFFFFF;
 530         }
 531
 532         /// Get connection state c_string
 533         const char *                                            getConnectionStateCStr()
 534         {
 535                 return ConnectionStateCStr[_ConnectionState];
 536         }
 537
 538         /// Return the login cookie
 539         const NLNET::CLoginCookie&      getLoginCookie() const
 540         {
 541                 return _LoginCookie;
 542         }
 543
 544 #ifdef ENABLE_INCOMING_MSG_RECORDER
 545         /// Return 'true' if currently recording.
 546         bool                                            isRecording() const {return _RecordIncomingMessagesOn;}
 547         /// Return 'true' if currently replaying.
 548         bool                                            isReplaying() const {return _ReplayIncomingMessagesOn;}
 549
 550         /// Start/stop recording the incoming messages (in online mode)
 551         void                                            setRecordingMode( bool onOff, const std::string& filename = "");
 552
 553         /// Start/stop replaying the incoming messages (in offline mode)
 554         void                                            setReplayingMode( bool onOff, const std::string& filename = "");
 555 #endif
 556
 557         void                                            decodeDiscreetProperty( NLMISC::CBitMemStream& msgin, CLFECOMMON::TPropIndex propIndex );
 558
 559         const std::string                       &getFrontendAddress() { return _FrontendAddress; }
 560
 561 protected:
 562         /// The current state of the connection
 563         TConnectionState                        _ConnectionState;
 564
 565         /// Connection Quality check
 566         bool                                            _ConnectionQuality;
 567
 568         /// The address of the frontend service
 569         std::string                                     _FrontendAddress;
 570
 571         /// The cookie for the login service
 572         NLNET::CLoginCookie                     _LoginCookie;
 573
 574         /// The UDP connection to the frontend
 575         NLNET::CUdpSimSock                      _Connection;
 576
 577         /// The receive buffer
 578         uint32                                          _ReceiveBuffer[65536];
 579
 580         /// The impulse decoder
 581         CImpulseDecoder                         _ImpulseDecoder;
 582
 583         /// The callback for generic actions
 584         TImpulseCallback                        _ImpulseCallback;
 585
 586         /// The callback argument
 587         void                                            *_ImpulseArg;
 588
 589
 590         /// Position update tick queues (used for statistical interval prediction), one per slot
 591         std::deque<NLMISC::TGameCycle>          _PosUpdateTicks[256];
 592
 593         /// Position update interval sorted sets (used for statistical interval prediction), one per slot
 594         std::multiset<NLMISC::TGameCycle>       _PosUpdateIntervals[256];
 595
 596         /// MD5 hash keys of msg.xml and database.xml
 597         NLMISC::CHashKeyMD5                     _MsgXmlMD5;
 598         NLMISC::CHashKeyMD5                     _DatabaseXmlMD5;
 599         // if prec don't work, those may (if the server run on windows, prec won't work)
 600         NLMISC::CHashKeyMD5                     _AltMsgXmlMD5;
 601         NLMISC::CHashKeyMD5                     _AltDatabaseXmlMD5;
 602
 603
 604         /// @name Network statistics
 605         //@{
 606
 607         class CMeanComputer
 608         {
 609         public:
 610                 CMeanComputer() : MeanPeriod(2000), Content(0.0f) {}
 611                 std::deque< std::pair<NLMISC::TTime, float> >   Values;
 612                 uint32                                                                                  MeanPeriod; // in ms
 613                 float                                                                                   Content;
 614
 615                 // checks all values have valid time (inside the mean period)
 616                 void                                    check(NLMISC::TTime time)
 617                 {
 618                         while (!Values.empty() && Values.front().first < time-MeanPeriod)
 619                         {
 620                                 Content -= Values.front().second;
 621                                 Values.pop_front();
 622                         }
 623                 }
 624
 625                 // updates the mean with a new value and time
 626                 void                                    update(float value, NLMISC::TTime time)
 627                 {
 628                         if (!Values.empty() && Values.back().first > time)
 629                                 return;
 630
 631                         check(time);
 632                         Values.push_back(std::make_pair(time, value));
 633                         Content += value;
 634                 }
 635
 636                 // gets the mean
 637                 float                                   mean(NLMISC::TTime time)
 638                 {
 639                         check(time);
 640                         return Content*1000.0f/(float)MeanPeriod;
 641                 }
 642         };
 643
 644         /// The total received length (from the beginning)
 645         uint32                                          _TotalReceivedBytes;
 646
 647         /// The partial received length (since last read)
 648         uint32                                          _PartialReceivedBytes;
 649
 650         /// The total sent length
 651         uint32                                          _TotalSentBytes;
 652
 653         /// Partial sent length
 654         uint32                                          _PartialSentBytes;
 655
 656         /// Total lost packets
 657         uint32                                          _TotalLostPackets;
 658
 659         /// Mean download (payload bytes)
 660         CMeanComputer                           _MeanDownload;
 661
 662         /// Mean upload (payload bytes)
 663         CMeanComputer                           _MeanUpload;
 664
 665         /// Mean packets
 666         CMeanComputer                           _MeanPackets;
 667
 668         /// Mean lost
 669         CMeanComputer                           _MeanLoss;
 670
 671         //@}
 672
 673
 674         /// The property decoder
 675         CPropertyDecoder                        _PropertyDecoder;
 676
 677         /// The database entry
 678         NLMISC::CCDBNodeBranch                          *_DataBase;
 679
 680
 681         /// @name Header message decoding
 682         //@{
 683
 684         /// Was the header decoded for the last received message?
 685         bool                                            _DecodedHeader;
 686
 687         /// The received number lastly decoded
 688         CLFECOMMON::TPacketNumber       _CurrentReceivedNumber;
 689
 690         /// The message is in system mode
 691         bool                                            _SystemMode;
 692
 693         /// Did we received a probe since last update
 694         bool                                            _ReceivedSync;
 695
 696         uint                                            _TotalMessages;
 697
 698         //@}
 699
 700
 701
 702         /// @name Client and Server packet numbering management
 703         //@{
 704
 705         CLFECOMMON::TPacketNumber       _CurrentSendNumber;             // number that will be used to send the next packet
 706
 707         CLFECOMMON::TPacketNumber       _LastReceivedNumber;    // number of the last packet receive from the server
 708         uint32                                          _AckBitMask;                    // this mask contains ack of old messages received by the server
 709         uint32                                          _LastAckBit;                    // a remember of the status of the previous received packet
 710         NLMISC::TTime                           _LastReceivedTime;              // last time the client received something from the server
 711
 712         NLMISC::CBitSet                         _LongAckBitField;
 713         CLFECOMMON::TPacketNumber       _LastAckInLongAck;
 714
 715         NLMISC::TGameCycle                      _LastSentCycle;
 716
 717         CLFECOMMON::TPacketNumber       _LastReceivedPacketInBothModes;
 718
 719         NLMISC::TTime                           _LastReceivedNormalTime;        // last time the client received valid normal message from the server
 720
 721         uint8                                           _ImpulseMultiPartNumber;
 722
 723         //@}
 724
 725
 726         /// @name Client and Server time management
 727         //@{
 728
 729         /// The stamps queues
 730         typedef std::deque<std::pair<sint32, NLMISC::TTime> >   TStampQueue;
 731
 732         // used for lag compensation
 733         NLMISC::TTime                           _CurrentClientTime;             // the time currently played at this frame (in the past)
 734         NLMISC::TGameCycle                      _CurrentClientTick;             // the tick for the current frame (also in the past)
 735         NLMISC::TGameCycle                      _CurrentServerTick;             // the last tick sent by the server.
 736         NLMISC::TTime                           _MachineTimeAtTick;             // the machine time at the beginning of the current tick
 737         NLMISC::TTicks                          _MachineTicksAtTick;
 738         sint32                                          _MsPerTick;
 739         NLMISC::TGameCycle                      _Synchronize;
 740         uint32                                          _BestPing;
 741         uint32                                          _InstantPing;
 742         NLMISC::TTime                           _LCT;                                   // Lag compensation time
 743         TStampQueue                                     _PacketStamps;
 744
 745         NLMISC::TTime                           _UpdateTime;
 746         NLMISC::TTicks                          _UpdateTicks;
 747         NLMISC::TTime                           _LastSentSync;
 748
 749         NLMISC::TTime                           _LastSendTime;
 750
 751         //@}
 752
 753         std::list<CLFECOMMON::CActionBlock>     _Actions;
 754
 755         /// Changes since
 756         std::vector<CChange>            _Changes;
 757
 758         // TEMP
 759         uint32                                          _DummySend;
 760
 761         static bool                                     _Registered;
 762
 763         /// @name Generic action multipart handling structures
 764         //@{
 765         struct CGenericMultiPartTemp
 766         {
 767                 CGenericMultiPartTemp () : NbBlock(0xFFFFFFFF) { }
 768                 uint32                                                          NbBlock;
 769                 uint32                                                          NbCurrentBlock;
 770                 uint32                                                          TempSize;
 771                 std::vector<std::vector<uint8> >        Temp;
 772
 773                 std::vector<bool>                                       BlockReceived;
 774
 775                 void set (CLFECOMMON::CActionGenericMultiPart *agmp, CNetworkConnection *parent);
 776         };
 777
 778         std::vector<CGenericMultiPartTemp>      _GenericMultiPartTemp;
 779         //@}
 780
 781         /// @name NLMISC::CEntityId handling (for gamedev)
 782         //@{
 783         struct CHash
 784         {
 785                 enum { bucket_size = 4, min_buckets = 8, };
 786                 size_t  operator () (const CLFECOMMON::TSheetId &id) const { return id; }
 787                 inline bool operator() (const CLFECOMMON::TSheetId &id1, const CLFECOMMON::TSheetId &id2) const { return (size_t)id1 < (size_t)id2; }
 788         };
 789
 790         typedef CHashMap<CLFECOMMON::TSheetId, CLFECOMMON::TCLEntityId, CHash>  TIdMap;
 791
 792         TIdMap                                          _IdMap;
 793         //@}
 794
 795
 796         TVPNodeClient                           *_VisualPropertyTreeRoot;
 797
 798
 799         /// \name Smooth ServerTick mgt.
 800         // @{
 801         sint64                                          _CurrentSmoothServerTick;
 802         NLMISC::TTime                           _SSTLastLocalTime;
 803
 804         void                                            updateSmoothServerTick();
 805         // @}
 806
 807         void                                            reinit();
 808
 809 private:
 810
 811         /// Set MsPerTick value
 812         void                                            setMsPerTick(sint32 msPerTick);
 813
 814
 815         /// Builds the CBitMemStream from the next incoming packet
 816         bool                                            buildStream(NLMISC::CBitMemStream &msgin);
 817
 818         /// @name Client automaton states and actions
 819         //@{
 820
 821         //
 822         void                                            sendSystemLogin();
 823         bool                                            stateLogin();
 824         NLMISC::TTime                           _LatestLoginTime;
 825         int                         m_LoginAttempts;
 826
 827         //
 828         void                                            receiveSystemSync(NLMISC::CBitMemStream &msgin);
 829         void                                            sendSystemAckSync();
 830         bool                                            stateSynchronize();
 831         NLMISC::TTime                           _LatestSyncTime;
 832         uint32                                          _LatestSync;
 833
 834         //
 835         void                                            receiveNormalMessage(NLMISC::CBitMemStream &msgin);
 836         void                                            sendNormalMessage();
 837         bool                                            stateConnected();
 838         CLFECOMMON::TPacketNumber       _LastReceivedAck;
 839         uint                                            _NormalPacketsReceived;
 840
 841         //
 842         void                                            receiveSystemProbe(NLMISC::CBitMemStream &msgin);
 843         void                                            sendSystemAckProbe();
 844         bool                                            stateProbe();
 845         std::vector<CLFECOMMON::TPacketNumber>  _LatestProbes;
 846         CLFECOMMON::TPacketNumber       _LatestProbe;
 847         NLMISC::TTime                           _LatestProbeTime;
 848
 849         //
 850         void                                            receiveSystemStalled(NLMISC::CBitMemStream &msgin);
 851         bool                                            stateStalled();
 852
 853         //
 854         void                                            sendSystemDisconnection();
 855
 856         //
 857         bool                                            stateQuit();
 858         void                                            receiveSystemAckQuit(NLMISC::CBitMemStream &msgin);
 859         void                                            sendSystemQuit();
 860         uint32                                          _QuitId;
 861         bool                                            _ReceivedAckQuit;
 862         NLMISC::TTime                           _LatestQuitTime;
 863
 864         //
 865         void                                            reset();
 866         void                                            initTicks();
 867
 868         //@}
 869
 870         //
 871         bool                                            decodeHeader(NLMISC::CBitMemStream &msgin, bool checkMessageNumber = true);
 872
 873         //
 874         void                                            buildSystemHeader(NLMISC::CBitMemStream &msgout);
 875
 876         //
 877         void                                            genericAction (CLFECOMMON::CActionGeneric *ag);
 878         void                                            genericAction (CLFECOMMON::CActionGenericMultiPart *agmp);
 879
 880         //
 881         void                                            statsSend(uint32 bytes);
 882         void                                            statsReceive(uint32 bytes);
 883
 884         bool                                            associationBitsHaveChanged( CLFECOMMON::TCLEntityId slot, uint32 associationBits )
 885         {
 886                 bool res = ((uint16)associationBits != _PropertyDecoder.associationBits( slot ));
 887                 _PropertyDecoder.associationBits( slot ) = (uint16)associationBits;
 888                 return res;
 889         }
 890
 891         void                                            decodeVisualProperties( NLMISC::CBitMemStream& msgin );
 892
 893         /// Return true if there is some messages to replay (in replay mode)
 894         bool                                            dataToReplayAvailable();
 895
 896         uint32                                          _AssociationBits;
 897
 898 #ifdef ENABLE_INCOMING_MSG_RECORDER
 899         NLMISC::COFile                          _RecordedMessagesOut;
 900
 901         NLMISC::CIFile                          _RecordedMessagesIn;
 902         NLMISC::TGameCycle                      _NextClientTickToReplay; // ~0 when no more message
 903         NLMISC::CBitMemStream           _NextMessageToReplay; // loaded at beginning of update(), read in buildStream()
 904
 905         bool                                            _RecordIncomingMessagesOn;
 906         bool                                            _ReplayIncomingMessagesOn;
 907
 908 #endif
 909
 910         //
 911         friend struct CGenericMultiPartTemp;
 912 };
 913
 914
 915 #endif // NL_NETWORK_CONNECTION_H
 916
 917 /* End of network_connection.h */