Changeset 9406 in orxonox.OLD for trunk/src/lib/network/network_stream.h

Timestamp:

Jul 24, 2006, 11:09:47 AM (18 years ago)

Author:

bensch

Message:

orxonox/trunk: merged the proxy back

merged with commandsvn merge -r9346:HEAD ​https://svn.orxonox.net/orxonox/branches/proxy .

no conflicts

File:

• trunk/src/lib/network/network_stream.h (modified) (4 diffs)

trunk/src/lib/network/network_stream.h

@@ -14 +14 @@
 #include "server_socket.h"
 #include "handshake.h"
-#include "connection_monitor.h"
+#include "monitor/connection_monitor.h"
 #include "udp_server_socket.h"
+#include "peer_info.h"
+
+#include "shared_network_data.h"
 
 class Synchronizeable;
@@ -21 +24 @@
 class ServerSocket;
 class NetworkGameManager;
+class NetworkMonitor;
 
-//!< this structure contains informations about the network node
-class PeerInfo
-{
-  public:
-    PeerInfo() { clear(); }
-    void clear() { userId = 0; isServer = false; socket = NULL; handshake = NULL; lastAckedState = 0; lastRecvedState = 0; connectionMonitor = NULL; }
-
-
-  public:
-    int                 userId;
-    bool                isServer;
-    NetworkSocket *     socket;
-    Handshake *         handshake;
-    ConnectionMonitor * connectionMonitor;
-    int                 lastAckedState;
-    int                 lastRecvedState;
-};
 
 typedef std::list<Synchronizeable*>  SynchronizeableList;
@@ -49 +36 @@
   public:
     NetworkStream();
-    NetworkStream( std::string host, int port);
-    NetworkStream( int port );
+    NetworkStream(int nodeType);
+    virtual ~NetworkStream();
 
-    virtual ~NetworkStream();
     void init();
+
+    void connectToMasterServer(std::string host, int port);
+    void connectToProxyServer(std::string host, int port);
+    void createServer(int port);
 
     void createNetworkGameManager();
     void startHandshake();
 
+    /* synchronizeable interface */
     void connectSynchronizeable(Synchronizeable& sync);
     void disconnectSynchronizeable(Synchronizeable& sync);
 
-    inline bool isServer() const { return (this->type == NET_SERVER)? true:false; }
-    inline bool isActive() const { return this->bActive; }
+    inline int getMaxConnections(){ return SharedNetworkData::getInstance()->getMaxPlayer(); }
 
-    inline int getMaxConnections(){ return MAX_CONNECTIONS; }
+    /* functions for the peerInfo information retreival */
+    inline bool isUserIdActive( int userID ) { return (peers.find(userID) != peers.end()); }
+    inline bool isUserMasterServer( int userID ){ if ( !isUserIdActive(userID) ) return false; return peers[userID].isMasterServer(); }
+    inline bool isUserProxyServer( int userID ){ if ( !isUserIdActive(userID) ) return false; return peers[userID].isProxyServer(); }
+    inline bool isUserClient( int userID ){ if ( !isUserIdActive(userID) ) return false; return peers[userID].isClient(); }
 
+    /* peering interface */
+    inline PeerInfo & getPeerInfo( int userId ) { return peers[userId]; }
+    inline PeerInfo* getPeerInfo() { return this->pInfo; }
+    inline PeerList getPeerInfoList() { return this->peers; }
+
+    /* data processing*/
     virtual void processData();
+
+    /* debugging */
+    void debug();
+
+
+  private:
 
     inline SynchronizeableList::const_iterator getSyncBegin(){ return synchronizeables.begin(); }
     inline SynchronizeableList::const_iterator getSyncEnd(){ return synchronizeables.end(); }
+    void cleanUpOldSyncList();
     int getSyncCount();
 
-    inline bool isUserIdActive( int userID ) { return (peers.find(userID) != peers.end()); }
-    inline bool isUserServer( int userID ){ if ( !isUserIdActive(userID) ) return false; return peers[userID].isServer; }
-
-    void debug();
-
-    inline PeerInfo & getPeerInfo( int userId ) { return peers[userId]; }
-
-
-  private:
     void updateConnectionList();
+    /* handle processes */
     void handleHandshakes();
     void handleUpstream( int tick );
     void handleDownstream(int tick );
+
+    /* handle events*/
     void handleNewClient( int userId );
-    void cleanUpOldSyncList();
+    void handleReconnect( int userId );
 
     void writeToNewDict( byte * data, int length, bool upstream );
@@ -92 +93 @@
 
   private:
-    SynchronizeableList        synchronizeables;
-    PeerList                   peers;
-    ServerSocket*              serverSocket;
-    int                        type;
-    bool                       bActive;
-    std::list<int>             freeSocketSlots;
+    PeerList                   peers;                       //!< list of the network node informations
 
-    int                        myHostId;
+    PeerInfo*                  pInfo;                       //!< the info about the local peer node (not in the PeerList)
 
+    std::list<int>             freeSocketSlots;             //!< list of free sockets (to ensure not to resycle sockets)
     int                        currentState;                //!< current state id
 
-    NetworkGameManager*        networkGameManager;
+    NetworkMonitor*            networkMonitor;              //!< the network monitor
+    NetworkGameManager*        networkGameManager;          //!< reference to the network game manager
+    ServerSocket*              serverSocket;                //!< the listening socket of the server
 
     std::map<int,int>          oldSynchronizeables;         //!< used to save recently deleted sync ids to not recreate them
+    SynchronizeableList        synchronizeables;            //!< list of the synchronizeables
 
     byte                       buf[UDP_PACKET_SIZE];        //!< used by handleUp/Downstream
     byte                       compBuf[UDP_PACKET_SIZE];    //!< used by handleUp/Downstream
-
     int                        remainingBytesToWriteToDict; //!< if > 0 NetworkStream will write packets to DATA/dicts/newdict
 
-    int dictServer;
-    int dictClient;
+    int                        dictServer;                  //!< the zip dict for the server
+    int                        dictClient;                  //!< the zip dict for the client
 };
 #endif /* _NETWORK_STREAM */