Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

Changeset 8228 in orxonox.OLD for trunk/src/lib/network


Ignore:
Timestamp:
Jun 8, 2006, 11:19:08 AM (19 years ago)
Author:
patrick
Message:

trunk: merged the network branche back to trunk with command: svn merge branches/network trunk -r8150:HEAD

Location:
trunk/src/lib/network
Files:
10 edited

Legend:

Unmodified
Added
Removed

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

    r8068 r8228  
    1717
    1818#include "message_manager.h"
     19
     20#include "network_stream.h"
    1921
    2022using namespace std;
    … …  
    312314         recieverType == RT_ALL_NOT_ME ||
    313315         recieverType == RT_USER && it->first == reciever ||
    314          recieverType == RT_NOT_USER && it->first != reciever
     316         recieverType == RT_NOT_USER && it->first != reciever ||
     317         recieverType == RT_SERVER && getNetworkStream()->isUserServer( it->first )
    315318       )
    316319    {

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

    r8147 r8228  
    3030  TESTMESSAGEID = 1,
    3131  MSGID_DELETESYNCHRONIZEABLE,
    32   MSGID_PREFEREDTEAM
     32  MSGID_PREFEREDTEAM,
     33  MSGID_CHANGEPLAYERNAME
    3334};
    3435
    … …  
    4041  RT_ALL_ME,           //!< message is sent to all users
    4142  RT_USER,             //!< message is only sent to reciever
    42   RT_NOT_USER          //!< message is sent to all but reciever
     43  RT_NOT_USER,         //!< message is sent to all but reciever
     44  RT_SERVER            //!< message is sent to server only
    4345};
    4446

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

    r8147 r8228  
    112112  stats->setPlayableUniqueId( playable.getUniqueID() );
    113113  stats->setModelFileName( playableModel );
     114 
     115  return true;
    114116}
    115117
    … …  
    122124bool NetworkGameManager::signalLeftPlayer(int userID)
    123125{
    124   delete PlayerStats::getStats( userID )->getPlayable();
    125   delete PlayerStats::getStats( userID );
     126  if ( PlayerStats::getStats( userID ) )
     127  {
     128    if ( PlayerStats::getStats( userID )->getPlayable() )
     129      delete PlayerStats::getStats( userID )->getPlayable();
     130    delete PlayerStats::getStats( userID );
     131  }
     132 
     133  return true;
    126134}
    127135
    … …  
    165173        return true;
    166174      }
    167        
     175     
    168176      delete dynamic_cast<Synchronizeable*>(*it);
    169177      return true;
    170178    }
    171179  }
     180 
     181  return true;
    172182}
    173183
    … …  
    210220 
    211221  NetworkGameManager::getInstance()->setPreferedTeam( userId, teamId );
     222 
     223  return true;
    212224}
    213225
    … …  
    220232 
    221233  stats.setPreferedTeamId( teamId );
    222  
    223234}
    224235

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

    r8147 r8228  
    5151
    5252  /* initialize the references */
    53   this->netStreamList = NULL;
    54   this->syncList = NULL;
    55   this->defaultSyncStream = NULL;
     53  this->networkStream = NULL;
    5654  this->sharedNetworkData = SharedNetworkData::getInstance();
    5755  this->elapsedTime = 0.0f;
    … …  
    7169 */
    7270NetworkManager::~NetworkManager()
    73 {}
     71{
     72  if ( this->networkStream )
     73  {
     74    delete this->networkStream;
     75    this->networkStream = NULL;
     76  }
     77}
    7478
    7579
    … …  
    7983void NetworkManager::initialize()
    8084{
    81   /* get the synchronizeable list from the class list */
    82   this->netStreamList = ClassList::getList(CL_SYNCHRONIZEABLE);
    8385  PRINTF(0)("NetworkManager initzalized\n");
    84 
    8586}
    8687
    … …  
    101102int NetworkManager::establishConnection(const std::string & name, unsigned int port)
    102103{
    103   this->defaultSyncStream = new NetworkStream( name, port );
    104   this->sharedNetworkData->setDefaultSyncStream(this->defaultSyncStream);
    105   this->defaultSyncStream->startHandshake();
     104  this->networkStream = new NetworkStream( name, port );
     105  this->sharedNetworkData->setDefaultSyncStream(this->networkStream);
     106  this->networkStream->startHandshake();
    106107  return 1;
    107108}
    … …  
    116117  this->sharedNetworkData->setHostID(0);
    117118  this->sharedNetworkData->setGameServer(true);
    118   this->defaultSyncStream = new NetworkStream(port);
    119   this->sharedNetworkData->setDefaultSyncStream(this->defaultSyncStream);
    120   this->defaultSyncStream->createNetworkGameManager();
     119  this->networkStream = new NetworkStream(port);
     120  this->sharedNetworkData->setDefaultSyncStream(this->networkStream);
     121  this->networkStream->createNetworkGameManager();
    121122  PRINTF(0)("CREATE SERVER\n");
    122123  SDL_Delay(20);
    … …  
    127128void NetworkManager::connectSynchronizeable(Synchronizeable& sync)
    128129{
    129   if( this->defaultSyncStream)
    130     this->defaultSyncStream->connectSynchronizeable(sync);
     130  if( this->networkStream)
     131    this->networkStream->connectSynchronizeable(sync);
    131132}
    132133
    … …  
    143144  this->elapsedTime = 0.0f;
    144145
    145   if (this->netStreamList != NULL || (this->netStreamList = ClassList::getList(CL_NETWORK_STREAM)) != NULL)
    146   {
    147     std::list<BaseObject*>::const_iterator stream;
    148     for (stream = this->netStreamList->begin(); stream != this->netStreamList->end(); ++stream)
    149       if( static_cast<NetworkStream*>(*stream)->isActive())
    150         static_cast<NetworkStream*>(*stream)->processData();
    151   }
     146  if ( networkStream->isActive() )
     147    networkStream->processData();
    152148 
    153149  NetworkGameManager::getInstance()->tick( this->elapsedTime );
    … …  
    162158{
    163159  PRINT(0)("=================Network::debug()=========\n");
    164   this->defaultSyncStream->debug();
     160  this->networkStream->debug();
    165161  PRINT(0)("===========================================\n");
    166162}

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

    r7954 r8228  
    5555
    5656  private:
    57     const std::list<BaseObject*>*    netStreamList;           // list with refs to all network streams
    58     const std::list<BaseObject*>*    syncList;                // list of synchronizeables
    5957    static NetworkManager*           singletonRef;            //!< Pointer to the only instance of this Class
    60     NetworkStream*                   defaultSyncStream;       //!< FIXME: this is only for testing purposes
     58    NetworkStream*                   networkStream;       //!< pointer to network stream
    6159
    6260    SharedNetworkData*               sharedNetworkData;       //!< reference to the shared data

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

    r8068 r8228  
    105105    serverSocket->close();
    106106    delete serverSocket;
     107    serverSocket = NULL;
    107108  }
    108109
    … …  
    123124  }
    124125 
    125   if ( serverSocket )
    126   {
    127     delete serverSocket;
    128     serverSocket = NULL;
    129   }
    130 
     126  for ( SynchronizeableList::const_iterator it = getSyncBegin(); it != getSyncEnd(); it ++ )
     127    (*it)->setNetworkStream( NULL );
    131128}
    132129
    … …  
    264261
    265262  //check if connections are ok else remove them
    266   for ( PeerList::iterator it = peers.begin(); it != peers.end(); it++ )
     263  for ( PeerList::iterator it = peers.begin(); it != peers.end(); )
    267264  {
    268265    if ( 
    … …  
    297294
    298295      freeSocketSlots.push_back( it->second.userId );
    299 
    300     }
     296     
     297      PeerList::iterator delit = it;
     298      it++;
     299     
     300      peers.erase( delit );
     301     
     302      continue;
     303    }
     304   
     305    it++;
    301306  }
    302307
    … …  
    651656          }
    652657        }
     658       
    653659
    654660        int n = sync->setStateDiff( peer->second.userId, buf+offset, syncDataLength, state, fromState );
    … …  
    664670      }
    665671     
    666       //TODO REMOVE THIS
    667       int saveOffset = offset;
    668672     
    669673      for ( SynchronizeableList::iterator it = synchronizeables.begin(); it != synchronizeables.end(); it++ )
    … …  
    682686      assert( peer->second.lastRecvedState < state );
    683687      peer->second.lastRecvedState = state;
    684      
    685       assert( saveOffset == offset );
    686      
     688
    687689    }
    688690 

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

    r8147 r8228  
    2121#include "player.h"
    2222#include "state.h"
     23#include "shared_network_data.h"
    2324
    2425
    … …  
    8586    this->setPlayableUniqueId( this->playableUniqueId );
    8687   
    87     PRINTF(0)("uniqueID changed %d %d\n", userId, getHostID());
     88    PRINTF(0)("uniqueID changed %d %d %d\n", userId, getHostID(), getUniqueID());
    8889  }
    8990}
    … …  
    99100 
    100101  if ( !list )
     102  {
    101103    return NULL;
     104  }
    102105 
    103106  for ( std::list<BaseObject*>::const_iterator it = list->begin(); it != list->end(); it++ )
    … …  
    108111    }
    109112  }
    110  
    111   //TODO maybe we should create an object here
    112113 
    113114  return NULL;
    … …  
    133134    {
    134135      this->playable = dynamic_cast<Playable*>(*it);
     136      //TODO when OM_PLAYERS is ticked add line:
     137      //this->playable->toList( OM_PLAYERS );
    135138      break;
    136139    }
    … …  
    138141 
    139142  if ( this->playable && userId == getHostID() )
     143  {
    140144    State::getPlayer()->setPlayable( this->playable );
     145  }
    141146 
    142147  this->playableUniqueId = uniqueId;

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

    r8147 r8228  
    369369void Synchronizeable::cleanUpUser( int userId )
    370370{
    371   for ( UserStateHistory::iterator it = sentStates.begin(); it != sentStates.end(); it++ )
    372   {
    373     for ( StateHistory::iterator it2 = it->begin(); it2 != it->end(); it2++ )
    374     {
    375       if ( (*it2)->data )
    376         delete [] (*it2)->data;
    377       (*it2)->data = NULL;
    378      
    379       delete *it2;
    380     }
    381   }
    382  
    383   sentStates.clear();
    384  
    385   for ( UserStateHistory::iterator it = recvStates.begin(); it != recvStates.end(); it++ )
    386   {
    387     for ( StateHistory::iterator it2 = it->begin(); it2 != it->end(); it2++ )
    388     {
    389       if ( (*it2)->data )
    390         delete [] (*it2)->data;
    391       (*it2)->data = NULL;
    392      
    393       delete *it2;
    394     }
    395   }
    396  
    397   recvStates.clear();
     371  if ( recvStates.size() > userId )
     372  {
     373    for ( std::list<StateHistoryEntry*>::iterator it = recvStates[userId].begin(); it != recvStates[userId].end(); it++ )
     374    {
     375      if ( (*it)->data )
     376        delete [] (*it)->data;
     377      (*it)->data = NULL;
     378   
     379      delete *it;
     380    }
     381    recvStates[userId].clear();
     382  }
     383 
     384  if ( sentStates.size() > userId )
     385  {
     386   
     387    for ( std::list<StateHistoryEntry*>::iterator it = sentStates[userId].begin(); it != sentStates[userId].end(); it++ )
     388    {
     389      if ( (*it)->data )
     390        delete [] (*it)->data;
     391      (*it)->data = NULL;
     392   
     393      delete *it;
     394    }
     395    sentStates[userId].clear();
     396  }
    398397}
    399398

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

    r7954 r8228  
    4444UdpServerSocket::~UdpServerSocket( )
    4545{
    46   for ( int i = 0; i < packetBuffer.size(); i++ )
     46  for ( int i = 0; i < (int)packetBuffer.size(); i++ )
    4747    removeUserPackets( i );
    4848 
    … …  
    9999{
    100100 
    101   for ( int i = 0; i < packetBuffer.size(); i++ )
     101  for ( int i = 0; i < (int)packetBuffer.size(); i++ )
    102102    removeUserPackets( i );
    103103 
    … …  
    115115void UdpServerSocket::removeUserPackets( int userId )
    116116{
    117   if ( userId >= packetBuffer.size() )
     117  if ( userId >= (int)packetBuffer.size() )
    118118    return;
    119119 
    … …  
    141141  res.length = 0;
    142142 
    143   if ( packetBuffer.size() > userId && packetBuffer[userId].size() > 0 )
     143  if ( (int)packetBuffer.size() > userId && (int)packetBuffer[userId].size() > 0 )
    144144  {
    145145    res.data = packetBuffer[userId].front().data;
    146146    res.length = packetBuffer[userId].front().length;
    147147    packetBuffer[userId].pop_front();
     148   
     149    if ( res.length == 0 )
     150      res.length = -1;
    148151  }
    149152 
    … …  
    158161int UdpServerSocket::getPacketCount( int userId )
    159162{
    160   if ( userId >= packetBuffer.size() )
     163  if ( userId >= (int)packetBuffer.size() )
    161164    return -1;
    162165 
    … …  
    179182  }
    180183 
    181   if ( userId < packetBuffer.size() )
     184  if ( userId < (int)packetBuffer.size() )
    182185    removeUserPackets( userId );
    183186 
    184   if ( packetBuffer.size() <= userId )
     187  if ( (int)packetBuffer.size() <= userId )
    185188    packetBuffer.resize( userId + 1 );
    186189 
    187   if ( userList.size() <= userId )
     190  if ( (int)userList.size() <= userId )
    188191    userList.resize( userId + 1 );
    189192 
    … …  
    199202  removeUserPackets( userId );
    200203 
    201   if ( userId >= userList.size() )
     204  if ( userId >= (int)userList.size() )
    202205    return;
    203206 
    … …  
    244247    bool isNewConnection = false;
    245248   
    246     for ( userId =0; userId < userList.size(); userId++ )
     249    for ( userId =0; userId < (int)userList.size(); userId++ )
    247250      if ( userList[userId].host == packet->address.host && userList[userId].port == packet->address.port )
    248251        break;
    249252   
    250     if ( userId >= userList.size() )
     253    if ( userId >= (int)userList.size() )
    251254    {
    252255     
    … …  
    260263      }
    261264     
    262       for ( userId =0; userId < userList.size(); userId++ )
     265      for ( userId =0; userId < (int)userList.size(); userId++ )
    263266        if ( userList[userId].host == 0 && userList[userId].port == 0 )
    264267          break;
    … …  
    281284    else
    282285    {
    283       if ( isNewConnection )
    284         continue;
    285      
    286286      networkPacket.data = NULL;
    287287    }

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

    r7954 r8228  
    8181UdpSocket::~UdpSocket( )
    8282{
     83  this->disconnectServer();
     84 
    8385  if ( serverSocket )
    8486    serverSocket->removeUser( userId );
    85  
    86   disconnectServer();
    87  
     87
    8888  if ( this->packet )
    8989    SDLNet_FreePacket( this->packet );
    … …  
    128128    return;
    129129  }
    130  
     130}
     131
     132/**
     133 * disconnect from server
     134 */
     135void UdpSocket::disconnectServer( )
     136{
     137  PRINTF(0)("disconnect\n");
    131138  writePacket( NULL, 0 );
    132 }
    133 
    134 /**
    135  * disconnect from server
    136  */
    137 void UdpSocket::disconnectServer( )
    138 {
    139139  SDLNet_UDP_Unbind( socket, -1 );
    140140  SDLNet_UDP_Close( socket );
    … …  
    171171    packet->len = length;
    172172   
    173     if ( SDLNet_UDP_Send( socket, 1, packet) == 0 )
     173    if ( socket && SDLNet_UDP_Send( socket, 1, packet) == 0 )
    174174    {
    175175      PRINTF(1)("SDLNet_UDP_Send: %s\n", SDLNet_GetError());
    … …  
    196196    NetworkPacket networkPacket = serverSocket->getPacket( this->userId );
    197197   
     198    if ( networkPacket.length == -1 )
     199    {
     200      this->disconnectServer();
     201      return 0;
     202    }
     203   
    198204    if ( networkPacket.length > 0 )
    199205    {
    … …  
    218224      assert( packet->len <= maxLength );
    219225     
     226      if ( packet->len == 0 )
     227      {
     228        this->disconnectServer();
     229        return 0;
     230      }
     231     
    220232      memcpy( data, packet->data, packet->len );
    221233      return packet->len;
Note: See TracChangeset for help on using the changeset viewer.