Changeset 332 for code/branches/merger/src

Timestamp:

Nov 28, 2007, 5:20:23 PM (17 years ago)

Author:

nicolasc

Message:

merge network

Location:

code/branches/merger/src

Files:

• network/CMakeLists.txt (modified) (1 diff)
• network/GameStateManager.cc (modified) (1 diff)
• network/GameStateManager.h (modified) (3 diffs)
• network/PacketDecoder.cc (modified) (8 diffs)
• network/PacketGenerator.cc (modified) (2 diffs)
• network/PacketManager.h (modified) (7 diffs)
• network/Synchronisable.h (modified) (4 diffs)
• orxonox/core/Iterator.h (modified) (1 diff)

code/branches/merger/src/network/CMakeLists.txt

@@ -1 +1 @@
 PROJECT(Orxonox)
 
-SET(SRC_FILES Client.cc ConnectionManager.cc PacketBuffer.cc PacketGenerator.cc Synchronisable.cc dummyclient2.cc ClientConnection.cc GameStateManager.cc PacketDecoder.cc Server.cc dummyclient.cc dummyserver.cc)
+SET(SRC_FILES Client.cc ConnectionManager.cc PacketBuffer.cc PacketGenerator.cc Synchronisable.cc ClientConnection.cc GameStateManager.cc PacketDecoder.cc Server.cc)
 
-ADD_LIBRARY(network ${SRC_FILES})
+INCLUDE_DIRECTORIES(..)
+
+ADD_LIBRARY(network ${SRC_FILES} ${ENet_LIBRARY})

code/branches/merger/src/network/GameStateManager.cc

@@ -22 +22 @@
 }
 
