Changeset 7872 in orxonox.OLD for branches/network/src/lib

Timestamp:

May 26, 2006, 2:08:51 PM (19 years ago)

Author:

rennerc

Message:

removing zerobytes should work now

Location:

branches/network/src/lib/network

Files:

• connection_monitor.cc (modified) (3 diffs)
• connection_monitor.h (modified) (1 diff)
• handshake.cc (modified) (5 diffs)
• handshake.h (modified) (3 diffs)
• message_manager.cc (modified) (1 diff)
• message_manager.h (modified) (1 diff)
• network_stream.cc (modified) (9 diffs)
• synchronizeable.cc (modified) (5 diffs)
• synchronizeable.h (modified) (1 diff)
• synchronizeable_var/synchronizeable_string.cc (modified) (1 diff)
• udp_server_socket.cc (modified) (1 diff)
• udp_socket.cc (modified) (1 diff)

branches/network/src/lib/network/connection_monitor.cc

@@ -126 +126 @@
   
   if ( packetHistory.size() <= 1 || tick - packetHistory.begin()->first == 0 )
-    res = 0;
+    res = 0.0f;
   else
     res /= (float)((tick - packetHistory.begin()->first)*( 1 + 1/((float)(packetHistory.size()-1)) ));
   
-  res *= 1000;
+  res *= 1000.0f;
   
   return res;
@@ -148 +148 @@
   outgoingZippedBandWidth = calculateBandWidth( outgoingZippedPacketHistory, tick );
   
-  NETPRINTF(n)("UPSTREAM: user: %d bandwidth %f\n", userId, outgoingZippedBandWidth );
+  NETPRINTF(n)("UPSTREAM: user: %d bandwidth %f nOutgoingPackets %d\n", userId, outgoingZippedBandWidth, nOutgoingPackets );
 
 }
@@ -163 +163 @@
   incomingZippedBandWidth = calculateBandWidth( incomingZippedPacketHistory, tick );
   
-  NETPRINTF(n)("DOWNSTREAM: user: %d bandwidth %f\n", userId, incomingZippedBandWidth );
+  NETPRINTF(n)("DOWNSTREAM: user: %d bandwidth %f nIncomingPackets %d\n", userId, incomingZippedBandWidth, nIncomingPackets );
   
 }
 
+
+bool ConnectionMonitor::hasTimedOut( )
+{
+  if ( lastPacketTick + SECS_TO_TIMEOUT*1000 < SDL_GetTicks() && nIncomingPackets > 0 )
+    return true;
+  
+  if ( nIncomingPackets == 0 && nOutgoingPackets >= NETWORK_FREQUENCY*SECS_TO_TIMEOUT )
+    return true;
+  
+  return false;
+}
+
+

branches/network/src/lib/network/connection_monitor.h

@@ -30 +30 @@
     void calculatePing();
     
-    bool hasTimedOut(){ return ( lastPacketTick + SECS_TO_TIMEOUT*1000 < SDL_GetTicks() ) && nIncomingPackets > 0; }
+    bool hasTimedOut();
     
   private:

branches/network/src/lib/network/handshake.cc

@@ -41 +41 @@
   errorString_handler = registerVarId( new SynchronizeableString( &localState.errorString, &remoteState.errorString, "errorString", PERMISSION_ALL ) );
   
+  candel_id = registerVarId( new SynchronizeableInt( &localState.canDel, &remoteState.canDel, "canDel", PERMISSION_ALL ) );
+  
   localState.completed = 0;
   localState.error = 0;
@@ -49 +51 @@
   localState.orxId = _ORXONOX_ID;
   localState.version = _ORXONOX_VERSION;
+  localState.canDel = 0;
   
   remoteState.completed = 0;
@@ -58 +61 @@
   remoteState.orxId = 0;
   remoteState.version = 0;
+  remoteState.canDel = 0;
 
   this->setSynchronized(true);
@@ -95 +99 @@
     }
     
+    if ( *it == candel_id )
+    {
+      PRINTF(0)("handshake finished candel changed\n");
+    }
+    
   }
   
