Changeset 1232

Timestamp:

May 5, 2008, 1:19:22 AM (17 years ago)

Author:

scheusso

Message:

a lot of changes in order to make it possible to have mulpiple clients with each one a new ship
camera changes
object changes
synchronisable: backsyncronisation should be possible now
gamestatemanager/gamestateclient: functions for backsyncronisation
some changes in order to get the input system (the old one) on the client working
TODO something with the camera position is wrong at the moment (clientside)

Location:

code/branches/network3/src

Files:

• network/Client.cc (modified) (4 diffs)
• network/Client.h (modified) (2 diffs)
• network/ClientInformation.h (modified) (2 diffs)
• network/ConnectionManager.cc (modified) (5 diffs)
• network/ConnectionManager.h (modified) (4 diffs)
• network/GameStateClient.cc (modified) (7 diffs)
• network/GameStateClient.h (modified) (3 diffs)
• network/GameStateManager.cc (modified) (7 diffs)
• network/GameStateManager.h (modified) (2 diffs)
• network/NetworkPrereqs.h (modified) (1 diff)
• network/PacketDecoder.cc (modified) (7 diffs)
• network/PacketGenerator.cc (modified) (5 diffs)
• network/PacketManager.h (modified) (5 diffs)
• network/PacketTypes.h (modified) (4 diffs)
• network/Server.cc (modified) (1 diff)
• network/Server.h (modified) (1 diff)
• network/Synchronisable.cc (modified) (7 diffs)
• network/Synchronisable.h (modified) (4 diffs)
• orxonox/Orxonox.cc (modified) (2 diffs)
• orxonox/objects/Camera.cc (modified) (2 diffs)
• orxonox/objects/Model.cc (modified) (1 diff)
• orxonox/objects/SpaceShip.cc (modified) (10 diffs)
• orxonox/objects/SpaceShip.h (modified) (2 diffs)
• orxonox/objects/WorldEntity.cc (modified) (2 diffs)

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

@@ -40 +40 @@
 
 #include "Client.h"
+#include "Synchronisable.h"
 #include "core/CoreIncludes.h"
 
@@ -47 +48 @@
   
   Client* Client::createSingleton(){
-    if(!_sClient)
+    if(!_sClient){
       _sClient = new Client();
+    }
     return _sClient;
   }
@@ -112 +114 @@
   */
   bool Client::establishConnection(){
+    Synchronisable::setClient(true);
     isConnected=client_connection.createConnection();
+    /*if(isConnected){
+      COUT(2) << "sending connectrequest" << std::endl;
+      client_connection.addPacket(pck_gen.generateConnectRequest());
+      client_connection.sendPackets();
+    }else
+      COUT(2) << "could not create connection" << std::endl;*/
     return isConnected;
   }
@@ -249 +258 @@
     COUT(0) << "Server: " << data->message << std::endl;
   }
+  
+  bool Client::processWelcome( welcome *w ){
+    COUT(4) << "processing welcome message" << std::endl;
+    clientID_ = w->clientID;
+    shipID_ = w->shipID;
+    
+  }
 
 }

code/branches/network3/src/network/Client.h

@@ -83 +83 @@
 
     bool sendPackets();
+    
+    int getShipID(){return shipID_;}
+    int getClientID(){return clientID_;}
 
     void tick(float time);
@@ -103 +106 @@
     void processClassid(classid *clid);
     void processChat( chat *data);
+    bool processWelcome( welcome *w );
+    int clientID_;     // this is the id the server gave to us
+    int shipID_;
   };
 

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

@@ -67 +67 @@
     ClientInformation *insertBefore(ClientInformation *ins);
     ClientInformation *insertBack(ClientInformation *ins);
+    
+    // set functions
     void setID(int clientID);
     void setPeer(ENetPeer *peer);
     void setGamestateID(int id);
+    inline void setShipID(int id){ShipID_=id;}
+    
+    // get functions
+    inline int getShipID(){return ShipID_;}
     int getID();
+    int getGamestateID();
     ENetPeer *getPeer();
-    int getGamestateID();
+    
+    
     bool removeClient(int clientID);
     bool removeClient(ENetPeer *peer);
@@ -92 +100 @@
     int clientID_;
     int gamestateID_;
+    int ShipID_;   // this is the unique objectID
     bool synched_;
   };

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

@@ -44 +44 @@
 
 #include "core/CoreIncludes.h"
+#include "core/BaseObject.h"
+#include "util/Math.h"
+#include "objects/SpaceShip.h"
 #include "ClientInformation.h"
 #include "ConnectionManager.h"
+#include "Synchronisable.h"
 
 namespace std
@@ -179 +183 @@
         case ENET_EVENT_TYPE_CONNECT:
           addClient(&event);
+          //this is a workaround to ensure thread safety
+          if(!addFakeConnectRequest(&event))
+            COUT(3) << "Problem pushing fakeconnectRequest to queue" << std::endl;
           COUT(5) << "Con.Man: connection event has occured" << std::endl;
           break;
@@ -237 +244 @@
   }
 
-  //bool ConnectionManager::clientDisconnect(ENetPeer *peer) {
-  //  return clientDisconnect(*peer);
-  //}
-
   bool ConnectionManager::clientDisconnect(ENetPeer *peer) {
     COUT(4) << "removing client from list" << std::endl;
@@ -260 +263 @@
     temp->setPeer(event->peer);
     COUT(4) << "Con.Man: added client id: " << temp->getID() << std::endl;
-    syncClassid(temp->getID());
-    temp->setSynched(true);
     return true;
   }
@@ -298 +299 @@
   }
 
