Changeset 6214 in orxonox.OLD for branches/network/src

Timestamp:

Dec 21, 2005, 9:11:47 AM (19 years ago)

Author:

rennerc

Message:

network_game_manager: implemented some functions

Location:

branches/network/src/lib/network

Files:

• network_game_manager.cc (modified) (16 diffs)
• network_game_manager.h (modified) (5 diffs)
• network_stream.cc (modified) (1 diff)
• network_stream.h (modified) (2 diffs)

branches/network/src/lib/network/network_game_manager.cc

@@ -22 +22 @@
 #include "factory.h"
 #include "network_stream.h"
+#include "converter.h"
 
 /* include your own header */
@@ -37 +38 @@
   /* set the class id for the base object */
   this->setClassID(CL_ENTITY_MANAGER, "EntityManager");
+
+  allOutBuffer.length = 0;
+
+  allOutBuffer.maxLength = 10*1024;
+
+  allOutBuffer.buffer = new byte[10*1024];
+
+  newUniqueID = MAX_CONNECTIONS + 2;
 }
 
@@ -44 +53 @@
 NetworkGameManager::~NetworkGameManager()
 {
-  for ( int i = 0; i<inBuffer.size(); i++)
-  {
-    if ( inBuffer[i].buffer )
-      delete inBuffer[i].buffer;
+  for ( int i = 0; i<outBuffer.size(); i++)
+  {
     if ( outBuffer[i].buffer )
       delete outBuffer[i].buffer;
   }
+
+  if ( allOutBuffer.buffer )
+    delete allOutBuffer.buffer;
 }
 
@@ -56 +66 @@
 void NetworkGameManager::writeBytes(const byte* data, int length, int sender)
 {
+  int i = 0;
+  byte b;
+
+  while ( i<length )
+  {
+    b = data[i++];
+
+    if ( b == REQUEST_CREATE )
+    {
+      return;
+    }
+    if ( b == REQUEST_REMOVE )
+    {
+      return;
+    }
+    if ( b == CREATE_ENTITY )
+    {
+      return;
+    }
+    if ( b == REMOVE_ENTITY )
+    {
+      return;
+    }
+    if ( b == REQUEST_SYNC )
+    {
+      return;
+    }
+    if ( b == YOU_ARE_ENTITY )
+    {
+      return;
+    }
+    if ( b == CREATE_ENTITY_LIST )
+    {
+      return;
+    }
+    if ( b == REMOVE_ENTITY_LIST )
+    {
+      return;
+    }
+  }
 }
 
 int NetworkGameManager::readBytes(byte* data, int maxLength, int * reciever)
 {
+  for ( int i = 0; i<outBuffer.size(); i++ )
+  {
+    if ( outBuffer[i].length>0 )
+    {
+      int nbytes = outBuffer[i].length;
+
+      if ( nbytes > maxLength )
+      {
+        PRINTF(1)("OutBuffer.length (%d) > (%d) networkStreamBuffer.maxLength\n", nbytes, maxLength);
+        return 0;
+      }
+
+      memcpy(data, outBuffer[i].buffer, nbytes);
+      return nbytes;
+    }
+  }
+
+  int nbytes = allOutBuffer.length;
+
+  if ( nbytes <=0 )
+    return 0;
+
+  if ( nbytes > maxLength )
+  {
+    PRINTF(1)("OutBuffer.length (%d) > (%d) networkStreamBuffer.length\n", nbytes, maxLength);
+    return 0;
+  }
+
+  memcpy( data, allOutBuffer.buffer, nbytes );
+  return nbytes;
 }
 
@@ -73 +153 @@
 /*!
  * Checks whether this is connected to a server or a client
- * and afterwards creates the needed entity if possible
+ * and afterwards creates the needed entity
  * @param classID: The ID of the class of which an entity should be created
  */
-void NetworkGameManager::createEntity(int classID)
-{
+void NetworkGameManager::createEntity(ClassID classID)
+{
+  if ( this->isServer() )
+  {
+    if ( newUniqueID < 0 )
+    {
+      PRINTF(1)("Cannot create entity! There are no more uniqueIDs left!\n");
+      return;
+    }
+
+    this->executeCreateEntity( classID, newUniqueID++ );
+  }
+  else
+  {
+    this->requestCreateEntity( classID);
+  }
 }
 
@@ -87 +181 @@
 void NetworkGameManager::removeEntity(int uniqueID)
 {
+  if ( this->isServer() )
+  {
+    this->executeRemoveEntity( uniqueID );
+  }
+  else
+  {
+    this->requestRemoveEntity( uniqueID );
+  }
 }
 
@@ -95 +197 @@
  * @param classID: The ID of the class of which an entity should be created
  */
-void NetworkGameManager::requestCreateEntity(int classID)
-{
+void NetworkGameManager::requestCreateEntity(ClassID classID)
+{
+  byte* bp;
+  byte b = REQUEST_CREATE;
+  bp = Converter::intToByteArray( classID );
+
+  if ( !writeToClientBuffer( allOutBuffer, &b, 1 ) )
+  {
+    PRINTF(1)("Could not write to clientBuffer\n");
+    return;
+  }
+
+  if ( !writeToClientBuffer( allOutBuffer, bp, INTSIZE ) )
+  {
+    PRINTF(1)("Could not write to clientBuffer\n");
+    delete bp;
+    return;
+  }
+  delete bp;
 }
 
@@ -105 +224 @@
 void NetworkGameManager::requestRemoveEntity(int uniqueID)
 {
+  byte* bp;
+  byte b = REQUEST_REMOVE;
+  bp = Converter::intToByteArray( uniqueID );
+
+  if ( !writeToClientBuffer( allOutBuffer, &b, 1 ) )
+  {
+    PRINTF(1)("Could not write to clientBuffer\n");
+    return;
+  }
+
+  if ( !writeToClientBuffer( allOutBuffer, bp, INTSIZE ) )
+  {
+    PRINTF(1)("Could not write to clientBuffer\n");
+    delete bp;
+    return;
+  }
+  delete bp;
 }
 
@@ -112 +248 @@
  * @param classID: The ID of the class of which an entity should be created
  */
-void NetworkGameManager::executeCreateEntity(int classID)
-{
+void NetworkGameManager::executeCreateEntity(ClassID classID, int uniqueID, int owner)
+{
+  byte* bp;
+  byte b = CREATE_ENTITY;
+
+  if ( !writeToClientBuffer( allOutBuffer, &b, 1 ) )
+  {
+    PRINTF(1)("Could not write to clientBuffer\n");
+    return;
+  }
+
+  bp = Converter::intToByteArray( uniqueID );
+  if ( !writeToClientBuffer( allOutBuffer, bp, INTSIZE ) )
+  {
+    PRINTF(1)("Could not write to clientBuffer\n");
+    delete bp;
+    return;
+  }
+  delete bp;
+
+  bp = Converter::intToByteArray( uniqueID );
+  if ( !writeToClientBuffer( allOutBuffer, bp, INTSIZE ) )
+  {
+    PRINTF(1)("Could not write to clientBuffer\n");
+    delete bp;
+    return;
+  }
+  delete bp;
+
+  bp = Converter::intToByteArray( owner );
+  if ( !writeToClientBuffer( allOutBuffer, bp, INTSIZE ) )
+  {
+    PRINTF(1)("Could not write to clientBuffer\n");
+    delete bp;
+    return;
+  }
+  delete bp;
+
+  doCreateEntity( classID, uniqueID, owner );
 }
 
@@ -123 +296 @@
 void NetworkGameManager::executeRemoveEntity(int uniqueID)
 {
+  byte* bp;
+  byte b = REMOVE_ENTITY;
+
+  if ( !writeToClientBuffer( allOutBuffer, &b, 1 ) )
+  {
+    PRINTF(1)("Could not write to clientBuffer\n");
+    return;
+  }
+
+  bp = Converter::intToByteArray( uniqueID );
+  if ( !writeToClientBuffer( allOutBuffer, bp, INTSIZE ) )
+  {
+    PRINTF(1)("Could not write to clientBuffer\n");
+    delete bp;
+    return;
+  }
+  delete bp;
+
+  doRemoveEntity(uniqueID);
 }
 
@@ -129 +321 @@
  * @return: true if the entity can be created, false otherwise
  */
-bool NetworkGameManager::canCreateEntity(int classID)
+bool NetworkGameManager::canCreateEntity(ClassID classID)
 {
   return true;
@@ -140 +332 @@
 void NetworkGameManager::sendEntityList( int userID )
 {
+  if ( !isServer() )
+    return;
+
+  if ( userID > outBuffer.size() )
+    resizeBufferVector( userID );
+
+  SynchronizeableList::const_iterator it, e;
+
+  it = this->networkStream->getSyncBegin();
+  e = this->networkStream->getSyncEnd();
+
+  byte b = CREATE_ENTITY_LIST;
+  byte* ib;
+
+  if ( !writeToClientBuffer( outBuffer[userID], &b, 1 ) )
+  {
+    PRINTF(1)("Could not write to clientBuffer\n");
+    return;
+  }
+
+  ib = Converter::intToByteArray( networkStream->getSyncCount() );
+  if ( !writeToClientBuffer( outBuffer[userID], ib, INTSIZE ) )
+  {
+    PRINTF(1)("Could not write to clientBuffer\n");
+    delete ib;
+    return;
+  }
+  delete ib;
+
+  while ( it != e )
+  {
+    ib = Converter::intToByteArray( (*it)->getClassID() );
+    if ( !writeToClientBuffer( outBuffer[userID], ib, INTSIZE ) )
+    {
+      PRINTF(1)("Could not write to clientBuffer\n");
+      delete ib;
+      return;
+    }
+    delete ib;
+
+    ib = Converter::intToByteArray( (*it)->getUniqueID() );
+    if ( !writeToClientBuffer( outBuffer[userID], ib, INTSIZE ) )
+    {
+      PRINTF(1)("Could not write to clientBuffer\n");
+      delete ib;
+      return;
+    }
+    delete ib;
+
+    ib = Converter::intToByteArray( (*it)->getOwner() );
+    if ( !writeToClientBuffer( outBuffer[userID], ib, INTSIZE ) )
+    {
+      PRINTF(1)("Could not write to clientBuffer\n");
+      delete ib;
+      return;
+    }
+    delete ib;
+
+    it++;
+  }
 }
 
@@ -148 +400 @@
 void NetworkGameManager::resizeBufferVector( int n )
 {
-  for ( int i = inBuffer.size(); i<=n; i++)
-  {
-    clientBuffer inBuf;
+  for ( int i = outBuffer.size(); i<=n; i++)
+  {
     clientBuffer outBuf;
 
-    inBuf.length = 0;
     outBuf.length = 0;
 
-    inBuf.maxLength = 5*1014;
     outBuf.maxLength = 5*1024;
 
-    inBuf.buffer = new byte[5*1014];
     outBuf.buffer = new byte[5*1014];
 
-    inBuffer.push_back(inBuf);
     outBuffer.push_back(outBuf);
   }
@@ -175 +422 @@
 void NetworkGameManager::doCreateEntity( ClassID classID, int uniqueID, int owner )
 {
-  //BaseObject * b = Factory::fabricate( classID );
-  BaseObject * b = NULL;
+  BaseObject * b = Factory::fabricate( classID );
+
+  if ( !b )
+  {
+    PRINTF(1)("Could not fabricate Object with classID %d\n", classID);
+    return;
+  }
 
   if ( b->isA(CL_SYNCHRONIZEABLE) )
@@ -209 +461 @@
       break;
     }
+    it++;
   }
 }
@@ -230 +483 @@
       break;
     }
-  }
-}
+    it++;
+  }
+}
+
+/**
+ * Copies length bytes to the clientBuffer with error checking
+ * @param clientBuffer: the clientBuffer to write to
+ * @param data: buffer to the data
+ * @param length: length of data
+ * @return false on error true else
+ */
+bool NetworkGameManager::writeToClientBuffer( clientBuffer &cb, byte * data, int length )
+{
+  if ( length > cb.maxLength-cb.length )
+  {
+    PRINTF(1)("No space left in clientBuffer\n");
+    return false;
+  }
+
+  memcpy( cb.buffer+cb.length, data, length );
+  return true;
+}
+
+/**
+ * Reads data from clientBuffer with error checking
+ * @param clientBuffer: the clientBuffer to read from
+ * @param data: pointer to the buffer
+ * @param length:
+ * @return
+ */
+bool NetworkGameManager::readFromClientBuffer( clientBuffer &cb, byte * data, int length )
+{
+  if ( cb.length < length )
+  {
+    PRINTF(0)("There is not enough data in clientBuffer\n");
+    return 0;
+  }
+
+  memcpy( data, cb.buffer+cb.length-length, length );
+  return true;
+}
+
+/**
+ * Tells this client that he has to control this entity
+ * @param uniqueID: the entity's uniqeID
+ */
+void NetworkGameManager::doYouAre( int uniqueID )
+{
+  //TODO: what has to be done
+}
+
+/**
+ * Tells a remote client that he has to control this entity
+ * @param uniqueID: the entity's uniqeID
+ * @param userID: the users ID
+ */
+void NetworkGameManager::sendYouAre( int uniqueID, int userID )
+{
+  if ( !isServer() )
+    return;
+
+  byte* bp;
+  byte b = YOU_ARE_ENTITY;
+
+  if ( userID != 0 )
+  {
+    if ( !writeToClientBuffer( allOutBuffer, &b, 1 ) )
+    {
+      PRINTF(1)("Could not write to clientBuffer\n");
+      return;
+    }
+
+    bp = Converter::intToByteArray( uniqueID );
+    if ( !writeToClientBuffer( allOutBuffer, bp, INTSIZE ) )
+    {
+      PRINTF(1)("Could not write to clientBuffer\n");
+      delete bp;
+      return;
+    }
+    delete bp;
+  }
+  else
+  {
+    doYouAre(uniqueID);
+  }
+}
+

