ryzom/server/src/frontend_service/property_history.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
  18
  19 #include "stdpch.h"
  20
  21
  22 #include "nel/misc/debug.h"
  23 #include "nel/misc/vector.h"
  24
  25 #include "property_history.h"
  26 #include "history.h"
  27 #include "game_share/action.h"
  28 #include "game_share/continuous_action.h"
  29 #include "game_share/action_position.h"
  30
  31 #include <nel/misc/hierarchical_timer.h>
  32
  33 using namespace std;
  34 using namespace NLMISC;
  35 using namespace CLFECOMMON;
  36
  37 /*
  38  * Constructor
  39  */
  40 CPropertyHistory::CPropertyHistory()
  41 {
  42         _MaxDeltaSend = DefaultMaxDeltaSend;
  43 }
  44
  45 void    CPropertyHistory::clear()
  46 {
  47         uint32  num = (uint32)_ClientEntries.size();
  48         _ClientEntries.clear();
  49         _ClientEntries.resize(num);
  50 }
  51
  52 void    CPropertyHistory::setMaximumClient(uint maxClient)
  53 {
  54         _ClientEntries.resize(maxClient);
  55 }
  56
  57 //
  58
  59 void    CPropertyHistory::addClient(TClientId clientId)
  60 {
  61         nlassert(clientId < _ClientEntries.size() && !_ClientEntries[clientId].EntryUsed);
  62
  63         CClientEntry    &entry = _ClientEntries[clientId];
  64         entry.reset();
  65         entry.EntryUsed = true;
  66 }
  67
  68 void    CPropertyHistory::removeClient(TClientId clientId)
  69 {
  70         nlassert(clientId < _ClientEntries.size() && _ClientEntries[clientId].EntryUsed);
  71         _ClientEntries[clientId].reset();
  72 }
  73
  74 void    CPropertyHistory::resetClient(TClientId clientId)
  75 {
  76         nlassert(clientId < _ClientEntries.size() && _ClientEntries[clientId].EntryUsed);
  77
  78         CClientEntry    &entry = _ClientEntries[clientId];
  79         uint    i;
  80         for (i=0; i<MAX_SEEN_ENTITIES_PER_CLIENT; ++i)
  81                 entry.Entities[i].clearEntityEntry();
  82 }
  83
  84 bool    CPropertyHistory::isValidClient(TClientId clientId)
  85 {
  86         return (clientId < _ClientEntries.size() && _ClientEntries[clientId].EntryUsed);
  87 }
  88
  89 //
  90
  91 bool    CPropertyHistory::addEntityToClient(TCLEntityId entityId, TClientId clientId)
  92 {
  93         nlassert(clientId < _ClientEntries.size() && _ClientEntries[clientId].EntryUsed);
  94
  95         // adds entity to the table in the client entry
  96         CEntityEntry    &entity = _ClientEntries[clientId].Entities[entityId];
  97         if (entity.Used)
  98         {
  99                 return false;
 100         }
 101         entity.resetEntityEntry();
 102         entity.Used = true;
 103         return true;
 104 }
 105
 106 void    CPropertyHistory::removeEntityOfClient(TCLEntityId entityId, TClientId clientId)
 107 {
 108         nlassert(clientId < _ClientEntries.size() && _ClientEntries[clientId].EntryUsed);
 109
 110         CEntityEntry    &entity = _ClientEntries[clientId].Entities[entityId];
 111         if ( ! entity.Used )
 112                 nlwarning( "Removing entity S%hu of client C%hu in history, but not used", (uint16)entityId, clientId );
 113         entity.resetEntityEntry();
 114 }
 115
 116 //
 117 /*
 118 bool    CPropertyHistory::packDelta(TClientId clientId, CAction &action, bool allowPack)
 119 {
 120         nlassert(clientId < _ClientEntries.size() && _ClientEntries[clientId].EntryUsed);
 121
 122         if (!action.isContinuous())
 123         {
 124                 return false;
 125         }
 126
 127         // cast action
 128         CContinuousAction       &act = static_cast<CContinuousAction &>(action);
 129
 130         if (act.isDelta())
 131         {
 132                 return true;
 133         }
 134
 135         // search if entity is already used
 136         CEntityEntry            &entity = _ClientEntries[clientId].Entities[action.CLEntityId];
 137         nlassert(entity.Used);
 138
 139         // This asumes the continuous properties are the same for everyone
 140         uint16                          propIndex = act.PropertyCode;
 141         CPropertyEntry          &entry = entity.Properties[propIndex];
 142
 143         if (entry.AllowDelta > 0 && allowPack)
 144         {
 145                 if (--entry.AllowDelta > 0)
 146                 {
 147                         act.packDelta(entry.Garanted);
 148                         return true;
 149                 }
 150                 else
 151                 {
 152                         // disable next incoming garanted packets
 153                         // until we send a garanted packet
 154                         entry.Packet = 0xFFFFFFFF;
 155                         return false;
 156                 }
 157         }
 158         else
 159         {
 160                 return false;
 161         }
 162 }
 163
 164 //
 165
 166 bool    CPropertyHistory::packDelta(TClientId clientId, CActionPosition &action, bool allowPack)
 167 {
 168         nlassert(clientId < _ClientEntries.size() && _ClientEntries[clientId].EntryUsed);
 169
 170         if (action.isDelta())
 171         {
 172                 return true;
 173         }
 174
 175         // search if entity is already used
 176         CEntityEntry            &entity = _ClientEntries[clientId].Entities[action.CLEntityId];
 177         nlassert(entity.Used);
 178
 179         CPropertyEntry          &ex = entity.Properties[PROPERTY_POSX];
 180
 181         if (ex.AllowDelta > 0 && allowPack)
 182         {
 183                 if (--ex.AllowDelta > 0)
 184                 {
 185                         action.packDelta(entity.Properties[PROPERTY_POSX].Garanted,
 186                                                          entity.Properties[PROPERTY_POSY].Garanted,
 187                                                          entity.Properties[PROPERTY_POSZ].Garanted);
 188                         return true;
 189                 }
 190                 else
 191                 {
 192                         // disable next incoming garanted packets
 193                         // until we send a garanted packet
 194                         ex.Packet = 0xFFFFFFFF;
 195                         return false;
 196                 }
 197         }
 198         else
 199         {
 200                 return false;
 201         }
 202 }
 203 */
 204 //
 205
 206 //
 207
 208
 209 //
 210
 211 void    CPropertyHistory::ackProperty(TClientId clientId, TCLEntityId entityId, uint32 packet, TPropIndex propId)
 212 {
 213         //nlassert(clientId < _ClientEntries.size() && _ClientEntries[clientId].EntryUsed);
 214 /*
 215         if (!isContinuousProperty(propId))
 216                 return;
 217
 218         CEntityEntry            &entity = _ClientEntries[clientId].Entities[entityId];
 219
 220         // search if entity exists already
 221         if (!entity.Used)
 222                 return;
 223
 224         CPropertyEntry          &entry = entity.Properties[propId];
 225
 226         // assume all previous packet have been ack'ed (ack- or ack+)
 227         if (packet == entry.Packet)
 228         {
 229                 if (entry.AllowDelta == 0)
 230                         entry.AllowDelta = _MaxDeltaSend;
 231
 232                 if (propId == PROPERTY_POSITION)
 233                 {
 234                         entity.garantyPosition();
 235                 }
 236                 else
 237                 {
 238                         entry.Garanted = entry.ToGaranty;
 239                 }
 240
 241                 entry.Packet = 0xFFFFFFFF;
 242 //              nldebug("FECONTH: Ack Garanted CL=%d CEId=%d Pk=%d (%.2f,%.2f)", clientId, entityId, packet, entry.Garanted.Float);
 243         }
 244 */
 245 }
 246
 247 void    CPropertyHistory::negAckProperty(TClientId clientId, TCLEntityId entityId, uint32 packet, TPropIndex propId)
 248 {
 249 /*
 250         nlassert(clientId < _ClientEntries.size() && _ClientEntries[clientId].EntryUsed);
 251
 252         CEntityEntry            &entity = _ClientEntries[clientId].Entities[entityId];
 253
 254         // search if entity exists already
 255         if (!entity.Used)
 256                 return;
 257
 258         CPropertyEntry          &entry = entity.Properties[propId];
 259
 260         if (packet == entry.Packet)
 261         {
 262                 entry.Packet = 0xFFFFFFFF;
 263 //              nldebug("FECONTH: negAcked CL=%d CEId=%d Pk=%d", entityId, propId, packet);
 264         }
 265 */
 266 }
 267
 268
 269 void    CPropertyHistory::ackProperties(TClientId clientId, TCLEntityId entityId, uint32 packet, const vector<TPropIndex> &ids)
 270 {
 271 /*
 272         nlassert(clientId < _ClientEntries.size() && _ClientEntries[clientId].EntryUsed);
 273
 274         CEntityEntry    &entity = _ClientEntries[clientId].Entities[entityId];
 275
 276         // search if entity exists already
 277         nlassert(entity.Used);
 278
 279         uint    i;
 280         for (i=0; i<ids.size(); ++i)
 281         {
 282                 TPropIndex      id = ids[i];
 283                 if (!isContinuousProperty(id))
 284                         continue;
 285
 286                 if (packet == entity.Properties[id].Packet)
 287                 {
 288                         entity.Properties[id].Garanted = entity.Properties[id].ToGaranty;
 289                         entity.Properties[id].Packet = 0xFFFFFFFF;
 290                 }
 291         }
 292 */
 293 }
 294
 295 //
 296
 297 /*
 298 void    CPropertyHistory::setPropertyConversion(uint32 property, sint8 conversion)
 299 {
 300         _PropertiesTranslation[property] = (conversion >= 0 ? conversion : -1);
 301 }
 302
 303 void    CPropertyHistory::setPropertyConversion(CPropertyTranslation *properties, sint numProperties)
 304 {
 305         sint    i;
 306         for (i=0; i<numProperties; ++i)
 307                 _PropertiesTranslation[properties[i].Property] = (properties[i].Translation >= 0 ? properties[i].Translation : -1);
 308 }
 309 */
 310