Changeset 1425 for code/branches/network/src/network

Timestamp:

May 25, 2008, 11:08:19 PM (16 years ago)

Author:

scheusso

Message:

implemented some sort of buffer for the spaceship movements (makes the movements on the client smoother)

Location:

code/branches/network/src/network

Files:

• Client.cc (modified) (2 diffs)
• GameStateClient.cc (modified) (6 diffs)
• GameStateClient.h (modified) (5 diffs)
• GameStateManager.cc (modified) (1 diff)
• GameStateManager.h (modified) (2 diffs)
• Server.cc (modified) (3 diffs)
• Synchronisable.cc (modified) (6 diffs)
• Synchronisable.h (modified) (1 diff)

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

@@ -246 +246 @@
       elaborate(event->packet, 0); // ================= i guess we got to change this .... (client_ID is always same = server)
     }
+    int gameStateID = gamestate.processGameState();
+    if(gameStateID!=GAMESTATEID_INITIAL){
+      // ack gamestate and set synched
+      if(!isSynched_)
+        isSynched_=true;
+      if(!client_connection.addPacket(pck_gen.acknowledgement(gameStateID)))
+        COUT(3) << "could not ack gamestate" << std::endl;
+    }
+    gamestate.cleanup();
     if(!client_connection.sendPackets())
       COUT(3) << "Problem sending packets to server" << std::endl;
@@ -252 +261 @@
 
   void Client::processGamestate( GameStateCompressed *data, int clientID){
-    int id = data->id;
     COUT(5) << "received gamestate id: " << data->id << std::endl;
-    if(gamestate.pushGameState(data)){
-      if(!isSynched_)
-        isSynched_=true;
-      if(!client_connection.addPacket(pck_gen.acknowledgement(id)))
-        return;
-        // we do this at the end of a tick
-      if(!client_connection.sendPackets())
-        COUT(2) << "Could not send acknowledgment" << std::endl;
-    }
+    gamestate.addGameState(data);
   }
 

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

@@ -21 +21 @@
  *
  *   Author:
- *      ...
+ *      Oliver Scheuss
  *   Co-authors:
- *      ...
+ *      Dumeni Manatschal
  *
  */
@@ -35 +35 @@
 #include "Synchronisable.h"
 
-#define GAMESTATEID_INITIAL -1
 
 namespace network
@@ -48 +47 @@
     last_diff_=0;
     last_gamestate_=GAMESTATEID_INITIAL-1;
+    tempGameState_=NULL;
+    myShip_=NULL;
   }
 
@@ -102 +103 @@
     delete gs;
     return cgs;
+  }
+  
+  void GameStateClient::addGameState(GameStateCompressed *gs){
+    if(tempGameState_!=NULL){
+      //delete the obsolete gamestate
+      if(tempGameState_->id>gs->id)
+        return;
+      delete[] tempGameState_->data;
+      delete tempGameState_;
+    }
+    tempGameState_=gs;
+  }
+  int GameStateClient::processGameState(){
+    if(tempGameState_==NULL)
+      return GAMESTATEID_INITIAL;
+    int id=tempGameState_->id;
+    bool b = saveShipCache();
+    if(pushGameState(tempGameState_)){
+      if(b)
+        loadShipCache();
+      return id;
+    }
+    else
+      return GAMESTATEID_INITIAL;
   }
   
@@ -388 +413 @@
       gameStateMap.erase(temp);
     }
+    tempGameState_=NULL;
   }
 
@@ -400 +426 @@
   }
   
+  bool GameStateClient::saveShipCache(){
+    if(myShip_==NULL)
+      myShip_ = orxonox::SpaceShip::getLocalShip();
+    if(myShip_){
+      //      unsigned char *data = new unsigned char[myShip_->getSize()];
+      int size=myShip_->getSize(0x3);
+      if(size==0)
+        return false;
+      unsigned char *data = new unsigned char [size];
+      shipCache_ = myShip_->getData(data, 0x1);
+      return true;
+    }else
+      return false;
+  }
+  
+  bool GameStateClient::loadShipCache(){
+    if(myShip_){
+      myShip_->updateData(shipCache_, 0x2);
+      if(shipCache_.data){
+        delete[] shipCache_.data;
+      }
+      return true;
+    }else
+      return false;
+  }
   
     //##### ADDED FOR TESTING PURPOSE #####

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

@@ -21 +21 @@
  *
  *   Author:
- *      ...
+ *      Oliver Scheuss
  *   Co-authors:
- *      ...
+ *      Dumeni Manatschal
  *
  */
@@ -33 +33 @@
 //
 //
-// Author:  <>, (C) 2007
+// Author:  Oliver Scheuss, (C) 2007
 //
 // Copyright: See COPYING file that comes with this distribution
@@ -46 +46 @@
 #include "core/CorePrereqs.h"
 #include "PacketTypes.h"
+#include "objects/SpaceShip.h"
 
+
+#define GAMESTATEID_INITIAL -1
 
 namespace network
@@ -56 +59 @@
     ~GameStateClient();
     
+    void addGameState(GameStateCompressed *gs);
+    int processGameState();
+    GameStateCompressed *popPartialGameState();
+    void cleanup();
+  private:
     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);
@@ -69 +74 @@
     void removeObject(orxonox::Iterator<Synchronisable> &it);
     void printGameStateMap();
+    bool saveShipCache();
+    bool loadShipCache();
 
     int           last_diff_;
     int           last_gamestate_;
     std::map<int, GameState *> gameStateMap;