-
-
-  void ConnectionManager::addClientsObjectID( int clientID, int objectID ) {
-    COUT(4) << "ship of client: " << clientID << ": " << objectID << " mapped" << std::endl;
-    clientsShip.insert( std::make_pair( clientID, objectID ) );
-  }
+  bool ConnectionManager::createClient(int clientID){
+    ClientInformation *temp = head_->findClient(clientID);
+    COUT(4) << "Con.Man: creating client id: " << temp->getID() << std::endl;
+    syncClassid(temp->getID());
+    COUT(4) << "creating spaceship for clientid: " << temp->getID() << std::endl;
+    // TODO: this is only a hack, untill we have a possibility to define default player-join actions
+    createShip(temp);
+    COUT(4) << "created spaceship" << std::endl;
+    temp->setSynched(true);
+    COUT(4) << "sending welcome" << std::endl;
+    sendWelcome(temp->getID(), temp->getShipID(), true);
+    return true;
+  }
+  
+  bool ConnectionManager::createShip(ClientInformation *client){
+    orxonox::Identifier* id = ID("SpaceShip");
+    if(!id){
+      COUT(4) << "We could not create the SpaceShip for client: " << client->getID() << std::endl;
+      return false;
+    }
+    orxonox::SpaceShip *no = dynamic_cast<orxonox::SpaceShip *>(id->fabricate());
+    no->setPosition(orxonox::Vector3(0,80,0));
+    no->setScale(10);
+    no->setYawPitchRoll(orxonox::Degree(-90),orxonox::Degree(-90),orxonox::Degree(0));
+    no->setMesh("assf3.mesh");
+    no->setMaxSpeed(500);
+    no->setMaxSideAndBackSpeed(50);
+    no->setMaxRotation(1.0);
+    no->setTransAcc(200);
+    no->setRotAcc(3.0);
+    no->setTransDamp(75);
+    no->setRotDamp(1.0);
+    no->setCamera("cam_"+client->getID());
+    no->create();
+    
+    client->setShipID(no->objectID);
+    return true;
+  }
+  
+  bool ConnectionManager::sendWelcome(int clientID, int shipID, bool allowed){
+    addPacket(packet_gen.generateWelcome(clientID, shipID, allowed),clientID);
+    sendPackets();
+  }
+  
+  bool ConnectionManager::addFakeConnectRequest(ENetEvent *ev){
+    ENetEvent event;
+    event.peer=ev->peer;
+    event.packet = packet_gen.generateConnectRequest();
+    return buffer.push(&event);
+  }
+  
+  
+//   int ConnectionManager::getNumberOfClients() {
+//     
+//     return clientsShip.size();
+//   }
+  
+  /*void ConnectionManager::addClientsObjectID( int clientID, int objectID ) {
+  COUT(4) << "ship of client: " << clientID << ": " << objectID << " mapped" << std::endl;
+  clientsShip.insert( std::make_pair( clientID, objectID ) );
+}
 
   int ConnectionManager::getClientsShipID( int clientID ) {
-    return clientsShip[clientID];
-  }
+  return clientsShip[clientID];
+}
 
   int ConnectionManager::getObjectsClientID( int objectID ) {
-    std::map<int, int>::iterator iter;
-    for( iter = clientsShip.begin(); iter != clientsShip.end(); iter++ ) {
-      if( iter->second == objectID ) return iter->first;
-    }
-    return -99;
-  }
+  std::map<int, int>::iterator iter;
+  for( iter = clientsShip.begin(); iter != clientsShip.end(); iter++ ) {
+  if( iter->second == objectID ) return iter->first;
+}
+  return -99;
+}
 
   void ConnectionManager::deleteClientIDReg( int clientID ) {
-    clientsShip.erase( clientID );
-  }
+  clientsShip.erase( clientID );
+}
 
   void ConnectionManager::deleteObjectIDReg( int objectID ) {
-    std::map<int, int>::iterator iter = clientsShip.begin();
-    for( iter = clientsShip.begin(); iter != clientsShip.end(); iter++ ) {
-      if( iter->second == objectID ) break;
-    }
-    clientsShip.erase( iter->first );
-  }
-  int ConnectionManager::getNumberOfClients() {
-    return clientsShip.size();
-  }
-}
+  std::map<int, int>::iterator iter = clientsShip.begin();
+  for( iter = clientsShip.begin(); iter != clientsShip.end(); iter++ ) {
+  if( iter->second == objectID ) break;
+}
+  clientsShip.erase( iter->first );
+}*/
+}

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

@@ -71 +71 @@
   class ConnectionManager{
   public:
+    ConnectionManager();
     ConnectionManager(ClientInformation *head);
     ConnectionManager(int port, const char *address, ClientInformation *head);
@@ -84 +85 @@
     bool sendPackets(ENetEvent *event);
     bool sendPackets();
+    bool createClient(int clientID);
 
-    //##### 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);
-    //bool clientDisconnect(ENetPeer peer);
     bool processData(ENetEvent *event);
     bool addClient(ENetEvent *event);
@@ -117 +97 @@
     void syncClassid(int clientID);
     ENetPeer *getClientPeer(int clientID);
+    bool createShip(ClientInformation *client);
+    bool sendWelcome(int clientID, int shipID, bool allowed);
+    bool addFakeConnectRequest(ENetEvent *ev);
     PacketBuffer buffer;
     PacketGenerator packet_gen;
@@ -126 +109 @@
     ClientInformation *head_;
 
+    
+//     int getNumberOfClients();
     //functions to map what object every clients uses
-    std::map<int, int> clientsShip;
+    /*std::map<int, int> clientsShip;
     void addClientsObjectID( int clientID, int objectID );
     int getClientsShipID( int clientID );
     int getObjectsClientID( int objectID );
     void deleteClientIDReg( int clientID );
-    void deleteObjectIDReg( int objectID );
-    int getNumberOfClients();
+    void deleteObjectIDReg( int objectID );*/
   };
 

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

@@ -86 +86 @@
     return false;
   }
