Changeset 436

Timestamp:

Dec 9, 2007, 12:42:46 PM (17 years ago)

Author:

scheusso

Message:

extended gamestatehandling for diffed and not diffed gamestates (initial states, etc)

Location:

code/branches/FICN/src/network

Files:

• ClientInformation.cc (modified) (2 diffs)
• ClientInformation.h (modified) (3 diffs)
• ConnectionManager.cc (modified) (7 diffs)
• ConnectionManager.h (modified) (5 diffs)
• GameStateClient.cc (modified) (3 diffs)
• GameStateClient.h (modified) (1 diff)
• GameStateManager.cc (modified) (7 diffs)
• GameStateManager.h (modified) (3 diffs)
• PacketTypes.h (modified) (2 diffs)
• Server.cc (modified) (9 diffs)
• Server.h (modified) (2 diffs)
• TODO (modified) (1 diff)

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

@@ -16 +16 @@
 ClientInformation::ClientInformation()
 {
+  gamestateID_=GAMESTATEID_INITIAL;
   preve=0;
   nexte=0;
+  this->head=false;
+}
+
+ClientInformation::ClientInformation(bool head)
+{
+  gamestateID_=GAMESTATEID_INITIAL;
+  preve=0;
+  nexte=0;
+  this->head=head;
 }
 //
@@ -54 +64 @@
 }
 