branches/network/src/lib/network/network_game_manager.h

@@ -27 +27 @@
  *  REQUEST_REMOVE:      UNIQUE_ID
  *
- *  REQUEST_CREATE_LIST: NUMBER, [CLASS_ID][0..NUMBER]
- *  REQUEST_CREATE_LIST: NUMBER, [UNIQUE_ID][0..NUMBER]
+ *  //REQUEST_CREATE_LIST: NUMBER, [CLASS_ID][0..NUMBER]
+ *  //REQUEST_CREATE_LIST: NUMBER, [UNIQUE_ID][0..NUMBER]
  *
  *  REQUEST_SYNC:        UNIQUE_ID
- *  REQUEST_SYNC_LIST:   NUMBER, [UNIQUE_ID][0..NUMBER]
+ *  //REQUEST_SYNC_LIST:   NUMBER, [UNIQUE_ID][0..NUMBER]
  *
+ *  YOU_ARE_ENTITY:      UNIQUE_ID
  *
  */
@@ -39 +40 @@
   CREATE_ENTITY = 0,
   REMOVE_ENTITY,
+  CREATE_ENTITY_LIST,
+  REMOVE_ENTITY_LIST,
   REQUEST_CREATE,
-  REQUEST_SYNC
+  REQUEST_REMOVE,
+  REQUEST_SYNC,
+  YOU_ARE_ENTITY
 };
 