+  
+  GameStateCompressed *GameStateClient::popPartialGameState(){
+    GameState *gs = getPartialSnapshot();
+    return compress_(gs);
+  }
+  
 
   /**
@@ -137 +143 @@
           }
           Synchronisable *no = dynamic_cast<Synchronisable *>(id->fabricate());
-          COUT(4) << "loadsnapshort: classid: " << sync.classID << " objectID: " << sync.objectID << " length: " << sync.length << std::endl;
+          COUT(4) << "loadsnapshot: classid: " << sync.classID << " objectID: " << sync.objectID << " length: " << sync.length << std::endl;
           no->objectID=sync.objectID;
           no->classID=sync.classID;
-          it=orxonox::ObjectList<Synchronisable>::end();
           // update data and create object/entity...
           if( !no->updateData(sync) )
@@ -146 +151 @@
           if( !no->create() )
             COUT(1) << "We couldn't manifest (create() ) the object: " << sync.objectID << std::endl;
+          it=orxonox::ObjectList<Synchronisable>::end();
         }
       } else {
@@ -159 +165 @@
   }
 
+  GameState *GameStateClient::getPartialSnapshot(){
+    //std::cout << "begin getSnapshot" << std::endl;
+    //the size of the gamestate
+    int totalsize=0;
+    int memsize=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=new GameState; //return value
+    retval->id=reference->id;
+    retval->diffed=false;
+    retval->complete=false;
+    COUT(4) << "G.ST.Client: producing partial gamestate with id: " << retval->id << std::endl;
+    // offset of memory functions
+    int offset=0, size=0;
+    // get total size of gamestate
+    for(it = orxonox::ObjectList<Synchronisable>::start(); it; ++it){
+      if(!it->getBacksync())
+        continue;
+      size+=it->getSize(); // size of the actual data of the synchronisable
+      size+=3*sizeof(int); // size of datasize, classID and objectID
+    }
+    //retval->data = (unsigned char*)malloc(size);
+    retval->data = new unsigned char[size];
+    if(!retval->data){
+      COUT(2) << "GameStateClient: could not allocate memory" << std::endl;
+      return NULL;
+    }
+    memsize=size;
+    // go through all Synchronisables
+    for(it = orxonox::ObjectList<Synchronisable>::start(); it; ++it){
+      if(!it->getBacksync())
+        continue;
+      //get size of the synchronisable
+      tempsize=it->getSize();
+      // add place for data and 3 ints (length,classid,objectid)
+      totalsize+=tempsize+3*sizeof(int);
+      // allocate+tempsize additional space
+      if(totalsize > size){
+        COUT(3) << "G.St.Cl: need additional memory" << 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));
+      memcpy(retval->data+offset, (void *)&(sync.length), sizeof(int));
+      memcpy(retval->data+offset+sizeof(int), (void *)&(sync.objectID), sizeof(int));
+      memcpy(retval->data+offset+2*sizeof(int), (void *)&(sync.classID), sizeof(int));
+      // increase data pointer
+      offset+=tempsize+3*sizeof(int);
+    }
+    retval->size=totalsize;
+    COUT(5) << "G.ST.Cl: Gamestate size: " << totalsize << std::endl;
+    COUT(5) << "G.ST.Cl: 'estimated' Gamestate size: " << size << std::endl;
+    return retval;
+  }
+  
+  
   GameState *GameStateClient::undiff(GameState *old, GameState *diff) {
+    if(!old || !diff)
+      return NULL;
     unsigned char *ap = old->data, *bp = diff->data;
     int of=0; // pointers offset
@@ -195 +264 @@
     r->diffed = false;
     r->data = dp;
+    r->complete = true;
     return r;
   }
 
-  //##### 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 #####
-
+
+
+  GameStateCompressed *GameStateClient::compress_(GameState *a) {
+    if(!a)
+      return NULL;
+    int size = a->size;
+
+    uLongf buffer = (uLongf)((a->size + 12)*1.01)+1;
+    unsigned char *dest = new unsigned char[buffer];
+    int retval;
+    retval = compress( dest, &buffer, a->data, (uLong)size );
+
+    switch ( retval ) {
+      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) << "G.St.Man: compress: not enough memory available in the buffer in gamestate.compress" << std::endl;
+      return NULL;
+      case Z_DATA_ERROR: COUT(2) << "G.St.Man: compress: data corrupted in gamestate.compress" << std::endl;
+      return NULL;
+    }
+
+    GameStateCompressed *compressedGamestate = new GameStateCompressed;
+    compressedGamestate->compsize = buffer;
+    compressedGamestate->normsize = size;
+    compressedGamestate->id = a->id;
+    compressedGamestate->data = dest;
+    compressedGamestate->diffed = a->diffed;
+    compressedGamestate->complete = a->complete;
+    compressedGamestate->base_id = a->base_id;
+    delete[] a->data;
+    delete a;
+    return compressedGamestate;
+  }
+  
+  
   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;
@@ -238 +334 @@
     gamestate->base_id = a->base_id;
     gamestate->diffed = a->diffed;
+    gamestate->complete = a->complete;
 
     delete[] a->data; //delete compressed data
@@ -286 +383 @@
   }
   
+  
+    //##### 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 #####
+  
+  
 }
+

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

@@ -42 +42 @@
 
 #include <map>
-
+// 
 #include "NetworkPrereqs.h"
 #include "core/CorePrereqs.h"
 #include "PacketTypes.h"
+
 
 namespace network
@@ -54 +55 @@
     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);
+    GameStateCompressed *popPartialGameState();
   private:
     bool loadSnapshot(GameState *state);
+    GameState *getPartialSnapshot();
     void cleanup();
     GameState *undiff(GameState *old, GameState *diff);
+    GameStateCompressed *compress_(GameState *a);
     GameState *decompress(GameStateCompressed *a);
     GameState *decode(GameState *old, GameStateCompressed *diff);
@@ -72 +73 @@
     int           last_diff_;
     std::map<int, GameState *> gameStateMap;
+    
+    
+    
+    
+  public:
+    //#### ADDED FOR TESTING PURPOSE ####
+    GameState* testDecompress( GameStateCompressed* gc );
+    GameState* testUndiff( GameState* g_old, GameState* g_diffed );
+    //#### END TESTING PURPOSE ####
   };
 

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

@@ -46 +46 @@
 
 #include "core/CoreIncludes.h"
+#include "core/BaseObject.h"
 #include "ClientInformation.h"
 #include "Synchronisable.h"
@@ -122 +123 @@
     }
   }
+  
+  bool GameStateManager::pushGameState( GameStateCompressed *gs, int clientID ){
+    GameState *ugs = decompress(gs);
+    return loadPartialSnapshot(ugs, clientID);
+    
+  }
 
   /**
@@ -188 +195 @@
     //#### bugfix
     retval->diffed = false;
+    retval->complete = true;
     //std::cout << "end snapShot" << std::endl;
     COUT(5) << "G.ST.Man: Gamestate size: " << totalsize << std::endl;
@@ -194 +202 @@
   }
 
+  bool GameStateManager::loadPartialSnapshot(GameState *state, int clientID){
+    unsigned char *data=state->data;
+    COUT(4) << "loadSnapshot: loading gs: " << state->id << std::endl;
+    // 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;
+
+      while(it && it->objectID!=sync.objectID)
+        ++it;
+
+
+      if(!it){
+        // the object does not exist yet
+        //COUT(4) << "loadSnapshot:\tclassid: " << sync.classID << ", name: " << ID((unsigned int) sync.classID)->getName() << std::endl;
+        orxonox::Identifier* id = ID((unsigned int)sync.classID);
+        if(!id){
+          COUT(4) << "We could not identify a new object; classid: " << sync.classID << std::endl;
+          continue;
+        }
+        Synchronisable *no = dynamic_cast<Synchronisable *>(id->fabricate());
+        COUT(4) << "loadpartialsnapshot (generating new object): classid: " << sync.classID << " objectID: " << sync.objectID << " length: " << sync.length << std::endl;
+        no->objectID=sync.objectID;
+        no->classID=sync.classID;
+        it=orxonox::ObjectList<Synchronisable>::end();
+        // update data and create object/entity...
+        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{
+        // we have our object
+        if(checkAccess(clientID, sync.objectID)){
+          if(! it->updateData(sync))
+            COUT(1) << "We couldn't update objectID: " \
+              << sync.objectID << "; classID: " << sync.classID << std::endl;
+        }else
+          COUT(4) << "loadPartialSnapshot: no access to change objectID: " << sync.objectID << std::endl;
+      }
+      ++it;
+    }
+
+    return true;
+  }
+  
+  
   //##### ADDED FOR TESTING PURPOSE #####
   GameStateCompressed* GameStateManager::testCompress( GameState* g ) {
@@ -269 +333 @@
     r->base_id = a->id;
     r->data = dp;
+    r->complete = true;
     return r;
   }
@@ -307 +372 @@
     compressedGamestate->data = dest;
     compressedGamestate->diffed = a->diffed;
+    compressedGamestate->complete = a->complete;
     compressedGamestate->base_id = a->base_id;
     //COUT(5) << "G.St.Man: saved compressed data in GameStateCompressed:" << std::endl;
     return compressedGamestate;
   }
+  
+  GameState *GameStateManager::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;
+    int bufsize;
+    if(normsize < compsize)
+      bufsize = compsize;
+    else
+      bufsize = normsize;
+//     unsigned char* dest = (unsigned char*)malloc( bufsize );
+    unsigned char *dest = new unsigned char[bufsize];
+    int retval;
+    uLongf length=normsize;
+    //std::cout << "gamestateclient" << std::endl;
+    //std::cout << "normsize " << a.normsize << " compsize " << a.compsize << " " << bufsize << std::endl;
+    retval = uncompress( dest, &length, a->data, (uLong)compsize );
+    //std::cout << "length " << length << std::endl;
+    switch ( retval ) {
+      case Z_OK: COUT(4) << "successfully decompressed" << std::endl; break;
+      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 (zlib)" << std::endl; return NULL;
+    }
+
+    GameState *gamestate = new GameState;
+    gamestate->id = a->id;
+    gamestate->size = normsize;
+    gamestate->data = dest;
+    gamestate->base_id = a->base_id;
+    gamestate->diffed = a->diffed;
+    gamestate->complete = a->complete;
+
+    delete[] a->data; //delete compressed data
+    delete a; //we do not need the old (struct) gamestate anymore
+
+    return gamestate;
+  }
+  
 
   void GameStateManager::ackGameState(int clientID, int gamestateID) {
@@ -336 +441 @@
     COUT(4) << std::endl;
   }
+  
+  bool GameStateManager::checkAccess(int clientID, int objectID){
+    // currently we only check, wheter the object is the clients spaceship
+    return head_->findClient(objectID)->getShipID()==objectID;
+  }
 
 }

code/branches/network3/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);
+    bool pushGameState(GameStateCompressed *gs, int clientID);
     void ackGameState(int clientID, int gamestateID);
   private:
     void cleanup(); // "garbage handler"
     GameState *getSnapshot();
+    bool loadPartialSnapshot(GameState *state, int clientID);
     GameStateCompressed *encode(GameState *a, GameState *b);
     GameStateCompressed *encode(GameState *a);
     GameState *diff(GameState *a, GameState *b);
     GameStateCompressed *compress_(GameState *a);
+    GameState *decompress(GameStateCompressed *a);
     bool printGameStates();
+    bool checkAccess(int clientID, int objectID);
 
     std::map<int, GameState*> gameStateMap; //map gsID to gamestate*
@@ -92 +93 @@
     ClientInformation *head_;
     int id_;
+    
+    
+    
+    
+  public:
+    //#### ADDED FOR TESTING PURPOSE ####
+    GameStateCompressed* testCompress( GameState* g );
+    GameState* testDiff( GameState* a, GameState* b );
+  //#### END TESTING PURPOSE ####
   };
 

code/branches/network3/src/network/NetworkPrereqs.h

@@ -78 +78 @@
   struct chat;
   struct classid;
+  struct welcome;
+  struct connectRequest;
   struct ClientList;
   struct GameState;

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

@@ -53 +53 @@
   bool PacketDecoder::elaborate( ENetPacket* packet, int clientId )
   {
-    int client = clientId;
-    COUT(5) << "PacketDecoder: clientId: " << client << std::endl; //control cout, not important, just debugging info
+    COUT(5) << "PacketDecoder: clientId: " << clientId << 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) << "PacketDecoder: packet id: " << id << std::endl;
@@ -64 +63 @@
     }
     switch( id ) {
-  case ACK:
-    acknowledgement( packet, clientId );
-    return true;
-    break;
-  case MOUSE:
-    mousem( packet, clientId );
-    return true;
-    break;
-  case KEYBOARD:
-    keystrike( packet, clientId );
-    return true;
-    break;
-  case CHAT:
-    chatMessage( packet, clientId );
-    return true;
-    break;
-  case GAMESTATE:
-    gstate( packet );
-    return true;
-    break;
-  case CLASSID:
-    clid(packet);
-    return true;
-    break;
+    case ACK:
+      acknowledgement( packet, clientId );
+      return true;
+    case COMMAND:
+      return command( packet, clientId );
+    case MOUSE:
+      mousem( packet, clientId );
+      return true;
+    case KEYBOARD:
+      keystrike( packet, clientId );
+      return true;
+    case CHAT:
+      chatMessage( packet, clientId );
+      return true;
+    case GAMESTATE:
+      gstate( packet );
+      return true;
+    case CLASSID:
+      clid(packet);
+      return true;
+    case WELCOME:
+      return decodeWelcome( packet, clientId );
+    case CONNECT:
+      return decodeConnectRequest( packet, clientId );
     }
     return false;
@@ -105 +104 @@
     //clean memory
     enet_packet_destroy( packet );
+  }
+  
+  bool PacketDecoder::command( ENetPacket* packet, int clientId ){
+    int length = *(int*)((unsigned char *)packet->data+sizeof(int));
+    void *data = (void *)new unsigned char[length];
+    memcpy(data, (void *)(packet->data+2*sizeof(int)), length);
+    return true;
   }
 
@@ -171 +177 @@
     //since the packetgenerator was changed, due to a new parameter, change this function too
     memcpy( (void*)&(currentState->diffed), (const void*)(packet->data+5*sizeof(int)), sizeof(bool));
+    memcpy( (void*)&(currentState->complete), (const void*)(packet->data+5*sizeof(int)+sizeof(bool)), sizeof(bool));
     //since data is not allocated, because it's just a pointer, allocate it with size of gamestatedatastream
     if(currentState->compsize==0)
@@ -178 +185 @@
       COUT(2) << "PacketDecoder: Gamestatepacket-decoder: memory leak" << std::endl;
     //copy the GameStateCompressed data
-    memcpy( (void*)(currentState->data), (const void*)(packet->data+5*sizeof( int ) + sizeof(bool)), currentState->compsize );
+    memcpy( (void*)(currentState->data), (const void*)(packet->data+5*sizeof( int ) + 2*sizeof(bool)), currentState->compsize );
 
     //clean memory
@@ -198 +205 @@
     processClassid(cid);
   }
+  
+  
+  bool PacketDecoder::decodeWelcome( ENetPacket* packet, int clientID ){
+    welcome *w = new welcome;
+    w->allowed = ((welcome *)(packet->data))->allowed;
+    w->shipID = ((welcome *)(packet->data))->shipID;
+    w->clientID = ((welcome *)(packet->data))->clientID;
+    w->id = ((welcome *)(packet->data))->id;
+    enet_packet_destroy( packet );
+    return processWelcome(w);
+  }
+  
+  bool PacketDecoder::decodeConnectRequest( ENetPacket *packet, int clientID ){
+    connectRequest *con = new connectRequest;
+    con->id = ((connectRequest *)(packet->data))->id;
+    enet_packet_destroy( packet );
+    return processConnectRequest(con, clientID );
+  }
 
 
@@ -224 +249 @@
     return;
   }
-
+  
+  bool PacketDecoder::processWelcome( welcome *w ){
+    return true;
+  }
+  
+  bool PacketDecoder::processConnectRequest( connectRequest *con, int clientID ){
+    COUT(3) << "packetdecoder: processing connectRequest" << std::endl;
+    return true;
+  }
 
   //these are some print functions for test stuff

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

@@ -61 +61 @@
     return packet;
   }
+  
+  ENetPacket* command( int dataLength, void *data, int reliable = ENET_PACKET_FLAG_RELIABLE )
+  {
+    void *stream = new char[dataLength + 2*sizeof(int)];
+    if(!stream)
+      return NULL;
+    packet_id a = COMMAND;
+    memcpy(stream, (void*)&a, sizeof(int));
+    memcpy((unsigned char *)stream+sizeof(int), (void*)&dataLength, sizeof(int));
+    memcpy((unsigned char *)stream+2*sizeof(int), data, dataLength);
+    return enet_packet_create(stream, dataLength+2*sizeof(int), reliable);
+  }
 
   /*### mouseupdates */