-GameState GameStateManager::getSnapshot(){
+/**
+ * This function goes through the whole list of synchronisables and 
+ * saves all the synchronisables to a flat "list".
+ * @return struct of type gamestate containing the size of the whole gamestate and a pointer linking to the flat list
+ */
+GameState GameStateManager::getSnapshot(int id)
+{
+  //the size of the gamestate
+  int totalsize=0;
+  //the size of one specific synchronisable
+  int tempsize=0;
+  // get the start of the Synchronisable list
+  orxonox::Iterator<Synchronisable> it;
+  // struct for return value of Synchronisable::getData()
+  syncData sync;
+  
+  GameState retval; //return value
+  retval.id=id;
+  // reserve a little memory and increase it later on
+  retval.data = (unsigned char*)malloc(1);
+  
+  // offset of memory functions
+  int offset=0;
+  // go through all Synchronisables
+  for(it = orxonox::ObjectList<Synchronisable>::start(); it != 0; ++it){
+    //get size of the synchronisable
+    tempsize=it->getSize();
+    // add place for data and 3 ints (length,classid,objectid)
+    totalsize+=tempsize+3*sizeof(int);
+    // allocate additional space
+    retval.data = (unsigned char *)realloc((void *)retval.data, totalsize);
+    
+    // run Synchronisable::getData with offset and additional place for 3 ints in between (for ids and length)
+    sync=it->getData(retval.data+offset+3*sizeof(int));
+    *(retval.data+offset)=sync.length;
+    *(retval.data+offset+sizeof(int))=sync.objectID;
+    *(retval.data+offset+2*sizeof(int))=sync.classID;
+    // increase data pointer
+    offset+=tempsize+3*sizeof(int);
+  }
+  retval.size=totalsize;
+  return retval;
+}
+
+/**
+ * This function loads a Snapshort of the gamestate into the universe
+ * @param state a GameState struct containing the size of the gamestate and a pointer linking to a flat list (returned by getSnapshot)
+ */
+bool GameStateManager::loadSnapshot(GameState state)
+{
+  unsigned char *data=state.data;
+  // get the start of the Synchronisable list
+  orxonox::Iterator<Synchronisable> it=orxonox::ObjectList<Synchronisable>::start();
+  syncData sync;
+  // loop as long as we have some data ;)
+  while(data < state.data+state.size){
+    // prepare the syncData struct
+    sync.length = *(int *)data;
+    data+=sizeof(int);
+    sync.objectID = *(int *)data;
+    data+=sizeof(int);
+    sync.classID = *(int *)data;
+    data+=sizeof(int);
+    sync.data = data;
+    data+=sync.length;
+    
+    if(it->objectID!=sync.objectID){
+      // bad luck ;)
+      // delete the synchronisable (obviously seems to be deleted on the server)
+      while(it != 0 && it->objectID!=sync.objectID){
+        removeObject(it);
+      }
+      if(it==0){  // add the new object
+        
+      }
+    } else {
+      // we have our object
+      if(! it->updateData(sync))
+        std::cout << "We couldn't update objectID: " \
+          << sync.objectID << "; classID: " << sync.classID << std::endl;
+    }
+    
+  }
+  
   
 }
 
-bool GameStateManager::loadSnapshot(GameState state){
-  
+/**
+ * This function removes a Synchronisable out of the universe
+ * @param it iterator of the list pointing to the object
+ * @return iterator pointing to the next object in the list
+ */
+// orxonox::Iterator<Synchronisable> removeObject(orxonox::Iterator<Synchronisable> it){
+void removeObject(orxonox::Iterator<Synchronisable> &it){
+  orxonox::Iterator<Synchronisable> temp=it;
+  ++it;
+  delete  *temp;
+//   return it;
 }
 
+
 }
+
+

code/branches/merger/src/network/GameStateManager.h

@@ -13 +13 @@
 #define NETWORK_GAMESTATEMANAGER_H
 
+#include "Synchronisable.h"
+#include "orxonox/core/IdentifierIncludes.h"
+#include "orxonox/core/Iterator.h"
+
 namespace network {
 
@@ -20 +24 @@
  * data: pointer to the data allocated in the memory
  */
-struct GameState{
+  struct GameState{
+  int id;
   int size;
   unsigned char *data;
@@ -36 +41 @@
   GameStateManager();
   ~GameStateManager();
-  GameState getSnapshot();
+  GameState getSnapshot(int id);
   bool loadSnapshot(GameState state);
 private:
-  
+  bool removeObject(orxonox::Iterator<Synchronisable> it);
+
 };
 

code/branches/merger/src/network/PacketDecoder.cc

@@ -1 +1 @@
 /*
  * Class contains functions to determine and decode incomming packages
+ * ->don't read this without the class PacketGenerator, since they belong together
  * 
  * Autor: Dumeni Manatschal
  * 
 */
-
 
 #include "enet/enet.h"
@@ -21 +21 @@
 {
         int client = clientId;
-        cout << "clientId: " << client << endl;
-        int id = (int)*packet->data;
+        cout << "clientId: " << client << endl; //control cout, not important, just debugging info
+        int id = (int)*packet->data; //the first 4 bytes are always the enet packet id
         switch( id ) {
         case ACK:
@@ -40 +40 @@
                 return true;
                 break;
+        case GAMESTATE:
+                gstate( packet );
+                return true;
+                break;
         }
         return false;
@@ -49 +53 @@
 {
         ack* a = new ack;
-        *a = *(ack*)packet->data;
-        printAck( a );
+        *a = *(ack*)packet->data; //press pattern of ack on new data
+        
+        //clean memory
+        enet_packet_destroy( packet );
+        
+        printAck( a ); //debug info
 }
 
@@ -56 +64 @@
 {
         mouse* mouseMove = new mouse;
-        *mouseMove = *(mouse*)packet->data;
-        printMouse( mouseMove );
+        //copy data of packet->data to new struct
+        *mouseMove = *(mouse*)packet->data; 
+        
+        //clean memory
+        enet_packet_destroy( packet );
+        
+        printMouse( mouseMove ); //debug info
 }
 
@@ -63 +76 @@
 {
         keyboard* key = new keyboard;
-        *key = *(keyboard*)packet->data;
-        printKey( key );
+        *key = *(keyboard*)packet->data; //see above
+        
+        //clean memory
+        enet_packet_destroy( packet );
+        
+        printKey( key ); //debug info
+
 }
 
@@ -70 +88 @@
 {
         chat* chatting = new chat;
-        chatting->id = (int)*packet->data;
-        char* reserve = new char[packet->dataLength-4];
-        memcpy( &reserve[0], packet->data+sizeof(int), packet->dataLength-4 );
+        chatting->id = (int)*packet->data; //first copy id into new struct
+        //since the chat message is a char*, allocate the memory needed
+        char* reserve = new char[packet->dataLength-4]; 
+        //copy the transmitted bytestream into the new generated char*,
+        //note the lenght of the message is represented as "packet->dataLength-sizeof( int )" 
+        memcpy( &reserve[0], packet->data+sizeof(int), packet->dataLength-sizeof(int) );
+        //put pointer of chatting struct to the begining of the new generated char*
         chatting->message = reserve;
-        printChat( chatting );
+        
+        //clean memory
+        enet_packet_destroy( packet );
+        
+        printChat( chatting ); //debug info
+        
+}
+
+void PacketDecoder::gstate( ENetPacket* packet )
+{
+        GameState* currentState = new GameState;
+        //since it's not alowed to use void* for pointer arithmetic
+        unsigned char* data = (unsigned char*)packet->data;
+        //copy the gamestate id into the struct, which is located at second place data+sizeof( int )
+        memcpy( (void*)&(currentState->id), (const void*)(data+sizeof( int )), sizeof( int ) );
+        //copy the size of the gamestate data into the new gamestate struct, located at 3th
+        //position of the data stream, data+2*sizeof( int )
+        memcpy( (void*)&(currentState->size), (const void*)(data+2*sizeof( int )), sizeof( int) );
+        //since data is not allocated, because it's just a pointer, allocate it with size of gamestatedatastream
+        currentState->data = (unsigned char*)(malloc( currentState->size ));
+        //copy the gamestate data
+        memcpy( (void*)(currentState->data), (const void*)(data+3*sizeof( int )), currentState->size );
+        
+        //clean memory
+        enet_packet_destroy( packet );
 }
 
@@ -100 +146 @@
 {
         cout << "data id: " << data->id << endl;
-        cout << "blablabla" << endl;
         cout << "data:    " << data->message << endl;
 }
+
+void PacketDecoder::printGamestate( GameState* data )
+{
+        cout << "id of gamestate:   " << data->id << endl;
+        cout << "size of gamestate: " << data->size << endl;
+}

code/branches/merger/src/network/PacketGenerator.cc

@@ -1 +1 @@
 /*
  *Class generates packets that can be send by enet
+ * ->don't read this without the class PacketDecoder, since they belong together
  * 
  * Autor: Dumeni Manatschal
@@ -68 +69 @@
 }
 
+/*### gamestate packet */
+ENetPacket* PacketGenerator::gstate( GameState* states, int reliable )
+{
+        int* gid; *gid = GAMESTATE; //first assign the correct enet id
+        int totalLen = 3*sizeof( int ) + states->size; //calculate the total size of the datastream memory
+        unsigned char* data = (unsigned char*)malloc( totalLen ); //allocate the memory for datastream
+        memcpy( (void*)(data), (const void*)gid, sizeof( int ) ); //this is the enet id
+        memcpy( (void*)(data+sizeof(int)), (const void*)&(states->id), sizeof(int) ); //the gamestate id
+        //this is the size of the gamestate data, place at 3th position of the enet datastream
+        memcpy( (void*)(data+2*sizeof(int)), (const void*)&(states->size), sizeof(int)); 
+        //place the gamestate data at the end of the enet datastream
+        memcpy( (void*)(data+3*sizeof( int )), (const void*)states->data, states->size );
+        //create an enet packet with the generated bytestream
+        ENetPacket *packet = enet_packet_create( data , totalLen, reliable );
+        
+        return packet;
+}

code/branches/merger/src/network/PacketManager.h

@@ -3 +3 @@
 
 #include <enet/enet.h>
+#include <network/GameStateManager.h>
 
 //enum netowk generaly used to set the type ID of a packet
@@ -11 +12 @@
         MOUSE,
         KEYBOARD,
-        CHAT
+        CHAT,
+        GAMESTATE
 };
 
@@ -17 +19 @@
  * class to generate packets
  * 
- * Autor: Dumeni Manatschal
+ * @autor: Dumeni Manatschal
  * 
 */ 
@@ -29 +31 @@
         ENetPacket* keystrike( char press, int reliable = ENET_PACKET_FLAG_RELIABLE );
         ENetPacket* chatMessage( const char* message, int reliable = ENET_PACKET_FLAG_RELIABLE );
+        ENetPacket* gstate( GameState* states, int reliable = ENET_PACKET_FLAG_RELIABLE );
 private:
         //used to set the bytes in the right order
@@ -51 +54 @@
  * class used to decode incoming packets
  * 
- * Autor: Dumeni Manatschal
+ * @autor: Dumeni Manatschal
  * 
 */
@@ -87 +90 @@
         void keystrike( ENetPacket* packet );
         void chatMessage( ENetPacket* packet );
+        void gstate( ENetPacket* packet );
         
         //print functions
@@ -93 +97 @@
         void printKey( keyboard* data );
         void printChat( chat* data );
-        void printPeer( ENetPeer* peer );
+        void printGamestate( GameState* data );
 };
 }

code/branches/merger/src/network/Synchronisable.h

@@ -14 +14 @@
 
 #include <list>
+#include <iostream>
+
+#include "orxonox/core/IdentifierIncludes.h"
 
 namespace network {
@@ -20 +23 @@
 struct syncData{
   int length;
+  int objectID;
   int classID;
-  int objectID;
   unsigned char *data;
 };
@@ -40 +43 @@
   Synchronisable();
 
-  ~Synchronisable();
+  virtual ~Synchronisable();
   int objectID;
   int classID;
@@ -52 +55 @@
 
 private:
+/*  bool removeObject(Iterator<Synchronisable> it);*/
+  
   std::list<SYNCVAR> syncList;
   int datasize;

code/branches/merger/src/orxonox/core/Iterator.h

@@ -1 @@
-#ifndef _Iterator_H__
-#define _Iterator_H__
+#ifndef _Iterator_H2__
+#define _Iterator_H2__
 
 namespace orxonox