ryzom/server/src/gpm_service/move_checker.cpp

   1 // Ryzom - MMORPG Framework <http://dev.ryzom.com/projects/ryzom/>
   2 // Copyright (C) 2010  Winch Gate Property Limited
   3 //
   4 // This program is free software: you can redistribute it and/or modify
   5 // it under the terms of the GNU Affero General Public License as
   6 // published by the Free Software Foundation, either version 3 of the
   7 // License, or (at your option) any later version.
   8 //
   9 // This program is distributed in the hope that it will be useful,
  10 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12 // GNU Affero General Public License for more details.
  13 //
  14 // You should have received a copy of the GNU Affero General Public License
  15 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
  16
  17 #include "stdpch.h"
  18
  19 #include "nel/misc/common.h"
  20
  21 #include "game_share/utils.h"
  22
  23 #include "move_checker.h"
  24
  25
  26 /****************************************************************\
  27                                         Static Stats Stuff (temp)
  28 \****************************************************************/
  29
  30 class CStatsRecord
  31 {
  32 private:
  33         std::vector<uint32> _Distances;
  34         uint32 _Counter;
  35         uint32 _LastTick;
  36         bool _Teleporting;
  37         uint32 _X,_Y;
  38         uint32 _MaxDist;
  39         uint32 _MaxDistTime;
  40
  41 public:
  42         CStatsRecord()
  43         {
  44                 _Distances.resize(50);
  45                 _Counter=0;
  46                 _LastTick=0;
  47                 _Teleporting=true;
  48                 _X=0;
  49                 _Y=0;
  50                 _MaxDist=0;
  51                 _MaxDistTime=(uint32)_Distances.size()/2;
  52         }
  53
  54         void start(TDataSetRow entityIndex, sint32 x, sint32 y, uint32 tick)
  55         {
  56                 std::fill(_Distances.begin(),_Distances.end(),0);
  57                 _Counter=0;
  58                 _LastTick=tick;
  59                 _Teleporting=true;
  60                 _X=x;
  61                 _Y=y;
  62                 _MaxDist=0;
  63                 _MaxDistTime=(uint32)_Distances.size()/2;
  64         }
  65
  66         void add(TDataSetRow entityIndex, sint32 x, sint32 y, uint32 tick)
  67         {
  68                 // if we've just teleported then there's no point worrying about the time since last update...
  69                 if (_Teleporting)
  70                 {
  71                         // flag teleporting as finished
  72                         _Teleporting= false;
  73                 }
  74                 else
  75                 {
  76                         // check whether entity has been updated recently
  77 //                      if((tick-_LastTick)!=1)
  78 //                      {
  79 //                              nlwarning("Move Checker Stats: entity %s has only received position update after %d ticks",entityIndex.toString().c_str(),tick-_LastTick);
  80 //                      }
  81                 }
  82
  83                 // calculate the distance moved and check whether its a new record
  84                 uint32 squaredist= (_X-x)*(_X-x) + (_Y-y)*(_Y-y);
  85                 if (squaredist>_MaxDist)
  86                 {
  87                         _MaxDist=squaredist;
  88                         _MaxDistTime= std::max((uint32)_Counter,(uint32)_Distances.size()/2);
  89                 }
  90                 _Distances[_Counter%_Distances.size()]= squaredist;
  91
  92                 // store away basic info for next time round
  93                 _X=x;
  94                 _Y=y;
  95                 _LastTick=tick;
  96
  97                 // increment our counter...
  98                 ++_Counter;
  99
 100                 // if we've hit a new record recently then display a log message
 101                 if ( (_Counter-_MaxDistTime) == (_Distances.size()/2) )
 102                 {
 103                         std::string s;
 104                         for (uint32 i=(uint32)_Distances.size();i!=0;--i)
 105                         {
 106                                 s+=NLMISC::toString(" %d",_Distances[(_Counter-i)%_Distances.size()]);
 107                         }
 108                         nlinfo("SpeedStats record for %s: %d (%.2f m/s): %s",entityIndex.toString().c_str(),_MaxDist,sqrt((double)_MaxDist)/200,s.c_str());
 109                 }
 110         }
 111 };
 112
 113 typedef std::map<TDataSetRow,CStatsRecord> TStats;
 114 TStats Stats;
 115
 116 static void startStats(TDataSetRow entityIndex, sint32 x, sint32 y, uint32 tick)
 117 {
 118         Stats[entityIndex].start(entityIndex,x,y,tick);
 119 }
 120
 121 static void addStats(TDataSetRow entityIndex, sint32 x, sint32 y, uint32 tick)
 122 {
 123         Stats[entityIndex].add(entityIndex,x,y,tick);
 124 }
 125
 126 static void endStats(TDataSetRow entityIndex)
 127 {
 128         Stats.erase(entityIndex);
 129 }
 130
 131
 132 /****************************************************************\
 133                                         CMoveChecker Methods
 134 \****************************************************************/
 135
 136 void CMoveChecker::teleport(TDataSetRow entityIndex, sint32 x, sint32 y, uint32 tick)
 137 {
 138         // get hold of the entity's record in the move checker (and creat a new entry if need be)
 139         SPosition& thePosition= _Positions[entityIndex];
 140
 141         nlinfo("Move checker teleporting player: %s from (%d,%d) @tick: %d to (%d,%d) @tick: %d",
 142                 entityIndex.toString().c_str(),thePosition.X,thePosition.Y,thePosition.Tick,x,y,tick);
 143
 144         // record the new position
 145         thePosition.X= x;
 146         thePosition.Y= y;
 147         thePosition.Tick= tick;
 148
 149         // generate a few stats
 150         startStats(entityIndex,x,y,tick);
 151 }
 152
 153 bool CMoveChecker::checkMove(TDataSetRow entityIndex, sint32& x, sint32& y, uint32 tick)
 154 {
 155         // setup a refference to the entity's position record, and bomb if it can't be found
 156         TPositions::iterator positionIt= _Positions.find(entityIndex);
 157         BOMB_IF(positionIt==_Positions.end(),"Ignoring call to 'checkMove' for an entity who doesn't exist in the move checker",return false);
 158         SPosition& thePosition= positionIt->second;
 159
 160         // if the character hasn't moved then just return
 161         if ( (x==thePosition.X) && (y==thePosition.Y) )
 162         {
 163                 return true;
 164         }
 165
 166 //      nlinfo("Checking player move: %s from (%d,%d) @tick: %d to (%d,%d) @tick: %d",
 167 //              entityIndex.toString().c_str(),thePosition.X,thePosition.Y,thePosition.Tick,x,y,tick);
 168
 169         // if the tick value is out of order (for instance, after an advanced tp request) then ignore the move
 170         DROP_IF(sint32(tick-thePosition.Tick)<0,"Ignoring out of order move for character "+entityIndex.toString(),return false);
 171
 172 // *** todo: perform a speed test here
 173 // *** todo: perform collision test here
 174 // *** NOTE: If move not legal then we need to change values of x and y and return false
 175
 176         // record the new position
 177         thePosition.X= x;
 178         thePosition.Y= y;
 179         thePosition.Tick= tick;
 180
 181         // generate a few stats
 182         addStats(entityIndex,x,y,tick);
 183
 184         return true;
 185 }
 186
 187 void CMoveChecker::remove(TDataSetRow entityIndex)
 188 {
 189         // remove the entity from our positions map
 190         _Positions.erase(entityIndex);
 191
 192         // generate a few stats
 193         endStats(entityIndex);
 194 }