-void ClientInformation::setPrev(ClientInformation *prev){
-  this->preve = prev;
+bool ClientInformation::setPrev(ClientInformation *prev){
+  if(!head)
+    this->preve = prev;
+  else
+    return false;
+  return true;
 }
 
-void ClientInformation::setNext(ClientInformation *next){
+bool ClientInformation::setNext(ClientInformation *next){
   this->nexte = next;
+  return true;
 }
 
-void ClientInformation::insertAfter(ClientInformation *ins){
+ClientInformation *ClientInformation::insertAfter(ClientInformation *ins){
   this->nexte->setPrev(ins);
   ins->setNext(this->nexte);
   ins->setPrev(this);
   this->nexte = ins;
+  return ins;
 }
 
-void ClientInformation::insertBefore(ClientInformation *ins){
+ClientInformation *ClientInformation::insertBefore(ClientInformation *ins){
   this->prev()->setNext(ins);
   ins->setPrev(this->preve);
   this->preve=ins;
   ins->setNext(this);
+  return ins;
+}
+
+void ClientInformation::setID(int clientID){
+  clientID_ = clientID;
+}
+void ClientInformation::setPeer(ENetPeer *peer){
+  peer_ = peer;
+}
+
+void ClientInformation::setGamestateID(int id){
+  gamestateID_=id;
+}
+
+int ClientInformation::getID(){
+  return clientID_;
+}
+ENetPeer *ClientInformation::getPeer(){
+  return peer_;
+}
+
+int ClientInformation::getGamestateID(){
+  return gamestateID_;
+}
+
+ClientInformation *ClientInformation::insertBack(ClientInformation *ins){
+  ClientInformation *temp = this;
+  while(temp->next()!=0){
+    temp = temp->next();
+  }
+  temp->setNext(ins);
+  ins->setPrev(temp);
+  return ins;
+}
+
+bool ClientInformation::removeClient(int clientID){
+  ClientInformation *temp = this;
+  while(temp!=0 && temp->getID()!=clientID)
+    temp = temp->next();
+  if(temp==0)
+    return false;
+  delete temp;
+  return true;
+}
+
+bool ClientInformation::removeClient(ENetPeer *peer){
+  ClientInformation *temp = this;
+  while(temp!=0 && (temp->getPeer()->address.host!=peer->address.host || temp->getPeer()->address.port!=peer->address.port))
+    temp = temp->next();
+  if(temp==0)
+    return false;
+  delete temp;
+  return true;
+}
+
+/**
+ * This function goes forward through the list and looks for an element with clientID
+ * 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
+ */
+ClientInformation *ClientInformation::findClient(int clientID, bool look_backwards){
+  ClientInformation *temp = this;
+  while(temp!=0 && temp->getID()!=clientID)
+    temp = temp->next();
+  // returns 0 if nothing has been found
+  return temp;
+}
+
+/**
+ * This function goes forward through the list and looks for an element with clientID
+ * This function should only be applied to the head of the list
+ * @param peer peer to look for
+ * @return pointer to the element in the list
+ */
+ClientInformation *ClientInformation::findClient(ENetAddress *address, bool look_backwards){
+  ClientInformation *temp = this;
+  while(temp!=0 && (temp->getPeer()->address.host!=address->host || temp->getPeer()->address.port != address->port))
+    temp = temp->next();
+  // returns 0 if nothing has been found
+  return temp;
 }
 

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

@@ -13 +13 @@
 #define NETWORKCLIENTINFORMATION_H
 
+#include <enet/enet.h>
+
+#define GAMESTATEID_INITIAL -1
+
 namespace network {
 
@@ -22 +26 @@
 public:
   ClientInformation();
+  ClientInformation(bool head);
 //   ClientInformation(ClientInformation *prev, ClientInformation *next);
 //   ClientInformation(ClientInformation *prev);
@@ -27 +32 @@
   ClientInformation *next();
   ClientInformation *prev();
-  void setNext(ClientInformation *next);
-  void setPrev(ClientInformation *prev);
-  void insertAfter(ClientInformation *ins);
-  void insertBefore(ClientInformation *ins);
+  bool setNext(ClientInformation *next);
+  bool setPrev(ClientInformation *prev);
+  ClientInformation *insertAfter(ClientInformation *ins);
+  ClientInformation *insertBefore(ClientInformation *ins);
+  ClientInformation *insertBack(ClientInformation *ins);
+  void setID(int clientID);
+  void setPeer(ENetPeer *peer);
+  void setGamestateID(int id);
+  int getID();
+  ENetPeer *getPeer();
+  int getGamestateID();
+  bool removeClient(int clientID);
+  bool removeClient(ENetPeer *peer);
+  ClientInformation *findClient(int clientID, bool look_backwards=false);
+  ClientInformation *findClient(ENetAddress *address, bool look_backwards=false);
+  bool head;
   
 private:
   ClientInformation *preve;
   ClientInformation *nexte;
+  //actual information:
+  ENetPeer *peer_;
+  int clientID_;
+  int gamestateID_;
 };
 

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

@@ -25 +25 @@
   boost::thread_group network_threads;
   
-  ConnectionManager::ConnectionManager(){
+  ConnectionManager::ConnectionManager(ClientInformation *head){
     quit=false;
     bindAddress.host = ENET_HOST_ANY;
     bindAddress.port = NETWORK_PORT;
-  }
-
-  ConnectionManager::ConnectionManager(int port, std::string address){
+    head_ = head;
+  }
+
+  ConnectionManager::ConnectionManager(int port, std::string address, ClientInformation *head){
     quit=false;
     enet_address_set_host (& bindAddress, address.c_str());
     bindAddress.port = NETWORK_PORT;
-  }
-
-  ConnectionManager::ConnectionManager(int port, const char *address){
+    head_ = head;
+  }
+
+  ConnectionManager::ConnectionManager(int port, const char *address, ClientInformation *head){
     quit=false;
     enet_address_set_host (& bindAddress, address);
     bindAddress.port = NETWORK_PORT;
+    head_ = head;
   }
 
@@ -53 +56 @@
     ENetAddress address;
     ENetPacket *packet=getPacket(address);
-    clientID=clientMap.find(address)->second;
+    clientID=head_->findClient(&address)->getID();
     return packet;
   }
@@ -74 +77 @@
 
   bool ConnectionManager::addPacket(ENetPacket *packet, ENetPeer *peer){
-    if(clientVector.size()==0)
-      return false;
-    if(enet_peer_send(peer, clientMap.find(peer->address)->second , packet)!=0)
+    if(enet_peer_send(peer, head_->findClient(&(peer->address))->getID() , packet)!=0)
       return false;
     return true;
@@ -82 +83 @@
   
   bool ConnectionManager::addPacket(ENetPacket *packet, int clientID){
-    if(clientVector.size()==0)
-      return false;
-    if(enet_peer_send(&(peerMap.find(clientVector[clientID])->second), clientID, packet)!=0)
+    if(enet_peer_send(head_->findClient(clientID)->getPeer(), clientID, packet)!=0)
       return false;
     return true;
@@ -90 +89 @@
   
   bool ConnectionManager::addPacketAll(ENetPacket *packet){
-    for(unsigned int i=0; i<clientVector.size(); i++){
-      if(enet_peer_send(&(peerMap.find(clientVector[i])->second), i, packet)!=0)
+    for(ClientInformation *i=head_->next(); i!=0; i=i->next()){
+      if(enet_peer_send(i->getPeer(), i->getID(), packet)!=0)
          return false;
     }
@@ -156 +155 @@
   
   void ConnectionManager::disconnectClients(){
-    bool disconnected=false;
     ENetEvent event;
-    for(unsigned int i=0; i<clientVector.size(); i++){
-      enet_peer_disconnect(&(peerMap.find(clientVector[i])->second), 0);
-      while( !disconnected && 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_RECEIVE:
-            enet_packet_destroy(event.packet);
-            break;
-          case ENET_EVENT_TYPE_DISCONNECT:
-            disconnected=true;
-            break;
-        }
-      }
-      disconnected=false;
+    ClientInformation *temp = head_->next();
+    while(temp!=0){
+      enet_peer_disconnect(temp->getPeer(), 0);
+      temp = temp->next();
+    }
+    temp = temp->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_RECEIVE:
+          enet_packet_destroy(event.packet);
+          break;
+        case ENET_EVENT_TYPE_DISCONNECT:
+          delete head_->findClient(&(event.peer->address));
+          temp = temp->next();
+          break;
+      }
     }
     return;
@@ -184 +185 @@
   }
 
+//   bool ConnectionManager::clientDisconnect(ENetPeer *peer){
+//     return clientDisconnect(*peer);
+//   }
+  
+  
+  
   bool ConnectionManager::clientDisconnect(ENetPeer *peer){
-    return clientDisconnect(*peer);
-  }
-  
-  bool ConnectionManager::clientDisconnect(ENetPeer peer){
-    std::map<ENetAddress, int>::iterator it;
-    it=clientMap.find(peer.address);
-    clientVector.erase(clientVector.begin()+it->second);
-    clientMap.erase(it);
-    peerMap.erase(peerMap.find(peer.address));
+    return head_->removeClient(peer);
     return true;
   }
 
   bool ConnectionManager::addClient(ENetEvent *event){
-    int id=clientVector.size();
-    clientVector.push_back((event->peer->address));
-    clientMap[event->peer->address]=id;
-    peerMap[event->peer->address]=*(event->peer);
-    syncClassid(id);
+    ClientInformation *temp = head_->insertBack(new ClientInformation);
+    temp->setID(temp->prev()->getID());
+    temp->setPeer(event->peer);
     return true;
   }
   
   int ConnectionManager::getClientID(ENetPeer peer){
-    return clientMap.find(peer.address)->second;
+    return getClientID(peer.address);
   }
   
   int ConnectionManager::getClientID(ENetAddress address){
-    return clientMap.find(address)->second;
-  }
-  
-  ENetPeer ConnectionManager::getClientPeer(int clientID){
-    return peerMap.find(clientVector[clientID])->second;
+    return head_->findClient(&address)->getID();
+  }
+  
+  ENetPeer *ConnectionManager::getClientPeer(int clientID){
+    return head_->findClient(clientID)->getPeer();
   }
   

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

@@ -23 +23 @@
 #include <boost/bind.hpp>
 // headerfiles
+#include "ClientInformation.h"
 #include "ConnectionManager.h"
 #include "PacketBuffer.h"
@@ -47 +48 @@
   class ConnectionManager{
     public:
-    ConnectionManager();
-    ConnectionManager(int port, const char *address);
-    ConnectionManager(int port, std::string address);
+    ConnectionManager(ClientInformation *head);
+    ConnectionManager(int port, const char *address, ClientInformation *head);
+    ConnectionManager(int port, std::string address, ClientInformation *head);
     ENetPacket *getPacket(ENetAddress &address); // thread1
     ENetPacket *getPacket(int &clientID);
@@ -60 +61 @@
     bool sendPackets(ENetEvent *event);
     bool sendPackets();
-    private:
+  private:
     bool clientDisconnect(ENetPeer *peer);
-    bool clientDisconnect(ENetPeer peer);
+    //bool clientDisconnect(ENetPeer peer);
     bool processData(ENetEvent *event);
     bool addClient(ENetEvent *event);
@@ -70 +71 @@
     int getClientID(ENetAddress address);
     void syncClassid(int clientID);
-    ENetPeer getClientPeer(int clientID);
+    ENetPeer *getClientPeer(int clientID);
     PacketBuffer buffer;
     PacketGenerator packet_gen;
@@ -78 +79 @@
     
     bool quit; // quit-variable (communication with threads)
-    std::map<ENetAddress, int> clientMap;
-    std::map<ENetAddress, ENetPeer> peerMap;
-    std::vector<ENetAddress> clientVector;
+    ClientInformation *head_;
   };
 

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

@@ -13 +13 @@
 
 bool GameStateClient::pushGameState(GameStateCompressed compstate){
-  return loadSnapshot(decode(reference, compstate));
+  if(compstate.diffed)
+    return loadSnapshot(decode(reference, compstate));
+  else
+    return loadSnapshot(decode(compstate));
 }
 
@@ -127 +130 @@
   gamestate.size = normsize;
   gamestate.data = dest;
+  gamestate.diffed = a.diffed;
   
   return gamestate;
@@ -137 +141 @@
 }
 
+GameState GameStateClient::decode(GameStateCompressed x){
+  GameState t = decompress(x);
+  return t;
+}
+
 
 

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

@@ -33 +33 @@
   GameState decompress(GameStateCompressed a);
   GameState decode(GameState a, GameStateCompressed x);
+  GameState decode(GameStateCompressed x);
   void removeObject(orxonox::Iterator<Synchronisable> &it);
   

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

@@ -14 +14 @@
 namespace network {
 
-GameStateManager::GameStateManager()
+GameStateManager::GameStateManager(ClientInformation *head)
 {
   id=0;
+  head_=head;
 }
 
@@ -25 +26 @@
 void GameStateManager::update(){
   reference = getSnapshot(id);
-  idGameState[id]=reference;
+  gameStateMap.insert(std::pair<int, GameState*>(id, reference));
+  gameStateUsed[id]=0;
   ++id;
   return;
@@ -31 +33 @@
 
 GameStateCompressed GameStateManager::popGameState(int clientID){
-  GameState *client = clientGameState[clientID];
+  int gID = head_->findClient(clientID)->getGamestateID();
+  if(gID!=GAMESTATEID_INITIAL){
+    GameState *client = gameStateMap[gID];
+    GameState *server = reference;
+    return encode(client, server);
+  }
   GameState *server = reference;
-  return encode(client, server);
+  return encode(server);
+  // return an undiffed gamestate and set appropriate flags
 }
 
@@ -85 +93 @@
 
 GameStateCompressed GameStateManager::encode(GameState *a, GameState *b){
-  GameState r = diff(a,b);
-  return compress_(r);
+    GameState r = diff(a,b);
+  r.diffed = true;
+  return compress_(&r);
 }
 
+GameStateCompressed GameStateManager::encode(GameState *a){
+  a->diffed=false;
+  return compress_(a);
+}
 
 GameState GameStateManager::diff(GameState *a, GameState *b){
@@ -122 +135 @@
 }
 
-GameStateCompressed GameStateManager::compress_(GameState a) {
-  int size = a.size;
-  uLongf buffer = (uLongf)((a.size + 12)*1.01)+1;
+GameStateCompressed GameStateManager::compress_(GameState *a) {
+  int size = a->size;
+  uLongf buffer = (uLongf)((a->size + 12)*1.01)+1;
   unsigned char* dest = (unsigned char*)malloc( buffer );
   int retval;
-  retval = compress( dest, &buffer, a.data, (uLong)size );  
+  retval = compress( dest, &buffer, a->data, (uLong)size );  
   
   switch ( retval ) {
@@ -141 +154 @@
   compressedGamestate.id = GAMESTATE;
   compressedGamestate.data = dest;
+  compressedGamestate.diffed = a->diffed;
   
   return compressedGamestate;
@@ -146 +160 @@
 
 void GameStateManager::ackGameState(int clientID, int gamestateID){
+  ClientInformation *temp = head_->findClient(clientID);
+  int curid = temp->getID();
+  // decrease usage of gamestate and save it
+  deleteUnusedGameState(curid);
+  //increase gamestateused
+  ++gameStateUsed.find(gamestateID)->second;
+  temp->setGamestateID(gamestateID);
+  /*
   GameState *old = clientGameState[clientID];
   deleteUnusedGameState(old);
-  clientGameState[clientID]=idGameState[gamestateID];
+  clientGameState[clientID]=idGameState[gamestateID];*/
 }
 
-bool GameStateManager::deleteUnusedGameState(GameState *state){
-  for(unsigned int i=0; i<clientGameState.size(); i++){
-    if(clientGameState[i]==state)
-      return false;
+bool GameStateManager::deleteUnusedGameState(int gamestateID){
+  int used = --(gameStateUsed.find(gamestateID)->second);
+  if(id-gamestateID>KEEP_GAMESTATES && used==0){
+    // delete gamestate
+    delete gameStateMap.find(gamestateID)->second;
+    gameStateMap.erase(gamestateID);
+    return true;
   }
-  delete state;
-  return true;
-}
-
-void GameStateManager::removeClient(int clientID){
-  clientGameState.erase(clientGameState.begin()+clientID);
+  return false;
 }
 

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

@@ -13 +13 @@
 #define NETWORK_GAMESTATEMANAGER_H
 
-#include <vector>
+#include <map>
 
 #include "zlib.h"
 
+#include "ClientInformation.h"
 #include "Synchronisable.h"
 #include "orxonox/core/IdentifierIncludes.h"
@@ -24 +25 @@
 namespace network {
 
-
+#define KEEP_GAMESTATES 20
 
 /**
@@ -43 +44 @@
 class GameStateManager{
 public:
-  GameStateManager();
+  GameStateManager(ClientInformation *head);
   ~GameStateManager();
   void update();
   GameStateCompressed popGameState(int clientID);
   void ackGameState(int clientID, int gamestateID);
-  void removeClient(int clientID);
 private:
   GameState *getSnapshot(int id);
   GameStateCompressed encode(GameState *a, GameState *b);
+  GameStateCompressed encode(GameState *a);
   GameState diff(GameState *a, GameState *b);
-  GameStateCompressed compress_(GameState a);
-  bool deleteUnusedGameState(GameState *state);
+  GameStateCompressed compress_(GameState *a);
+  bool deleteUnusedGameState(int gamestateID);
   
-  std::vector<GameState *> clientGameState;
-  std::vector<GameState *> idGameState;
+  std::map<int, GameState*> gameStateMap; //map gsID to gamestate*
+  std::map<int, int> gameStateUsed; // save the number of clients, that use the specific gamestate
   GameState *reference;
   int id;
+  ClientInformation *head_;
 };
 

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

@@ -33 +33 @@
     int id;
     int size;
+    // new ---- change functions
+    bool diffed;
     unsigned char *data;
   };
@@ -46 +48 @@
     int compsize;
     int normsize;
+    // new ----- change functions
+    bool diffed;
     unsigned char *data;
   };

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

@@ -21 +21 @@
    */
   Server::Server(){
-    connection = ConnectionManager();
-    gamestates = GameStateManager();
     packet_gen = PacketGenerator();
+    clients = new ClientInformation();
+    connection = new ConnectionManager(clients);
+    gamestates = new GameStateManager(clients);
   }
 
@@ -32 +33 @@
    */
   Server::Server(int port, std::string bindAddress){
-    connection = ConnectionManager(port, bindAddress);
-    gamestates = GameStateManager();
     packet_gen = PacketGenerator();
+    clients = new ClientInformation();
+    connection = new ConnectionManager(port, bindAddress, clients);
+    gamestates = new GameStateManager(clients);
   }
 
@@ -43 +45 @@
    */
   Server::Server(int port, const char *bindAddress){
-    connection = ConnectionManager(port, bindAddress);
-    gamestates = GameStateManager();
     packet_gen = PacketGenerator();
+    clients = new ClientInformation();
+    connection = new ConnectionManager(port, bindAddress, clients);
+    gamestates = new GameStateManager(clients);
   }
   
@@ -52 +55 @@
    */
   void Server::open(){
-    connection.createListener();
+    connection->createListener();
     return;
   }
@@ -60 +63 @@
    */
   void Server::close(){
-    connection.quitListener();
+    connection->quitListener();
     return;
   }
@@ -71 +74 @@
   bool Server::sendMSG(std::string msg){
     ENetPacket *packet = packet_gen.chatMessage(msg.c_str());
-    connection.addPacketAll(packet);
-    return connection.sendPackets();
+    connection->addPacketAll(packet);
+    return connection->sendPackets();
   }
   /**
@@ -81 +84 @@
   bool Server::sendMSG(const char *msg){
     ENetPacket *packet = packet_gen.chatMessage(msg);
-    connection.addPacketAll(packet);
-    return connection.sendPackets();
+    connection->addPacketAll(packet);
+    return connection->sendPackets();
   }
   
@@ -101 +104 @@
     ENetPacket *packet;
     int clientID=-1;
-    while(!connection.queueEmpty()){
-      packet = connection.getPacket(clientID);
+    while(!connection->queueEmpty()){
+      packet = connection->getPacket(clientID);
       elaborate(packet, clientID);
     }
@@ -111 +114 @@
    */
   void Server::updateGamestate(){
-    gamestates.update();
+    gamestates->update();
     sendGameState();
   }

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

@@ -20 +20 @@
 #include "GameStateManager.h"
 #include "enet/enet.h"
+#include "ClientInformation.h"
 
 namespace network{
@@ -39 +40 @@
     private:
     bool sendGameState();
-    ConnectionManager connection;
-    GameStateManager gamestates;
+    ConnectionManager *connection;
+    GameStateManager *gamestates;
     PacketGenerator packet_gen;
     
     void processQueue();
     void updateGamestate();
+    ClientInformation *clients;
   };
 

code/branches/FICN/src/network/TODO

@@ -3 +3 @@
 - change ConnectionManager clientlist
 - change gamestatemanager clientlist
-- put them together into ClientInformation
+- put them together into ClientInformation [done]
 
 - do better gamestate-update/snapshot-handling
+- integrate ClientInformation into gamestatemanager [done]
 
 - write dummyserver and dummyclient (chat system)