@@ -101 +110 @@
       remoteState.version == _ORXONOX_VERSION
      )
-    localState.completed = true;
+    localState.completed = 1;
 }
 

branches/network/src/lib/network/handshake.h

@@ -23 +23 @@
   
   int completed;
+  int canDel;
   
   int error;
@@ -39 +40 @@
     inline int        getMessageManagerId(){ return remoteState.messageManagerId; }
     inline void       doReject( std::string reason ){ localState.error = 1; localState.errorString = "the server rejected your connection ["+ reason +"]"; }
+    inline bool       canDel(){ return localState.canDel == 1 && remoteState.canDel == 1; }
+    inline bool       allowDel(){ return localState.canDel == 1; }
+    inline void       del(){ localState.canDel = 1; }
     
     virtual void varChangeHandler( std::list<int> & id );
@@ -54 +58 @@
     int orxId_handler;
     int version_handler;
+    int candel_id;
 
 };

branches/network/src/lib/network/message_manager.cc

@@ -288 +288 @@
   // just do something so map creates a new entry
   messageQueue[userId].toAck.clear();
-  assert( messageQueue[userId].messages.size() == 0 );
+  //assert( messageQueue[userId].messages.size() == 0 );
 }
 

branches/network/src/lib/network/message_manager.h

@@ -92 +92 @@
    virtual int setStateDiff( int userId, byte* data, int length, int stateId, int fromStateId );
    virtual void cleanUpUser( int userId );
+   virtual void handleSentState( int userId, int stateId, int fromStateId ){}
+   virtual void handleRecvState( int userId, int stateId, int fromStateId ){}
    
    void initUser( int userId );

branches/network/src/lib/network/network_stream.cc