@@ -108 +120 @@
     //std::cout << "states->compsize " << states->compsize << std::endl;
     int gid = GAMESTATE; //first assign the correct enet id
-    int totalLen = 5*sizeof( int ) + sizeof(bool) + states->compsize; //calculate the total size of the datastream memory
+    int totalLen = 5*sizeof( int ) + 2*sizeof(bool) + states->compsize; //calculate the total size of the datastream memory
     //std::cout << "totalLen " << totalLen << std::endl;
-    unsigned char *data = (unsigned char*)malloc( totalLen ); //allocate the memory for datastream
+    //unsigned char *data = (unsigned char*)malloc( totalLen ); //allocate the memory for datastream
+    unsigned char *data = new unsigned char[totalLen];
     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 GameStateCompressed id
@@ -118 +131 @@
     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+5*sizeof( int ) + sizeof(bool)), (const void*)states->data, states->compsize );
+    memcpy( (void*)(data+5*sizeof( int ) + sizeof(bool)), (const void*)&(states->complete), sizeof(bool) );
+    memcpy( (void*)(data+5*sizeof( int ) + 2*sizeof(bool)), (const void*)states->data, states->compsize );
     //create an enet packet with the generated bytestream
     COUT(4) << "PacketGenerator generating totalLen " << totalLen << std::endl;
