Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

Changeset 8068 in orxonox.OLD for trunk/src/lib


Ignore:
Timestamp:
Jun 1, 2006, 2:28:16 PM (18 years ago)
Author:
patrick
Message:

trunk: merged the network branche back to trunk

Location:
trunk/src/lib
Files:
12 edited
2 copied

Legend:

Unmodified
Added
Removed

  • trunk/src/lib/graphics/importer/height_map.cc

    r7954 r8068  
    134134    w = yOffset;
    135135
    136     PRINTF(0)("Values: i = %i, w = %i\n", i, w);
     136//    PRINTF(0)("Values: i = %i, w = %i\n", i, w);
    137137
    138138    // add a vertex to the list
    … …  
    599599  float c = normalVectorField [(xInt)][yInt].y;
    600600
    601   PRINTF(0)("a: %f \n" ,a);
    602   PRINTF(0)("b: %f \n" ,b);
    603   PRINTF(0)("c: %f \n" ,c);
     601//  PRINTF(0)("a: %f \n" ,a);
     602//  PRINTF(0)("b: %f \n" ,b);
     603//  PRINTF(0)("c: %f \n" ,c);
    604604
    605605

  • trunk/src/lib/network/Makefile.am

    r7954 r8068  
    2323                      network_log.cc \
    2424                      zip.cc \
     25                      player_stats.cc \
    2526                      \
    2627                      synchronizeable_var/synchronizeable_var.cc \
    … …  
    5657                 network_log.h \
    5758                 zip.h \
     59                 player_stats.h \
    5860                 \
    5961                 synchronizeable_var/synchronizeable_var.h \

  • trunk/src/lib/network/connection_monitor.cc

    r7954 r8068  
    6161 * @param stateId packet's state id
    6262 */
    63 void ConnectionMonitor::processUnzippedOutgoingPacket( byte * data, int length, int stateId )
    64 {
    65   int tick = SDL_GetTicks();
    66  
     63void ConnectionMonitor::processUnzippedOutgoingPacket( int tick, byte * data, int length, int stateId )
     64{
    6765  nOutgoingPackets++;
    6866 
    … …  
    7775 
    7876  // count zero bytes
    79   int nZeroBytes = 0;
    80  
    81   for ( int i = 0; i < length; i++ )
    82     if ( data[i] == '\0' )
    83       nZeroBytes++;
     77  //int nZeroBytes = 0;
     78 
     79  //for ( int i = 0; i < length; i++ )
     80  //  if ( data[i] == '\0' )
     81  //    nZeroBytes++;
    8482 
    8583  //NETPRINTF(n)( "ZEROBYTES: %d (%f%%)\n", nZeroBytes, ((float)100)*nZeroBytes/length );
    … …  
    9391 * @param ackedState state which was acked by this packet
    9492 */
    95 void ConnectionMonitor::processUnzippedIncomingPacket( byte * data, int length, int stateId, int ackedState )
    96 {
    97   int tick = SDL_GetTicks();
    98  
     93void ConnectionMonitor::processUnzippedIncomingPacket( int tick, byte * data, int length, int stateId, int ackedState )
     94{
    9995  nIncomingPackets++;
    10096 
    … …  
    149145  for ( std::map<int,int>::iterator it = packetHistory.begin(); it != packetHistory.end(); it++ )
    150146  {
    151     res += it->second;
     147    if ( it != packetHistory.begin() )
     148      res += it->second;
    152149  }
    153150 
    … …  
    155152    res = 0.0f;
    156153  else
    157     res /= (float)((tick - packetHistory.begin()->first)*( 1 + 1/((float)(packetHistory.size()-1)) ));
     154    res /= (float)(tick - packetHistory.begin()->first);
    158155 
    159156  res *= 1000.0f;
    … …  
    169166 * @param stateId packet's state id
    170167 */
    171 void ConnectionMonitor::processZippedOutgoingPacket( byte * data, int length, int stateId )
    172 {
    173   int tick = SDL_GetTicks();
    174  
     168void ConnectionMonitor::processZippedOutgoingPacket( int tick, byte * data, int length, int stateId )
     169{
    175170  nZOutgoingPackets++;
    176171 
    … …  
    196191 * @param ackedState state which was acked by this packet
    197192 */
    198 void ConnectionMonitor::processZippedIncomingPacket( byte * data, int length, int stateId, int ackedState )
    199 {
    200   int tick = SDL_GetTicks();
    201  
     193void ConnectionMonitor::processZippedIncomingPacket( int tick, byte * data, int length )
     194{
    202195  nZIncomingPackets++;
    203196 
    … …  
    233226void ConnectionMonitor::printStatis( )
    234227{
    235   NETPRINT(n)("=========NETWORKSTATS FOR USER %d=========\n", userId);
    236   NETPRINT(n)("PING = %d\n", ping);
     228  NETPRINT(n)("============NETWORKSTATS FOR USER %d============\n", userId);
     229  NETPRINT(n)("PING = %d\n", ping );
    237230  NETPRINT(n)("BANDWIDTH: UP: %f (%f) DOWN %f (%f)\n", outgoingZippedBandWidth, outgoingUnzippedBandWidth, incomingZippedBandWidth, incomingUnzippedBandWidth);
    238   NETPRINT(n)("==========================================");
    239 }
    240 
    241 
     231  NETPRINT(n)("PACKETS: RECIEVED %d; SENT %d\n", nIncomingPackets, nOutgoingPackets );
     232  NETPRINT(n)("================================================\n");
     233}
     234
     235

  • trunk/src/lib/network/connection_monitor.h

    r7954 r8068  
    2222    virtual ~ConnectionMonitor();
    2323
    24     void processUnzippedOutgoingPacket( byte * data, int length, int stateId );
    25     void processUnzippedIncomingPacket( byte * data, int length, int stateId, int ackedState );
     24    void processUnzippedOutgoingPacket( int tick, byte * data, int length, int stateId );
     25    void processUnzippedIncomingPacket( int tick, byte * data, int length, int stateId, int ackedState );
    2626   
    27     void processZippedOutgoingPacket( byte * data, int length, int stateId );
    28     void processZippedIncomingPacket( byte * data, int length, int stateId, int ackedState );
     27    void processZippedOutgoingPacket( int tick, byte * data, int length, int stateId );
     28    void processZippedIncomingPacket( int tick, byte * data, int length );
    2929   
    3030    void calculatePing();

  • trunk/src/lib/network/message_manager.cc

    r7954 r8068  
    309309  {
    310310    if (
    311          recieverType == RT_ALL ||
     311         recieverType == RT_ALL_ME ||
     312         recieverType == RT_ALL_NOT_ME ||
    312313         recieverType == RT_USER && it->first == reciever ||
    313314         recieverType == RT_NOT_USER && it->first != reciever
    … …  
    324325     
    325326      it->second.messages.push_back( msg );
    326     }
    327   }
    328 }
    329 
    330 
     327     
     328      if ( recieverType == RT_ALL_ME )
     329        incomingMessabeBuffer.push_back( msg );
     330    }
     331  }
     332}
     333
     334

  • trunk/src/lib/network/message_manager.h

    r7954 r8068  
    2929{
    3030  TESTMESSAGEID = 1,
    31   MSGID_YOU_ARE
     31  MSGID_DELETESYNCHRONIZEABLE
    3232};
    3333
    … …  
    3636enum RecieverType
    3737{
    38   RT_ALL = 1,   //!< message is sent to all users
    39   RT_USER,      //!< message is only sent to reciever
    40   RT_NOT_USER   //!< message is sent to all but reciever
     38  RT_ALL_NOT_ME = 1,   //!< message is sent to all users
     39  RT_ALL_ME,           //!< message is sent to all users
     40  RT_USER,             //!< message is only sent to reciever
     41  RT_NOT_USER          //!< message is sent to all but reciever
    4142};
    4243

  • trunk/src/lib/network/network_game_manager.cc

    r7954 r8068  
    3434#include "game_world.h"
    3535
     36#include "game_rules.h"
     37#include "network_game_rules.h"
     38
    3639#include "network_game_manager.h"
    3740
    … …  
    5558  this->setSynchronized(true);
    5659 
    57   MessageManager::getInstance()->registerMessageHandler( MSGID_YOU_ARE, youAreHandler, NULL );
     60  MessageManager::getInstance()->registerMessageHandler( MSGID_DELETESYNCHRONIZEABLE, delSynchronizeableHandler, NULL );
     61 
     62  this->gameState = 0;
     63  registerVar( new SynchronizeableInt( &gameState, &gameState, "gameState" ) );
    5864}
    5965
    … …  
    6369NetworkGameManager::~NetworkGameManager()
    6470{
    65 #if 0
    66   for ( int i = 0; i<outBuffer.size(); i++)
    67   {
    68     if ( outBuffer[i].buffer )
    69       delete outBuffer[i].buffer;
    70   }
    71 #endif
    72 
    73 }
    74 
    75 #if 0
    76 int NetworkGameManager::writeBytes(const byte* data, int length, int sender)
    77 {
    78   int i = 0;
    79   byte b;
    80 
    81   while ( i<length )
    82   {
    83     b = data[i++];
    84 
    85     /**************** Commands only processed by servers ****************/
    86     if ( isServer() )
    87     {
    88       if ( b == NET_REQUEST_CREATE )
    89       {
    90         if ( !handleRequestCreate( i, data, length, sender ) )
    91           return i;
    92         continue;
    93       }
    94       else if ( b == NET_REQUEST_REMOVE )
    95       {
    96         if ( !handleRequestRemove( i, data, length, sender ) )
    97           return i;
    98         continue;
    99       }
    100       else if ( b == NET_REQUEST_PNODE_PATH )
    101       {
    102         if ( !handleRequestPNodePath( i, data, length, sender ) )
    103           return i;
    104         continue;
    105       }
    106     }
    107     else
    108     {
    109       /**************** Commands only processed by clients ****************/
    110       if ( b == NET_CREATE_ENTITY )
    111       {
    112         PRINTF(0)("CREATE_ENTITY\n");
    113         if ( !handleCreateEntity( i, data, length, sender ) )
    114           return i;
    115         continue;
    116       }
    117       else if ( b == NET_REMOVE_ENTITY )
    118       {
    119         if ( !handleRemoveEntity( i, data, length, sender ) )
    120           return i;
    121         continue;
    122       }
    123       else if ( b == NET_CREATE_ENTITY_LIST )
    124       {
    125         if ( !handleCreateEntityList( i, data, length, sender ) )
    126           return i;
    127         continue;
    128       }
    129       else if ( b == NET_REMOVE_ENTITY_LIST )
    130       {
    131         if ( !handleRemoveEntityList( i, data, length, sender ) )
    132           return i;
    133         continue;
    134       }
    135       else if ( b == NET_YOU_ARE_ENTITY )
    136       {
    137         if ( !handleYouAreEntity( i, data, length, sender ) )
    138           return i;
    139         continue;
    140       }
    141     }
    142 
    143     /**************** Commands processed by servers and clients ****************/
    144     if ( b == NET_REQUEST_ENTITY_LIST )
    145     {
    146       sendEntityList( sender );
    147       continue;
    148     }
    149 
    150 
    151     PRINTF(1)("Network is asynchronous: couldn't decode the command sent by %i\n", sender);
    152     PRINTF(1)("Probably this is because the network protocol has different \n");
    153     PRINTF(1)("versions or there occured an error in the sending algorithm\n");
    154     PRINTF(1)("Data is not in the right format! i=%d\n", i);
    155     return i;
    156   }
    157 
    158   return i;
    159 }
    160 #endif
    161 
    162 #if 0
    163 int NetworkGameManager::readBytes(byte* data, int maxLength, int * reciever)
    164 {
    165   if ( !isServer() && !hasRequestedWorld )
    166   {
    167     assert( maxLength >= 1 );
    168     data[0] = NET_REQUEST_ENTITY_LIST;
    169     hasRequestedWorld = true;
    170     return 1;
    171   }
    172 
    173   for ( int i = 0; i<outBuffer.size(); i++ )
    174   {
    175     *reciever = i;
    176     if ( outBuffer[i].length>0 )
    177     {
    178       int nbytes = outBuffer[i].length;
    179       outBuffer[i].length = 0;
    180 
    181       if ( nbytes > maxLength )
    182       {
    183         PRINTF(1)("OutBuffer.length (%d) > (%d) networkStreamBuffer.maxLength\n", nbytes, maxLength);
    184         return 0;
    185       }
    186 
    187       memcpy(data, outBuffer[i].buffer, nbytes);
    188       return nbytes;
    189     }
    190   }
    191 
    192   return 0;
    193 }
    194 #endif
    195 
    196 #if 0
    197 void NetworkGameManager::writeDebug() const
    198 {
    199 }
    200 
    201 void NetworkGameManager::readDebug() const
    202 {
    203 }
    204 #endif
    205 
    206 
    207 /*!
    208  * Checks whether this is connected to a server or a client
    209  * and afterwards creates the needed entity
    210  * @param classID: The ID of the class of which an entity should be created
    211  */
    212 int NetworkGameManager::createEntity( ClassID classID, int owner )
    213 {
    214   if ( this->isServer())
    215   {
    216     int res = this->executeCreateEntity( classID, SharedNetworkData::getInstance()->getNewUniqueID(), owner );
    217    
    218     if ( res < 0 )
    219     {
    220       PRINTF(1)("Cannot create entity! There are no more uniqueIDs left!\n");
    221       return -1;
    222     }
    223    
    224     return res;
    225   }
    226   else
    227   {
    228 #if 0
    229     this->requestCreateEntity( classID );
    230 #endif
    231     return -1;
    232   }
    23371}
    23472
    23573
    236 /*!
    237  * Checks whether this is connected to a server or a client
    238  * and afterwards creates the needed entity
    239  * @param classID: The ID of the class of which an entity should be created
     74/**
     75 * insert new player into game
     76 * @param userId
     77 * @return
    24078 */
    241 BaseObject* NetworkGameManager::createEntity(const TiXmlElement* element)
     79bool NetworkGameManager::signalNewPlayer( int userId )
    24280{
    243   if ( this->isServer() )
    244   {
    245     if ( SharedNetworkData::getInstance()->getNewUniqueID() < 0 )
    246     {
    247       PRINTF(1)("Cannot create entity! There are no more uniqueIDs left!\n");
    248       return NULL;
    249     }
    250 
    251     BaseObject * b = Factory::fabricate( element );
    252 
    253     if ( !b )
    254     {
    255       PRINTF(1)("Could not fabricate Object with className %s\n", element->Value() );
    256       return NULL;
    257     }
    258 
    259 
    260     if ( b->isA(CL_SYNCHRONIZEABLE) )
    261     {
    262       Synchronizeable * s = dynamic_cast<Synchronizeable*>(b);
    263       s->setUniqueID( SharedNetworkData::getInstance()->getNewUniqueID() );
    264       s->setOwner( 0 );
    265       // all entities created via this function are added automaticaly to the synchronizeable list
    266       s->setSynchronized(true);
    267       return b;
    268     }
    269     else
    270     {
    271       PRINTF(1)("Class %s is not a synchronizeable!\n", b->getClassName() );
    272       delete b;
    273     }
    274 
    275   }
    276   else
    277 
    278   {
    279     PRINTF(1)("This node is not a server and cannot create id %x\n", element->Value());
    280   }
    281   return NULL;
     81  assert( SharedNetworkData::getInstance()->isGameServer() );
     82  assert( State::getGameRules() );
     83  assert( State::getGameRules()->isA( CL_NETWORK_GAME_RULES ) );
     84 
     85  NetworkGameRules & rules = *(dynamic_cast<NetworkGameRules*>(State::getGameRules()));
     86 
     87  int team = rules.getTeamForNewUser();
     88  ClassID playableClassId = rules.getPlayableClassId( team );
     89  std::string playableModel = rules.getPlayableModelFileName( team, playableClassId );
     90 
     91  BaseObject * bo = Factory::fabricate( playableClassId );
     92 
     93  assert( bo != NULL );
     94  assert( bo->isA( CL_PLAYABLE ) );
     95 
     96  Playable & playable = *(dynamic_cast<Playable*>(bo));
     97 
     98  playable.loadModel( playableModel );
     99  playable.setOwner( userId );
     100  playable.setUniqueID( SharedNetworkData::getInstance()->getNewUniqueID() );
     101  playable.setSynchronized( true );
     102 
     103  PlayerStats * stats = rules.getNewPlayerStats( userId );
     104 
     105  stats->setUniqueID( SharedNetworkData::getInstance()->getNewUniqueID() );
     106  stats->setSynchronized( true );
     107  stats->setOwner( getHostID() );
     108 
     109  stats->setTeamId( team );
     110  stats->setPlayableClassId( playableClassId );
     111  stats->setPlayableUniqueId( playable.getUniqueID() );
     112  stats->setModelFileName( playableModel );
    282113}
    283114
    284115
    285 /*!
    286  * Checks whether this is connected to a server or a client
    287  * and afterwards removes the specified entity
    288  * @param uniqueID: The ID of the entity object which should be removed
     116/**
     117 * remove player from game
     118 * @param userID
     119 * @return
    289120 */
    290 void NetworkGameManager::removeEntity(int uniqueID)
     121bool NetworkGameManager::signalLeftPlayer(int userID)
    291122{
    292   if ( this->isServer() )
    293   {
    294     this->executeRemoveEntity( uniqueID );
    295   }
    296   else
    297   {
    298 #if 0
    299     this->requestRemoveEntity( uniqueID );
    300 #endif
    301   }
    302 }
    303 
    304 
    305 #if 0
    306 /*!
    307  * Creates the needed entity on the server if possible
    308  * @param classID: The ID of the class of which an entity should be created
    309  */
    310 void NetworkGameManager::requestCreateEntity(ClassID classID)
    311 {
    312   for ( int i = 0; i<outBuffer.size(); i++)
    313   {
    314     if ( !this->networkStream->isUserIdActive( i ) )
    315       continue;
    316 
    317     if ( !writeToClientBuffer( outBuffer[i], (byte)NET_REQUEST_CREATE ) )
    318       return;
    319     if ( !writeToClientBuffer( outBuffer[i], (int)classID ) )
    320       return;
    321   }
    322 }
    323 #endif
    324 
    325 #if 0
    326 /*!
    327  * Removes the specified entity on the server
    328  * @param uniqueID: The ID of the entity object which should be removed
    329  */
    330 void NetworkGameManager::requestRemoveEntity(int uniqueID)
    331 {
    332   for ( int i = 0; i<outBuffer.size(); i++)
    333   {
    334     if ( !this->networkStream->isUserIdActive( i ) )
    335       continue;
    336 
    337     if ( !writeToClientBuffer( outBuffer[i], (byte)NET_REQUEST_REMOVE ) )
    338       return;
    339     if ( !writeToClientBuffer( outBuffer[i], uniqueID ) )
    340       return;
    341   }
    342 }
    343 #endif
    344 
    345 /*!
    346  * Creates the needed entity if possible
    347  * This function is called if this is a server
    348  * @param classID: The ID of the class of which an entity should be created
    349  */
    350 int NetworkGameManager::executeCreateEntity(ClassID classID, int uniqueID, int owner)
    351 {
    352 #if 0
    353   for ( int i = 0; i<outBuffer.size(); i++)
    354   {
    355     if ( !this->networkStream->isUserIdActive( i ) )
    356       continue;
    357 
    358     if ( !writeToClientBuffer( outBuffer[i], (byte)NET_CREATE_ENTITY ) )
    359       return -1;
    360     if ( !writeToClientBuffer( outBuffer[i], (int)classID ) )
    361       return -1;
    362     if ( !writeToClientBuffer( outBuffer[i], uniqueID ) )
    363       return -1;
    364     if ( !writeToClientBuffer( outBuffer[i], owner ) )
    365       return -1;
    366   }
    367 #endif
    368   PRINTF(0)("ExecuteCreateEntity: server side: classID: %x, uniqueID: %i, owner: %i\n", classID, uniqueID, owner);
    369   doCreateEntity( classID, uniqueID, owner );
    370 
    371   return uniqueID;
    372 }
    373 
    374 /*!
    375  * Removes the specified entity
    376  * This function is called if this is a server
    377  * @param uniqueID: The ID of the entity object which should be removed
    378  */
    379 void NetworkGameManager::executeRemoveEntity(int uniqueID)
    380 {
    381 #if 0
    382   for ( int i = 0; i<outBuffer.size(); i++)
    383   {
    384     if ( !this->networkStream->isUserIdActive( i ) )
    385       continue;
    386 
    387     if ( !writeToClientBuffer( outBuffer[i], (byte)NET_REMOVE_ENTITY ) )
    388       return;
    389     if ( !writeToClientBuffer( outBuffer[i], uniqueID ) )
    390       return;
    391   }
    392 #endif
    393 
    394   doRemoveEntity(uniqueID);
    395 }
    396 
    397 /*!
    398  * Checks whether it is possible to create an entity of a given class
    399  * @return: true if the entity can be created, false otherwise
    400  */
    401 bool NetworkGameManager::canCreateEntity(ClassID classID)
    402 {
    403   return true;
    404 }
    405 
    406 #if 0
    407 /*!
    408  * Sends the Entities to the new connected client
    409  * @param userID: The ID of the user
    410  */
    411 void NetworkGameManager::sendEntityList( int userID )
    412 {
    413   if ( !isServer() )
    414     return;
    415 
    416   if ( userID >= outBuffer.size() )
    417     resizeBufferVector( userID );
    418 
    419   SynchronizeableList::const_iterator it, e;
    420 
    421   it = this->networkStream->getSyncBegin();
    422   e = this->networkStream->getSyncEnd();
    423 
    424   // send the packet header
    425   if ( !writeToClientBuffer( outBuffer[userID], (byte)NET_CREATE_ENTITY_LIST ) )
    426     return;
    427 
    428   // send the number of entities: -2 because you must not send network_game_manager and handshake
    429   if ( !writeToClientBuffer( outBuffer[userID], networkStream->getSyncCount() ) )
    430     return;
    431 
    432   //PRINTF(0)("SendEntityList: n = %d\n", networkStream->getSyncCount()-2 );
    433 
    434   // first send the NullParent
    435   if ( !writeToClientBuffer( outBuffer[userID], (int)PNode::getNullParent()->getLeafClassID()) )
    436     return;
    437   if ( !writeToClientBuffer( outBuffer[userID], (int)PNode::getNullParent()->getUniqueID()) )
    438     return;
    439   if ( !writeToClientBuffer( outBuffer[userID], (int)PNode::getNullParent()->getOwner()) )
    440     return;
    441 
    442   // now send the rest of the entities
    443   while ( it != e )
    444   {
    445     if( (*it)->beSynchronized() && (*it) != PNode::getNullParent())
    446     {
    447       PRINTF(0)("SENDING ENTITY %s classid: %x, uniqueid %d\n", (*it)->getClassName(), (*it)->getLeafClassID(), (*it)->getUniqueID() );
    448       if ( !writeToClientBuffer( outBuffer[userID], (int)((*it)->getLeafClassID()) ) )
    449         return;
    450 
    451       if ( !writeToClientBuffer( outBuffer[userID], (int)((*it)->getUniqueID()) ) )
    452         return;
    453 
    454       if ( !writeToClientBuffer( outBuffer[userID], (int)((*it)->getOwner()) ) )
    455         return;
    456     }
    457     it++;
    458   }
    459 
    460   signalNewPlayer( userID );
    461 }
    462 #endif
    463 
    464 
    465 
    466 bool NetworkGameManager::signalNewPlayer(int userId)
    467 {
    468   /* create new playable for Player*/
    469   PRINTF(0)("Request for creation: %i\n", userId);
    470   int uniqueId = this->createEntity(CL_SPACE_SHIP, userId);
    471   PRINTF(0)("Request for creation: userid: %i, uniqueid: %i\n", userId, uniqueId);
    472   this->sendYouAre(uniqueId, userId);
     123  delete PlayerStats::getStats( userID )->getPlayable();
     124  delete PlayerStats::getStats( userID );
    473125}
    474126
    475127
    476128
    477 bool NetworkGameManager::signalLeftPlayer(int userID)
     129/**
     130 * handler for remove synchronizeable messages
     131 * @param messageId
     132 * @param data
     133 * @param dataLength
     134 * @param someData
     135 * @param userId
     136 * @return true on successfull handling else handler will be called again
     137 */
     138bool NetworkGameManager::delSynchronizeableHandler( MessageId messageId, byte * data, int dataLength, void * someData, int userId )
    478139{
    479   const std::list<BaseObject*>* playableList = ClassList::getList(CL_PLAYABLE);
     140  if ( getInstance()->isServer() )
     141  {
     142    PRINTF(2)("Recieved DeleteSynchronizeable message from client %d!\n", userId);
     143    return true;
     144  }
    480145 
    481   if ( !playableList )
    482     return false;
     146  int uniqueId = 0;
     147  int len = Converter::byteArrayToInt( data, &uniqueId );
    483148 
    484   std::list<BaseObject*>::const_iterator it = playableList->begin();
    485 
    486   for(; it != playableList->end(); it++)
     149  if ( len != dataLength )
    487150  {
    488     if( dynamic_cast<Synchronizeable*>(*it)->getOwner() == userID )
     151    PRINTF(2)("Recieved DeleteSynchronizeable message with incorrect size (%d) from client %d!\n", dataLength, userId);
     152    return true;
     153  }
     154 
     155  const std::list<BaseObject*> * list = ClassList::getList( CL_SYNCHRONIZEABLE );
     156 
     157  for ( std::list<BaseObject*>::const_iterator it = list->begin(); it != list->end(); it++ )
     158  {
     159    if ( dynamic_cast<Synchronizeable*>(*it)->getUniqueID() == uniqueId )
    489160    {
    490       PRINTF(0)("remove playable from %i\n", userID);
    491       this->removeEntity(dynamic_cast<Synchronizeable*>(*it)->getUniqueID());
     161      delete dynamic_cast<Synchronizeable*>(*it);
    492162      return true;
    493163    }
    494164  }
    495   return false;
    496 }
    497 
    498 #if 0
    499 /**
    500  * Creates a buffer for user n
    501  * @param n The ID of the user
    502  */
    503 void NetworkGameManager::resizeBufferVector( int n )
    504 {
    505   for ( int i = outBuffer.size(); i<=n; i++)
    506   {
    507     clientBuffer outBuf;
    508 
    509     outBuf.length = 0;
    510 
    511     outBuf.maxLength = 5*1024;
    512 
    513     outBuf.buffer = new byte[5*1014];
    514 
    515     outBuffer.push_back(outBuf);
    516   }
    517 }
    518 #endif
    519 
    520 /**
    521  * Creates the entity on this host
    522  * @param classID: ClassID of the entity to create
    523  * @param uniqueID: Unique ID to assign to the synchronizeable
    524  * @param owner: owner of this synchronizealbe
    525  */
    526 BaseObject* NetworkGameManager::doCreateEntity( ClassID classID, int uniqueID, int owner )
    527 {
    528   PRINTF(0)("Creating Entity via Factory: classid: %x, uniqueID: %i, owner: %i\n", classID, uniqueID, owner);
    529 
    530   BaseObject * b;
    531   /* These are some small exeptions in creation: Not all objects can/should be created via Factory */
    532   /* Exception 1: NullParent */
    533   if( classID == CL_NULL_PARENT)
    534   {
    535     b = (BaseObject*)PNode::getNullParent();
    536   }
    537   else
    538     b = Factory::fabricate( classID );
    539 
    540   if ( !b )
    541   {
    542     PRINTF(1)("Could not fabricate Object with classID %x\n", classID);
    543     return NULL;
    544   }
    545 
    546   if ( b->isA(CL_SYNCHRONIZEABLE) )
    547   {
    548     Synchronizeable * s = dynamic_cast<Synchronizeable*>(b);
    549     s->setUniqueID( uniqueID );
    550     s->setOwner( owner );
    551     s->setSynchronized(true);
    552     //this->networkStream->connectSynchronizeable( *s );
    553 
    554     PRINTF(0)("Fabricated %s with id %d\n", s->getClassName(), s->getUniqueID());
    555 
    556     //TODO HACK: hack to prevent collision
    557     if ( b->isA(CL_WORLD_ENTITY) && !b->isA(CL_PLAYABLE) )
    558     {
    559       if ( SharedNetworkData::getInstance()->getHostID()!=0 )
    560       {
    561         static Vector pos = Vector(1000.0, 1000.0, 1000.0);
    562         PNode *p = dynamic_cast<PNode*>(b);
    563         p->setAbsCoor(pos);
    564         p->updateNode(0);
    565         pos += Vector(1000.0, 1000.0, 1000.0);
    566       }
    567     }
    568     ///TODO HACK this is only for network multiplayer games.
    569     if( b->isA(CL_PLAYABLE))
    570     {
    571       Playable* ss = dynamic_cast<Playable*>(b);
    572       if( owner%2 == 0)
    573       {
    574 
    575         ss->loadModel("models/ships/reap_0.obj");
    576         ss->toList(OM_GROUP_00);
    577         ss->setAbsCoor(213.37, 57.71, -47.98);
    578         ss->setAbsDir(Quaternion(0.16, 0.98, -0.10));
    579       }
    580       else
    581       {
    582         ss->loadModel( "models/ships/fighter.obj" );
    583         ss->toList(OM_GROUP_01);
    584         ss->setAbsCoor(-314.450, 40.701, 83.554);
    585       }
    586     }
    587 
    588     return b;
    589   }
    590   else
    591   {
    592     PRINTF(1)("Class with ID %x is not a synchronizeable!", (int)classID);
    593     delete b;
    594   }
    595   return NULL;
    596165}
    597166
    598167/**
    599  * Removes a entity on this host
    600  * @param uniqueID: unique ID assigned with the entity to remove
     168 * removes synchronizeable (also on clients)
     169 * @param uniqueId uniqueid to delete
    601170 */
    602 void NetworkGameManager::doRemoveEntity( int uniqueID )
     171void NetworkGameManager::removeSynchronizeable( int uniqueId )
    603172{
    604   SynchronizeableList::const_iterator it,e;
    605   it = this->networkStream->getSyncBegin();
    606   e = this->networkStream->getSyncEnd();
    607 
    608   while ( it != e )
    609   {
    610     if ( (*it)->getUniqueID() == uniqueID )
    611     {
    612       assert((*it)->isA(CL_WORLD_ENTITY));
    613       dynamic_cast<WorldEntity*>(*it)->leaveWorld();
    614       dynamic_cast<WorldEntity*>(*it)->toList(OM_DEAD);
    615       break;
    616     }
    617     it++;
    618   }
    619 }
    620 
    621 #if 0
    622 /**
    623  * Copies length bytes to the clientBuffer with error checking
    624  * @param clientBuffer: the clientBuffer to write to
    625  * @param data: buffer to the data
    626  * @param length: length of data
    627  * @return false on error true else
    628  */
    629 bool NetworkGameManager::writeToClientBuffer( clientBuffer &cb, byte * data, int length )
    630 {
    631   if ( length > cb.maxLength-cb.length )
    632   {
    633     PRINTF(1)("No space left in clientBuffer\n");
    634     return false;
    635   }
    636 
    637   memcpy( cb.buffer+cb.length, data, length );
    638   return true;
    639 }
    640 #endif
    641 
    642 #if 0
    643 /**
    644  * Reads data from clientBuffer with error checking
    645  * @param clientBuffer: the clientBuffer to read from
    646  * @param data: pointer to the buffer
    647  * @param length:
    648  * @return
    649  */
    650 bool NetworkGameManager::readFromClientBuffer( clientBuffer &cb, byte * data, int length )
    651 {
    652   if ( cb.length < length )
    653   {
    654     PRINTF(0)("There is not enough data in clientBuffer\n");
    655     return 0;
    656   }
    657 
    658   memcpy( data, cb.buffer+cb.length-length, length );
    659   return true;
    660 }
    661 #endif
    662 
    663 /**
    664  * Tells this client that he has to control this entity
    665  * @param uniqueID: the entity's uniqeID
    666  */
    667 void NetworkGameManager::doYouAre( int uniqueID )
    668 {
    669 
    670   SynchronizeableList::const_iterator it = this->networkStream->getSyncBegin();
    671 
    672   Playable *p = NULL;
    673   Synchronizeable *s = NULL;
    674 
    675   for ( ; it !=networkStream->getSyncEnd(); it++ )
    676   {
    677     if ( (*it)->getUniqueID()==uniqueID )
    678     {
    679       if ( (*it)->isA( CL_SYNCHRONIZEABLE ) )
    680       {
    681         s = dynamic_cast<Synchronizeable*>(*it);
    682       }
    683       if ( (*it)->isA( CL_PLAYABLE ) )
    684       {
    685         p = dynamic_cast<Playable*>(*it);
    686         break;
    687       } else
    688       {
    689         PRINTF(1)("UniqueID %d is not a Playable\n", uniqueID);
    690       }
    691     }
    692   }
    693 
    694   Player* player = State::getPlayer();
    695   assert(p != NULL);
    696   assert(s != NULL);
    697   assert(player != NULL);
    698 
    699   PRINTF(0)("uniqueID = %d\n", s->getUniqueID());
    700 
    701   player->setPlayable(p);
    702 
    703 
    704 }
    705 
    706 /**
    707  * Tells a remote client that he has to control this entity
    708  * @param uniqueID: the entity's uniqeID
    709  * @param userID: the users ID
    710  */
    711 void NetworkGameManager::sendYouAre( int uniqueID, int userID )
    712 {
    713   if ( !isServer() )
    714     return;
    715  
    716173  byte buf[INTSIZE];
    717174 
    718   Converter::intToByteArray( uniqueID, buf, INTSIZE );
     175  assert( Converter::intToByteArray( uniqueId, buf, INTSIZE ) == INTSIZE );
    719176 
    720   MessageManager::getInstance()->sendMessage( MSGID_YOU_ARE, buf, INTSIZE, RT_USER, userID, MP_HIGHBANDWIDTH);
    721 }
    722 
    723 bool NetworkGameManager::handleRequestCreate( int & i, const byte * data, int length, int sender )
    724 {
    725   if ( INTSIZE > length-i )
    726   {
    727     PRINTF(1)("Cannot read classID from buffer! Not enough data left!\n");
    728     return false;
    729   }
    730   int classID;
    731   i += Converter::byteArrayToInt( &data[i], &classID );
    732 
    733   createEntity( (ClassID)classID );
    734 
    735   return true;
    736 }
    737 
    738 bool NetworkGameManager::handleRequestRemove( int & i, const byte * data, int length, int sender )
    739 {
    740   if ( INTSIZE > length-i )
    741   {
    742     PRINTF(1)("Cannot read uniqueID from buffer! Not enough data left!\n");
    743     return false;
    744   }
    745   int uniqueID;
    746   i += Converter::byteArrayToInt( &data[i], &uniqueID );
    747 
    748   removeEntity( uniqueID );
    749 
    750   return true;
    751 }
    752 
    753 bool NetworkGameManager::handleCreateEntity( int & i, const byte * data, int length, int sender )
    754 {
    755   if ( INTSIZE > length-i )
    756   {
    757     PRINTF(1)("Cannot read classID from buffer! Not enough data left!\n");
    758     return false;
    759   }
    760   int classID;
    761   i += Converter::byteArrayToInt( &data[i], &classID );
    762 
    763   if ( INTSIZE > length-i )
    764   {
    765     PRINTF(1)("Cannot read uniqueID from buffer! Not enough data left!\n");
    766     return false;
    767   }
    768   int uniqueID;
    769   i += Converter::byteArrayToInt( &data[i], &uniqueID );
    770 
    771   if ( INTSIZE > length-i )
    772   {
    773     PRINTF(1)("Cannot read owner from buffer! Not enough data left!\n");
    774     return false;
    775   }
    776   int owner;
    777   i += Converter::byteArrayToInt( &data[i], &owner );
    778 
    779   PRINTF(0)("handleCreateEntity: client side: classID: %x, uniqueID: %i, owner: %i\n", classID, uniqueID, owner);
    780   doCreateEntity( (ClassID)classID, uniqueID, owner );
    781 
    782   return true;
    783 }
    784 
    785 bool NetworkGameManager::handleRemoveEntity( int & i, const byte * data, int length, int sender )
    786 {
    787   if ( INTSIZE > length-i )
    788   {
    789     PRINTF(1)("Cannot read uniqueID from buffer! Not enough data left!\n");
    790     return false;
    791   }
    792   int uniqueID;
    793   i += Converter::byteArrayToInt( &data[i], &uniqueID );
    794 
    795   doRemoveEntity( uniqueID );
    796 
    797   return true;
    798 }
    799 
    800 bool NetworkGameManager::handleCreateEntityList( int & i, const byte * data, int length, int sender )
    801 {
    802   if ( INTSIZE > length-i )
    803   {
    804     PRINTF(1)("Cannot read n from buffer! Not enough data left!\n");
    805     return false;
    806   }
    807 
    808   PRINTF(0)("HandleCreateEntityList:  data[i..i+3] = %d %d %d %d\n", data[i], data[i+1], data[i+2], data[i+3]);
    809 
    810   int n;
    811   i += Converter::byteArrayToInt( &data[i], &n );
    812 
    813 
    814   PRINTF(0)("HandleCreateEntityList: n = %d\n", n);
    815 
    816   int classID, uniqueID, owner;
    817 
    818   for ( int j = 0; j<n; j++ )
    819   {
    820 
    821     if ( INTSIZE > length-i )
    822     {
    823       PRINTF(1)("Cannot read classID from buffer! Not enough data left!\n");
    824       return false;
    825     }
    826     i += Converter::byteArrayToInt( &data[i], &classID );
    827 
    828     if ( INTSIZE > length-i )
    829     {
    830       PRINTF(1)("Cannot read uniqueID from buffer! Not enough data left!\n");
    831       return false;
    832     }
    833     i += Converter::byteArrayToInt( &data[i], &uniqueID );
    834 
    835     if ( INTSIZE > length-i )
    836     {
    837       PRINTF(1)("Cannot read owner from buffer! Not enough data left!\n");
    838       return false;
    839     }
    840     i += Converter::byteArrayToInt( &data[i], &owner );
    841 
    842     if ( classID != CL_NETWORK_GAME_MANAGER && classID != CL_HANDSHAKE )
    843     {
    844       BaseObject* b = doCreateEntity( (ClassID)classID, uniqueID, owner );
    845     }
    846 
    847   }
    848 
    849   return true;
    850 }
    851 
    852 bool NetworkGameManager::handleRemoveEntityList( int & i, const byte * data, int length, int sender )
    853 {
    854   if ( INTSIZE > length-i )
    855   {
    856     PRINTF(1)("Cannot read n from buffer! Not enough data left!\n");
    857     return false;
    858   }
    859   int n;
    860   i += Converter::byteArrayToInt( &data[i], &n );
    861 
    862   int uniqueID;
    863 
    864   for ( int j = 0; j<n; j++ )
    865   {
    866 
    867     if ( INTSIZE > length-i )
    868     {
    869       PRINTF(1)("Cannot read uniqueID from buffer! Not enough data left!\n");
    870       return false;
    871     }
    872     i += Converter::byteArrayToInt( &data[i], &uniqueID );
    873 
    874     doRemoveEntity( uniqueID );
    875   }
    876 
    877   return true;
    878 }
    879 
    880 bool NetworkGameManager::handleYouAreEntity( int & i, const byte * data, int length, int sender )
    881 {
    882   if ( INTSIZE > length-i )
    883   {
    884     PRINTF(1)("Cannot read uniqueID from buffer! Not enough data left!\n");
    885     return false;
    886   }
    887 
    888   int uniqueID;
    889   i += Converter::byteArrayToInt( &data[i], &uniqueID );
    890 
    891   doYouAre( uniqueID );
    892 
    893   return true;
    894 }
    895 
    896 /**
    897  *  handles the network signal NET_REQUEST_PNODE_PATH
    898  * @param i byte offset in the buffer
    899  * @param data data array
    900  * @param length length of the data arary
    901  * @param sender the sender id
    902  * @return true if process terminated sucessfully
    903  */
    904 bool NetworkGameManager::handleRequestPNodePath(int& i, const byte* data, int length, int sender)
    905 {
    906   if( INTSIZE > length-i )
    907   {
    908     PRINTF(1)("Cannot read n from buffer! Not enough data left!\n");
    909     return false;
    910   }
    911   PRINTF(0)("HandleRequestPNodePath:  data[i..i+3] = %d %d %d %d\n", data[i], data[i+1], data[i+2], data[i+3]);
    912 
    913   int uniqueID1, uniqueID2;
    914   if( INTSIZE > length-i )
    915   {
    916     PRINTF(1)("Cannot read uniqueID from buffer! Not enough data left!\n");
    917     return false;
    918   }
    919   i += Converter::byteArrayToInt( &data[i], &uniqueID1 );
    920 
    921   if( INTSIZE > length-i )
    922   {
    923     PRINTF(1)("Cannot read uniqueID from buffer! Not enough data left!\n");
    924     return false;
    925   }
    926   i += Converter::byteArrayToInt( &data[i], &uniqueID2 );
    927 
    928 
    929   PRINTF(0)("HandleRequestPNodePath: got a request for path from uid %i to uid %i\n", uniqueID1, uniqueID2);
    930 
    931   return true;
    932 }
    933 
    934 bool NetworkGameManager::youAreHandler( MessageId messageId, byte * data, int dataLength, void * someData, int userId )
    935 {
    936   assert( dataLength == INTSIZE );
    937   int uniqueId;
    938  
    939   Converter::byteArrayToInt( data, &uniqueId );
    940  
    941   SynchronizeableList::const_iterator it = NetworkGameManager::getInstance()->networkStream->getSyncBegin();
    942 
    943   Playable *p = NULL;
    944   Synchronizeable *s = NULL;
    945 
    946   for ( ; it !=NetworkGameManager::getInstance()->networkStream->getSyncEnd(); it++ )
    947   {
    948     if ( (*it)->getUniqueID()==uniqueId )
    949     {
    950       break;
    951     }
    952   }
    953  
    954   if ( it == NetworkGameManager::getInstance()->networkStream->getSyncEnd() )
    955     return false;
    956  
    957   NetworkGameManager::getInstance()->doYouAre( uniqueId );
    958  
    959   return true;
    960 }
    961 
    962 #if 0
    963 bool NetworkGameManager::writeToClientBuffer( clientBuffer & cb, byte b )
    964 {
    965   if ( cb.maxLength-cb.length < 1 )
    966   {
    967     PRINTF(1)("Cannot write to clientBuffer! Not enough space for 1 byte\n");
    968     return false;
    969   }
    970 
    971   cb.buffer[cb.length++] = b;
    972 
    973   return true;
     177  MessageManager::getInstance()->sendMessage( MSGID_DELETESYNCHRONIZEABLE, buf, INTSIZE, RT_ALL_NOT_ME, 0, MP_HIGHBANDWIDTH );
    974178}
    975179
    976180
    977 bool NetworkGameManager::writeToClientBuffer( clientBuffer & cb, int i )
    978 {
    979   int n = Converter::intToByteArray( i, cb.buffer+cb.length, cb.maxLength-cb.length );
    980   cb.length += n;
    981 
    982   if ( n <= 0 )
    983   {
    984     PRINTF(1)("Cannot write to clientBuffer! Not enough space for 1 int\n");
    985     return false;
    986   }
    987 
    988   return true;
    989 }
    990 #endif
    991181
    992182
     183
     184

  • trunk/src/lib/network/network_game_manager.h

    r7954 r8068  
    4747  public:
    4848    virtual ~NetworkGameManager();
    49 
     49   
    5050    static NetworkGameManager* NetworkGameManager::getInstance()
    5151    { if (!NetworkGameManager::singletonRef) NetworkGameManager::singletonRef = new NetworkGameManager(); return NetworkGameManager::singletonRef; }
    5252
    53 #if 0
    54     virtual int writeBytes(const byte* data, int length, int sender);
    55     virtual int readBytes(byte* data, int maxLength, int * reciever);
    56     virtual void writeDebug() const;
    57     virtual void readDebug() const;
    58 #endif
    5953
    60     int createEntity( ClassID classID, int owner = 0 );
    61     BaseObject* createEntity(const TiXmlElement* element);
    62     void removeEntity( int uniqueID );
    63     void sendYouAre( int uniqueID, int userID );
     54    bool signalNewPlayer( int userId );
     55    bool signalLeftPlayer( int userID );
     56   
     57    void removeSynchronizeable( int uniqueId );
    6458
    65 #if 0
    66     void sendEntityList(int userID);
    67 #endif
    68 
    69     bool signalNewPlayer(int userId);
    70     bool signalLeftPlayer(int userID);
    71 
     59    inline void setGameState( int gameState ){ this->gameState = gameState; }
     60    inline int getGameState(){ return this->gameState; }
    7261
    7362  private:
    7463    NetworkGameManager();
    7564   
    76     static bool youAreHandler(MessageId messageId, byte * data, int dataLength, void * someData, int userId );
     65    static bool delSynchronizeableHandler( MessageId messageId, byte * data, int dataLength, void * someData, int userId );
    7766
    78 
    79     /* some network signal handlers */
    80     bool handleRequestCreate( int& i, const byte* data, int length, int sender );
    81     bool handleRequestRemove( int& i, const byte* data, int length, int sender );
    82     bool handleCreateEntity( int& i, const byte* data, int length, int sender );
    83     bool handleRemoveEntity( int& i, const byte* data, int length, int sender );
    84     bool handleCreateEntityList( int& i, const byte* data, int length, int sender );
    85     bool handleRemoveEntityList( int& i, const byte* data, int length, int sender );
    86     bool handleYouAreEntity( int& i, const byte* data, int length, int sender );
    87     bool handleRequestPNodePath(int& i, const byte* data, int length, int sender);
    88     bool handleSendPNodePath(int& i, const byte* data, int length, int sender);
    89 
    90 
    91     /* some network handlers helper functions */
    92 //    void requestCreateEntity(ClassID classID);
    93     int executeCreateEntity(ClassID classID, int uniqueID = 0, int owner = 0);
    94     BaseObject* doCreateEntity(ClassID classID, int uniqueID, int owner);
    95 
    96 //    void requestRemoveEntity(int uniqueID);
    97     void executeRemoveEntity(int uniqueID);
    98     void doRemoveEntity(int uniqueID);
    99 
    100     void doYouAre( int uniqueID );
    101 
    102 //    void requestPNodePath(const PNode* node1, const PNode* node2);
    103     void executeRequestPNodePath(const PNode* node2, const PNode* node2);
    104     void doRequestPNodePath(const PNode* node1, const PNode* node2);
    105 
    106     bool canCreateEntity(ClassID classID);
    107 #if 0
    108     void resizeBufferVector(int n);
    109 
    110 
    111     bool writeToClientBuffer( clientBuffer &cb, byte*data, int length );
    112     bool writeToClientBuffer( clientBuffer &cb, byte b );
    113     bool writeToClientBuffer( clientBuffer &cb, int i );
    114     bool readFromClientBuffer( clientBuffer &cb, byte*data, int length );
    115 #endif
    116 
    117   private:
    118 #if 0
    119     std::vector<clientBuffer>     outBuffer;
    120     //clientBuffer                  allOutBuffer;
    121 #endif
    12267    static NetworkGameManager*    singletonRef;
     68   
     69    int                           gameState;
    12370};
    12471

  • trunk/src/lib/network/network_stream.cc

    r7954 r8068  
    177177void NetworkStream::processData()
    178178{
     179  int tick = SDL_GetTicks();
     180 
    179181  currentState++;
    180182 
    … …  
    207209  // order of up/downstream is important!!!!
    208210  // don't change it
    209   handleDownstream();
    210   handleUpstream();
     211  handleDownstream( tick );
     212  handleUpstream( tick );
    211213
    212214}
    … …  
    277279      PRINTF(0)("Client is gone: %d (%s)\n", it->second.userId, reason.c_str());
    278280     
    279       assert(false);
     281      //assert(false);
    280282
    281283      it->second.socket->disconnectServer();
    … …  
    391393 * handle upstream network traffic
    392394 */
    393 void NetworkStream::handleUpstream( )
     395void NetworkStream::handleUpstream( int tick )
    394396{
    395397  int offset;
    396398  int n;
    397399 
    398   for ( PeerList::iterator peer = peers.begin(); peer != peers.end(); peer++ )
     400  for ( PeerList::reverse_iterator peer = peers.rbegin(); peer != peers.rend(); peer++ )
    399401  {
    400402    offset = INTSIZE; //make already space for length
    … …  
    496498      writeToNewDict( buf, offset );
    497499   
    498     peer->second.connectionMonitor->processUnzippedOutgoingPacket( buf, offset, currentState );
    499     peer->second.connectionMonitor->processZippedOutgoingPacket( compBuf, compLength, currentState );
     500    peer->second.connectionMonitor->processUnzippedOutgoingPacket( tick, buf, offset, currentState );
     501    peer->second.connectionMonitor->processZippedOutgoingPacket( tick, compBuf, compLength, currentState );
    500502   
    501503    //NETPRINTF(n)("send packet: %d userId = %d\n", offset, peer->second.userId);
    … …  
    506508 * handle downstream network traffic
    507509 */
    508 void NetworkStream::handleDownstream( )
     510void NetworkStream::handleDownstream( int tick )
    509511{
    510512  int offset = 0;
    … …  
    527529    while ( 0 < (compLength = peer->second.socket->readPacket( compBuf, UDP_PACKET_SIZE )) )
    528530    {
    529       //TODO tell monitor about zipped packet. because dropped packets dont count to bandwidth
     531      peer->second.connectionMonitor->processZippedIncomingPacket( tick, compBuf, compLength );
     532     
    530533      //PRINTF(0)("GGGGGOOOOOOOOOOTTTTTTTT: %d\n", compLength);
    531534      packetLength = Zip::getInstance()->unZip( compBuf, compLength, buf, UDP_PACKET_SIZE );
    … …  
    547550      //NETPRINTF(n)("ackedstate: %d\n", ackedState);
    548551      offset = 4*INTSIZE;
     552     
     553      peer->second.connectionMonitor->processUnzippedIncomingPacket( tick, buf, offset, state, ackedState );
    549554
    550555      //NETPRINTF(n)("got packet: %d, %d\n", length, packetLength);
    … …  
    672677      }
    673678     
    674       peer->second.connectionMonitor->processZippedIncomingPacket( compBuf, compLength, state, ackedState );
    675       peer->second.connectionMonitor->processUnzippedIncomingPacket( buf, offset, state, ackedState );
    676    
    677679      assert( peer->second.lastAckedState <= ackedState );
    678680      peer->second.lastAckedState = ackedState;

  • trunk/src/lib/network/network_stream.h

    r7954 r8068  
    7979    void updateConnectionList();
    8080    void handleHandshakes();
    81     void handleUpstream();
    82     void handleDownstream();
     81    void handleUpstream( int tick );
     82    void handleDownstream(int tick );
    8383    void handleNewClient( int userId );
    8484    void cleanUpOldSyncList();

  • trunk/src/lib/network/synchronizeable.cc

    r7954 r8068  
    2121#include "netdefs.h"
    2222#include "network_log.h"
     23#include "network_game_manager.h"
    2324
    2425#include "state.h"
    … …  
    3637{
    3738  this->setClassID(CL_SYNCHRONIZEABLE, "Synchronizeable");
    38   this->owner = -1;
     39  this->owner = 0;
    3940  this->hostID = SharedNetworkData::getInstance()->getHostID();
    4041  this->setIsServer(this->hostID == 0);
    … …  
    6869  if ( this->networkStream )
    6970    this->networkStream->disconnectSynchronizeable(*this);
     71 
     72  if ( this->isServer() && this->beSynchronized() && this->getUniqueID() > 0 )
     73    NetworkGameManager::getInstance()->removeSynchronizeable( this->getUniqueID() );
    7074}
    7175
    … …  
    175179            this->isServer() && (*it)->checkPermission( PERMISSION_SERVER ) ||
    176180            this->owner == this->hostID && (*it)->checkPermission( PERMISSION_OWNER ) ||
     181            this->isServer() && this->owner != userId && (*it)->checkPermission( PERMISSION_OWNER ) ||
    177182            (*it)->checkPermission( PERMISSION_ALL )
    178183                    );
    … …  
    289294        (*it)->checkPermission( PERMISSION_SERVER ) && networkStream->isUserServer( userId ) ||
    290295        (*it)->checkPermission( PERMISSION_OWNER ) && this->owner == userId ||
     296        networkStream->isUserServer( userId ) && this->owner != getHostID() && (*it)->checkPermission( PERMISSION_OWNER ) ||
    291297        (*it)->checkPermission( PERMISSION_ALL )
    292298       )
    … …  
    331337void Synchronizeable::registerVar( SynchronizeableVar * var )
    332338{
    333   PRINTF(0)("ADDING VAR: %s\n", var->getName().c_str());
     339  //PRINTF(0)("ADDING VAR: %s\n", var->getName().c_str());
    334340  syncVarList.push_back( var );
    335341}
    … …  
    343349int Synchronizeable::registerVarId( SynchronizeableVar * var )
    344350{
    345   PRINTF(0)("ADDING VAR: %s\n", var->getName().c_str());
     351  //PRINTF(0)("ADDING VAR: %s\n", var->getName().c_str());
    346352  syncVarList.push_back( var );
    347353  var->setWatched( true );

  • trunk/src/lib/network/synchronizeable.h

    r7954 r8068  
    6161    virtual void handleSentState( int userId, int stateId, int fromStateId );
    6262    virtual void handleRecvState( int userId, int stateId, int fromStateId );
    63 
     63   
    6464    void registerVar( SynchronizeableVar * var );
    6565    int registerVarId( SynchronizeableVar * var );
Note: See TracChangeset for help on using the changeset viewer.