@@ -188 +188 @@
   else
   {
-    if ( peers[0].socket && !peers[0].socket->isOk() )
+    if ( peers[0].socket && ( !peers[0].socket->isOk() || peers[0].connectionMonitor->hasTimedOut() ) )
     {
       PRINTF(1)("lost connection to server\n");
@@ -272 +272 @@
        )
     {
-      PRINTF(0)("Client is gone: %d\n", it->second.userId);
+      std::string reason = "disconnected";
+      if ( it->second.connectionMonitor->hasTimedOut() )
+        reason = "timeout";
+      PRINTF(0)("Client is gone: %d (%s)\n", it->second.userId, reason.c_str());
+      
+      assert(false);
 
       it->second.socket->disconnectServer();
@@ -340 +345 @@
         if ( it->second.handshake->ok() )
         {
-          if ( type != NET_SERVER )
-          {
-            SharedNetworkData::getInstance()->setHostID( it->second.handshake->getHostId() );
-            myHostId = SharedNetworkData::getInstance()->getHostID();
-
-            this->networkGameManager = NetworkGameManager::getInstance();
-            this->networkGameManager->setUniqueID( it->second.handshake->getNetworkGameManagerId() );
-            MessageManager::getInstance()->setUniqueID( it->second.handshake->getMessageManagerId() );
+          if ( !it->second.handshake->allowDel() )
+          {
+            if ( type != NET_SERVER )
+            {
+              SharedNetworkData::getInstance()->setHostID( it->second.handshake->getHostId() );
+              myHostId = SharedNetworkData::getInstance()->getHostID();
+
+              this->networkGameManager = NetworkGameManager::getInstance();
+              this->networkGameManager->setUniqueID( it->second.handshake->getNetworkGameManagerId() );
+              MessageManager::getInstance()->setUniqueID( it->second.handshake->getMessageManagerId() );
+            }
+              
+
+            PRINT(0)("handshake finished id=%d\n", it->second.handshake->getNetworkGameManagerId());
+
+            it->second.handshake->del();
           }
           else
-            handleNewClient( it->second.userId );
-
-          PRINT(0)("handshake finished id=%d\n", it->second.handshake->getNetworkGameManagerId());
-
-          delete it->second.handshake;
-          it->second.handshake = NULL;
+          {
+            if ( it->second.handshake->canDel() )
+            {
+              if ( type == NET_SERVER )
+              {
+                handleNewClient( it->second.userId );
+              }
+              
+              PRINT(0)("handshake finished delete it\n");
+              delete it->second.handshake;
+              it->second.handshake = NULL;
+            }
+          }
 
         }
@@ -429 +449 @@
       n = sync.getStateDiff( peer->second.userId, buf + offset, UDP_PACKET_SIZE-offset, currentState, peer->second.lastAckedState, -1000 );
       offset += n;
-      //PRINTF(0)("GGGGGEEEEEEETTTTTTTT: %d\n", n);
+      //NETPRINTF(0)("GGGGGEEEEETTTTT: %s (%d) %d\n",sync.getClassName(), sync.getUniqueID(), n);
       
       assert( Converter::intToByteArray( n, buf + offset - n - INTSIZE, INTSIZE ) == INTSIZE );
       
+      //check if all bytes == 0 -> remove data 
+
+      bool allZero = true; 
+      for ( int i = 0; i < n; i++ ) 
+      { 
+         if ( buf[i+oldOffset+2*INTSIZE] != 0 ) 
+           allZero = false; 
+      } 
+
+      if ( allZero ) 
+      { 
+        //NETPRINTF(n)("REMOVE ZERO DIFF: %s (%d)\n", sync.getClassName(), sync.getUniqueID()); 
+        offset = oldOffset; 
+      } 
+
+      
+    }
+    
+    for ( SynchronizeableList::iterator it = synchronizeables.begin(); it != synchronizeables.end(); it++ )
+    {
+      Synchronizeable & sync = **it;
+      
+      if ( !sync.beSynchronized() || sync.getUniqueID() < 0 )
+        continue;
+      
+      sync.handleSentState( peer->second.userId, currentState, peer->second.lastAckedState );
     }
     
@@ -481 +527 @@
     while ( 0 < (compLength = peer->second.socket->readPacket( compBuf, UDP_PACKET_SIZE )) )
     {
+      //PRINTF(0)("GGGGGOOOOOOOOOOTTTTTTTT: %d\n", compLength);
       packetLength = Zip::getInstance()->unZip( compBuf, compLength, buf, UDP_PACKET_SIZE );
       
@@ -523 +570 @@
         
         assert( syncDataLength > 0 );
-        assert( syncDataLength < 1000 );
+        assert( syncDataLength < 10000 );
       
         Synchronizeable * sync = NULL;
@@ -545 +592 @@
             continue;
           }
-
+          
           if ( !peers[peer->second.userId].isServer )
           {
@@ -601 +648 @@
         int n = sync->setStateDiff( peer->second.userId, buf+offset, syncDataLength, state, fromState ); 
         offset += n;
-        //PRINTF(0)("SSSSSEEEEETTTTT: %d\n", n);
+        //NETPRINTF(0)("SSSSSEEEEETTTTT: %s %d\n",sync->getClassName(), n);
+
       }
       
@@ -610 +658 @@
       }
       
-      peer->second.connectionMonitor->processZippedIncomingPacket( compBuf, compLength, currentState, ackedState );
-      peer->second.connectionMonitor->processUnzippedIncomingPacket( buf, offset, currentState, ackedState );
-    
+      //TODO REMOVE THIS
+      int saveOffset = offset;
+      
+      for ( SynchronizeableList::iterator it = synchronizeables.begin(); it != synchronizeables.end(); it++ )
+      {
+        Synchronizeable & sync = **it;
+      
+        if ( !sync.beSynchronized() || sync.getUniqueID() < 0 )
+          continue;
+      
+        sync.handleRecvState( peer->second.userId, state, fromState );
+      }
+      
+      peer->second.connectionMonitor->processZippedIncomingPacket( compBuf, compLength, state, ackedState );
+      peer->second.connectionMonitor->processUnzippedIncomingPacket( buf, offset, state, ackedState );
+    
+      assert( peer->second.lastAckedState <= ackedState );
       peer->second.lastAckedState = ackedState;
       
+      assert( peer->second.lastRecvedState < state );
       peer->second.lastRecvedState = state;
+      
+      assert( saveOffset == offset );
       
     }

branches/network/src/lib/network/synchronizeable.cc