@@ -128 +142 @@
   ENetPacket* PacketGenerator::clid( int classid, std::string classname, int reliable )
   {
-    unsigned char* data = (unsigned char *)malloc(3*sizeof(int)+classname.length()+1);
+    //unsigned char* data = (unsigned char *)malloc(3*sizeof(int)+classname.length()+1);
+    unsigned char *data = new unsigned char[3*sizeof(int)+classname.length()+1];
     std::cout << "PacketGenerator: classid: " << classid << ", name: " << classname << std::endl;
     *(int *)data = CLASSID;
@@ -137 +152 @@
     return packet;
   }
+  
+  ENetPacket* PacketGenerator::generateWelcome( int clientID,int shipID, bool allowed , int reliable ){
+    welcome *wc = new welcome;
+    wc->id = WELCOME;
+    wc->clientID = clientID;
+    wc->shipID = shipID;
+    wc->allowed = true;
+    ENetPacket *packet = enet_packet_create( wc, sizeof(welcome), reliable);
+    return packet;
+  }
+  
+  ENetPacket* PacketGenerator::generateConnectRequest( int reliable ){
+    connectRequest *con = new connectRequest;
+    con->id=CONNECT;
+    return enet_packet_create( con, sizeof(connectRequest), reliable);
+  }
 
 }

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

@@ -54 +54 @@
     //call one of this functions out of an instance of PacketGenerator to create a packet
     ENetPacket* acknowledgement( int state, int reliable = ENET_PACKET_FLAG_RELIABLE );
+    ENetPacket* command( int dataLength, void *data, int reliable = ENET_PACKET_FLAG_RELIABLE );
     ENetPacket* mousem( double x, double y, int reliable = ENET_PACKET_FLAG_RELIABLE );
     ENetPacket* keystrike( char press, int reliable = ENET_PACKET_FLAG_RELIABLE );