@@ -64 +69 @@
     virtual void readDebug() const;
 
-    void createEntity(int classID);
+    void createEntity(ClassID classID);
     void removeEntity(int uniqueID);
+    void sendYouAre( int uniqueID, int userID );
 
     void sync(int uniqueID);
@@ -72 +78 @@
 
   private:
-    void requestCreateEntity(int classID);
-    void executeCreateEntity(int classID);
+    void requestCreateEntity(ClassID classID);
+    void executeCreateEntity(ClassID classID, int uniqueID = 0, int owner = 0);
 
     void requestRemoveEntity(int uniqueID);
@@ -81 +87 @@
     void doRemoveEntity(int uniqueID);
     void doRequestSync(int uniqueID, int userID);
+    void doYouAre( int uniqueID );
 
-    bool canCreateEntity(int classID);
+    bool canCreateEntity(ClassID classID);
 
     void resizeBufferVector(int n);
 
+    inline bool writeToClientBuffer( clientBuffer &cb, byte*data, int length );
+    inline bool readFromClientBuffer( clientBuffer &cb, byte*data, int length );
+
   private:
-    std::vector<clientBuffer>     inBuffer;
     std::vector<clientBuffer>     outBuffer;
+    clientBuffer                  allOutBuffer;
+
+    int                           newUniqueID;
 };
 

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

@@ -382 +382 @@
     return;
   }
+
+  if ( n > MAX_CONNECTIONS )
+  {
+    PRINTF(1)("Cannot set maxConnectiosn to %d because of hardcoded limit %d\n", n, MAX_CONNECTIONS);
+    return;
+  }
+
   this->maxConnections = n;
   this->networkGameManager->setUniqueID( n+2 );

branches/network/src/lib/network/network_stream.h

@@ -14 +14 @@
 #include "server_socket.h"
 #include "handshake.h"
+
+#define MAX_CONNECTIONS 1000
 
 class Synchronizeable;
@@ -51 +53 @@
     inline SynchronizeableList::const_iterator getSyncBegin(){ return synchronizeables.begin(); }
     inline SynchronizeableList::const_iterator getSyncEnd(){ return synchronizeables.end(); }
+    inline int getSyncCount(){ return synchronizeables.size(); }
 
   private: