Changeset 1098 for code/branches/network2/src

Timestamp:

Apr 17, 2008, 2:35:51 PM (17 years ago)

Author:

rgrieder

Message:

merged network branch into new network2 branch (from trunk)

Location:

code/branches/network2/src

Files:

• network/CMakeLists.txt (modified) (3 diffs)
• network/Client.cc (modified) (1 diff)
• network/ClientConnection.cc (modified) (4 diffs)
• network/ClientInformation.cc (modified) (3 diffs)
• network/ClientInformation.h (modified) (1 diff)
• network/ConnectionManager.cc (modified) (10 diffs)
• network/ConnectionManager.h (modified) (2 diffs)
• network/GameStateClient.cc (modified) (6 diffs)
• network/GameStateClient.h (modified) (3 diffs)
• network/GameStateManager.cc (modified) (9 diffs)
• network/GameStateManager.h (modified) (2 diffs)
• network/PacketBuffer.cc (modified) (2 diffs)
• network/PacketDecoder.cc (modified) (7 diffs)
• network/PacketGenerator.cc (modified) (5 diffs)
• network/PacketTypes.h (modified) (2 diffs)
• network/Server.cc (modified) (4 diffs)
• network/Synchronisable.cc (modified) (8 diffs)
• network/Synchronisable.h (modified) (2 diffs)
• network/diffTest.cc (copied) (copied from code/branches/network/src/network/diffTest.cc)
• orxonox/Orxonox.cc (modified) (1 diff)
• orxonox/objects/Ambient.cc (modified) (4 diffs)
• orxonox/objects/Ambient.h (modified) (3 diffs)
• orxonox/objects/Model.cc (modified) (2 diffs)
• orxonox/objects/NPC.cc (modified) (2 diffs)
• orxonox/objects/NPC.h (modified) (1 diff)
• orxonox/objects/Skybox.cc (modified) (4 diffs)
• orxonox/objects/Skybox.h (modified) (2 diffs)
• orxonox/objects/WorldEntity.cc (modified) (3 diffs)

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

@@ -11 +11 @@
   Server.cc
   Synchronisable.cc
-  dummyserver3.cc
 )
 
@@ -30 +29 @@
 # build those parts only on request.
 IF(NETWORK_TESTING_ENABLED)
+  ##### test for gamestate stuff #####
+  SET( TEST_SRC_FILES
+    ConnectionManager.cc
+    GameStateManager.cc
+    PacketBuffer.cc
+    PacketDecoder.cc
+    PacketGenerator.cc
+    ClientConnection.cc
+    ClientInformation.cc
+    diffTest.cc
+    GameStateClient.cc
+    Server.cc
+    Client.cc  
+    Synchronisable.cc  
+  )
+
+  ADD_EXECUTABLE(networktest ${TEST_SRC_FILES})
+  TARGET_LINK_LIBRARIES( networktest
+    ${OGRE_LIBRARIES}
+    network
+    ${ENet_LIBRARY}
+    ${ZLIB_LIBRARY}
+    ${WINDOWS_ENET_DEPENDENCIES}
+  )
+  ##### end test for gamestate stuff #####
+ENDIF(NETWORK_TESTING_ENABLED)
+IF(BLABLA)
   SET( CHATCLIENT_SRC_FILES
     ClientConnection.cc
@@ -95 +121 @@
     ${WINDOWS_ENET_DEPENDENCIES}
   )
-ENDIF(NETWORK_TESTING_ENABLED)
+ENDIF(BLABLA)
+

code/branches/network2/src/network/Client.cc

@@ -205 +205 @@
     if(id!=NULL)
       id->setNetworkID(clid->clid);
-    COUT(4) << "received and set network id: " << clid->clid << "; classname: " << clid->message << std::endl;
+    COUT(4) << "Client: received and set network id: " << clid->clid << "; classname: " << clid->message << std::endl;
     return;
   }

code/branches/network2/src/network/ClientConnection.cc

@@ -87 +87 @@
 
   ENetPacket *ClientConnection::getPacket() {
-    ENetAddress address;
+    ENetAddress address; //sems that address is not needed
     return getPacket(address);
   }
@@ -162 +162 @@
       case ENET_EVENT_TYPE_CONNECT:
       case ENET_EVENT_TYPE_RECEIVE:
-        COUT(5) << "receiver-Thread: got new packet" << std::endl;
-        processData(&event);
+        COUT(5) << "Cl.Con: receiver-Thread while loop: got new packet" << std::endl;
+        if ( !processData(&event) ) COUT(2) << "Current packet was not pushed to packetBuffer -> ev ongoing SegFault" << std::endl;
         break;
       case ENET_EVENT_TYPE_DISCONNECT:
@@ -203 +203 @@
   bool ClientConnection::establishConnection() {
     ENetEvent event;
-    // connect to peer
+    // connect to peer (server is type ENetPeer*)
     server = enet_host_connect(client, &serverAddress, NETWORK_CLIENT_CHANNELS);
     if(server==NULL)
@@ -218 +218 @@
 
   bool ClientConnection::processData(ENetEvent *event) {
-    COUT(5) << "got packet, pushing to queue" << std::endl;
+    COUT(5) << "Cl.Con: got packet, pushing to queue" << std::endl;
     // just add packet to the buffer
     // this can be extended with some preprocessing

code/branches/network2/src/network/ClientInformation.cc

@@ -190 +190 @@
   * This function should only be applied to the head of the list
   * @param clientID id to look for
-  * @return pointer to the element in the list or 0 if the search was unsuccessfull
+  * @return pointer to the last element in the list or 0 if the search was unsuccessfull
   */
   ClientInformation *ClientInformation::findClient(int clientID, bool look_backwards) {
@@ -196 +196 @@
     if (temp->head)
       temp=temp->next();
-    while(temp!=0 && temp->getID()!=clientID){
+    //bugfix: temp to temp->next(), get last elem if not found, not segflt
+    while(temp->next()!=0 && temp->getID()!=clientID){
       temp = temp->next();
     }
@@ -211 +212 @@
   ClientInformation *ClientInformation::findClient(ENetAddress *address, bool look_backwards) {
     ClientInformation *temp = this;
-    while(temp!=0){
+    //bugfix: temp to temp->next(), get last elem if not found, not segflt
+    while(temp->next()!=0){
       if(temp->head){
         temp = temp->next();

code/branches/network2/src/network/ClientInformation.h

@@ -75 +75 @@
     bool removeClient(int clientID);
     bool removeClient(ENetPeer *peer);
+    //## add bool mask-function eventually
     ClientInformation *findClient(int clientID, bool look_backwards=false);
+    //## add bool mask-function eventually
     ClientInformation *findClient(ENetAddress *address, bool look_backwards=false);
 

code/branches/network2/src/network/ConnectionManager.cc

@@ -60 +60 @@
 {
   boost::thread_group network_threads;
-
+  
+  ConnectionManager::ConnectionManager(){}
+  
   ConnectionManager::ConnectionManager(ClientInformation *head) {
     quit=false;
@@ -88 +90 @@
       return NULL;
   }
-
+/**
+This function only pops the first element in PacketBuffer (first in first out)
+used by processQueue in Server.cc
+*/
   ENetPacket *ConnectionManager::getPacket(int &clientID) {
     ENetAddress address;
@@ -174 +179 @@
         case ENET_EVENT_TYPE_CONNECT:
           addClient(&event);
+          COUT(5) << "Con.Man: connection event has occured" << std::endl;
           break;
         case ENET_EVENT_TYPE_RECEIVE:
           //std::cout << "received data" << std::endl;
+          COUT(5) << "Con.Man: receive event has occured" << std::endl;
           processData(&event);
           break;
@@ -191 +198 @@
     enet_host_destroy(server);
   }
-
+  
+  //### added some bugfixes here, but we cannot test them because
+  //### the server crashes everytime because of some gamestates
+  //### (trying to resolve that now)
   void ConnectionManager::disconnectClients() {
     ENetEvent event;
@@ -199 +209 @@
       temp = temp->next();
     }
-    temp = temp->next();
+    //bugfix: might be the reason why server crashes when clients disconnects
+    //temp = temp->next();
+    temp = head_->next();
     while( temp!=0 && enet_host_service(server, &event, NETWORK_WAIT_TIMEOUT) > 0){
       switch (event.type)
       {
-      case ENET_EVENT_TYPE_NONE:
-      case ENET_EVENT_TYPE_CONNECT:
+      case ENET_EVENT_TYPE_NONE: break;
+      case ENET_EVENT_TYPE_CONNECT: break;
       case ENET_EVENT_TYPE_RECEIVE:
         enet_packet_destroy(event.packet);
         break;
       case ENET_EVENT_TYPE_DISCONNECT:
-        std::cout << "disconnecting client" << std::endl;
+        COUT(4) << "disconnecting all clients" << std::endl;
         delete head_->findClient(&(event.peer->address));
+        //maybe needs bugfix: might also be a reason for the server to crash
         temp = temp->next();
         break;
@@ -229 +242 @@
 
   bool ConnectionManager::clientDisconnect(ENetPeer *peer) {
+    COUT(4) << "removing client from list" << std::endl;
     return head_->removeClient(peer);
   }
-
+/**
+This function adds a client that connects to the clientlist of the server
+NOTE: if you change this, don't forget to change the test function
+addClientTest in diffTest.cc since addClient is not good for testing because of syncClassid
+*/
   bool ConnectionManager::addClient(ENetEvent *event) {
     ClientInformation *temp = head_->insertBack(new ClientInformation);
-    if(temp->prev()->head)
+    if(temp->prev()->head) { //not good if you use anything else than insertBack
+      temp->prev()->setID(0); //bugfix: not necessary but usefull
       temp->setID(1);
+    }
     else
       temp->setID(temp->prev()->getID()+1);
     temp->setPeer(event->peer);
-    std::cout << "added client id: " << temp->getID() << std::endl;
+    COUT(4) << "Con.Man: added client id: " << temp->getID() << std::endl;
     syncClassid(temp->getID());
     temp->setSynched(true);
@@ -268 +288 @@
       classname = id->getName();
       network_id = id->getNetworkID();
-      COUT(4) << "network_id: " << network_id << ", classname: " << classname << std::endl;
+      COUT(4) << "Con.Man:syncClassid:\tnetwork_id: " << network_id << ", classname: " << classname << std::endl;
 
       addPacket(packet_gen.clid( (int)network_id, classname ), clientID);
@@ -275 +295 @@
     }
     sendPackets();
+    COUT(4) << "syncClassid:\tall synchClassID packets have been sent" << std::endl;
   }
 
@@ -289 +310 @@
 
   int ConnectionManager::getObjectsClientID( int objectID ) {
-    std::map<int, int>::iterator iter = clientsShip.begin();
-    while( iter != clientsShip.end() ) {
+    std::map<int, int>::iterator iter;
+    for( iter = clientsShip.begin(); iter != clientsShip.end(); iter++ ) {
       if( iter->second == objectID ) return iter->first;
     }
@@ -302 +323 @@
   void ConnectionManager::deleteObjectIDReg( int objectID ) {
     std::map<int, int>::iterator iter = clientsShip.begin();
-    while( iter != clientsShip.end() ) {
+    for( iter = clientsShip.begin(); iter != clientsShip.end(); iter++ ) {
       if( iter->second == objectID ) break;
     }
     clientsShip.erase( iter->first );
   }
-
+  int ConnectionManager::getNumberOfClients() {
+    return clientsShip.size();
+  }
 }

code/branches/network2/src/network/ConnectionManager.h

@@ -84 +84 @@
     bool sendPackets(ENetEvent *event);
     bool sendPackets();
+
+    //##### for testing purpose only #####
+    ConnectionManager();
+    std::map<int, int> testGetClientsShip() { 
+      return clientsShip; 
+    }
+    void testAddClientsShipID( int clientID, int objectID ) {
+      addClientsObjectID( clientID, objectID );
+    }
+    int testGetClientsShipID( int clientID ) { 
+      return getClientsShipID( clientID ); 
+    }
+    int testGetObjectsClientID( int objectID ) {
+       return getObjectsClientID( objectID );
+    }
+    void testDeleteClientsIDReg( int clientID ) { 
+      deleteClientIDReg( clientID );
+    }
+    void testDeleteObjectIDReg( int objectID ) {
+      deleteObjectIDReg( objectID );
+    }
+    //##### for testing purpose only #####
   private:
     bool clientDisconnect(ENetPeer *peer);
@@ -111 +133 @@
     void deleteClientIDReg( int clientID );
     void deleteObjectIDReg( int objectID );
+    int getNumberOfClients();
   };
-
-
-
-
-
-
-
 
 }

code/branches/network2/src/network/GameStateClient.cc

@@ -32 +32 @@
 
 #include "core/CoreIncludes.h"
+#include "core/BaseObject.h"
 #include "Synchronisable.h"
 
 namespace network
 {
+  struct GameStateItem{
+    GameState *state;
+    int id;
+  };
+  
   GameStateClient::GameStateClient() {
+    COUT(5) << "this: " << this << std::endl;
   }
 
@@ -44 +51 @@
   bool GameStateClient::pushGameState(GameStateCompressed *compstate) {
     GameState *gs;
-    if(compstate->diffed)
-      gs = decode(reference, compstate);
+    if(compstate->diffed){
+      while(compstate->base_id > gameStateList.front()->id){
+        // clean up old gamestates
+        free(gameStateList.front()->data);
+        // TODO: critical section
+        delete gameStateList.front();
+        gameStateList.pop();
+      }
+      if(compstate->base_id!=gameStateList.front()->id){
+        COUT(4) << "pushGameState: no reference found to diff" << std::endl;
+        return false;
+      }
+      gs = decode(gameStateList.front(), compstate);
+    }
     else
       gs = decode(compstate);
@@ -95 +114 @@
 
         if(!it){
-          COUT(5) << "classid: " << sync.classID << ", name: " << ID((unsigned int) sync.classID)->getName() << std::endl;
-          Synchronisable *no = (Synchronisable*)(ID((unsigned int) sync.classID)->fabricate());
+          COUT(4) << "loadSnapshot:\tclassid: " << sync.classID << ", name: " << ID((unsigned int) sync.classID)->getName() << std::endl;
+          Synchronisable *no = dynamic_cast<Synchronisable *>(ID((unsigned int) sync.classID)->fabricate());
           no->objectID=sync.objectID;
           no->classID=sync.classID;
           it=orxonox::ObjectList<Synchronisable>::end();
           // update data and create object/entity...
-          if( !no->updateData(sync) && !no->create() )
-            COUT(1) << "We couldn't create/update the object: " << sync.objectID << std::endl;
-          ++it;
+          if( !no->updateData(sync) )
+            COUT(1) << "We couldn't update the object: " << sync.objectID << std::endl;
+          if( !no->create() )
+            COUT(1) << "We couldn't manifest (create() ) the object: " << sync.objectID << std::endl;
         }
       } else {
@@ -154 +174 @@
   }
 
+  //##### ADDED FOR TESTING PURPOSE #####
+  GameState* GameStateClient::testDecompress( GameStateCompressed* gc ) {
+    return decompress( gc );
+  }
+  
+  GameState* GameStateClient::testUndiff( GameState* g_old, GameState* g_diffed ) {
+    return undiff( g_old, g_diffed );
+  }
+  //##### ADDED FOR TESTING PURPOSE #####
+
   GameState *GameStateClient::decompress(GameStateCompressed *a) {
+    //COUT(4) << "GameStateClient: uncompressing gamestate. id: " << a->id << ", baseid: " << a->base_id << ", normsize: " << a->normsize << ", compsize: " << a->compsize << std::endl;
     int normsize = a->normsize;
     int compsize = a->compsize;
@@ -173 +204 @@
       case Z_MEM_ERROR: COUT(1) << "not enough memory available" << std::endl; return NULL;
       case Z_BUF_ERROR: COUT(2) << "not enough memory available in the buffer" << std::endl; return NULL;
-      case Z_DATA_ERROR: COUT(2) << "data corrupted" << std::endl; return NULL;
+      case Z_DATA_ERROR: COUT(2) << "data corrupted (zlib)" << std::endl; return NULL;
     }
 
@@ -189 +220 @@
 
   GameState *GameStateClient::decode(GameState *a, GameStateCompressed *x) {
-    GameState *t = decompress(x);
-    return undiff(a, t);
+    GameState *t = decode(x);
+    gameStateList.push(t);
+    //return undiff(a, t);
+    return t;
   }
 
   GameState *GameStateClient::decode(GameStateCompressed *x) {
-    GameState *t = decompress(x);
+    //GameState *t = decompress(x);
+    GameState *t = new GameState;
+    t->base_id = x->base_id;
+    t->id = x->id;
+    t->diffed = x->diffed;
+    t->data = x->data;
+    t->size = x->normsize;
+    gameStateList.push(t);
     return t;
   }

code/branches/network2/src/network/GameStateClient.h

@@ -41 +41 @@
 #define _GameStateClient_H__
 
+#include <queue>
+
 #include "NetworkPrereqs.h"
 #include "core/CorePrereqs.h"
-#include "GameStateManager.h"
+#include "PacketTypes.h"
 
 namespace network
@@ -52 +54 @@
     GameStateClient();
     ~GameStateClient();
+    //#### ADDED FOR TESTING PURPOSE ####
+    GameState* testDecompress( GameStateCompressed* gc );
+    GameState* testUndiff( GameState* g_old, GameState* g_diffed );
+    //#### END TESTING PURPOSE ####
     bool pushGameState(GameStateCompressed *compstate);
   private:
@@ -61 +67 @@
     void removeObject(orxonox::Iterator<Synchronisable> &it);
 
-    GameState *reference;
+    GameState     *reference;
+    std::queue<GameState *> gameStateList;
   };
 

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

@@ -60 +60 @@
 
   void GameStateManager::update(){
+    cleanup();
     reference = getSnapshot(id);
     gameStateMap.insert(std::pair<int, GameState*>(id, reference));
@@ -66 +67 @@
     return;
   }
+  
+  
+  /**
+   * this function is used to keep the memory usage low
+   * it tries to delete all the unused gamestates
+   * 
+   * 
+   */
+  void GameStateManager::cleanup(){
+    std::map<int,int>::iterator it = gameStateUsed.begin();
+    while(it!=gameStateUsed.end()){
+      if( (*it).second <= 0 ){
+        free(gameStateMap[(*it).first]->data);
+        delete gameStateMap[(*it).first];
+        gameStateMap.erase((*it).first);
+        gameStateUsed.erase(it++);
+      }else  //as soon as we got a used gamestate break here because we could use newer gamestates in future
+        break;
+    }
+  }
 
   GameStateCompressed *GameStateManager::popGameState(int clientID) {
+    //why are we searching the same client's gamestate id as we searched in
+    //Server::sendGameState?
     int gID = head_->findClient(clientID)->getGamestateID();
-    COUT(4) << "popgamestate: sending gstate id: " << id << "diffed from: " << gID << std::endl;
-    if(gID!=GAMESTATEID_INITIAL){
+    COUT(4) << "G.St.Man: popgamestate: sending gstate_id: " << id << " diffed from: " << gID << " (not diffed yet)" << std::endl;
+    
+    //chose wheather the next gamestate is the first or not
+    if(gID != GAMESTATEID_INITIAL){
       GameState *client = gameStateMap[gID];
       GameState *server = reference;
@@ -90 +115 @@
   GameState *GameStateManager::getSnapshot(int id)
   {
+    //std::cout << "begin getSnapshot" << std::endl;
     //the size of the gamestate
     int totalsize=0;
@@ -102 +128 @@
     GameState *retval=new GameState; //return value
     retval->id=id++;
-    COUT(4) << "producing gamestate with id: " << retval->id << std::endl;
+    COUT(4) << "G.ST.Man: producing gamestate with id: " << retval->id << std::endl;
     // reserve a little memory and increase it later on
-    COUT(5) << "mallocing" << std::endl;
+    COUT(5) << "G.ST.Man: mallocing: " << memsize << std::endl;
     retval->data = (unsigned char*)malloc(memsize);
-    COUT(5) << "malloced" << std::endl;
+    COUT(5) << "G.ST.Man: malloced: " << memsize << std::endl;
 
     // offset of memory functions
@@ -112 +138 @@
     // go through all Synchronisables
     for(it = orxonox::ObjectList<Synchronisable>::start(); it; ++it){
+      //std::cout << "begin inner loop" << std::endl;
       //std::cout << "gamestatemanager: in for loop" << std::endl;
       //get size of the synchronisable
       tempsize=it->getSize();
-//       COUT(5) << "size of temp gamestate: " << tempsize << std::endl;
+      //COUT(5) << "size of temp gamestate: " << tempsize << std::endl;
       //COUT(2) << "size of synchronisable: " << tempsize << std::endl;
       // add place for data and 3 ints (length,classid,objectid)
       totalsize+=tempsize+3*sizeof(int);
       //std::cout << "totalsize: " << totalsize << std::endl;
+      //COUT(5) << "G.St.Man: current totalsize=" << totalsize << std::endl;
+      //COUT(5) << "G.St.Man: current it->classID=" << it->classID << " it->objectID=" << it->objectID << std::endl;
       // allocate additional space
-      if(totalsize+tempsize>memsize){
-        if(tempsize<1000){
+      if((totalsize+tempsize) > memsize){
+        COUT(5) << "G.St.Man: need additional memory" << std::endl;
+        if(tempsize < 1000){
           retval->data = (unsigned char *)realloc((void *)retval->data, totalsize+1000);
           memsize+=1000;
@@ -129 +159 @@
           memsize+=tempsize+1000;
         }
+        COUT(5) << "G.St.Man: additional space allocation finished" << std::endl;
       }
 
       // 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)=(unsigned char)sync.length;
-      *(retval->data+offset+sizeof(int))=(unsigned char)sync.objectID;
-      *(retval->data+offset+2*sizeof(int))=(unsigned char)sync.classID;
+      memcpy(retval->data+offset, (void *)&sync.length, sizeof(int));
+      //*(retval->data+offset)=sync.length;
+      memcpy(retval->data+offset+sizeof(int), (void *)&sync.objectID, sizeof(int));
+      //*(retval->data+offset+sizeof(int))=sync.objectID;
+      memcpy(retval->data+offset+2*sizeof(int), (void *)&sync.classID, sizeof(int));
+      //*(retval->data+offset+2*sizeof(int))=sync.classID;
       // increase data pointer
       offset+=tempsize+3*sizeof(int);
-    }
-    COUT(5) << "Gamestate size: " << totalsize << std::endl;
+      //std::cout << "end inner loop" << std::endl;
+    }
     retval->size=totalsize;
+    //#### bugfix
+    retval->diffed = false;
+    //std::cout << "end snapShot" << std::endl;
+    COUT(5) << "G.ST.Man: Gamestate size: " << totalsize << std::endl;
     return retval;
   }
 
+  //##### ADDED FOR TESTING PURPOSE #####
+  GameStateCompressed* GameStateManager::testCompress( GameState* g ) {
+    return compress_( g );
+  }
+
+  GameState* GameStateManager::testDiff( GameState* a, GameState* b ) {
+    return diff( a, b );
+  }
+  //##### END TESTING PURPOSE #####
+
   GameStateCompressed *GameStateManager::encode(GameState *a, GameState *b) {
+    COUT(5) << "G.St.Man: this will be a DIFFED gamestate" << std::endl;
     //GameState r = diff(a,b);
     //r.diffed = true;
     GameState *r = b;
     r->diffed = false;
-    return compress_(r);
+    //return compress_(r);
+    GameStateCompressed *g = new GameStateCompressed;
+    g->base_id = b->base_id;
+    g->id = b->id;
+    g->diffed = b->diffed;
+    g->data = b->data;
+    g->normsize = b->size;
+    g->compsize = b->size;
+    return g;
   }
 
   GameStateCompressed *GameStateManager::encode(GameState *a) {
+    COUT(5) << "G.St.Man: this will be a not diffed gamestate" << std::endl;
     a->diffed=false;
-    return compress_(a);
+    GameStateCompressed *g = new GameStateCompressed;
+    g->base_id = a->base_id;
+    g->id = a->id;
+    g->diffed = a->diffed;
+    g->data = a->data;
+    g->normsize = a->size;
+    g->compsize = a->size;
+    return g;
   }
 
@@ -189 +254 @@
     r->size = dest_length;
     r->diffed = true;
+    r->base_id = a->id;
     r->data = dp;
     return r;
@@ -194 +260 @@
 
   GameStateCompressed *GameStateManager::compress_(GameState *a) {
-    COUT(5) << "compressing gamestate" << std::endl;
+    //COUT(4) << "G.St.Man: compressing gamestate" << std::endl;
+
+    //COUT(4) << "G.St.Man: a: id: " << a->id << " base_id: " << a->base_id << " size: " << a->size << " diffed: " << a->diffed << std::endl;
     int size = a->size;
+
     uLongf buffer = (uLongf)((a->size + 12)*1.01)+1;
+    //COUT(4) << "size: " << size << ", buffer: " << buffer << std::endl;
     unsigned char* dest = (unsigned char*)malloc( buffer );
+    //COUT(4) << "dest: " << dest << std::endl;
     int retval;
     //std::cout << "before ziped " << buffer << std::endl;
     retval = compress( dest, &buffer, a->data, (uLong)size );
+    //COUT(4) << "bloablabla aft3er compress" << std::endl;
     //std::cout << "after ziped " << buffer << std::endl;
 
     switch ( retval ) {
-      case Z_OK: COUT(5) << "successfully compressed" << std::endl; break;
-      case Z_MEM_ERROR: COUT(1) << "not enough memory available in gamestate.compress" << std::endl;
+      case Z_OK: COUT(5) << "G.St.Man: compress: successfully compressed" << std::endl; break;
+      case Z_MEM_ERROR: COUT(1) << "G.St.Man: compress: not enough memory available in gamestate.compress" << std::endl; 
       return NULL;
-      case Z_BUF_ERROR: COUT(2) << "not enough memory available in the buffer in gamestate.compress" << std::endl;
+      case Z_BUF_ERROR: COUT(2) << "G.St.Man: compress: not enough memory available in the buffer in gamestate.compress" << std::endl;
       return NULL;
-      case Z_DATA_ERROR: COUT(2) << "decompress: data corrupted in gamestate.compress" << std::endl;
+      case Z_DATA_ERROR: COUT(2) << "G.St.Man: compress: data corrupted in gamestate.compress" << std::endl;
       return NULL;
     }
@@ -221 +293 @@
     compressedGamestate->data = dest;
     compressedGamestate->diffed = a->diffed;
-
+    compressedGamestate->base_id = a->base_id;
+    //COUT(5) << "G.St.Man: saved compressed data in GameStateCompressed:" << std::endl;
     return compressedGamestate;
   }

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

@@ -71 +71 @@
     GameStateManager(ClientInformation *head);
     ~GameStateManager();
+    //#### ADDED FOR TESTING PURPOSE ####
+    GameStateCompressed* testCompress( GameState* g );
+    GameState* testDiff( GameState* a, GameState* b );
+    //#### END TESTING PURPOSE ####
     void update();
     GameStateCompressed *popGameState(int clientID);
@@ -76 +80 @@
     int id;
   private:
+    void cleanup(); // "garbage handler"
     GameState *getSnapshot(int id);
     GameStateCompressed *encode(GameState *a, GameState *b);

code/branches/network2/src/network/PacketBuffer.cc

@@ -61 +61 @@
       last=first;
       last->next=NULL;
-      // change this!!!!!!!
+      // change this!!!!!!! 
       last->packet = ev->packet;
-      last->address = ev->peer->address;
+      //last->address = ev->peer->address;
     } else {
       //insert a new element at the bottom
@@ -72 +72 @@
       // save the packet to the new element
       last->packet = ev->packet;
-      last->address = ev->peer->address;
+      //last->address = ev->peer->address;
     }
-    return true;
+    // pseudo bugfix: added a return false statement for error handling
+    if ( last->packet == ev->packet ) return true;
+    return false;
   }
 
+  //returns the first element in the list without deleting it but
+  //moving first pointer to next element
   ENetPacket *PacketBuffer::pop() {
     boost::mutex::scoped_lock lock(networkPacketBufferMutex);

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

@@ -54 +54 @@
   {
     int client = clientId;
-    COUT(5) << "clientId: " << client << std::endl; //control cout, not important, just debugging info
+    COUT(5) << "PacketDecoder: clientId: " << client << std::endl; //control cout, not important, just debugging info
     int id = (int)*packet->data; //the first 4 bytes are always the enet packet id
-    COUT(5) << "packet id: " << id << std::endl;
-//     COUT(5) << "packet size inside packetdecoder: " << packet->dataLength << std::endl;
+    COUT(5) << "PacketDecoder: packet id: " << id << std::endl;
+    //COUT(5) << "packet size inside packetdecoder: " << packet->dataLength << std::endl;
+
+    if ( packet == NULL ) {
+      COUT(4) << "PacketDecoder: no packets->packetbuffer queue is empty" << std::endl;
+      return false;
+    }
     switch( id ) {
   case ACK:
@@ -95 +100 @@
 
 
-    COUT(5) << "got ack id: " << a->id << std::endl;
+    COUT(5) << "PacketDecoder: got ack id: " << a->id << std::endl;
     processAck( a, clientId ); //debug info
 
@@ -149 +154 @@
     currentState = new GameStateCompressed;
     if(currentState == NULL){
-      COUT(3) << "could not generate new GameStateCompressed" << std::endl;
+      COUT(3) << "PacketDecoder: could not generate new GameStateCompressed" << std::endl;
       return;
     }
@@ -159 +164 @@
     //currentState->id = *((int *)packet->data+sizeof(int));
     memcpy( (void*)&(currentState->id), (const void*)(packet->data+1*sizeof( int )), sizeof( int) );
-    COUT(5) << "decoder: received gs id: " << currentState->id << std::endl;
+    COUT(5) << "PacketDecoder: received gs id: " << currentState->id << std::endl;
 //     std::cout << "id: " << currentState->id << std::endl;
     //copy the size of the GameStateCompressed compressed data into the new GameStateCompressed struct, located at 3th
@@ -168 +173 @@
     //size of uncompressed data
     memcpy( (void*)&(currentState->normsize), (const void*)(packet->data+3*sizeof( int )), sizeof( int ) );
+    memcpy( (void*)&(currentState->base_id), (const void*)(packet->data+4*sizeof( int )), sizeof( int ) );
     //currentState->normsize = (int)*(data+3*sizeof(int));
 //     std::cout << "normsize. " << currentState->normsize << std::endl;
     //since the packetgenerator was changed, due to a new parameter, change this function too
-    memcpy( (void*)&(currentState->diffed), (const void*)(packet->data+4*sizeof(int)), sizeof(bool));
+    memcpy( (void*)&(currentState->diffed), (const void*)(packet->data+5*sizeof(int)), sizeof(bool));
     //currentState->diffed = (bool)*(data+4*sizeof(int));
 //     std::cout << "diffed: " << currentState->diffed << std::endl;
     //since data is not allocated, because it's just a pointer, allocate it with size of gamestatedatastream
     if(currentState->compsize==0)
-      COUT(2) << "compsize is 0" << std::endl;
+      COUT(2) << "PacketDecoder: compsize is 0" << std::endl;
     currentState->data = (unsigned char*)(malloc( currentState->compsize ));
     if(currentState->data==NULL)
-      COUT(2) << "Gamestatepacket-decoder: memory leak" << std::endl;
+      COUT(2) << "PacketDecoder: Gamestatepacket-decoder: memory leak" << std::endl;
     //copy the GameStateCompressed data
     //std::cout << "packet size (enet): " << packet->dataLength << std::endl;
@@ -199 +205 @@
     void *data  = (void *)cid->message;
     memcpy(data, (const void*)(packet->data+3*sizeof(int)), cid->length);
-    COUT(4) << "classid: " << cid->clid << ", name: " << cid->message << std::endl;
+    COUT(4) << "PacketDecoder: classid: " << cid->clid << ", name: " << cid->message << std::endl;
     enet_packet_destroy( packet );
     processClassid(cid);
@@ -214 +220 @@
   void PacketDecoder::processGamestate( GameStateCompressed *state )
   {
+    COUT(5) << "PacketDecoder: processing Gamestate" << std::endl;
+    //printGamestate( state );
   }
 

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

@@ -52 +52 @@
   ENetPacket* PacketGenerator::acknowledgement( int state, int reliable )
   {
-    COUT(4) << "generating new acknowledgement, id: " << state << std::endl;
+    COUT(4) << "PacketGenerator: generating new acknowledgement, id: " << state << std::endl;
     ack* ackreq = new ack;
     ackreq->id = ACK;
@@ -65 +65 @@
   ENetPacket* PacketGenerator::mousem( double x, double y, int reliable )
   {
-    COUT(4) << "generating new mouse" << std::endl;
+    COUT(4) << "PacketGenerator: generating new mouse" << std::endl;
     mouse* mousemove = new mouse;
     mousemove->id = MOUSE;
@@ -79 +79 @@
   ENetPacket* PacketGenerator::keystrike( char press, int reliable )
   {
-    COUT(4) << "generating new keyboard" << std::endl;
+    COUT(4) << "PacketGenerator: generating new keyboard" << std::endl;
     keyboard* key = new keyboard;
     key->id = KEYBOARD;
@@ -115 +115 @@
     memcpy( (void*)(data+2*sizeof(int)), (const void*)&(states->compsize), sizeof(int));
     memcpy( (void*)(data+3*sizeof(int)), (const void*)&(states->normsize), sizeof(int));
-    memcpy( (void*)(data+4*sizeof(int)), (const void*)&(states->diffed), sizeof(bool));
-    /*(int)*(data) = gid;
-    (int)*(data+sizeof(int)) = states->id;
-    //this is the compressed size of the GameStateCompressed data, place at 3th position of the enet datastream
-    (int)*(data+2*sizeof(int)) = states->compsize;
-    //this is the uncompressed size of GameStateCompressed data
-    (int)*(data+3*sizeof(int)) = states->normsize;
-    //since there is a new parameter inside GameStateCompressed, change this function to create packet
-    (bool)*(data+4*sizeof(int)) = states->diffed;*/
+    memcpy( (void*)(data+4*sizeof(int)), (const void*)&(states->base_id), sizeof(int));
+    memcpy( (void*)(data+5*sizeof(int)), (const void*)&(states->diffed), sizeof(bool));
     //place the GameStateCompressed data at the end of the enet datastream
-    memcpy( (void*)(data+4*sizeof( int ) + sizeof(bool)), (const void*)states->data, states->compsize );
+    memcpy( (void*)(data+5*sizeof( int ) + sizeof(bool)), (const void*)states->data, states->compsize );
     //create an enet packet with the generated bytestream
     ENetPacket *packet = enet_packet_create( data , totalLen, reliable );
@@ -135 +128 @@
   {
     unsigned char* data = (unsigned char *)malloc(3*sizeof(int)+classname.length()+1);
-    std::cout << "classid: " << classid << ", name: " << classname << std::endl;
+    std::cout << "PacketGenerator: classid: " << classid << ", name: " << classname << std::endl;
     *(int *)data = CLASSID;
     *((int *)data+1) = classname.length()+1;

code/branches/network2/src/network/PacketTypes.h

@@ -65 +65 @@
     int size;                       //!< total size of data
     // new ---- change functions
+    int base_id;                  // if gamestate is diffed this is the id of the old gamestate (base)
     bool diffed;
     unsigned char *data;            //!< pointer to data
@@ -80 +81 @@
     int normsize;                   //!< size of uncompressed data
     // new ----- change functions
+    int base_id;                  // if gamestate is diffed this is the id of the old gamestate (base)
     bool diffed;
     unsigned char *data;            //!< gamestate data

code/branches/network2/src/network/Server.cc

@@ -124 +124 @@
   bool Server::sendMSG(const char *msg) {
     ENetPacket *packet = packet_gen.chatMessage(msg);
-    std::cout <<"adding Packets" << std::endl;
+    COUT(4) <<"Server: adding Packets" << std::endl;
     connection->addPacketAll(packet);
     //std::cout <<"added packets" << std::endl;
     if (connection->sendPackets()){
-      std::cout << "Sucessfully" << std::endl;
+      COUT(4) << "Server: Sucessfully" << std::endl;
       return true;
     }
@@ -155 +155 @@
     while(!connection->queueEmpty()){
       //std::cout << "Client " << clientID << " sent: " << std::endl;
+      //clientID here is a reference to grab clientID from ClientInformation
       packet = connection->getPacket(clientID);
-      elaborate(packet, clientID);
+      //if statement to catch case that packetbuffer is empty
+      if( !elaborate(packet, clientID) ) 
+        COUT(4) << "Server: PacketBuffer empty" << std::endl;
     }
   }
@@ -165 +168 @@
   void Server::updateGamestate() {
     gamestates->update();
+    COUT(4) << "Server: one gamestate update complete, goig to sendGameState" << std::endl;
     //std::cout << "updated gamestate, sending it" << std::endl;
     //if(clients->getGamestateID()!=GAMESTATEID_INITIAL)
-      sendGameState();
+    sendGameState();
+    COUT(4) << "Server: one sendGameState turn complete, repeat in next tick" << std::endl;
     //std::cout << "sent gamestate" << std::endl;
   }
@@ -175 +180 @@
   */
   bool Server::sendGameState() {
-    COUT(5) << "starting sendGameState" << std::endl;
+    COUT(5) << "Server: starting function sendGameState" << std::endl;
     ClientInformation *temp = clients;
     bool added=false;
-    while(temp!=NULL){
+    while(temp != NULL){
       if(temp->head){
         temp=temp->next();
+        //think this works without continue
         continue;
       }
       if( !(temp->getSynched()) ){
-        COUT(5) << "not sending gamestate" << std::endl;
+        COUT(5) << "Server: not sending gamestate" << std::endl;
         temp=temp->next();
+        //think this works without continue
         continue;
       }
-      COUT(5) << "doing gamestate gamestate preparation" << std::endl;
-      int gid = temp->getGamestateID();
-      int cid = temp->getID();
-      COUT(5) << "server, got acked (gamestate) ID: " << gid << std::endl;
+      COUT(5) << "Server: doing gamestate gamestate preparation" << std::endl;
+      int gid = temp->getGamestateID(); //get gamestate id
+      int cid = temp->getID(); //get client id
+      COUT(5) << "Server: got acked (gamestate) ID from clientlist: " << gid << std::endl;
       GameStateCompressed *gs = gamestates->popGameState(cid);
       if(gs==NULL){
-        COUT(2) << "could not generate gamestate" << std::endl;
+        COUT(2) << "Server: could not generate gamestate (NULL from compress)" << std::endl;
         return false;
       }
       //std::cout << "adding gamestate" << std::endl;
-      connection->addPacket(packet_gen.gstate(gs), cid);
+      if ( !(connection->addPacket(packet_gen.gstate(gs), cid)) )
+        COUT(4) << "Server: packet with client id (cid): " << cid << " not sended" << std::endl; 
       //std::cout << "added gamestate" << std::endl;
       added=true;
       temp=temp->next();
     }
-    if(added)
+    if(added) {
+      //std::cout << "send gamestates from server.cc in sendGameState" << std::endl;
       return connection->sendPackets();
-    COUT(5) << "had no gamestates to send" << std::endl;
+    }
+    COUT(5) << "Server: had no gamestates to send" << std::endl;
     return false;
   }
 
   void Server::processAck( ack *data, int clientID) {
-    COUT(5) << "processing ack from client: " << clientID << "; ack-id: " << data->id << std::endl;
+    COUT(5) << "Server: processing ack from client: " << clientID << "; ack-id: " << data->id << std::endl;
     clients->findClient(clientID)->setGamestateID(data->a);
   }

code/branches/network2/src/network/Synchronisable.cc

@@ -57 +57 @@
     datasize=0;
     objectID=idCounter++;
+    syncList = new std::list<synchronisableVariable *>;
     //registerAllVariables();
   }
@@ -71 +72 @@
   void Synchronisable::registerVar(const void *var, int size, variableType t){
     // create temporary synch.Var struct
-    synchronisableVariable temp={size, var, t};
+    synchronisableVariable *temp = new synchronisableVariable;
+    temp->size = size;
+    temp->var = var;
+    temp->type = t;
+    COUT(5) << "Syncronisable::registering var with size: " << temp->size << " and type: " << temp->type << std::endl; 
     // increase datasize
     datasize+=sizeof(int)+size;
-    // push temp to syncList (at the bottom)
-    syncList.push_back(temp);
+    //std::cout << "push temp to syncList (at the bottom) " << datasize << std::endl;
+    COUT(5) << "Syncronisable::objectID: " << objectID << " this: " << this << " name: " << this->getIdentifier()->getName() << " networkID: " << this->getIdentifier()->getNetworkID() << std::endl;
+    syncList->push_back(temp);
   }
 
@@ -91 +97 @@
   //   int totalsize=0;
   //   //figure out size of data to be allocated
-  //   for(i=syncList.begin(); i!=syncList.end(); i++){
+  //   for(i=syncList->begin(); i!=syncList->end(); i++){
   //     // increase size (size of variable and size of size of variable ;)
   //     if(i->type == STRING)
@@ -107 +113 @@
   //   //CHANGED: REMOVED DECLARATION int n=0 FROM LOOP
   //   int n=0;
-  //   for(i=syncList.begin(); n<totalsize && i!=syncList.end(); i++){
+  //   for(i=syncList->begin(); n<totalsize && i!=syncList->end(); i++){
   //     std::memcpy(retVal.data+n, (const void*)(i->size), sizeof(int));
   //     n+=sizeof(int);
@@ -134 +140 @@
   */
   syncData Synchronisable::getData(unsigned char *mem){
-    std::list<synchronisableVariable>::iterator i;
+    //std::cout << "inside getData" << std::endl;
+    std::list<synchronisableVariable *>::iterator i;
     syncData retVal;
     retVal.objectID=this->objectID;
@@ -141 +148 @@
     retVal.data=mem;
     // copy to location
-    int n=0;
-    for(i=syncList.begin(); n<datasize && i!=syncList.end(); ++i){
-      //COUT(2) << "size of variable: " << i->size << std::endl;
+    int n=0; //offset
+    for(i=syncList->begin(); n<datasize && i!=syncList->end(); ++i){
       //(std::memcpy(retVal.data+n, (const void*)(&(i->size)), sizeof(int));
-      memcpy( (void *)(retVal.data+n), (const void*)&(i->size), sizeof(int) );
+      memcpy( (void *)(retVal.data+n), (const void *)&((*i)->size), sizeof(int) );
       n+=sizeof(int);
-      switch(i->type){
+      switch((*i)->type){
       case DATA:
-        std::memcpy( (void *)(retVal.data+n), (const void*)(i->var), i->size);
-        n+=i->size;
+        std::memcpy( (void *)(retVal.data+n), (const void*)((*i)->var), (*i)->size);
+        n+=(*i)->size;
         break;
       case STRING:
-        std::memcpy( retVal.data+n, (const void*)( ( (std::string *) i->var)->c_str()), ( (std::string *)i->var )->length()+1);
-        n+=((std::string *) i->var)->length()+1;
+        std::memcpy( retVal.data+n, (const void*)( ( (std::string *) (*i)->var)->c_str()), (*i)->size);
+        n+=(*i)->size;
         break;
       }
@@ -168 +174 @@
   bool Synchronisable::updateData(syncData vars){
     unsigned char *data=vars.data;
-    std::list<synchronisableVariable>::iterator i;
-    for(i=syncList.begin(); i!=syncList.end(); i++){
-      if((int)*data==i->size || i->type==STRING){
-        switch(i->type){
-      case DATA:
-        data+=sizeof(int);
-        memcpy((void*)i->var, data, i->size);
-        data+=i->size;
-        break;
-      case STRING:
-        i->size = (int)*data;
-        data+=sizeof(int);
-        *((std::string *)i->var) = std::string((const char*)data);
-        data += i->size;
-        break;
+    std::list<synchronisableVariable *>::iterator i;
+    if(syncList->empty()){
+      COUT(4) << "Synchronisable::updateData syncList is empty" << std::endl;
+      return false;
+    }
+    COUT(5) << "Synchronisable: objectID " << objectID << ", classID " << classID << " synchronising data" << std::endl;
+    for(i=syncList->begin(); i!=syncList->end(); i++){
+      COUT(5) << "element size: " << (*i)->size << " type: " << (*i)->type << std::endl;
+      if(*(int *)data==(*i)->size || (*i)->type==STRING){
+        switch((*i)->type){
+        case DATA:
+          data+=sizeof(int);
+          memcpy((void*)(*i)->var, data, (*i)->size);
+          data+=(*i)->size;
+          break;
+        case STRING:
+          (*i)->size = *(int *)data;
+          data+=sizeof(int);
+          *((std::string *)((*i)->var)) = std::string((const char*)data);
+          data += (*i)->size;
+          break;
         }
       } else
@@ -196 +208 @@
   int Synchronisable::getSize(){
     int tsize=0;
-    std::list<synchronisableVariable>::iterator i;
-    for(i=syncList.begin(); i!=syncList.end(); i++){
-      switch(i->type){
-    case DATA:
-      tsize+=sizeof(int);
-      tsize+=i->size;
-      break;
-    case STRING:
-      tsize+=sizeof(int);
-      tsize+=((std::string *)i->var)->length()+1;
-      break;
+    std::list<synchronisableVariable *>::iterator i;
+    for(i=syncList->begin(); i!=syncList->end(); i++){
+      switch((*i)->type){
+      case DATA:
+        tsize+=sizeof(int);
+        tsize+=(*i)->size;
+        break;
+      case STRING:
+        tsize+=sizeof(int);
+        (*i)->size=((std::string *)(*i)->var)->length()+1;
+        tsize+=(*i)->size;
+        break;
       }
     }

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

@@ -75 +75 @@
   public:
 
-      virtual ~Synchronisable();
+    virtual ~Synchronisable();
     int objectID;
     int classID;
@@ -91 +91 @@
     /*  bool removeObject(Iterator<Synchronisable> it);*/
 
-    std::list<SYNCVAR> syncList;
+    std::list<synchronisableVariable *> *syncList;
     int datasize;
   };

code/branches/network2/src/orxonox/Orxonox.cc

@@ -305 +305 @@
     hudOverlay->show();
 
-    client_g->establishConnection();
+    if( !client_g->establishConnection() )
+      COUT(1) <<"CLIENT COULD NOT ESTABLISH CONNECTION" << std::endl;
     client_g->tick(0);
 

code/branches/network2/src/orxonox/objects/Ambient.cc

@@ -57 +57 @@
         RegisterObject(Ambient);
         Ambient::instance_s = this;
+        registerAllVariables();
     }
 
@@ -63 +64 @@
     }
 
+    bool Ambient::create(){
+      Orxonox::getSingleton()->getSceneManager()->setAmbientLight(ambientLight_);
+      return true;
+    }
+    
+    void Ambient::registerAllVariables(){
+      registerVar(&ambientLight_, sizeof(ColourValue), network::DATA);
+      
+    }
+    
     void Ambient::loadParams(TiXmlElement* xmlElem)
     {
@@ -83 +94 @@
    {
         GraphicsEngine::getSingleton().getSceneManager()->setAmbientLight(colour);
+      ambientLight_=colour;     
    }
 
@@ -96 +108 @@
 
         XMLPortParamLoadOnly(Ambient, "colourvalue", setAmbientLight, xmlelement, mode);
+        create();
     }
 }

code/branches/network2/src/orxonox/objects/Ambient.h

@@ -34 +34 @@
 #include "util/Math.h"
 #include "core/BaseObject.h"
+#include "network/Synchronisable.h"
 
 namespace orxonox
 {
-    class _OrxonoxExport Ambient : public BaseObject
+    class _OrxonoxExport Ambient : public BaseObject, network::Synchronisable
     {
         public:
@@ -46 +47 @@
             virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);
             void setAmbientLight(const ColourValue& colour);
+            bool create();
+            void registerAllVariables();
 
             static void setAmbientLightTest(const ColourValue& colour)
@@ -52 +55 @@
         private:
             static Ambient* instance_s;
+            ColourValue ambientLight_;
 
     };

code/branches/network2/src/orxonox/objects/Model.cc

@@ -82 +82 @@
 
     bool Model::create(){
-      WorldEntity::create();
+      if(!WorldEntity::create())
+        return false;
       if ((this->meshSrc_ != "") && (this->meshSrc_.size() > 0))
       {
         this->mesh_.setMesh(meshSrc_);
         this->attachObject(this->mesh_.getEntity());
-        COUT(4) << "Loader: Created model" << std::endl;
+        COUT(4) << "Loader (Model.cc): Created model" << std::endl;
       }
       return true;
@@ -93 +94 @@
 
     void Model::registerAllVariables(){
-      WorldEntity::registerAllVariables();
+//       WorldEntity::registerAllVariables();
+      COUT(5) << "Model.cc:registering new meshsrc with size: " << meshSrc_.length()+1 << " this: " << this << std::endl;
       registerVar(&meshSrc_, meshSrc_.length() + 1, network::STRING);
     }

code/branches/network2/src/orxonox/objects/NPC.cc

@@ -40 +40 @@
     RegisterObject(NPC);
     movable_ = true;
+    registerAllVariables();
   }
 
@@ -59 +60 @@
     this->translate(location);
     movable_ = movable;
+  }
+  
+  void NPC::registerAllVariables(){
+    Model::registerAllVariables();
+    registerVar(&movable_, sizeof(movable_), network::DATA);
+  }
+  
+  bool NPC::create(){
+    Model::create();
+    return true;
   }
 

code/branches/network2/src/orxonox/objects/NPC.h

@@ -52 +52 @@
       void update();
       void setValues(Vector3 location, Vector3 speed, Vector3 acceleration, bool movable);
+      void registerAllVariables();
+      bool create();
 
     private:

code/branches/network2/src/orxonox/objects/Skybox.cc

@@ -47 +47 @@
     {
         RegisterObject(Skybox);
+        registerAllVariables();
     }
 
@@ -57 +58 @@
         if (xmlElem->Attribute("src"))
         {
-                std::string skyboxSrc = xmlElem->Attribute("src");
-                this->setSkybox(skyboxSrc);
+                skyboxSrc_ = xmlElem->Attribute("src");
+        this->create();
 
-                COUT(4) << "Loader: Set skybox: "<< skyboxSrc << std::endl << std::endl;
+                COUT(4) << "Loader: Set skybox: "<< skyboxSrc_ << std::endl << std::endl;
         }
    }
@@ -69 +70 @@
    }
 
+   void Skybox::setSkyboxSrc(std::string src){
+     skyboxSrc_ = src;
+   }
+   
     /**
         @brief XML loading and saving.
@@ -80 +85 @@
 
         XMLPortParamLoadOnly(Skybox, "src", setSkybox, xmlelement, mode);
+        XMLPortParamLoadOnly(Skybox, "src", setSkyboxSrc, xmlelement, loading);
+        create();
     }
+    
+    bool Skybox::create(){
+      this->setSkybox(skyboxSrc_);
+      return true;
+    }
+    
+    void Skybox::registerAllVariables(){
+      registerVar(&skyboxSrc_, skyboxSrc_.length()+1 ,network::STRING);
+    }
+    
 }

code/branches/network2/src/orxonox/objects/Skybox.h

@@ -33 +33 @@
 
 #include "core/BaseObject.h"
+#include "network/Synchronisable.h"
 
 namespace orxonox
 {
-    class _OrxonoxExport Skybox : public BaseObject
+    class _OrxonoxExport Skybox : public BaseObject, public network::Synchronisable
     {
         public:
@@ -45 +46 @@
             virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);
             void setSkybox(const std::string& skyboxname);
+            
+            bool create();
+            void registerAllVariables();
+            void setSkyboxSrc(std::string src);
 
         private:
+            std::string skyboxSrc_;
 
 

code/branches/network2/src/orxonox/objects/WorldEntity.cc

@@ -72 +72 @@
         }
     }
+    
 
     WorldEntity::~WorldEntity()
@@ -162 +163 @@
 */
     }
+    
 
     void WorldEntity::setYawPitchRoll(const Degree& yaw, const Degree& pitch, const Degree& roll)
@@ -188 +190 @@
 
         XMLPortObject(WorldEntity, WorldEntity, "attached", attachWorldEntity, getAttachedWorldEntity, xmlelement, mode, false, true);
+        
+        //create();
     }