@@ -59 +60 @@
     ENetPacket* gstate( GameStateCompressed *states, int reliable = ENET_PACKET_FLAG_RELIABLE );
     ENetPacket* clid( int classid, std::string classname, int reliable = ENET_PACKET_FLAG_RELIABLE );
+    ENetPacket* generateWelcome( int clientID,int shipID, bool allowed, int reliable = ENET_PACKET_FLAG_RELIABLE );
+    ENetPacket* generateConnectRequest( int reliable = ENET_PACKET_FLAG_RELIABLE );
   private:
   };
@@ -85 +88 @@
 
     void acknowledgement( ENetPacket* packet, int clientId = CLIENTID_CLIENT );
+    bool command( ENetPacket* packet, int clientId );
     void mousem( ENetPacket* packet, int clientId = CLIENTID_CLIENT );
     void keystrike( ENetPacket* packet, int clientId = CLIENTID_CLIENT );
@@ -90 +94 @@
     void gstate( ENetPacket* packet );
     void clid( ENetPacket *packet);
+    bool decodeWelcome( ENetPacket* packet, int clientID = CLIENTID_CLIENT );
+    bool decodeConnectRequest( ENetPacket *packet, int clientID = CLIENTID_CLIENT );
 
     //process data
@@ -96 +102 @@
     virtual void processAck( ack *data, int clientID);
     virtual void processClassid( classid *cid);
+    virtual bool processWelcome( welcome *w );
+    virtual bool processConnectRequest( connectRequest *con, int clientID );
     //virtual void processAck( ack *data);
 

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

@@ -49 +49 @@
     ACK,
     MOUSE,
+    COMMAND,
     KEYBOARD,
     CHAT,
     GAMESTATE ,
-    CLASSID
+    CLASSID,
+    WELCOME,
+    CONNECT,
   };
 
@@ -65 +68 @@
     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)
+    int base_id;                    // if gamestate is diffed this is the id of the old gamestate (base)
     bool diffed;
+    bool complete;                  // this determines, wheter all objects are in this gamestate (server) or only few objects (client)
     unsigned char *data;            //!< pointer to data
   };
@@ -83 +87 @@
     int base_id;                  // if gamestate is diffed this is the id of the old gamestate (base)
     bool diffed;
+    bool complete;                  // this determines, wheter all objects are in this gamestate (server) or only few objects (client)
     unsigned char *data;            //!< gamestate data
   };
@@ -116 +121 @@
   };
 
+  struct welcome {
+    int id;
+    int clientID;
+    int shipID;
+    bool allowed;
+  };
+  
+  struct connectRequest{
+    int id;
+  };
 }
 

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

@@ -223 +223 @@
     gamestates->ackGameState(clientID, data->a);
   }
+  
+  bool Server::processConnectRequest( connectRequest *con, int clientID ){
+    COUT(4) << "processing connectRequest " << std::endl;
+    //connection->addPacket(packet_gen.gstate(gamestates->popGameState(clientID)) , clientID);
+    connection->createClient(clientID);
+  }
 
 }

code/branches/network3/src/network/Server.h

@@ -73 +73 @@
     bool sendGameState();
     void processAck( ack *data, int clientID);
+    bool processConnectRequest( connectRequest *con, int clientID );
     ConnectionManager *connection;
     GameStateManager *gamestates;

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