@@ -20 +20 @@
 #include "network_stream.h"
 #include "netdefs.h"
+#include "network_log.h"
 
 #include "state.h"
@@ -179 +180 @@
     if ( ( hasPermission && (*it)->getPriority() >= priorityTH ) || sizeIter == stateFrom->sizeList.end() )
     {
+      n = (*it)->writeToBuf( stateTo->data+i, stateTo->dataLength - i );
+      //NETPRINTF(0)("getvar %s %d\n", (*it)->getName().c_str(), n);
+      stateTo->sizeList.push_back( n );
       //(*it)->debug();
-      n = (*it)->writeToBuf( stateTo->data+i, stateTo->dataLength - i );
-      stateTo->sizeList.push_back( n );
       i += n;
     }
@@ -192 +194 @@
         i++;
       }
+      //NETPRINTF(0)("getvar %s %d\n", (*it)->getName().c_str(), *sizeIter);
       stateTo->sizeList.push_back( (*sizeIter) );
     }
@@ -237 +240 @@
   stateTo->data = new byte[ length ];
 
+
+  //find state to apply diff to
+  StateHistoryEntry * stateFrom = NULL;
+
+  StateHistory::iterator it = recvStates[userId].begin();
+  while ( it != recvStates[userId].end() && (*it)->stateId != fromStateId )
+    it++;
+
+  
+//  if ( getLeafClassID() == CL_SPACE_SHIP )
+//  {
+//    PRINTF(0)("setStateDiff:SpaceShip from: %d stateId: %d\n", (it == recvStates[userId].end())?-1:fromStateId, stateId);
+//  }
+
+  if ( it == recvStates[userId].end() )
+  {
+    StateHistoryEntry * initialEntry = new StateHistoryEntry();
+
+    initialEntry->stateId = fromStateId;
+    initialEntry->dataLength = 0;
+    initialEntry->data = NULL;
+
+    stateFrom = initialEntry;
+  }
+  else
+    stateFrom = (*it);
+  
+  //apply diff
+  for ( int i = 0; i<length; i++ )
+  {
+    if ( i < stateFrom->dataLength )
+      stateTo->data[i] = stateFrom->data[i] + data[i];
+    else
+      stateTo->data[i] = data[i];
+    
+  }
+  
+  //add state to state history
+  recvStates[userId].push_back( stateTo );
+  
+  int i = 0;
+  int n = 0;
+  std::list<int> changes;
+  
+  for ( SyncVarList::iterator it = syncVarList.begin(); it != syncVarList.end(); it++ )
+  {
+    if (
+        (*it)->checkPermission( PERMISSION_SERVER ) && networkStream->isUserServer( userId ) ||
+        (*it)->checkPermission( PERMISSION_OWNER ) && this->owner == userId ||
+        (*it)->checkPermission( PERMISSION_ALL ) 
+       )
+    {
+      n = (*it)->readFromBuf( stateTo->data + i, stateTo->dataLength - i );
+      i += n;
+      //NETPRINTF(0)("%s::setvar %s %d\n", getClassName(), (*it)->getName().c_str(), n);
+      //(*it)->debug();
+      if ( (*it)->getHasChanged() )
+      {
+        changes.push_back( (*it)->getVarId() );
+      }
+    }
+    else
+    {
+//      PRINTF(0)("DONT SET VAR BECAUSE OF PERMISSION: %s %d %d %d %d %d %d\n", (*it)->getName().c_str(), (*it)->checkPermission( PERMISSION_SERVER ), (*it)->checkPermission( PERMISSION_OWNER ), (*it)->checkPermission( PERMISSION_ALL ), networkStream->isUserServer( userId ), this->owner, userId );
+      n = (*it)->getSizeFromBuf( stateTo->data + i, stateTo->dataLength - i );
+      //NETPRINTF(0)("%s::setvar %s %d\n", getClassName(), (*it)->getName().c_str(), n);
+      //(*it)->debug();
+      i += n;
+    }
+  }
+
+  this->varChangeHandler( changes );
+  
+  return i;
+}
+
+ /**
+ * override this function to be notified on change
+ * of your registred variables.
+ * @param id id's which have changed
+ */
+void Synchronizeable::varChangeHandler( std::list<int> & id )
+{
+}
+
+/**
+ * registers a varable to be synchronized over network
+ * @param var see src/lib/network/synchronizeable_var/ for available classes
+ */
+void Synchronizeable::registerVar( SynchronizeableVar * var )
+{
+  PRINTF(0)("ADDING VAR: %s\n", var->getName().c_str());
+  syncVarList.push_back( var );
+}
+
+/**
+ * registers a varable to be synchronized over network
+ * return value is passed to varChangeHandler on change
+ * @param var see src/lib/network/synchronizeable_var/ for available classes
+ * @return handle passed to varChangeHandler on changes
+ */
+int Synchronizeable::registerVarId( SynchronizeableVar * var )
+{
+  PRINTF(0)("ADDING VAR: %s\n", var->getName().c_str());
+  syncVarList.push_back( var );
+  var->setWatched( true );
+  var->setVarId( syncVarList.size()-1 );
+  return syncVarList.size()-1;
+}
+
+/**
+ * removed user's states from memory
+ * @param userId user to clean
+ */
+void Synchronizeable::cleanUpUser( int userId )
+{
+  for ( UserStateHistory::iterator it = sentStates.begin(); it != sentStates.end(); it++ )
+  {
+    for ( StateHistory::iterator it2 = it->begin(); it2 != it->end(); it2++ )
+    {
+      if ( (*it2)->data )
+        delete [] (*it2)->data;
+      (*it2)->data = NULL;
+      
+      delete *it2;
+    }
+  }
+  
+  sentStates.clear();
+  
+  for ( UserStateHistory::iterator it = recvStates.begin(); it != recvStates.end(); it++ )
+  {
+    for ( StateHistory::iterator it2 = it->begin(); it2 != it->end(); it2++ )
+    {
+      if ( (*it2)->data )
+        delete [] (*it2)->data;
+      (*it2)->data = NULL;
+      
+      delete *it2;
+    }
+  }
+  
+  recvStates.clear();
+}
+
+/**
+ * this function is called after recieving a state.
+ * @param userId 
+ * @param stateId 
+ * @param fromStateId 
+ */
+void Synchronizeable::handleRecvState( int userId, int stateId, int fromStateId )
+{
+   //make sure this user has his history
+  if ( recvStates.size() <= userId )
+    recvStates.resize( userId+1 );
+  
   //remove old states
   StateHistory::iterator it = recvStates[userId].begin();
 
+#if 0
   while ( it != recvStates[userId].end() && (*it)->stateId < fromStateId )
     it++;
@@ -255 +416 @@
     recvStates[userId].erase( recvStates[userId].begin(), it );
   }