+    GameStateCompressed *tempGameState_; // we save the received gamestates here during processQueue
+    orxonox::SpaceShip *myShip_;
+    syncData shipCache_;
     
     

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

@@ -68 +68 @@
     printGameStates();
     return;
+  }
+  
+  void GameStateManager::addGameState(GameStateCompressed *gs, int clientID){
+    if(!gs)
+      return;
+    std::map<int, GameStateCompressed*>::iterator it = gameStateQueue.find(clientID);
+    if(it!=gameStateQueue.end()){
+      // delete obsolete gamestate
+      delete[] it->second->data;
+      delete it->second;
+    }
+    gameStateQueue[clientID] = gs;
+    return;
+  }
+  
+  void GameStateManager::processGameStates(){
+    std::map<int, GameStateCompressed*>::iterator it;
+    // now push only the most recent gamestates we received (ignore obsolete ones)
+    for(it = gameStateQueue.begin(); it!=gameStateQueue.end(); it++){
+      pushGameState(it->second, it->first);
+    }
+    // now clear the queue
+    gameStateQueue.clear();
   }
   

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

@@ -72 +72 @@
     ~GameStateManager();
     
+    void addGameState(GameStateCompressed *gs, int clientID);
+    void processGameStates();
+    
     void update();
     GameStateCompressed *popGameState(int clientID);
-    bool pushGameState(GameStateCompressed *gs, int clientID);
     void ackGameState(int clientID, int gamestateID);
     void removeClient(ClientInformation *client);
-  private:
+    private:
+    bool pushGameState(GameStateCompressed *gs, int clientID);
     void cleanup(); // "garbage handler"
     GameState *getSnapshot();
@@ -91 +94 @@
     std::map<int, GameState*> gameStateMap; //map gsID to gamestate*
     std::map<int, int> gameStateUsed; // save the number of clients, that use the specific gamestate
+    std::map<int, GameStateCompressed*> gameStateQueue;
     GameState *reference;
     ClientInformation *head_;

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

@@ -157 +157 @@
   void Server::tick(float time) {
     processQueue();
+    gamestates->processGameStates();
     updateGamestate();
 //     usleep(500000); // TODO remove
@@ -245 +246 @@
           disconnectClient(temp);
       //std::cout << "added gamestate" << std::endl;
-      }
+      }else
+        temp->resetFailures();
       added=true;
       temp=temp->next();
@@ -276 +278 @@
   void Server::processGamestate( GameStateCompressed *data, int clientID){
     COUT(4) << "processing partial gamestate from client " << clientID << std::endl;
-    if(!gamestates->pushGameState(data, clientID))
-        COUT(3) << "Could not push gamestate\t\t\t\t=====" << std::endl;
+    gamestates->addGameState(data, clientID);
+        /*COUT(3) << "Could not push gamestate\t\t\t\t=====" << std::endl;
     else
       if(clients->findClient(clientID))
-        clients->findClient(clientID)->resetFailures();
+        clients->findClient(clientID)->resetFailures();*/
   }
   

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

@@ -70 +70 @@
   bool Synchronisable::create(){
     this->classID = this->getIdentifier()->getNetworkID();
+    COUT(4) << "setting classid from " << this->getIdentifier()->getName() << " to: " << classID << std::endl;
     return true;
   }
@@ -156 +157 @@
   * @return data containing all variables and their sizes
   */
-  syncData Synchronisable::getData(unsigned char *mem){
+  syncData Synchronisable::getData(unsigned char *mem, int mode){
     //std::cout << "inside getData" << std::endl;
+    if(mode==0x0)
+      mode=state_;
     if(classID==0)
       COUT(3) << "classid 0 " << this->getIdentifier()->getName() << std::endl;
@@ -172 +175 @@
     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 ){
+      if( ((*i)->mode & mode) == 0 ){
         COUT(5) << "not getting data: " << std::endl;
         continue;  // this variable should only be received
@@ -199 +202 @@
   * @return true/false
   */
-  bool Synchronisable::updateData(syncData vars){
+  bool Synchronisable::updateData(syncData vars, int mode){
+    if(mode==0x0)
+      mode=state_;
     unsigned char *data=vars.data;
     std::list<synchronisableVariable *>::iterator i;
@@ -208 +213 @@
     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 ){
+      if( ((*i)->mode ^ mode) == 0 ){
         COUT(5) << "synchronisable: not updating variable " << std::endl;
-        continue;  // this variable should only be updated
+        continue;  // this variable should only be set
       }
       COUT(5) << "Synchronisable: element size: " << (*i)->size << " type: " << (*i)->type << std::endl;
@@ -235 +240 @@
   * @return amount of bytes
   */
-  int Synchronisable::getSize(){
+  int Synchronisable::getSize(int mode){
     int tsize=0;
+    if(mode==0x0)
+      mode=state_;
     std::list<synchronisableVariable *>::iterator i;
     for(i=syncList->begin(); i!=syncList->end(); i++){
-      if( ((*i)->mode & state_) == 0 )
+      if( ((*i)->mode & mode) == 0 )
         continue;  // this variable should only be received, so dont add its size to the send-size
       switch((*i)->type){

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

@@ -83 +83 @@
     void registerVar(void *var, int size, variableType t, int mode=1);
     //  syncData getData();
-    syncData getData(unsigned char *mem);
-    int getSize();
-    bool updateData(syncData vars);
+    syncData getData(unsigned char *mem, int mode=0x0);
+    int getSize(int mode=0x0);
+    bool updateData(syncData vars, int mode=0x0);
     void setBacksync(bool sync);
     bool getBacksync();