ryzom/client/src/time_client.cpp

   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 //
   7 // This program is free software: you can redistribute it and/or modify
   8 // it under the terms of the GNU Affero General Public License as
   9 // published by the Free Software Foundation, either version 3 of the
  10 // License, or (at your option) any later version.
  11 //
  12 // This program is distributed in the hope that it will be useful,
  13 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 // GNU Affero General Public License for more details.
  16 //
  17 // You should have received a copy of the GNU Affero General Public License
  18 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
  19
  20
  21
  22 #include "stdpch.h"
  23
  24
  25 /////////////
  26 // INCLUDE //
  27 /////////////
  28 // Misc;
  29 #include "nel/misc/debug.h"
  30 // client.
  31 #include "time_client.h"
  32 #include "interface_v3/interface_manager.h"
  33 #include "nel/gui/interface_property.h"
  34 #include "client_cfg.h"
  35 #include "net_manager.h"
  36 #include "game_share/zc_shard_common.h"
  37 #include "weather.h"
  38 #include "game_share/light_cycle.h"
  39
  40 #ifdef DEBUG_NEW
  41 #define new DEBUG_NEW
  42 #endif
  43
  44 ///////////
  45 // USING //
  46 ///////////
  47 using namespace std;
  48
  49
  50 ////////////
  51 // GLOBAL //
  52 ////////////
  53 sint64  T0 = 0;                         // Time for the last frame.
  54 sint64  T1 = 0;                         // Time for the current frame.
  55 sint64  TS = 0;                         // Time since the really first Frame.
  56 sint64  DT64 = 0;                       // Diff time with current and last frame in ms.
  57 float   DT = 0.f;                       // Diff time with current and last frame in sec.
  58 TTime   TSend = 0;                      // Next Time to send motions.
  59 TTime   DTSend = 100;           // Delta of time to generate the next time to send motions.
  60 double  TimeInSec = 0.0;        // Time for the current frame in second.
  61 double  FirstTimeInSec = 0.0;   // Game local origin time
  62 float   TimeFactor = 1.f; // Factor applied to current date (local mode only)
  63
  64
  65 TTime   LCT = 1000;                             // Default LCT (Lag Compensation time).
  66 TTime   LocalTimeStep = 100;    // Time Step factor on the client.
  67 TTime   CurrentPacketTime = 0;  // Local Time for the current packet.
  68 uint8   CurrentPacket = 0;              // Packet currently valid.
  69 uint8   LastPacketReceived = 0; // Last received packet.
  70 uint8   LastPacketAck = 0;              // Last acknowledged packet.
  71
  72 NLMISC::TGameCycle LastGameCycle = 0;
  73
  74 CRyzomTime                      RT;
  75 CClientDate                     SmoothedClientDate;
  76
  77 // Hierarchical timer
  78 H_AUTO_DECL ( RZ_Client_Update_Time )
  79
  80
  81 ///////////
  82 // LOCAL //
  83 ///////////
  84 // Map with all time for each packet sent to the server.
  85 map<uint8, TTime> PacketTime;
  86 // Map with all Infos for each packet received.
  87 map<uint8, CPacketInfos> PacketInfos;
  88
  89
  90 ///////////////
  91 // FUNCTIONS //
  92 ///////////////
  93 //-----------------------------------------------
  94 // removePacketTime :
  95 // Remove the packet 'numPacket' from the 'PacketTime' list.
  96 //-----------------------------------------------
  97 void removePacketTime(uint8 numPacket)
  98 {
  99         PacketTime.erase(numPacket);
 100 }// removePacketTime //
 101
 102 //-----------------------------------------------
 103 // insertPacketTime :
 104 // Insert a packet in the PacketTime map.
 105 //-----------------------------------------------
 106 void insertPacketTime(uint8 numPacket, TTime time)
 107 {
 108         PacketTime.insert(make_pair(numPacket, time));
 109 }// insertPacketTime //
 110
 111
 112 //-----------------------------------------------
 113 // checkLocalTimeStep :
 114 // Check if the Local Time Step is still valid with the new packet.
 115 //-----------------------------------------------
 116 void checkLocalTimeStep(const CPacketInfos &packetInfos)
 117 {
 118         // Compute how many packets there are since the current packet.
 119         sint nbPacket = packetInfos.Num - CurrentPacket;
 120         if(nbPacket < 0)
 121                 nbPacket += 256;
 122
 123         // \todo GUIGUI : check why this happen.
 124         if(nbPacket==0)
 125                 return;
 126
 127         // Compute the predicted Local Time for this packet.
 128         TTime predictedTime = CurrentPacketTime + LocalTimeStep*nbPacket;
 129
 130         TTime localTimeStep = LocalTimeStep;
 131
 132         // If the predicted time is too small according to the min time computed for the packet -> increase 'LocalTimeStep'.
 133         if(predictedTime < packetInfos.Min)
 134         {
 135 //              nlwarning("packetInfos.Min : %f", (double)packetInfos.Min);
 136 //              nlwarning("CurrentPacketTime : %f", (double)CurrentPacketTime);
 137 //              nlwarning("packetInfos.Min - CurrentPacketTime : %f", (double)((double)packetInfos.Min - (double)CurrentPacketTime));
 138
 139                 LocalTimeStep = (packetInfos.Min - CurrentPacketTime)/nbPacket;
 140
 141 //              nlwarning("LocalTimeStep : %f", (double)LocalTimeStep);
 142         }
 143         // If the predicted time is too big according to the max time computed for the packet -> increase 'LocalTimeStep'.
 144         else if(predictedTime > packetInfos.Max)
 145         {
 146 //              nlwarning("packetInfos.Max : %f", (double)packetInfos.Max);
 147 //              nlwarning("CurrentPacketTime : %f", (double)CurrentPacketTime);
 148 //              nlwarning("packetInfos.Max - CurrentPacketTime : %f", (double)((double)packetInfos.Max - (double)CurrentPacketTime));
 149
 150                 LocalTimeStep = (packetInfos.Max - CurrentPacketTime)/nbPacket;
 151
 152 //              nlwarning("LocalTimeStep : %f", (double)LocalTimeStep);
 153         }
 154
 155         if(LocalTimeStep == 0)
 156         {
 157                 LocalTimeStep = localTimeStep;
 158 //              nlwarning("LocalTimeStep (corrected): %f", (double)LocalTimeStep);
 159         }
 160 }// checkLocalTimeStep //
 161
 162 //-----------------------------------------------
 163 // removePacket :
 164 // Remove the packet 'numPacket' from the 'PacketInfos' list.
 165 //-----------------------------------------------
 166 void removePacket(uint8 numPacket)
 167 {
 168         PacketInfos.erase(numPacket);
 169 }// removePacket //
 170
 171 //-----------------------------------------------
 172 // insertPacket :
 173 // Insert the packet received information in a list.
 174 //-----------------------------------------------
 175 void insertPacket(const CPacketInfos &packetInfos)
 176 {
 177         // Upadte the last packet received.
 178         LastPacketReceived = packetInfos.Num;
 179
 180         // Insert the packet information.
 181         PacketInfos.insert(make_pair(LastPacketReceived, packetInfos));
 182
 183         // Check Local Time Step with the new packet.
 184         checkLocalTimeStep(packetInfos);
 185 }// insertPacket //
 186
 187
 188 //-----------------------------------------------
 189 // getSentPacketTime :
 190 // Return the sent time for a given packet or 0 if the packet is not found
 191 //-----------------------------------------------
 192 TTime getSentPacketTime(uint8 numPacket)
 193 {
 194         map<uint8, TTime>::iterator it = PacketTime.find(numPacket);
 195         if(it != PacketTime.end())
 196                 return (*it).second;
 197         else
 198                 return 0;
 199 }// getSentPacketTime //
 200
 201 //-----------------------------------------------
 202 // ackPacketTimeBefore :
 203 //
 204 //-----------------------------------------------
 205 void ackPacketTimeBefore(uint8 ackPacketNumber)
 206 {
 207         // If the acknowledged packet is not in the list -> player do not have send any packet for the time.
 208         map<uint8, TTime>::iterator itEnd = PacketTime.find(ackPacketNumber);
 209         if(itEnd != PacketTime.end())
 210         {
 211                 // If the packet cannot be found -> First valid packet the server is acknowledging
 212                 map<uint8, TTime>::iterator itBegin = PacketTime.find(LastPacketAck);
 213                 if(itBegin != PacketTime.end())
 214                 {
 215                         while(itBegin != itEnd)
 216                         {
 217                                 //
 218                                 map<uint8, TTime>::iterator itTmp = itBegin;
 219                                 itBegin++;
 220                                 // Destroy packets between the last acknowledged packet and the recent one.
 221                                 PacketTime.erase(itTmp);
 222
 223                                 if(itBegin == PacketTime.end())
 224                                         itBegin = PacketTime.begin();
 225                         }
 226                 }
 227         }
 228
 229         LastPacketAck = ackPacketNumber;
 230 }// ackPacketTimeBefore //
 231
 232 static  CInterfaceProperty      *InterfaceTime = NULL;
 233 static  CInterfaceProperty      *InterfaceServerTick = NULL;
 234 static  CInterfaceProperty      *InterfaceSmoothServerTick = NULL;
 235 static  CInterfaceProperty      *InterfaceDay = NULL;
 236 static  CInterfaceProperty      *InterfaceDayBeforeNextZCDistrib = NULL;
 237
 238 //-----------------------------------------------
 239 // initClientTime
 240 //
 241 //-----------------------------------------------
 242 void initClientTime()
 243 {
 244         nlassert (InterfaceTime == NULL);
 245         nlassert (InterfaceServerTick == NULL);
 246         nlassert (InterfaceSmoothServerTick == NULL);
 247         nlassert (InterfaceDay== NULL);
 248         nlassert (InterfaceDayBeforeNextZCDistrib== NULL);
 249
 250         InterfaceTime = new CInterfaceProperty;
 251         InterfaceServerTick = new CInterfaceProperty;
 252         InterfaceSmoothServerTick = new CInterfaceProperty;
 253         InterfaceDay = new CInterfaceProperty;
 254         InterfaceDayBeforeNextZCDistrib = new CInterfaceProperty;
 255
 256         CInterfaceManager       *pIM= CInterfaceManager::getInstance();
 257
 258         // get a direct link to the database
 259         NLGUI::CDBManager::getInstance()->getDbProp("UI:VARIABLES:CURRENT_TIME");
 260         InterfaceTime->link("UI:VARIABLES:CURRENT_TIME");
 261         NLGUI::CDBManager::getInstance()->getDbProp("UI:VARIABLES:CURRENT_SERVER_TICK");
 262         InterfaceServerTick->link("UI:VARIABLES:CURRENT_SERVER_TICK");
 263         NLGUI::CDBManager::getInstance()->getDbProp("UI:VARIABLES:CURRENT_SMOOTH_SERVER_TICK");
 264         InterfaceSmoothServerTick->link("UI:VARIABLES:CURRENT_SMOOTH_SERVER_TICK");
 265         NLGUI::CDBManager::getInstance()->getDbProp("UI:VARIABLES:CURRENT_DAY");
 266         InterfaceDay->link("UI:VARIABLES:CURRENT_DAY");
 267         NLGUI::CDBManager::getInstance()->getDbProp("UI:VARIABLES:DAY_BEFORE_ZC_DISTRIB");
 268         InterfaceDayBeforeNextZCDistrib->link("UI:VARIABLES:DAY_BEFORE_ZC_DISTRIB");
 269 }
 270
 271 //-----------------------------------------------
 272
 273 void releaseClientTime()
 274 {
 275         if (InterfaceTime)
 276         {
 277                 delete InterfaceTime;
 278                 InterfaceTime = NULL;
 279         }
 280         if (InterfaceServerTick)
 281         {
 282                 delete InterfaceServerTick;
 283                 InterfaceServerTick = NULL;
 284         }
 285         if (InterfaceSmoothServerTick)
 286         {
 287                 delete InterfaceSmoothServerTick;
 288                 InterfaceSmoothServerTick = NULL;
 289         }
 290         if (InterfaceDay)
 291         {
 292                 delete InterfaceDay;
 293                 InterfaceDay = NULL;
 294         }
 295         if (InterfaceDayBeforeNextZCDistrib)
 296         {
 297                 delete InterfaceDayBeforeNextZCDistrib;
 298                 InterfaceDayBeforeNextZCDistrib = NULL;
 299         }
 300 }
 301
 302
 303
 304
 305 //-----------------------------------------------
 306 // updateClientTime :
 307 //
 308 //-----------------------------------------------
 309 CWidgetManager::SInterfaceTimes times;
 310
 311 void updateClientTime()
 312 {
 313         H_AUTO_USE ( RZ_Client_Update_Time )
 314
 315         // Last T0
 316         T0        = T1;
 317
 318         // Constant delta time ?
 319         if (ClientCfg.ForceDeltaTime == 0)
 320         {
 321                 T1 = ryzomGetLocalTime();
 322                 if (T1 <= T0)
 323                 {
 324                         // This case is known to occurs if the framerate is very fast (e.g. during the
 325                         // loading stage) or if the machine has got a heavy load (e.g. lots of AGP data)
 326                         // delaying the timer updates.
 327                         //nlwarning ("getLocalTime has returned the same time! START");
 328                         while (T1 <= T0)
 329                         {
 330                                 T1 = ryzomGetLocalTime();
 331                                 // give up the time slice to let time to other process
 332                                 NLMISC::nlSleep(0);
 333                         }
 334                         //nlwarning ("getLocalTime has returned the same time! END");
 335                 }
 336         }
 337         else
 338         {
 339                 // First time ?
 340                 static bool firstTime = true;
 341                 if (firstTime)
 342                 {
 343                         T1 = ryzomGetLocalTime();
 344                         firstTime = false;
 345                 }
 346                 else
 347                 {
 348                         T1 += ClientCfg.ForceDeltaTime;
 349                 }
 350         }
 351
 352         if(T0 == T1)
 353                 nlwarning("updateClientTime: T0 should not be = T1.");
 354
 355         // Update time variables
 356         DT64      = T1-T0;
 357         TS        += DT64;
 358         DT        = ((float)DT64)*0.001f;
 359
 360         TimeInSec = T1*0.001;
 361
 362         // First time ?
 363         if (FirstTimeInSec == 0.0)
 364                 FirstTimeInSec = TimeInSec;
 365
 366         // Set the InterfaceManager current time.
 367         if (InterfaceTime)
 368                 InterfaceTime->setSInt64(T1);
 369         if (InterfaceServerTick)
 370                 InterfaceServerTick->setSInt64(NetMngr.getCurrentServerTick());
 371         // Set the Smooth ServerTick
 372         if (InterfaceSmoothServerTick)
 373                 InterfaceSmoothServerTick->setSInt64(NetMngr.getCurrentSmoothServerTick());
 374
 375         // Day, and Day before ZC distrib
 376         if(InterfaceDay)
 377                 InterfaceDay->setSInt64(RT.getRyzomDay());
 378         if(InterfaceDayBeforeNextZCDistrib)
 379         {
 380                 sint    d= RT.getRyzomDay()%ZCSTATE::ZCDistribPeriod;
 381                 // Must dispaly at least "1".
 382                 d= ZCSTATE::ZCDistribPeriod - d;
 383                 InterfaceDayBeforeNextZCDistrib->setSInt64(d);
 384         }
 385
 386 #ifdef ENABLE_INCOMING_MSG_RECORDER
 387         // Init For the Replay.
 388         if(NetMngr.isReplayStarting())
 389                 NetMngr.startReplay();
 390 #endif
 391
 392         times.lastFrameMs = T0;
 393         times.thisFrameMs = T1;
 394         times.frameDiffMs = DT64;
 395
 396         CWidgetManager::getInstance()->updateInterfaceTimes( times );
 397
 398 }// updateClientTime //
 399
 400
 401 // update smoothed time
 402 void updateSmoothedTime()
 403 {
 404         #define REAL_SECONDS_TO_RYZOM_HOUR(s) (double(s) * 10 / double(RYZOM_HOURS_IN_TICKS))
 405         //
 406         CClientDate oldSmoothedClientDate = SmoothedClientDate;
 407         double dHour = REAL_SECONDS_TO_RYZOM_HOUR(DT);
 408         SmoothedClientDate.Hour += (float) dHour;
 409         if (SmoothedClientDate.Hour > WorldLightCycle.NumHours)
 410         {
 411                 SmoothedClientDate.Day += (sint32) ceil(dHour / WorldLightCycle.NumHours);
 412                 SmoothedClientDate.Hour = (float) fmod(SmoothedClientDate.Hour, WorldLightCycle.NumHours);
 413         }
 414         double smoothedClientDateInHour = (double) SmoothedClientDate.Day * 24 + SmoothedClientDate.Hour;
 415         double ryzomDateInHour = (double) RT.getRyzomDay() * 24 + (double) RT.getRyzomTime();
 416         const double SMOOTHED_DATE_MAX_ERROR_IN_RYZOM_HOUR = REAL_SECONDS_TO_RYZOM_HOUR(10);
 417         double hourError = fabs(smoothedClientDateInHour - ryzomDateInHour);
 418         if (hourError > SMOOTHED_DATE_MAX_ERROR_IN_RYZOM_HOUR)
 419         {
 420                 if (smoothedClientDateInHour < ryzomDateInHour)
 421                 {
 422                         // smoothed time is late
 423                         SmoothedClientDate.Day = RT.getRyzomDay();
 424                         SmoothedClientDate.Hour = RT.getRyzomTime();
 425                 }
 426                 else
 427                 {
 428                         if (hourError > (2 * SMOOTHED_DATE_MAX_ERROR_IN_RYZOM_HOUR))
 429                         {
 430                                 // if difference is too big, rescale smoothed time on server time
 431                                 SmoothedClientDate.Day = RT.getRyzomDay();
 432                                 SmoothedClientDate.Hour = RT.getRyzomTime();
 433                         }
 434                         else
 435                         {
 436                                 // cancel time increment (wait until server time is up with smoothed client time)
 437                                 SmoothedClientDate = oldSmoothedClientDate;
 438                         }
 439                 }
 440         }
 441 }
 442
 443
 444
 445
 446
 447
 448
 449
 450
 451
 452
 453
 454
 455
 456
 457
 458
 459
 460
 461
 462