-
-  //find state to apply diff to
-  StateHistoryEntry * stateFrom = NULL;
-
-  it = recvStates[userId].begin();
-  while ( it != recvStates[userId].end() && (*it)->stateId != fromStateId )
+#endif
+
+  for ( it = recvStates[userId].begin(); it != recvStates[userId].end();  )
+  {
+    if ( (*it)->stateId < fromStateId )
+    {
+      StateHistory::iterator delIt = it;
+      it ++;
+      
+      if ( (*delIt)->data )
+        delete [] (*delIt)->data;
+      recvStates[userId].erase( delIt );
+      
+      continue;
+    }
     it++;
-
-  
-//  if ( getLeafClassID() == CL_SPACE_SHIP )
-//  {
-//    PRINTF(0)("setStateDiff:SpaceShip from: %d stateId: %d\n", (it == recvStates[userId].end())?-1:fromStateId, stateId);
-//  }
-
-  if ( it == recvStates[userId].end() )
-  {
-    StateHistoryEntry * initialEntry = new StateHistoryEntry();
-
-    initialEntry->stateId = fromStateId;
-    initialEntry->dataLength = 0;
-    initialEntry->data = NULL;
-
-    stateFrom = initialEntry;
-  }
-  else
-    stateFrom = (*it);
-  
-  //apply diff
-  for ( int i = 0; i<length; i++ )
-  {
-    if ( i < stateFrom->dataLength )
-      stateTo->data[i] = stateFrom->data[i] + data[i];
+  }
+  
+  StateHistory::iterator fromState = recvStates[userId].end();
+  StateHistory::iterator toState = recvStates[userId].end();
+  
+  for ( it = recvStates[userId].begin(); it != recvStates[userId].end(); it++ )
+  {
+    if ( (*it)->stateId == stateId )
+      toState = it;
+    if ( (*it)->stateId == fromStateId )
+      fromState = it;
+    
+    if ( fromState != recvStates[userId].end() && toState != recvStates[userId].end() )
+      break;
+  }
+  
+  // setStateDiff was not called and i know fromStateId
+  if ( fromState != recvStates[userId].end() && toState == recvStates[userId].end() )
+  {
+    StateHistoryEntry * entry = new StateHistoryEntry;
+    
+    entry->dataLength = (*fromState)->dataLength;
+    if ( entry->dataLength > 0 )
+    {
+      entry->data = new byte[entry->dataLength];
+          
+      assert( (*fromState)->data );
+      memcpy( entry->data, (*fromState)->data, entry->dataLength );
+    }
     else
-      stateTo->data[i] = data[i];
-    
-  }
-  
-  //add state to state history
-  recvStates[userId].push_back( stateTo );
-  
-  int i = 0;
-  std::list<int> changes;
-  
-  for ( SyncVarList::iterator it = syncVarList.begin(); it != syncVarList.end(); it++ )
-  {
-    if (
-        (*it)->checkPermission( PERMISSION_SERVER ) && networkStream->isUserServer( userId ) ||
-        (*it)->checkPermission( PERMISSION_OWNER ) && this->owner == userId ||
-        (*it)->checkPermission( PERMISSION_ALL ) 
-       )
-    {
-      i += (*it)->readFromBuf( stateTo->data + i, stateTo->dataLength - i );
-      if ( (*it)->getHasChanged() )
-        changes.push_back( (*it)->getVarId() );
+      entry->data = NULL;
+    
+    entry->sizeList = (*fromState)->sizeList;
+    entry->stateId = stateId;
+    
+    recvStates[userId].push_back(entry);
+  }
+}
+
+/**
+ * this function is called after sending a state
+ * @param userId 
+ * @param stateId 
+ * @param fromStateId 
+ */
+void Synchronizeable::handleSentState( int userId, int stateId, int fromStateId )
+{
+   //make sure this user has his history
+  if ( sentStates.size() <= userId )
+    sentStates.resize( userId+1 );
+
+   //remove old states
+  StateHistory::iterator it = sentStates[userId].begin();
+
+  for ( it = sentStates[userId].begin(); it != sentStates[userId].end();  )
+  {
+    if ( (*it)->stateId < fromStateId )
+    {
+      StateHistory::iterator delIt = it;
+      it ++;
+      
+      if ( (*delIt)->data )
+        delete [] (*delIt)->data;
+      sentStates[userId].erase( delIt );
+      
+      continue;
+    }
+    it++;
+  }
+
+  
+  StateHistory::iterator fromState = sentStates[userId].end();
+  StateHistory::iterator toState = sentStates[userId].end();
+  
+  for ( it = sentStates[userId].begin(); it != sentStates[userId].end(); it++ )
+  {
+    if ( (*it)->stateId == stateId )
+      toState = it;
+    if ( (*it)->stateId == fromStateId )
+      fromState = it;
+    
+    if ( fromState != sentStates[userId].end() && toState != sentStates[userId].end() )
+      break;
+  }
+
+  
+  // getStateDiff was not called and i know fromStateId
+  if ( fromState != sentStates[userId].end() && toState == sentStates[userId].end() )
+  {
+    StateHistoryEntry * entry = new StateHistoryEntry;
+    
+    entry->dataLength = (*fromState)->dataLength;
+    if ( entry->dataLength > 0 )
+    {
+      entry->data = new byte[entry->dataLength];
+      
+      assert( (*fromState)->data );
+      memcpy( entry->data, (*fromState)->data, entry->dataLength );
     }
     else
-    {
-//      PRINTF(0)("DONT SET VAR BECAUSE OF PERMISSION: %s %d %d %d %d %d %d\n", (*it)->getName().c_str(), (*it)->checkPermission( PERMISSION_SERVER ), (*it)->checkPermission( PERMISSION_OWNER ), (*it)->checkPermission( PERMISSION_ALL ), networkStream->isUserServer( userId ), this->owner, userId );
-      i += (*it)->getSizeFromBuf( stateTo->data + i, stateTo->dataLength - i );
-    }
-  }
-
-  this->varChangeHandler( changes );
-  
-  return i;
-}
-
- /**
- * override this function to be notified on change
- * of your registred variables.
- * @param id id's which have changed
- */
-void Synchronizeable::varChangeHandler( std::list<int> & id )
-{
-}
-
-/**
- * registers a varable to be synchronized over network
- * @param var see src/lib/network/synchronizeable_var/ for available classes
- */
-void Synchronizeable::registerVar( SynchronizeableVar * var )
-{
-  syncVarList.push_back( var );
-}
-
-/**
- * registers a varable to be synchronized over network
- * return value is passed to varChangeHandler on change
- * @param var see src/lib/network/synchronizeable_var/ for available classes
- * @return handle passed to varChangeHandler on changes
- */
-int Synchronizeable::registerVarId( SynchronizeableVar * var )
-{
-  syncVarList.push_back( var );
-  var->setWatched( true );
-  var->setVarId( syncVarList.size()-1 );
-  return syncVarList.size()-1;
-}
-
-/**
- * removed user's states from memory
- * @param userId user to clean
- */
-void Synchronizeable::cleanUpUser( int userId )
-{
-  for ( UserStateHistory::iterator it = sentStates.begin(); it != sentStates.end(); it++ )
-  {
-    for ( StateHistory::iterator it2 = it->begin(); it2 != it->end(); it2++ )
-    {
-      if ( (*it2)->data )
-        delete [] (*it2)->data;
-      (*it2)->data = NULL;
-      
-      delete *it2;
-    }
-  }
-  
-  sentStates.clear();
-  
-  for ( UserStateHistory::iterator it = recvStates.begin(); it != recvStates.end(); it++ )
-  {
-    for ( StateHistory::iterator it2 = it->begin(); it2 != it->end(); it2++ )
-    {
-      if ( (*it2)->data )
-        delete [] (*it2)->data;
-      (*it2)->data = NULL;
-      
-      delete *it2;
-    }
-  }
-  
-  recvStates.clear();
-}
-
-
-
+      entry->data = NULL;
+    
+    entry->sizeList = (*fromState)->sizeList;
+    entry->stateId = stateId;
+    
+    sentStates[userId].push_back(entry);
+  }
+  
+}
+
+
+

branches/network/src/lib/network/synchronizeable.h

@@ -59 +59 @@
     virtual int setStateDiff( int userId, byte* data, int length, int stateId, int fromStateId );
     virtual void cleanUpUser( int userId );
+    virtual void handleSentState( int userId, int stateId, int fromStateId );
+    virtual void handleRecvState( int userId, int stateId, int fromStateId );
 
     void registerVar( SynchronizeableVar * var );

branches/network/src/lib/network/synchronizeable_var/synchronizeable_string.cc

@@ -95 +95 @@
   
   int res = Converter::byteArrayToString( buf, t, maxLength );
-
   
   assert( res > 0 );

branches/network/src/lib/network/udp_server_socket.cc

@@ -35 +35 @@
   
   memset( packet->data, 0, UDP_PACKET_SIZE );
-  PRINTF(0)("PACKET DATA: %x\n", packet->data);
   
   listen( port );

branches/network/src/lib/network/udp_socket.cc

@@ -124 +124 @@
   if ( channel == -1 ) 
   {
-    PRINTF(2)("SDLNet_UDP_Bind: %s\n", SDLNet_GetError());
+    PRINTF(1)("SDLNet_UDP_Bind: %s\n", SDLNet_GetError());
     bOk = false;
     return;