@@ -48 +48 @@
 namespace network
 {
+  
+  
+  int Synchronisable::state_=1; // detemines wheter we are server (default) or client
+  
   /**
   * Constructor:
@@ -63 +67 @@
   Synchronisable::~Synchronisable(){
   }
+  
+  void Synchronisable::setClient(bool b){
+    if(b) // client
+      state_=0x2;
+    else  // server
+      state_=0x1;
+  }
 
   /**
@@ -70 +81 @@
   * @param size size of the datatype the variable consists of
   */
-  void Synchronisable::registerVar(void *var, int size, variableType t){
+  void Synchronisable::registerVar(void *var, int size, variableType t, int mode){
     // create temporary synch.Var struct
     synchronisableVariable *temp = new synchronisableVariable;
     temp->size = size;
     temp->var = var;
+    temp->mode = mode; 
     temp->type = t;
     COUT(5) << "Syncronisable::registering var with size: " << temp->size << " and type: " << temp->type << std::endl; 
@@ -153 +165 @@
     for(i=syncList->begin(); n<datasize && i!=syncList->end(); ++i){
       //(std::memcpy(retVal.data+n, (const void*)(&(i->size)), sizeof(int));
+      if( ((*i)->mode & state_) == 0 )
+        continue;  // this variable should only be received
       switch((*i)->type){
       case DATA:
@@ -185 +199 @@
     COUT(5) << "Synchronisable: objectID " << vars.objectID << ", classID " << vars.classID << " size: " << vars.length << " synchronising data" << std::endl;
     for(i=syncList->begin(); i!=syncList->end(); i++){
+      if( ((*i)->mode ^ state_) == 0 )
+        continue;  // this variable should only be sent
       COUT(5) << "Synchronisable: element size: " << (*i)->size << " type: " << (*i)->type << std::endl;
       switch((*i)->type){
@@ -212 +228 @@
     std::list<synchronisableVariable *>::iterator i;
     for(i=syncList->begin(); i!=syncList->end(); i++){
+      if( ((*i)->mode & state_) == 0 )
+        continue;  // this variable should only be received, so dont add its size to the send-size
       switch((*i)->type){
       case DATA:
@@ -226 +244 @@
     return tsize;
   }
-
+  
+  void Synchronisable::setBacksync(bool sync){
+    backsync_=sync;
+  }
+
+  bool Synchronisable::getBacksync(){
+    return backsync_;
+  }
+  
 }

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

@@ -62 +62 @@
   typedef struct synchronisableVariable{
     int size;
+    int mode; // this determines in which direction the variable gets synchronised
     void *var;
     variableType type;
@@ -69 +70 @@
   /**
   * This class is the base class of all the Objects in the universe that need to be synchronised over the network
-  * Every class, that inherits from this class has to link the DATA THAT NEEDS TO BE SYNCHRONISED into the linked list. Additionally it also has to provide a Constructor, that takes exactly the variables in this linked list.
+   * Every class, t
+  int mode;hat inherits from this class has to link the DATA THAT NEEDS TO BE SYNCHRONISED into the linked list. Additionally it also has to provide a Constructor, that takes exactly the variables in this linked list.
   * @author Oliver Scheuss
   */
@@ -79 +81 @@
     int classID;
 
-    void registerVar(void *var, int size, variableType t);
+    void registerVar(void *var, int size, variableType t, int mode=1);
     //  syncData getData();
     syncData getData(unsigned char *mem);
     int getSize();
     bool updateData(syncData vars);
+    void setBacksync(bool sync);
+    bool getBacksync();
     virtual void registerAllVariables()=0;
     virtual bool create()=0;
+    static void setClient(bool b);
   protected:
     Synchronisable();
@@ -93 +98 @@
     std::list<synchronisableVariable *> *syncList;
     int datasize;
+    static int state_; // detemines wheter we are server (default) or client
+    bool backsync_; // if true the variables with mode > 1 will be synchronised to server (client -> server)
   };
 }

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

@@ -326 +326 @@
     orxonoxHUD_->setEnergyDistr(20,20,60);
     hudOverlay->show();
+    setupInputSystem();
 
     client_g->establishConnection();
@@ -362 +363 @@
   }
 
-  void Orxonox::createScene(void)
+  void Orxonox::createScene()
   {
           // Init audio

code/branches/network3/src/orxonox/objects/Camera.cc

@@ -127 +127 @@
     COUT(0) << "t " << this->targetNode_->getPosition() << std::endl;
     if(this->positionNode_ != NULL)
-      //this->cam_->setPosition(this->positionNode_->getPosition());
+      this->cam_->setPosition(this->positionNode_->getPosition());
     if(this->targetNode_ != NULL)
       this->cam_->lookAt(this->targetNode_->getPosition());
@@ -139 +139 @@
   {
     this->bHasFocus_ = false;
+    this->positionNode_->detachObject(cam_);
   }
 

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

@@ -73 +73 @@
         XMLPortParamLoadOnly(Model, "mesh", setMesh, xmlelement, mode);
 
-        create();
+        Model::create();
     }
 

code/branches/network3/src/orxonox/objects/SpaceShip.cc

@@ -80 +80 @@
 
         this->camNode_ = 0;
+        this->camName_ = "camNode";
 
         this->tt_ = 0;
@@ -160 +161 @@
 
     void SpaceShip::registerAllVariables(){
-
-
-
+      registerVar( &camName_, camName_.length()+1, network::STRING);
     }
 
     void SpaceShip::init()
     {
-        createCamera();
+        COUT(4) << "================ \t\t\t\tspaceship::init" << std::endl;
         // START CREATING THRUSTER
         this->tt_ = new ParticleInterface(GraphicsEngine::getSingleton().getSceneManager(),"twinthruster" + this->getName(),"Orxonox/engineglow");
@@ -198 +197 @@
         this->greenNode_->setInheritScale(false);
 
+        COUT(4) << "attaching red billboard" << std::endl;
         this->redNode_->attachObject(this->redBillboard_.getBillboardSet());
         this->redNode_->setScale(0.3, 0.3, 0.3);
 
+        COUT(4) << "attaching green billboard" << std::endl;
         this->greenNode_->attachObject(this->greenBillboard_.getBillboardSet());
         this->greenNode_->setScale(0.3, 0.3, 0.3);
@@ -214 +215 @@
         this->chFarNode_->setInheritScale(false);
 
+        COUT(4) << "attaching crosshair near billboard" << std::endl;
         this->chNearNode_->attachObject(this->crosshairNear_.getBillboardSet());
         this->chNearNode_->setScale(0.2, 0.2, 0.2);
 
+        COUT(4) << "attaching crosshair far billboard" << std::endl;
         this->chFarNode_->attachObject(this->crosshairFar_.getBillboardSet());
         this->chFarNode_->setScale(0.4, 0.4, 0.4);
-
+        COUT(4) << "attaching camera" << std::endl;
+        
+        createCamera();
         // END of testing crosshair
     }
@@ -232 +237 @@
     void SpaceShip::loadParams(TiXmlElement* xmlElem)
     {
+      COUT(4) << "using loadparams" << std::endl;
         Model::loadParams(xmlElem);
         this->create();
+        this->getFocus();
 /*
         if (xmlElem->Attribute("forward") && xmlElem->Attribute("rotateupdown") && xmlElem->Attribute("rotaterightleft") && xmlElem->Attribute("looprightleft"))
@@ -284 +291 @@
     void SpaceShip::setCamera(const std::string& camera)
     {
+      camName_=camera;
       // change camera attributes here, if you want to ;)
+    }
+    
+    void SpaceShip::getFocus(){
+      COUT(4) << "requesting focus" << std::endl;
+      if(network::Client::getSingleton()==0 || network::Client::getSingleton()->getShipID()==objectID)
+        CameraHandler::getInstance()->requestFocus(cam_);
+      
     }
     
     void SpaceShip::createCamera(){
-      this->camNode_ = this->getNode()->createChildSceneNode("CamNode");
-      camNode_->setPosition(this->getNode()->getPosition() + Vector3(-50,0,10));
+      COUT(4) << "begin camera creation" << std::endl;
+      this->camNode_ = this->getNode()->createChildSceneNode(camName_);
+      COUT(4) << "position: (this)" << this->getNode()->getPosition() << std::endl;
+      this->camNode_->setPosition(this->getNode()->getPosition() + Vector3(-50,0,10));
+      COUT(4) << "position: (cam)" << this->camNode_->getPosition() << std::endl;
 /*
 //        node->setInheritOrientation(false);
@@ -295 +313 @@
       cam->lookAt(Vector3(0,20,0));
       cam->roll(Degree(0));
-*/
+      */COUT(4) << "creating new camera" << std::endl;
       cam_ = new Camera(this->camNode_);
+      COUT(4) << "setting target node" << std::endl;
       cam_->setTargetNode(this->getNode());
-      CameraHandler::getInstance()->requestFocus(cam_);
+      // this only applies to clients
+      if(network::Client::getSingleton()!=0 && network::Client::getSingleton()->getShipID()==objectID)
+        CameraHandler::getInstance()->requestFocus(cam_);
 //        cam->setPosition(Vector3(0,-350,0));
       //cam->roll(Degree(-90));
 
       //this->camNode_->attachObject(cam);
-      
+      COUT(4) << "created camera" << std::endl;
     }
 
@@ -329 +350 @@
     void SpaceShip::XMLPort(Element& xmlelement, XMLPort::Mode mode)
     {
+      COUT(4) << "using xmlport" << std::endl;
         Model::XMLPort(xmlelement, mode);
 
@@ -339 +361 @@
         XMLPortParamLoadOnly(SpaceShip, "transDamp", setTransDamp, xmlelement, mode);
         XMLPortParamLoadOnly(SpaceShip, "rotDamp", setRotDamp, xmlelement, mode);
+        
+        SpaceShip::create();
+        getFocus();
     }
 
@@ -534 +559 @@
         }
 
-        if(!network::Client::getSingleton()){
+        if(!network::Client::getSingleton() || network::Client::getSingleton()->getShipID() == objectID){
           if (mKeyboard->isKeyDown(OIS::KC_UP) || mKeyboard->isKeyDown(OIS::KC_W))
               this->acceleration_.x = this->translationAcceleration_;

code/branches/network3/src/orxonox/objects/SpaceShip.h

@@ -63 +63 @@
             void setTransDamp(float value);
             void setRotDamp(float value);
+            
+            void getFocus();
 
             static void setMaxSpeedTest(float value)
@@ -83 +85 @@
 
             Ogre::SceneNode* camNode_;
-            Camera* cam_;
+            Camera* cam_;  
+            std::string camName_;
+
 
             ParticleInterface* tt_;

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

@@ -190 +190 @@
         XMLPortObject(WorldEntity, WorldEntity, "attached", attachWorldEntity, getAttachedWorldEntity, xmlelement, mode, false, true);
         
-        //create();
+        WorldEntity::create();
     }
 
@@ -197 +197 @@
     {
       // register coordinates
-      registerVar( (void*) &(this->getPosition().x), sizeof(this->getPosition().x), network::DATA);
-      registerVar( (void*) &(this->getPosition().y), sizeof(this->getPosition().y), network::DATA);
-      registerVar( (void*) &(this->getPosition().z), sizeof(this->getPosition().z), network::DATA);
+      registerVar( (void*) &(this->getPosition().x), sizeof(this->getPosition().x), network::DATA, 0x3);
+      registerVar( (void*) &(this->getPosition().y), sizeof(this->getPosition().y), network::DATA, 0x3);
+      registerVar( (void*) &(this->getPosition().z), sizeof(this->getPosition().z), network::DATA, 0x3);
       // register orientation
-      registerVar( (void*) &(this->getOrientation().w), sizeof(this->getOrientation().w), network::DATA);
-      registerVar( (void*) &(this->getOrientation().x), sizeof(this->getOrientation().x), network::DATA);
-      registerVar( (void*) &(this->getOrientation().y), sizeof(this->getOrientation().y), network::DATA);
-      registerVar( (void*) &(this->getOrientation().z), sizeof(this->getOrientation().z), network::DATA);
+      registerVar( (void*) &(this->getOrientation().w), sizeof(this->getOrientation().w), network::DATA, 0x3);
+      registerVar( (void*) &(this->getOrientation().x), sizeof(this->getOrientation().x), network::DATA, 0x3);
+      registerVar( (void*) &(this->getOrientation().y), sizeof(this->getOrientation().y), network::DATA, 0x3);
+      registerVar( (void*) &(this->getOrientation().z), sizeof(this->getOrientation().z), network::DATA, 0x3);
       // register velocity_
-      registerVar( (void*) &(this->getVelocity().x), sizeof(this->getVelocity().x), network::DATA);
-      registerVar( (void*) &(this->getVelocity().y), sizeof(this->getVelocity().y), network::DATA);
-      registerVar( (void*) &(this->getVelocity().z), sizeof(this->getVelocity().z), network::DATA);
+      registerVar( (void*) &(this->getVelocity().x), sizeof(this->getVelocity().x), network::DATA, 0x3);
+      registerVar( (void*) &(this->getVelocity().y), sizeof(this->getVelocity().y), network::DATA, 0x3);
+      registerVar( (void*) &(this->getVelocity().z), sizeof(this->getVelocity().z), network::DATA, 0x3);
       // register rotationAxis/rate
-      registerVar( (void*) &(this->getRotationRate()), sizeof(this->getRotationRate()), network::DATA);
-      registerVar( (void*) &(this->getRotationAxis().x), sizeof(this->getRotationAxis().x), network::DATA);
-      registerVar( (void*) &(this->getRotationAxis().y), sizeof(this->getRotationAxis().y), network::DATA);
-      registerVar( (void*) &(this->getRotationAxis().z), sizeof(this->getRotationAxis().z), network::DATA);
+      registerVar( (void*) &(this->getRotationRate()), sizeof(this->getRotationRate()), network::DATA, 0x3);
+      registerVar( (void*) &(this->getRotationAxis().x), sizeof(this->getRotationAxis().x), network::DATA, 0x3);
+      registerVar( (void*) &(this->getRotationAxis().y), sizeof(this->getRotationAxis().y), network::DATA, 0x3);
+      registerVar( (void*) &(this->getRotationAxis().z), sizeof(this->getRotationAxis().z), network::DATA, 0x3);
       // register scale of node
-      registerVar( (void*) &(this->getScale().x), sizeof(this->getScale().x), network::DATA);
-      registerVar( (void*) &(this->getScale().y), sizeof(this->getScale().y), network::DATA);
-      registerVar( (void*) &(this->getScale().z), sizeof(this->getScale().z), network::DATA);
+      registerVar( (void*) &(this->getScale().x), sizeof(this->getScale().x), network::DATA, 0x3);
+      registerVar( (void*) &(this->getScale().y), sizeof(this->getScale().y), network::DATA, 0x3);
+      registerVar( (void*) &(this->getScale().z), sizeof(this->getScale().z), network::DATA, 0x3);
       //register staticity
-      registerVar( (void*) &(this->bStatic_), sizeof(this->bStatic_), network::DATA);
+      registerVar( (void*) &(this->bStatic_), sizeof(this->bStatic_), network::DATA, 0x3);
+      //register acceleration
+      // register velocity_
+      registerVar( (void*) &(this->getAcceleration().x), sizeof(this->getAcceleration().x), network::DATA, 0x3);
+      registerVar( (void*) &(this->getAcceleration().y), sizeof(this->getAcceleration().y), network::DATA, 0x3);
+      registerVar( (void*) &(this->getAcceleration().z), sizeof(this->getAcceleration().z), network::DATA, 0x3);
     }