Changeset 3084 for code/trunk

Timestamp:

May 26, 2009, 9:20:57 PM (16 years ago)

Author:

landauf

Message:

merged netp3 branch back to trunk

Location:

code/trunk

Files:

• . (modified) (1 prop)
• src/CMakeLists.txt (modified) (1 diff)
• src/core/Game.cc (modified) (1 diff)
• src/core/Game.h (modified) (1 diff)
• src/core/GameState.cc (modified) (1 diff)
• src/core/GameState.h (modified) (2 diffs)
• src/core/input/InputManager.cc (modified) (4 diffs)
• src/core/input/InputManager.h (modified) (1 diff)
• src/network/CMakeLists.txt (modified) (1 diff)
• src/network/Client.cc (modified) (4 diffs)
• src/network/Client.h (modified) (2 diffs)
• src/network/ClientConnection.cc (modified) (10 diffs)
• src/network/ClientConnection.h (modified) (4 diffs)
• src/network/ConnectionManager.cc (modified) (11 diffs)
• src/network/ConnectionManager.h (modified) (3 diffs)
• src/network/FunctionCallManager.cc (copied) (copied from code/branches/netp3/src/network/FunctionCallManager.cc) (1 prop)
• src/network/FunctionCallManager.h (copied) (copied from code/branches/netp3/src/network/FunctionCallManager.h) (1 prop)
• src/network/GamestateManager.cc (modified) (3 diffs)
• src/network/GamestateManager.h (modified) (1 diff)
• src/network/Host.h (modified) (1 diff)
• src/network/NetworkFunction.cc (copied) (copied from code/branches/netp3/src/network/NetworkFunction.cc) (1 prop)
• src/network/NetworkFunction.h (copied) (copied from code/branches/netp3/src/network/NetworkFunction.h) (1 prop)
• src/network/NetworkPrereqs.h (modified) (3 diffs)
• src/network/Server.cc (modified) (4 diffs)
• src/network/Server.h (modified) (2 diffs)
• src/network/TrafficControl.cc (modified) (14 diffs)
• src/network/TrafficControl.h (modified) (5 diffs)
• src/network/packet/CMakeLists.txt (modified) (1 diff)
• src/network/packet/ClassID.cc (modified) (1 diff)
• src/network/packet/FunctionCalls.cc (copied) (copied from code/branches/netp3/src/network/packet/FunctionCalls.cc) (1 prop)
• src/network/packet/FunctionCalls.h (copied) (copied from code/branches/netp3/src/network/packet/FunctionCalls.h) (1 prop)
• src/network/packet/FunctionIDs.cc (copied) (copied from code/branches/netp3/src/network/packet/FunctionIDs.cc) (1 prop)
• src/network/packet/FunctionIDs.h (copied) (copied from code/branches/netp3/src/network/packet/FunctionIDs.h) (1 prop)
• src/network/packet/Gamestate.cc (modified) (7 diffs)
• src/network/packet/Gamestate.h (modified) (4 diffs)
• src/network/packet/Packet.cc (modified) (3 diffs)
• src/network/packet/Packet.h (modified) (3 diffs)
• src/network/synchronisable/NetworkCallbackManager.cc (modified) (2 diffs)
• src/network/synchronisable/Synchronisable.cc (modified) (6 diffs)
• src/network/synchronisable/Synchronisable.h (modified) (7 diffs)
• src/network/synchronisable/SynchronisableSpecialisations.cc (modified) (3 diffs)
• src/network/synchronisable/SynchronisableVariable.cc (copied) (copied from code/branches/netp3/src/network/synchronisable/SynchronisableVariable.cc) (1 prop)
• src/network/synchronisable/SynchronisableVariable.h (modified) (15 diffs)
• src/orxonox/OrxonoxPrereqs.h (modified) (1 diff)
• src/orxonox/gamestates/GSGraphics.cc (modified) (3 diffs)
• src/orxonox/gamestates/GSGraphics.h (modified) (1 diff)
• src/orxonox/gamestates/GSRoot.cc (modified) (2 diffs)
• src/orxonox/gamestates/GSRoot.h (modified) (1 diff)
• src/orxonox/objects/CMakeLists.txt (modified) (1 diff)
• src/orxonox/objects/Test.cc (modified) (4 diffs)
• src/orxonox/objects/Test.h (modified) (4 diffs)
• src/orxonox/objects/controllers/AIController.cc (modified) (2 diffs)
• src/orxonox/objects/worldentities/ControllableEntity.cc (modified) (1 diff)
• src/orxonox/objects/worldentities/MobileEntity.h (modified) (1 diff)
• src/orxonox/objects/worldentities/PongBall.cc (modified) (3 diffs)
• src/orxonox/objects/worldentities/PongBall.h (modified) (4 diffs)
• src/orxonox/objects/worldentities/PongBat.cc (modified) (3 diffs)
• src/orxonox/objects/worldentities/pawns/Pawn.cc (modified) (4 diffs)
• src/orxonox/objects/worldentities/pawns/Pawn.h (modified) (1 diff)
• src/util/MultiType.h (modified) (3 diffs)
• src/util/MultiTypeValue.h (modified) (2 diffs)
• src/util/Serialise.h (copied) (copied from code/branches/netp3/src/util/Serialise.h) (1 prop)

code/trunk/src/CMakeLists.txt

@@ -106 +106 @@
   # Bullet headers really need the include directory
   ${CMAKE_CURRENT_SOURCE_DIR}/bullet
+  # OIS headers need the root dir as well
+  ${CMAKE_CURRENT_SOURCE_DIR}/ois
   # Convenience directory
   ${CMAKE_CURRENT_SOURCE_DIR}/orxonox

code/trunk/src/core/Game.cc

@@ -185 +185 @@
             for (std::vector<GameState*>::const_iterator it = this->activeStates_.begin();
                 it != this->activeStates_.end(); ++it)
+            {
+                // Add tick time for most of the states
+                uint64_t timeBeforeTick;
+                if ((*it)->getCountTickTime())
+                    timeBeforeTick = this->gameClock_->getRealMicroseconds();
+                
                 (*it)->update(*this->gameClock_);
+
+                if ((*it)->getCountTickTime())
+                    this->addTickTime(this->gameClock_->getRealMicroseconds() - timeBeforeTick);
+            }
 
             // STATISTICS

code/trunk/src/core/Game.h

@@ -43 +43 @@
 #include "OrxonoxClass.h"
 
-#define AddGameState(classname, name) \
-    static bool MACRO_CONCATENATE(bGameStateDummy_##classname, __LINE__) = orxonox::Game::addGameState(new classname(name))
+/**
+@def
+    Adds a new GameState to the Game. The second parameter is the name as string
+    and every following paramter is a constructor argument (which is usually non existent)
+*/
+#define AddGameState(classname, ...) \
+    static bool MACRO_CONCATENATE(bGameStateDummy_##classname, __LINE__) = orxonox::Game::addGameState(new classname(__VA_ARGS__))
 
 // tolua_begin

code/trunk/src/core/GameState.cc

@@ -45 +45 @@
         Constructor only initialises variables and sets the name permanently.
     */
-    GameState::GameState(const std::string& name)
+    GameState::GameState(const std::string& name, bool countTickTime)
         : name_(name)
+        , bCountTickTime_(countTickTime)
         , parent_(0)
     {

code/trunk/src/core/GameState.h

@@ -78 +78 @@
 
     public:
-        GameState(const std::string& name);
+        GameState(const std::string& name, bool countTicktime = true);
         virtual ~GameState();
 
         const std::string& getName() const { return name_; }
-        State getActivity() const    { return this->activity_; }
-        GameState* getParent() const       { return this->parent_; }
+        State getActivity()          const { return this->activity_; }
+        GameState* getParent()       const { return this->parent_; }
+
+        bool getCountTickTime()      const { return this->bCountTickTime_; }
 
         void addChild(GameState* state);
@@ -102 +104 @@
         const std::string                        name_;
         State                                    activity_;
+        const bool                               bCountTickTime_;
         GameState*                               parent_;
         std::map<std::string, GameState*>        children_;

code/trunk/src/core/input/InputManager.cc

@@ -41 +41 @@
 #include "ois/OISException.h"
 #include "ois/OISInputManager.h"
+#include "core/ConsoleCommand.h"
+
+// HACK
+#ifdef ORXONOX_PLATFORM_LINUX
+#  include "ois/linux/LinuxMouse.h"
+#endif
 
 #include "util/Exception.h"
@@ -47 +53 @@
 #include "core/ConfigValueIncludes.h"
 #include "core/CommandExecutor.h"
-#include "core/ConsoleCommand.h"
 #include "core/CommandLine.h"
 #include "util/Debug.h"
@@ -64 +69 @@
     SetConsoleCommand(InputManager, calibrate, true);
     SetConsoleCommand(InputManager, reload, false);
+#ifdef ORXONOX_PLATFORM_LINUX
+    SetConsoleCommand(InputManager, grabMouse, true);
+    SetConsoleCommand(InputManager, ungrabMouse, true);
+#endif
     SetCommandLineSwitch(keyboard_no_grab);
 
@@ -1469 +1478 @@
         getInstance().reloadInputSystem(joyStickSupport);
     }
+
+
+    // ############################################################
+    // #####                   ugly hacks                     #####
+    // ##########                                        ##########
+    // ############################################################
+
+#ifdef ORXONOX_PLATFORM_LINUX
+    void InputManager::grabMouse()
+    {
+        OIS::LinuxMouse* linuxMouse = dynamic_cast<OIS::LinuxMouse*>(singletonRef_s->mouse_);
+        assert(linuxMouse);
+        linuxMouse->grab(true);
+    }
+
+    void InputManager::ungrabMouse()
+    {
+        OIS::LinuxMouse* linuxMouse = dynamic_cast<OIS::LinuxMouse*>(singletonRef_s->mouse_);
+        assert(linuxMouse);
+        linuxMouse->grab(false);
+    }
+#endif
 }

code/trunk/src/core/input/InputManager.h

@@ -137 +137 @@
         bool requestEnterState     (const std::string& name);
         bool requestLeaveState     (const std::string& name);
+
+#ifdef ORXONOX_PLATFORM_LINUX
+        // HACK!
+        static void grabMouse();
+        static void ungrabMouse();
+#endif
 
         void update(const Clock& time);

code/trunk/src/network/CMakeLists.txt

@@ -25 +25 @@
   ClientConnectionListener.cc
   ConnectionManager.cc
+  FunctionCallManager.cc
   GamestateManager.cc
   GamestateClient.cc
   GamestateHandler.cc
+  NetworkFunction.cc
+  Host.cc
   PacketBuffer.cc
   Server.cc
   TrafficControl.cc
-  Host.cc
 )
 ADD_SUBDIRECTORY(packet)

code/trunk/src/network/Client.cc

@@ -21 +21 @@
  *
  *   Author:
- *      Oliver Scheuss, (C) 2007
+ *      Oliver Scheuss
  *   Co-authors:
  *      ...
@@ -48 +48 @@
 #include "core/CoreIncludes.h"
 #include "packet/Packet.h"
+#include "FunctionCallManager.h"
 
 // #include "packet/Acknowledgement.h"
@@ -140 +141 @@
    */
   void Client::update(const Clock& time){
-//     COUT(3) << ".";
-    if(client_connection.isConnected() && isSynched_){
-      COUT(4) << "popping partial gamestate: " << std::endl;
-      packet::Gamestate *gs = gamestate.getGamestate();
-      if(gs){
-        COUT(4) << "client tick: sending gs " << gs << std::endl;
-        if( !gs->send() )
-          COUT(3) << "Problem adding partial gamestate to queue" << std::endl;
+    //this steers our network frequency
+    timeSinceLastUpdate_+=time.getDeltaTime();
+    if(timeSinceLastUpdate_>=NETWORK_PERIOD){
+      timeSinceLastUpdate_ -= static_cast<unsigned int>( timeSinceLastUpdate_ / NETWORK_PERIOD ) * NETWORK_PERIOD;
+      //     COUT(3) << ".";
+      if(client_connection.isConnected() && isSynched_){
+        COUT(4) << "popping partial gamestate: " << std::endl;
+        packet::Gamestate *gs = gamestate.getGamestate();
+        //assert(gs); <--- there might be the case that no data has to be sent, so its commented out now
+        if(gs){
+          COUT(4) << "client tick: sending gs " << gs << std::endl;
+          if( !gs->send() )
+            COUT(3) << "Problem adding partial gamestate to queue" << std::endl;
         // gs gets automatically deleted by enet callback
+        }
+        FunctionCallManager::sendCalls();
       }
     }
+    
     ENetEvent *event;
     // stop if the packet queue is empty
@@ -167 +176 @@
     }
     gamestate.cleanup();
+
     return;
   }

code/trunk/src/network/Client.h

@@ -21 +21 @@
  *
  *   Author:
- *      Oliver Scheuss, (C) 2007
+ *      Oliver Scheuss
  *   Co-authors:
  *      ...
@@ -88 +88 @@
 
     bool gameStateFailure_;
+    float timeSinceLastUpdate_;
   };
 

code/trunk/src/network/ClientConnection.cc

@@ -21 +21 @@
  *
  *   Author:
- *      Oliver Scheuss, (C) 2007
+ *      Oliver Scheuss
  *   Co-authors:
  *      ...
@@ -42 +42 @@
 #include <enet/enet.h>
 #include <iostream>
+#include <cassert>
 // boost.thread library for multithreading support
 #include <boost/thread/thread.hpp>
@@ -57 +58 @@
 
   ClientConnection::ClientConnection(int port, const std::string& address) {
-    quit=false;
+    quit_=false;
     server=NULL;
     serverAddress = new ENetAddress();
@@ -66 +67 @@
 
   ClientConnection::ClientConnection(int port, const char *address) {
-    quit=false;
+    quit_=false;
     server=NULL;
     serverAddress = new ENetAddress();
@@ -106 +107 @@
 
   bool ClientConnection::closeConnection() {
-    quit=true;
+    quit_=true;
     //network_threads.join_all();
     receiverThread_->join();
@@ -150 +151 @@
       COUT(2) << "ClientConnection: could not create client host" << std::endl;
       // add some error handling here ==========================
-      quit=true;
+      quit_=true;
     }
     //connect to the server
     if(!establishConnection()){
       COUT(2) << "clientConn: receiver thread: could not establishConnection" << std::endl;
-      quit=true;
+      quit_=true;
       return;
     }
     event = new ENetEvent;
     //main loop
-    while(!quit){
+    while(!quit_){
       //std::cout << "connection loop" << std::endl;
       {
@@ -166 +167 @@
         if(enet_host_service(client, event, NETWORK_CLIENT_WAIT_TIME)<0){
           // we should never reach this point
-          quit=true;
-          continue;
+//              assert(0);
+          printf("ClientConnection: ENet returned with an error!\n");
+          quit_=true;
+          break;
           // add some error handling here ========================
         }
@@ -183 +186 @@
         break;
       case ENET_EVENT_TYPE_DISCONNECT:
-        quit=true;
+        quit_=true;
+        printf("Received disconnect Packet from Server!\n");
         // server closed the connection
         return;
@@ -204 +208 @@
   bool ClientConnection::disconnectConnection() {
     ENetEvent event;
+    if(this->quit_)
+      return true;
     boost::recursive_mutex::scoped_lock lock(enet_mutex_g);
     enet_peer_disconnect(server, 0);
-    while(enet_host_service(client, &event, NETWORK_CLIENT_WAIT_TIME) > 0){
+    while(enet_host_service(client, &event, NETWORK_CLIENT_WAIT_TIME) >= 0){
       switch (event.type)
       {
@@ -233 +239 @@
     }
     // handshake
-    while(enet_host_service(client, &event, NETWORK_CLIENT_WAIT_TIME)>=0 && !quit){
+    while(enet_host_service(client, &event, NETWORK_CLIENT_WAIT_TIME)>=0 && !quit_){
       if( event.type == ENET_EVENT_TYPE_CONNECT ){
         established=true;

code/trunk/src/network/ClientConnection.h

@@ -21 +21 @@
  *
  *   Author:
- *      Oliver Scheuss, (C) 2007
+ *      Oliver Scheuss
  *   Co-authors:
  *      ...
@@ -53 +53 @@
     const int NETWORK_PORT = 55556;
     const int NETWORK_CLIENT_MAX_CONNECTIONS = 5;
-    const int NETWORK_CLIENT_WAIT_TIME = 1;
+    const int NETWORK_CLIENT_WAIT_TIME = 10;
     const int NETWORK_CLIENT_CONNECT_TIMEOUT = 3000; // miliseconds
     const int NETWORK_CLIENT_CHANNELS = 2;
@@ -76 +76 @@
     //bool sendPackets(ENetEvent *event);
     bool waitEstablished(int milisec);
-    bool isConnected(){return established;}
+    inline bool isConnected(){return established;}
+    inline bool checkConnection(){ return !quit_ && isConnected(); }
   private:
     ClientConnection(const ClientConnection& copy); // not used
@@ -90 +91 @@
     ENetAddress *serverAddress;
     // quit-variable (communication with threads)
-    bool quit;
+    bool quit_;
     bool established;
     // clientlist

code/trunk/src/network/ConnectionManager.cc

@@ -58 +58 @@
 {
   bool operator< (ENetAddress a, ENetAddress b) {
-    if(a.host <= b.host)
-      return true;
-    else
-      return false;
+    return a.host <= b.host;
   }
 }
@@ -75 +72 @@
     assert(instance_==0);
     instance_=this;
-    quit=false;
+    quit_=false;
     bindAddress = new ENetAddress();
     bindAddress->host = ENET_HOST_ANY;
@@ -84 +81 @@
     assert(instance_==0);
     instance_=this;
-    quit=false;
+    quit_=false;
     bindAddress = new ENetAddress();
     bindAddress->host = ENET_HOST_ANY;
@@ -93 +90 @@
     assert(instance_==0);
     instance_=this;
-    quit=false;
+    quit_=false;
     bindAddress = new ENetAddress();
     enet_address_set_host (bindAddress, address.c_str());
@@ -102 +99 @@
     assert(instance_==0);
     instance_=this;
-    quit=false;
+    quit_=false;
     bindAddress = new ENetAddress();
     enet_address_set_host (bindAddress, address);
@@ -109 +106 @@
 
   ConnectionManager::~ConnectionManager(){
-    if(!quit)
+    if(!quit_)
       quitListener();
     instance_=0;
@@ -133 +130 @@
 
   bool ConnectionManager::quitListener() {
-    quit=true;
+    quit_=true;
     receiverThread_->join();
     return true;
@@ -189 +186 @@
     if(server==NULL){
       // add some error handling here ==========================
-      quit=true;
+      quit_=true;
       return;
     }
 
     event = new ENetEvent;
-    while(!quit){
+    while(!quit_)
+    {
       { //mutex scope
         boost::recursive_mutex::scoped_lock lock(enet_mutex_g);
         if(enet_host_service(server, event, NETWORK_WAIT_TIMEOUT)<0){
           // we should never reach this point
-          quit=true;
+          printf("ConnectionManager: ENet returned with an error\n");
+          quit_=true;
+          printf("waaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaahhhhhhhhhhhhhhhh\n");
           continue;
           // add some error handling here ========================
@@ -208 +208 @@
         // log handling ================
         case ENET_EVENT_TYPE_CONNECT:
+//             printf("====================================================================");
         case ENET_EVENT_TYPE_DISCONNECT:
         case ENET_EVENT_TYPE_RECEIVE:
@@ -215 +216 @@
         case ENET_EVENT_TYPE_NONE:
           //receiverThread_->yield();
-          msleep(1);
+          msleep(10);
           break;
       }
@@ -267 +268 @@
   }
 
-  bool ConnectionManager::processData(ENetEvent *event) {
-    // just add packet to the buffer
-    // this can be extended with some preprocessing
-    return buffer.push(event);
-  }
-
-
 
   int ConnectionManager::getClientID(ENetPeer* peer) {

code/trunk/src/network/ConnectionManager.h

@@ -55 +55 @@
     const int NETWORK_PORT = 55556;
     const int NETWORK_MAX_CONNECTIONS = 50;
-    const int NETWORK_WAIT_TIMEOUT = 1;
+    const int NETWORK_WAIT_TIMEOUT = 10;
     const int NETWORK_DEFAULT_CHANNEL = 0;
 
@@ -81 +81 @@
     void disconnectClient(ClientInformation *client);
     void syncClassid(unsigned int clientID);
+    bool checkReceiverThread(){ return !quit_; }
 
   private:
     ConnectionManager(const ConnectionManager& copy); // not used
-    bool processData(ENetEvent *event);
+    inline bool processData(ENetEvent *event){ return buffer.push(event); }
     void receiverThread();
     void disconnectClients();
@@ -95 +96 @@
     ENetAddress *bindAddress;
 
-    bool quit; // quit-variable (communication with threads)
+    bool quit_; // quit-variable (communication with threads)
 
     boost::thread *receiverThread_;

code/trunk/src/network/GamestateManager.cc

@@ -21 +21 @@
  *
  *   Author:
- *      Oliver Scheuss, (C) 2007
+ *      Oliver Scheuss
  *   Co-authors:
  *      ...
@@ -132 +132 @@
     if(client){
 //       COUT(3) << "diffing" << std::endl;
+//       packet::Gamestate* gs1  = gs;
       gs = gs->diff(client);
+//       packet::Gamestate* gs2 = gs->undiff(client);
 //       gs = new packet::Gamestate(*gs);
+//       assert(*gs1==*gs2);
     }
     else{
@@ -161 +164 @@
       for(it = gamestateMap_[clientID].begin(); it!=gamestateMap_[clientID].end(); ){
         delete it->second;
+
         gamestateMap_[clientID].erase(it++);
       }

code/trunk/src/network/GamestateManager.h

@@ -21 +21 @@
  *
  *   Author:
- *      Oliver Scheuss, (C) 2007
+ *      Oliver Scheuss
  *   Co-authors:
  *      ...

code/trunk/src/network/Host.h

@@ -35 +35 @@
 
 namespace orxonox {
+
+  const int CLIENTID_SERVER = 0;
+  const unsigned int NETWORK_FREQUENCY = 30;
+  const float NETWORK_PERIOD = 1.0f/NETWORK_FREQUENCY;
 
 /**

code/trunk/src/network/NetworkPrereqs.h

@@ -90 +90 @@
   class ClientInformation;
   class ConnectionManager;
+  class FunctionCallManager;
   class GamestateClient;
   class GamestateManager;
@@ -96 +97 @@
   template <class T> class NetworkCallback;
   class NetworkCallbackManager;
+  class NetworkFunctionBase;
+  class NetworkFunctionStatic;
+  class NetworkMemberFunctionBase;
+  template <class T> class NetworkMemeberFunction;
+  struct NetworkFunctionPointer;
   class PacketBuffer;
   class Server;
@@ -112 +118 @@
   namespace packet
   {
+    class Acknowledgement;
+    class Chat;
+    class ClassID;
+    class FunctionCalls;
+    class FunctionIDs;
     class Gamestate;
+    class NetworkIDs;
     class Packet;
-    class Acknowledgement;
-    class ClassID;
     class Welcome;
-    class Chat;
   }
 }

code/trunk/src/network/Server.cc

@@ -21 +21 @@
  *
  *   Author:
- *      Oliver Scheuss, (C) 2007
+ *      Oliver Scheuss
  *   Co-authors:
  *      ...
@@ -61 +61 @@
 #include "util/Convert.h"
 #include "ChatListener.h"
+#include "FunctionCallManager.h"
+#include "packet/FunctionIDs.h"
+
 
 namespace orxonox
@@ -152 +155 @@
   void Server::update(const Clock& time) {
     processQueue();
+    gamestates_->processGamestates();
     //this steers our network frequency
     timeSinceLastUpdate_+=time.getDeltaTime();
     if(timeSinceLastUpdate_>=NETWORK_PERIOD){
       timeSinceLastUpdate_ -= static_cast<unsigned int>( timeSinceLastUpdate_ / NETWORK_PERIOD ) * NETWORK_PERIOD;
-      gamestates_->processGamestates();
       updateGamestate();
+      FunctionCallManager::sendCalls();
     }
   }
@@ -341 +345 @@
       return false;
     }
-    COUT(4) << "Con.Man: creating client id: " << temp->getID() << std::endl;
+    COUT(5) << "Con.Man: creating client id: " << temp->getID() << std::endl;
+    
+    // synchronise class ids
     connection->syncClassid(temp->getID());
+    
+    // now synchronise functionIDs
+    packet::FunctionIDs *fIDs = new packet::FunctionIDs();
+    fIDs->setClientID(clientID);
+    bool b = fIDs->send();
+    assert(b);
+    
     temp->setSynched(true);
-    COUT(3) << "sending welcome" << std::endl;
+    COUT(4) << "sending welcome" << std::endl;
     packet::Welcome *w = new packet::Welcome(temp->getID(), temp->getShipID());
     w->setClientID(temp->getID());
-    bool b = w->send();
+    b = w->send();
     assert(b);
     packet::Gamestate *g = new packet::Gamestate();

code/trunk/src/network/Server.h

@@ -21 +21 @@
  *
  *   Author:
- *      Oliver Scheuss, (C) 2007
+ *      Oliver Scheuss
  *   Co-authors:
  *      ...
  *
  */
-
-//
-// C++ Interface: Server
-//
-// Description:
-//
-//
-// Author:  Oliver Scheuss, (C) 2007
-//
-// Copyright: See COPYING file that comes with this distribution
-//
-//
 
 #ifndef _Server_H__
@@ -51 +39 @@
 namespace orxonox
 {
-  const int CLIENTID_SERVER = 0;
-  const unsigned int NETWORK_FREQUENCY = 25;
-  const float NETWORK_PERIOD = 1.f/NETWORK_FREQUENCY;
 
   /**

code/trunk/src/network/TrafficControl.cc

@@ -21 +21 @@
  *
  *   Author:
- *      Oliver Scheuss <scheusso [at] ee.ethz.ch>, (C) 2008
+ *      Oliver Scheuss <scheusso [at] ee.ethz.ch>
  *   Co-authors:
  *      ...
@@ -91 +91 @@
   void TrafficControl::setConfigValues()
   {
-    SetConfigValue ( bActive_, true );
-    SetConfigValue ( targetSize, 5000 );
+    SetConfigValue ( bActive_, false );
+    SetConfigValue ( targetSize, 10000 );
   }
 
@@ -121 +121 @@
 
 
-        void TrafficControl::processObjectList(unsigned int clientID, unsigned int gamestateID, std::list<obj> *list)
-        {
-//        copiedVector = *list;
+        void TrafficControl::processObjectList(unsigned int clientID, unsigned int gamestateID, std::list<obj>& list)
+        {
           currentClientID=clientID;
           currentGamestateID=gamestateID;
@@ -143 +142 @@
     assert(clientListTemp_.find(clientID) != clientListTemp_.end() );
     assert(clientListPerm_.find(clientID) != clientListPerm_.end() );
-          assert( clientListTemp_[clientID].find(gamestateID) != clientListTemp_[clientID].end() );
-
-    for(itvec = clientListTemp_[clientID][gamestateID].begin(); itvec != clientListTemp_[clientID][gamestateID].end(); itvec++)
+    assert( clientListTemp_[clientID].find(gamestateID) != clientListTemp_[clientID].end() );
+    
+    // shortcut for maps
+    std::map<unsigned int, objInfo >& objectListPerm = clientListPerm_[clientID];
+    std::map<unsigned int, std::list<obj> >& objectListTemp = clientListTemp_[clientID];
+
+    for(itvec = objectListTemp[gamestateID].begin(); itvec != objectListTemp[gamestateID].end(); itvec++)
           {
-      if(clientListPerm_[clientID].find((*itvec).objID) != clientListPerm_[clientID].end()) // check whether the obj already exists in our lists
-      {
-        clientListPerm_[clientID][(*itvec).objID].objCurGS = gamestateID;
-        clientListPerm_[clientID][(*itvec).objID].objValueSched = 0; //set scheduling value back
+      if(objectListPerm.find((*itvec).objID) != objectListPerm.end()) // check whether the obj already exists in our lists
+      {
+        objectListPerm[(*itvec).objID].objCurGS = gamestateID;
+        objectListPerm[(*itvec).objID].objValueSched = 0; //set scheduling value back
       }
       else
       {
         assert(0);
-        clientListPerm_[clientID][(*itvec).objID].objCurGS = gamestateID;
-        clientListPerm_[clientID][(*itvec).objID].objID = (*itvec).objID;
-        clientListPerm_[clientID][(*itvec).objID].objCreatorID = (*itvec).objCreatorID;
-        clientListPerm_[clientID][(*itvec).objID].objSize = (*itvec).objSize;
+        objectListPerm[(*itvec).objID].objCurGS = gamestateID;
+        objectListPerm[(*itvec).objID].objID = (*itvec).objID;
+        objectListPerm[(*itvec).objID].objCreatorID = (*itvec).objCreatorID;
+        objectListPerm[(*itvec).objID].objSize = (*itvec).objSize;
       }
           }
            // remove temporary list (with acked objects) from the map
-    clientListTemp_[clientID].erase( clientListTemp_[clientID].find(gamestateID) );
+    objectListTemp.erase( objectListTemp.find(gamestateID) );
         }
 
@@ -176 +179 @@
         {
           std::map<unsigned int,std::map<unsigned int, objInfo> >::iterator itperm;//iterator clientListPerm over clientIDs
-//        itperm = (clientListPerm_).find(clientID);
-//        assert(itperm != clientListPerm_.end() );
     unsigned int gsid=GAMESTATEID_INITIAL, gsdiff=currentGamestateID, prioperm=Synchronisable::getSynchronisable(objinf.objID)->getPriority(), priomom=0;
     clientListPerm_[clientID][objinf.objID] = objInfo(objinf.objID, objinf.objCreatorID,gsid,gsdiff, objinf.objSize,prioperm,priomom);
-//        itperm->second.insert(std::pair<unsigned int, objInfo>(objid,objinf));
-//     permObjPrio_.insert(objid, objinf.objValuePerm);
         }
 
@@ -188 +187 @@
   * takes the shortened list which will be sent to the gsmanager and puts the *info into clientListTemp
   */
-  void TrafficControl::updateClientListTemp(std::list<obj> *list)
-  {
-    clientListTemp_[currentClientID][currentGamestateID] = std::list<obj>(*list);
+  void TrafficControl::updateClientListTemp(std::list<obj>& list)
+  {
+    clientListTemp_[currentClientID][currentGamestateID] = std::list<obj>(list);
   }
 
@@ -197 +196 @@
   *takes the current list that has to be returned to the gsmanager and shortens it in criteria of bandwidth of clientID(XY)
   */
-  void TrafficControl::cut(std::list<obj> *list, unsigned int targetsize)
+  void TrafficControl::cut(std::list<obj>& list, unsigned int targetsize)
   {
     unsigned int size=0;
     std::list<obj>::iterator itvec, ittemp;
-    assert(!list->empty());
-    for(itvec = list->begin(); itvec != list->end();)
+    assert(!list.empty());
+    for(itvec = list.begin(); itvec != list.end();)
     {
       assert( (*itvec).objSize < 1000);
@@ -213 +212 @@
       {
         clientListPerm_[currentClientID][(*itvec).objID].objValueSched += SCHED_PRIORITY_OFFSET; // NOTE: SCHED_PRIORITY_OFFSET is negative
-        list->erase(itvec++);
+        list.erase(itvec, list.end());
+        break;
       }
 //       printList(list, currentClientID);
     }
-    assert(!list->empty());
+    assert(!list.empty());
   }
 
@@ -224 +224 @@
         *evaluateList evaluates whether new obj are there, whether there are things to be updatet and manipulates all this.
         */
-        void TrafficControl::evaluateList(unsigned int clientID, std::list<obj> *list)
+        void TrafficControl::evaluateList(unsigned int clientID, std::list<obj>& list)
         {
 
@@ -232 +232 @@
     //if listToProcess contains new Objects, add them to clientListPerm
     std::list<obj>::iterator itvec;
-          for( itvec=list->begin(); itvec != list->end(); itvec++)
+    
+    std::map<unsigned int, objInfo >& objectListPerm = clientListPerm_[clientID];
+    
+          for( itvec=list.begin(); itvec != list.end(); itvec++)
           {
-            if ( clientListPerm_[clientID].find( (*itvec).objID) != clientListPerm_[clientID].end() )
+            if ( objectListPerm.find( (*itvec).objID) != objectListPerm.end() )
       {
         // we already have the object in our map
         //obj bleibt in liste und permanente prio wird berechnet
-        clientListPerm_[clientID][(*itvec).objID].objDiffGS = currentGamestateID - clientListPerm_[clientID][(*itvec).objID].objCurGS;
+        objectListPerm[(*itvec).objID].objDiffGS = currentGamestateID - objectListPerm[(*itvec).objID].objCurGS;
         continue;//check next objId
       }
@@ -254 +257 @@
       //sort copied list according to priorities
       // use boost bind here because we need to pass a memberfunction to stl sort
-      list->sort(boost::bind(&TrafficControl::prioritySort, this, clientID, _1, _2) );
+//       sort( list.begin(), list.end(), boost::bind(&TrafficControl::prioritySort, this, clientID, _1, _2) );
+      list.sort( boost::bind(&TrafficControl::prioritySort, this, clientID, _1, _2) );
+      
+//       list.sort(boost::bind(&TrafficControl::prioritySort, this, clientID, _1, _2) );
 
       //now we check, that the creator of an object always exists on a client
       std::list<obj>::iterator itcreator;
-      for(itvec = list->begin(); itvec != list->end(); itvec++)
+      for(itvec = list.begin(); itvec != list.end(); itvec++)
       {
         fixCreatorDependencies(itvec, list, clientID);
@@ -266 +272 @@
 //       printList(list, clientID);
       cut(list, targetSize);
-
       //now sort again after objDataOffset
-      list->sort(boost::bind(&TrafficControl::dataSort, this, _1, _2) );
+//       sort(list.begin(), list.end(), boost::bind(&TrafficControl::dataSort, this, _1, _2) );
+      list.sort( boost::bind(&TrafficControl::dataSort, this, _1, _2) );
     }
     //diese Funktion updateClientList muss noch gemacht werden
@@ -275 +281 @@
   }
 
-  void TrafficControl::printList(std::list<obj> *list, unsigned int clientID)
+  void TrafficControl::printList(std::list<obj>& list, unsigned int clientID)
   {
     std::list<obj>::iterator it;
     COUT(0) << "=========== Objectlist ===========" << endl;
-    for( it=list->begin(); it!=list->end(); it++)
+    for( it=list.begin(); it!=list.end(); it++)
       COUT(0) << "ObjectID: " << (*it).objID << " creatorID: " << (*it).objCreatorID << " Priority: " << clientListPerm_[clientID][(*it).objID].objValuePerm + clientListPerm_[clientID][(*it).objID].objValueSched << " size: " << (*it).objSize << endl;
   }
 
-  void TrafficControl::fixCreatorDependencies(std::list<obj>::iterator it1, std::list<obj> *list, unsigned int clientID)
+  void TrafficControl::fixCreatorDependencies(std::list<obj>::iterator it1, std::list<obj>& list, unsigned int clientID)
   {
     if ( (*it1).objCreatorID == OBJECTID_UNKNOWN )
@@ -290 +296 @@
       return;
     std::list<obj>::iterator it2, it3=it1;
-    for( it2 = ++it3; it2 != list->end(); it2++ )
+    for( it2 = ++it3; it2 != list.end(); it2++ )
     {
       if( (*it2).objID == (*it1).objCreatorID )
       {
-        it3 = list->insert(it1, *it2); //insert creator before it1
-        list->erase(it2);
+        it3 = list.insert(it1, *it2); //insert creator before it1
+        list.erase(it2);
 //         printList(list, clientID);
         fixCreatorDependencies( it3, list, clientID );

code/trunk/src/network/TrafficControl.h

@@ -21 +21 @@
  *
  *   Author:
- *      Oliver Scheuss <scheusso [at] ee.ethz.ch>, (C) 2008
+ *      Oliver Scheuss <scheusso [at] ee.ethz.ch>
  *   Co-authors:
  *      ...
@@ -83 +83 @@
 
     /**
-    *Lists that will be used:
-    *listToProcess
-    *clientListPerm
-    *clientListTemp
-    *referenceList
-    *permObjPrio list
-    *schedObjPrio
-    */
-    //start: lists to be used
-    /**
-    *creates list (typ map) that contains objids, struct with info concerning object(objid)
-    */
-//     std::map<unsigned int, objInfo> listToProcess_;//copy of argument, when traffic control tool is being called, the original of this must be returned later on, eg the list given by GS
-    /**
     *permanent client list: contains client ids, object ids and objectInfos (in this order)
     */
@@ -106 +92 @@
     */
     std::map<unsigned int, std::map<unsigned int, std::list<obj> > > clientListTemp_;
-    /**
-    *static priority list: contains obj id, basic priority (in this order)
-    */
-//     std::map<unsigned int, unsigned int> permObjPrio_;
-    /**
-    *dynamic priority list: contains obj id, dynamic priority (eg scheduled) (in this order)
-    */
-//     std::map<unsigned int, unsigned int> schedObjPrio_;
-    //end: lists to be used
 
     /**updateReferenceList
@@ -123 +100 @@
     unsigned int targetSize;
     bool         bActive_;
-    /**
-    *copiedVector is a copy of the given Vector by the GSmanager, on this list all manipulations are performed
-    */
-//     std::list<obj> copiedVector;
-
-//     void updateReferenceList(std::map<unsigned int, objInfo> *list);//done
-    void insertinClientListPerm(unsigned int clientID, obj objinf);//done
-    /**
-    *creates listToProcess, which can be easialy compared with other lists
-    */
-//     void copyList(std::list<obj> *list);//done
     
-    void cut(std::list<obj> *list, unsigned int targetsize);
-    void updateClientListTemp(std::list<obj> *list);//done
+    void insertinClientListPerm(unsigned int clientID, obj objinf);
+    
+    void cut(std::list<obj>& list, unsigned int targetsize);
+    void updateClientListTemp(std::list<obj>& list);//done
     /**
     *evaluates Data given (list) and produces result(->Data to be updated)
     */
-    void evaluateList(unsigned int clientID, std::list<obj> *list);//done    
+    void evaluateList(unsigned int clientID, std::list<obj>& list);//done    
     void ack(unsigned int clientID, unsigned int gamestateID);  // this function gets called when the server receives an ack from the client
     
@@ -162 +130 @@
     void setConfigValues();
     static TrafficControl *getInstance();
-    void processObjectList(unsigned int clientID, unsigned int gamestateID, std::list<obj>* list); //gets a pointer to the list (containing objectIDs) and sorts it
-    //done
+    void processObjectList(unsigned int clientID, unsigned int gamestateID, std::list<obj>& list); //gets a pointer to the list (containing objectIDs) and sorts it
     static void processAck(unsigned int clientID, unsigned int gamestateID)
     { return instance_->ack(clientID, gamestateID); }
-    //done
     void deleteObject(unsigned int objectID);                           // this function gets called when an object has been deleted (in order to clean up lists and maps)
     
     bool prioritySort(uint32_t clientID, obj i, obj j);
     bool dataSort(obj i, obj j);
-    void printList(std::list<obj> *list, unsigned int clientID);
-    void fixCreatorDependencies(std::list<obj>::iterator it, std::list<obj> *list, unsigned int clientID);
+    void printList(std::list<obj>& list, unsigned int clientID);
+    void fixCreatorDependencies(std::list<obj>::iterator it, std::list<obj>& list, unsigned int clientID);
 };
 

code/trunk/src/network/packet/CMakeLists.txt

@@ -1 +1 @@
 ADD_SOURCE_FILES(NETWORK_SRC_FILES
   Packet.cc
+  Acknowledgement.cc
   Chat.cc
   ClassID.cc
-  Acknowledgement.cc
+  DeleteObjects.cc
+  FunctionIDs.cc
+  FunctionCalls.cc
   Gamestate.cc
   Welcome.cc
-  DeleteObjects.cc
 )

code/trunk/src/network/packet/ClassID.cc

@@ -93 +93 @@
   }
   
-  COUT(0) << "classid packetSize is " << packetSize << endl;
+  COUT(5) << "classid packetSize is " << packetSize << endl;
   
 }

code/trunk/src/network/packet/Gamestate.cc

@@ -21 +21 @@
  *
  *   Author:
- *      Oliver Scheuss, (C) 2008
+ *      Oliver Scheuss
  *   Co-authors:
  *      ...
@@ -107 +107 @@
   for(it = ObjectList<Synchronisable>::begin(); it; ++it){
     
-    tempsize=it->getSize(id, mode);
+//     tempsize=it->getSize(id, mode);
+
+    tempsize = it->getData(mem, id, mode);
+    if ( tempsize != 0 )
+      dataVector_.push_back( obj(it->getObjectID(), it->getCreatorID(), tempsize, mem-data_) );
+    
 #ifndef NDEBUG
     if(currentsize+tempsize > size){
@@ -123 +128 @@
     }// stop allocate additional memory
 #endif
-
-    if ( it->doSync( id, mode ) )
-      dataMap_.push_back( obj(it->getObjectID(), it->getCreatorID(), tempsize, mem-data_) );
-    if(!it->getData(mem, id, mode))
-      return false; // mem pointer gets automatically increased because of call by reference
+//     if(!it->getData(mem, id, mode))
+//       return false; // mem pointer gets automatically increased because of call by reference
     // increase size counter by size of current synchronisable
     currentsize+=tempsize;
@@ -177 +179 @@
     }
   }
-
    // In debug mode, check first, whether there are no duplicate objectIDs
 #ifndef NDEBUG
-  ObjectList<Synchronisable>::iterator it;
-  for (it = ObjectList<Synchronisable>::begin(); it != ObjectList<Synchronisable>::end(); ++it) {
-    if (it->getObjectID() == OBJECTID_UNKNOWN) {
-      if (it->objectMode_ != 0x0) {
-        COUT(0) << "Found object with OBJECTID_UNKNOWN on the client with objectMode != 0x0!" << std::endl;
-        COUT(0) << "Possible reason for this error: Client created a synchronized object without the Server's approval." << std::endl;
-        COUT(0) << "Objects class: " << it->getIdentifier()->getName() << std::endl;
-        assert(false);
+  if(this->getID()%1000==0){
+    std::list<uint32_t> v1;
+    ObjectList<Synchronisable>::iterator it;
+    for (it = ObjectList<Synchronisable>::begin(); it != ObjectList<Synchronisable>::end(); ++it) {
+      if (it->getObjectID() == OBJECTID_UNKNOWN) {
+        if (it->objectMode_ != 0x0) {
+          COUT(0) << "Found object with OBJECTID_UNKNOWN on the client with objectMode != 0x0!" << std::endl;
+          COUT(0) << "Possible reason for this error: Client created a synchronized object without the Server's approval." << std::endl;
+          COUT(0) << "Objects class: " << it->getIdentifier()->getName() << std::endl;
+          assert(false);
+        }
       }
-    }
-    else {
-      ObjectList<Synchronisable>::iterator it2;
-      for (it2 = ObjectList<Synchronisable>::begin(); it2 != ObjectList<Synchronisable>::end(); ++it2) {
-        if (it->getObjectID() == it2->getObjectID() && *it != *it2) {
-           COUT(0) << "Found duplicate objectIDs on the client!" << std::endl
-                   << "Are you sure you don't create a Sychnronisable objcect with 'new' \
-                       that doesn't have objectMode = 0x0?" << std::endl;
-           assert(false);
+      else {
+        std::list<uint32_t>::iterator it2;
+        for (it2 = v1.begin(); it2 != v1.end(); ++it2) {
+          if (it->getObjectID() == *it2) {
+            COUT(0) << "Found duplicate objectIDs on the client!" << std::endl
+                    << "Are you sure you don't create a Sychnronisable objcect with 'new' \
+                        that doesn't have objectMode = 0x0?" << std::endl;
+            assert(false);
+          }
         }
+        v1.push_back(it->getObjectID());
       }
     }
@@ -221 +226 @@
   uint8_t *d1 = data_+GamestateHeader::getSize();
   uint8_t *d2 = gs.data_+GamestateHeader::getSize();
+  GamestateHeader* h1 = new GamestateHeader(data_);
+  GamestateHeader* h2 = new GamestateHeader(gs.data_);
+  assert(h1->getDataSize() == h2->getDataSize());
   assert(!isCompressed());
   assert(!gs.isCompressed());
-  while(d1<data_+header_->getDataSize())
-  {
-    if(*d1!=*d2)
-      return false;
-    d1++;
-    d2++;
-  }
-  return true;
+  return memcmp(d1, d2, h1->getDataSize())==0;
 }
 
@@ -357 +358 @@
 }
 
+// Gamestate *Gamestate::diff(Gamestate *base)
+// {
+//   assert(data_);
+//   assert(!header_->isCompressed());
+//   assert(!header_->isDiffed());
+//   GamestateHeader diffHeader(base->data_);
+//   uint8_t *basep = GAMESTATE_START(base->data_), *gs = GAMESTATE_START(this->data_);
+//   uint32_t of=0; // pointers offset
+//   uint32_t dest_length=0;
+//   dest_length=header_->getDataSize();
+//   if(dest_length==0)
+//     return NULL;
+//   uint8_t *ndata = new uint8_t[dest_length*sizeof(uint8_t)+GamestateHeader::getSize()];
+//   uint8_t *dest = ndata + GamestateHeader::getSize();
+//   
+//   
+//   // LOOP-UNROLLED DIFFING
+//   uint32_t *dest32 = (uint32_t*)dest, *base32 = (uint32_t*)basep, *gs32 = (uint32_t*)gs;
+//   // diff in 4-byte steps
+//   while( of < (uint32_t)(header_->getDataSize())/4 ){
+//     if( of < (uint32_t)(diffHeader.getDataSize())/4 )
+//     {
+//       *(dest32+of)=*(base32+of) ^ *(gs32+of); // do the xor
+//       ++of;
+//     }
+//     else
+//     {
+//       *(dest32+of)=*(gs32+of); // same as 0 ^ *(gs32+of)
+//       ++of;
+//     }
+//   }
+//   for( unsigned int of2 = 0; of2 < header_->getDataSize()%4; ++of2 )
+//   {
+//     if( of*4+of2 < diffHeader.getDataSize() )
+//     {
+//       *(dest+4*of+of2)=*(basep+4*of+of2) ^ *(gs+4*of+of2); // do the xor
+//     }
+//     else
+//     {
+//       *(dest+4*of+of2)=*(gs+4*of+of2); // same as 0 ^ *(gs32+of)
+//     }
+//   }
+// 
+//   Gamestate *g = new Gamestate(ndata, getClientID());
+//   *(g->header_) = *header_;
+//   g->header_->setDiffed( true );
+//   g->header_->setBaseID( base->getID() );
+//   g->flags_=flags_;
+//   g->packetDirection_ = packetDirection_;
+//   return g;
+// }
+
 Gamestate* Gamestate::doSelection(unsigned int clientID, unsigned int targetSize){
   assert(data_);
@@ -378 +431 @@
 
   //call TrafficControl
-  TrafficControl::getInstance()->processObjectList( clientID, header_->getID(), &dataMap_ );
+  TrafficControl::getInstance()->processObjectList( clientID, header_->getID(), dataVector_ );
 
   //copy in the zeros
-  for(it=dataMap_.begin(); it!=dataMap_.end();){
+//   std::list<obj>::iterator itt;
+//   COUT(0) << "myvector contains:";
+//   for ( itt=dataVector_.begin() ; itt!=dataVector_.end(); itt++ )
+//     COUT(0) << " " << (*itt).objID;
+//   COUT(0) << endl;
+  for(it=dataVector_.begin(); it!=dataVector_.end();){
     SynchronisableHeader oldobjectheader(origdata);
     SynchronisableHeader newobjectheader(newdata);

code/trunk/src/network/packet/Gamestate.h

@@ -21 +21 @@
  *
  *   Author:
- *      Oliver Scheuss, (C) 2008
+ *      Oliver Scheuss
  *   Co-authors:
  *      ...
@@ -37 +37 @@
 #include <string.h>
 #include <map>
-#include <list>
+#include <vector>
 #include <cassert>
 #ifndef NDEBUG
@@ -120 +120 @@
     bool compressData();
     bool decompressData();
+    bool operator ==(packet::Gamestate gs);
 
     // Packet functions
@@ -126 +127 @@
     virtual inline bool process();
 
-    bool operator ==(packet::Gamestate gs);
   private:
     uint32_t calcGamestateSize(int32_t id, uint8_t mode=0x0);
-    std::list<obj> dataMap_;
+    std::list<obj> dataVector_;
     GamestateHeader* header_;
 };

code/trunk/src/network/packet/Packet.cc

@@ -39 +39 @@
 
 #include "Acknowledgement.h"
+#include "DeleteObjects.h"
 #include "Chat.h"
 #include "ClassID.h"
+#include "FunctionCalls.h"
+#include "FunctionIDs.h"
 #include "Gamestate.h"
 #include "Welcome.h"
-#include "DeleteObjects.h"
 #include "network/Host.h"
 #include "core/CoreIncludes.h"
@@ -153 +155 @@
     case ENUM::Welcome:
     case ENUM::DeleteObjects:
+    case ENUM::FunctionIDs:
+    case ENUM::FunctionCalls:
       break;
     default:
@@ -170 +174 @@
   unsigned int clientID = ClientInformation::findClient(&peer->address)->getID();
   Packet *p = 0;
-  COUT(5) << "packet type: " << *(ENUM::Type *)&data[_PACKETID] << std::endl;
+  COUT(6) << "packet type: " << *(ENUM::Type *)&data[_PACKETID] << std::endl;
   switch( *(ENUM::Type *)(data + _PACKETID) )
   {
     case ENUM::Acknowledgement:
-      COUT(4) << "ack" << std::endl;
+      COUT(5) << "ack" << std::endl;
       p = new Acknowledgement( data, clientID );
       break;
     case ENUM::Chat:
-      COUT(4) << "chat" << std::endl;
+      COUT(5) << "chat" << std::endl;
       p = new Chat( data, clientID );
       break;
     case ENUM::ClassID:
-      COUT(4) << "classid" << std::endl;
+      COUT(5) << "classid" << std::endl;
       p = new ClassID( data, clientID );
       break;
     case ENUM::Gamestate:
-      COUT(4) << "gamestate" << std::endl;
+      COUT(5) << "gamestate" << std::endl;
       // TODO: remove brackets
       p = new Gamestate( data, clientID );
       break;
     case ENUM::Welcome:
-      COUT(4) << "welcome" << std::endl;
+      COUT(5) << "welcome" << std::endl;
       p = new Welcome( data, clientID );
       break;
     case ENUM::DeleteObjects:
-      COUT(4) << "deleteobjects" << std::endl;
+      COUT(5) << "deleteobjects" << std::endl;
       p = new DeleteObjects( data, clientID );
+      break;
+    case ENUM::FunctionCalls:
+      COUT(5) << "functionCalls" << std::endl;
+      p = new FunctionCalls( data, clientID );
+      break;
+    case ENUM::FunctionIDs:
+      COUT(5) << "functionIDs" << std::endl;
+      p = new FunctionIDs( data, clientID );
       break;
     default:

code/trunk/src/network/packet/Packet.h

@@ -45 +45 @@
   enum Type{
     Acknowledgement,
+    Chat,
+    ClassID,
+    DeleteObjects,
+    FunctionIDs,
+    FunctionCalls,
     Gamestate,
-    ClassID,
-    Chat,
-    Welcome,
-    DeleteObjects
+    Welcome
   };
 }
@@ -66 +68 @@
     virtual unsigned int getSize() const =0;
     virtual bool process()=0;
-    uint32_t getFlags()
+    inline uint32_t getFlags()
       { return flags_; }
-    int getClientID()
+    inline int getClientID()
       { return clientID_; }
-    void setClientID( int id )
+    inline void setClientID( int id )
       { clientID_ = id; }
 
@@ -78 +80 @@
     Packet(uint8_t *data, unsigned int clientID);
 //    Packet(ENetPacket *packet, ENetPeer *peer);
+    inline bool isDataENetAllocated() const
+      { return bDataENetAllocated_; }
+
     uint32_t flags_;
     unsigned int clientID_;

code/trunk/src/network/synchronisable/NetworkCallbackManager.cc

@@ -32 +32 @@
 
 namespace orxonox{
-
+  
   std::set<NetworkCallbackBase*> NetworkCallbackManager::callbackSet_;
   std::queue<NetworkCallbackBase*> NetworkCallbackManager::triggeredCallbacks_;
@@ -60 +60 @@
     while( triggeredCallbacks_.empty()==false )
     {
-      triggeredCallbacks_.front()->call();
+      //make sure callback hasn't been deleted before
+      if ( callbackSet_.find(triggeredCallbacks_.front()) != callbackSet_.end() )
+        triggeredCallbacks_.front()->call();
       triggeredCallbacks_.pop();
     }

code/trunk/src/network/synchronisable/Synchronisable.cc

@@ -66 +66 @@
       objectID=OBJECTID_UNKNOWN;
     classID = static_cast<uint32_t>(-1);
-
+    
+    // set dataSize to 0
+    this->dataSize_ = 0;
     // set standard priority
     this->setPriority( priority::normal );
@@ -96 +98 @@
     // delete callback function objects
     if(!Identifier::isCreatingHierarchy()){
-      for(std::list<SynchronisableVariableBase*>::iterator it = syncList.begin(); it!=syncList.end(); it++)
+      for(std::vector<SynchronisableVariableBase*>::iterator it = syncList.begin(); it!=syncList.end(); it++)
         delete (*it);
       if (this->objectMode_ != 0x0 && (Host::running() && Host::isServer()))
@@ -236 +238 @@
    * @return true: if !doSync or if everything was successfully saved
    */
-  bool Synchronisable::getData(uint8_t*& mem, int32_t id, uint8_t mode){
+  uint32_t Synchronisable::getData(uint8_t*& mem, int32_t id, uint8_t mode){
     if(mode==0x0)
       mode=state_;
     //if this tick is we dont synchronise, then abort now
     if(!doSync(id, mode))
-      return true;
+      return 0;
     uint32_t tempsize = 0;
     if (this->classID==0)
@@ -250 +252 @@
 
     assert(this->classID==this->getIdentifier()->getNetworkID());
-    std::list<SynchronisableVariableBase*>::iterator i;
-    uint32_t size;
-    size=getSize(id, mode);
+    std::vector<SynchronisableVariableBase*>::iterator i;
 
     // start copy header
     SynchronisableHeader header(mem);
-    header.setDataSize( size );
+    mem += SynchronisableHeader::getSize();
+    // end copy header
+
+
+    COUT(5) << "Synchronisable getting data from objectID: " << objectID << " classID: " << classID << std::endl;
+    // copy to location
+    for(i=syncList.begin(); i!=syncList.end(); ++i){
+      tempsize += (*i)->getData( mem, mode );
+      //tempsize += (*i)->getSize( mode );
+    }
+    
+    tempsize += SynchronisableHeader::getSize();
     header.setObjectID( this->objectID );
     header.setCreatorID( this->creatorID );
     header.setClassID( this->classID );
     header.setDataAvailable( true );
-    tempsize += SynchronisableHeader::getSize();
-    mem += SynchronisableHeader::getSize();
-    // end copy header
-
-
-    COUT(5) << "Synchronisable getting data from objectID: " << objectID << " classID: " << classID << " length: " << size << std::endl;
-    // copy to location
-    for(i=syncList.begin(); i!=syncList.end(); ++i){
-      (*i)->getData( mem, mode );
-      tempsize += (*i)->getSize( mode );
-    }
+    header.setDataSize( tempsize );
+    
+#ifndef NDEBUG
+    uint32_t size;
+    size=getSize(id, mode);
     assert(tempsize==size);
-    return true;
+#endif
+    return tempsize;
   }
 
@@ -286 +292 @@
     if(mode==0x0)
       mode=state_;
-    std::list<SynchronisableVariableBase *>::iterator i;
+    std::vector<SynchronisableVariableBase *>::iterator i;
     if(syncList.empty()){
       assert(0);
@@ -325 +331 @@
   uint32_t Synchronisable::getSize(int32_t id, uint8_t mode){
     int tsize=SynchronisableHeader::getSize();
-    if(mode==0x0)
+    if (mode==0x0)
       mode=state_;
-    if(!doSync(id, mode))
+    if (!doSync(id, mode))
       return 0;
-    std::list<SynchronisableVariableBase*>::iterator i;
-    for(i=syncList.begin(); i!=syncList.end(); i++){
+    assert( mode==state_ );
+    tsize += this->dataSize_;
+    std::vector<SynchronisableVariableBase*>::iterator i;
+    for(i=stringList.begin(); i!=stringList.end(); ++i){
       tsize += (*i)->getSize( mode );
     }

code/trunk/src/network/synchronisable/Synchronisable.h

@@ -33 +33 @@
 
 #include <list>
+#include <vector>
 #include <map>
 #include <queue>
 #include <cassert>
+#include <string>
 #include "util/Math.h"
 #include "util/mbool.h"
@@ -120 +122 @@
   public:
     friend class packet::Gamestate;
-//     friend class Server;
     virtual ~Synchronisable();
 
@@ -139 +140 @@
     Synchronisable(BaseObject* creator);
     template <class T> void registerVariable(T& variable, uint8_t mode=0x1, NetworkCallbackBase *cb=0, bool bidirectional=false);
-    template <class T> void unregisterVariable(T& var);
+    //template <class T> void unregisterVariable(T& var);
     void setObjectMode(uint8_t mode);
     void setPriority(unsigned int freq){ objectFrequency_ = freq; }
@@ -145 +146 @@
 
   private:
-    bool getData(uint8_t*& men, int32_t id, uint8_t mode=0x0);
+    uint32_t getData(uint8_t*& men, int32_t id, uint8_t mode=0x0);
     uint32_t getSize(int32_t id, uint8_t mode=0x0);
     bool updateData(uint8_t*& mem, uint8_t mode=0x0, bool forceCallback=false);
@@ -155 +156 @@
     uint32_t classID;
 
-    std::list<SynchronisableVariableBase*> syncList;
+    std::vector<SynchronisableVariableBase*> syncList;
+    std::vector<SynchronisableVariableBase*> stringList;
+    uint32_t dataSize_; //size of all variables except strings
     static uint8_t 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)
@@ -164 +167 @@
   };
 
-  template <class T> void Synchronisable::registerVariable(T& variable, uint8_t mode, NetworkCallbackBase *cb, bool bidirectional)
-  {
-    if (bidirectional)
-      syncList.push_back(new SynchronisableVariableBidirectional<const T>(variable, mode, cb));
-    else
-      syncList.push_back(new SynchronisableVariable<const T>(variable, mode, cb));
-  }
-
-  template <class T> void Synchronisable::unregisterVariable(T& var){
-    std::list<SynchronisableVariableBase*>::iterator it = syncList.begin();
-    while(it!=syncList.end()){
-      if( ((*it)->getReference()) == &var ){
-        delete (*it);
-        syncList.erase(it);
-        return;
-      }
-      else
-        it++;
-    }
-    bool unregistered_nonexistent_variable = false;
-    assert(unregistered_nonexistent_variable); //if we reach this point something went wrong:
-    // the variable has not been registered before
-  }
-
   // ================= Specialisation declarations
+  
+//   template <> _NetworkExport void Synchronisable::registerVariable( const std::string& variable, uint8_t mode, NetworkCallbackBase *cb, bool bidirectional);
+  template <> _NetworkExport void Synchronisable::registerVariable( std::string& variable, uint8_t mode, NetworkCallbackBase *cb, bool bidirectional);
   template <> _NetworkExport void Synchronisable::registerVariable( const ColourValue& variable, uint8_t mode, NetworkCallbackBase* cb, bool bidirectional);
   template <> _NetworkExport void Synchronisable::registerVariable( ColourValue& variable, uint8_t mode, NetworkCallbackBase* cb, bool bidirectional);
@@ -200 +182 @@
   template <> _NetworkExport void Synchronisable::registerVariable( const Quaternion& variable, uint8_t mode, NetworkCallbackBase* cb, bool bidirectional);
   template <> _NetworkExport void Synchronisable::registerVariable( Quaternion& variable, uint8_t mode, NetworkCallbackBase* cb, bool bidirectional);
+  
+  template <class T> void Synchronisable::registerVariable(T& variable, uint8_t mode, NetworkCallbackBase *cb, bool bidirectional)
+  {
+    if (bidirectional)
+    {
+      syncList.push_back(new SynchronisableVariableBidirectional<const T>(variable, mode, cb));
+      this->dataSize_ += syncList.back()->getSize(state_);
+    }
+    else
+    {
+      syncList.push_back(new SynchronisableVariable<const T>(variable, mode, cb));
+      if ( this->state_ == mode )
+        this->dataSize_ += syncList.back()->getSize(state_);
+    }
+  }
+  
+
+
+//   template <class T> void Synchronisable::unregisterVariable(T& var){
+//     std::vector<SynchronisableVariableBase*>::iterator it = syncList.begin();
+//     while(it!=syncList.end()){
+//       if( ((*it)->getReference()) == &var ){
+//         delete (*it);
+//         syncList.erase(it);
+//         return;
+//       }
+//       else
+//         it++;
+//     }
+//     bool unregistered_nonexistent_variable = false;
+//     assert(unregistered_nonexistent_variable); //if we reach this point something went wrong:
+//     // the variable has not been registered before
+//   }
+
+  
 }
 

code/trunk/src/network/synchronisable/SynchronisableSpecialisations.cc

@@ -29 +29 @@
 
 #include "network/synchronisable/Synchronisable.h"
+#include <string>
 
 // ================ template spezialisation
@@ -34 +35 @@
   
 namespace orxonox{
+  
+//   template <> void Synchronisable::registerVariable( const std::string& variable, uint8_t mode, NetworkCallbackBase *cb, bool bidirectional)
+//   {
+//     if (bidirectional)
+//       syncList.push_back(new SynchronisableVariableBidirectional<const std::string>(variable, mode, cb));
+//     else
+//       syncList.push_back(new SynchronisableVariable<const std::string>(variable, mode, cb));
+//     stringList.push_back(syncList.back());
+//   }
+  
+  template <> void Synchronisable::registerVariable( std::string& variable, uint8_t mode, NetworkCallbackBase *cb, bool bidirectional)
+  {
+    if (bidirectional)
+      syncList.push_back(new SynchronisableVariableBidirectional<const std::string>(variable, mode, cb));
+    else
+      syncList.push_back(new SynchronisableVariable<const std::string>(variable, mode, cb));
+    stringList.push_back(syncList.back());
+  }
   
   template <> void Synchronisable::registerVariable( const ColourValue& variable, uint8_t mode, NetworkCallbackBase* cb, bool bidirectional)
@@ -52 +71 @@
     registerVariable(variable.y, mode, cb, bidirectional);
   }
-  template <> void Synchronisable::registerVariable( Vector2& variable, uint8_t mode, NetworkCallbackBase* cb, bool bidirectional)
-  {
-    registerVariable( (const ColourValue&)variable, mode, cb, bidirectional);
-  }
+//   template <> void Synchronisable::registerVariable( Vector2& variable, uint8_t mode, NetworkCallbackBase* cb, bool bidirectional)
+//   {
+//     registerVariable( (const ColourValue&)variable, mode, cb, bidirectional);
+//   }
   
   template <> void Synchronisable::registerVariable( const Vector3& variable, uint8_t mode, NetworkCallbackBase* cb, bool bidirectional)

code/trunk/src/network/synchronisable/SynchronisableVariable.h

@@ -21 +21 @@
  *
  *   Author:
- *      Oliver Scheuss, (C) 2008
+ *      Oliver Scheuss
  *   Co-authors:
  *      ...
@@ -35 +35 @@
 #include <string>
 #include <cassert>
-#include "util/Math.h"
+#include "util/Serialise.h"
+#include "core/Core.h"
+#include "core/CoreIncludes.h"
+#include "core/GameMode.h"
 #include "network/synchronisable/NetworkCallback.h"
 #include "network/synchronisable/NetworkCallbackManager.h"
@@ -55 +58 @@
   {
     public:
-      virtual void getData(uint8_t*& mem, uint8_t mode)=0;
+      virtual uint32_t getData(uint8_t*& mem, uint8_t mode)=0;
       virtual void putData(uint8_t*& mem, uint8_t mode, bool forceCallback = false)=0;
       virtual uint32_t getSize(uint8_t mode)=0;
@@ -62 +65 @@
       virtual ~SynchronisableVariableBase() {}
     protected:
-      static void setState();
       static uint8_t state_;
   };
@@ -74 +76 @@
 
       virtual inline uint8_t getMode(){ return mode_; }
-      virtual inline void getData(uint8_t*& mem, uint8_t mode);
+      virtual inline uint32_t getData(uint8_t*& mem, uint8_t mode);
       virtual inline void putData(uint8_t*& mem, uint8_t mode, bool forceCallback = false);
       virtual inline uint32_t getSize(uint8_t mode);
       virtual inline void* getReference(){ return (void *)&this->variable_; }
     protected:
-      bool checkEquality(uint8_t* mem);
-      void setAndIncrease(uint8_t*& mem);
-      void getAndIncrease(uint8_t*& mem);
-      uint32_t returnSize();
       
       T& variable_;
@@ -97 +95 @@
       
       virtual inline uint8_t getMode(){ return 0x3; } //this basically is a hack ^^
-      virtual void getData(uint8_t*& mem, uint8_t mode);
+      virtual inline uint32_t getData(uint8_t*& mem, uint8_t mode);
       virtual void putData(uint8_t*& mem, uint8_t mode, bool forceCallback = false);
-      virtual uint32_t getSize(uint8_t mode);
+      virtual inline uint32_t getSize(uint8_t mode);
     private:
       T varBuffer_;
@@ -110 +108 @@
       variable_( variable ), mode_( syncDirection ), callback_( cb )
   {
-      setState();
+    if ( state_ == 0x0 )
+    {
+      state_ = GameMode::isMaster() ? 0x1 : 0x2;  // set the appropriate mode here
+    }
   }
   
@@ -119 +120 @@
   }
 
-  template <class T> void SynchronisableVariable<T>::getData(uint8_t*& mem, uint8_t mode)
+  template <class T> inline uint32_t SynchronisableVariable<T>::getData(uint8_t*& mem, uint8_t mode)
   {
     if ( state_ == this->mode_ )
-      getAndIncrease( mem );
-//   mem += SynchronisableVariable<T>::getSize();
+    {
+      saveAndIncrease( this->variable_, mem );
+      return returnSize( this->variable_ );
+    }
+    else
+      return 0;
   }
 
@@ -135 +140 @@
     if ( this->callback_ != 0 )
     {
-      if( forceCallback || !checkEquality( mem ) )
+      if( forceCallback || !checkEquality( this->variable_, mem ) )
         callback = true;
     }
   // write the data
-    setAndIncrease( mem );
-//   mem += SynchronisableVariable<T>::getSize();
+    loadAndIncrease( this->variable_, mem );
   // now do a callback if neccessary
     if ( callback )
       NetworkCallbackManager::triggerCallback( this->callback_ );
-      //this->callback_->call();
-  }
-
-  template <class T> uint32_t SynchronisableVariable<T>::getSize(uint8_t mode)
+  }
+
+  template <class T> inline uint32_t SynchronisableVariable<T>::getSize(uint8_t mode)
   {
     if ( mode == this->mode_ )
-      return returnSize();
+      return returnSize( this->variable_ );
     else
       return 0;
   }
 
-  template <> _NetworkExport uint32_t SynchronisableVariable<const bool>::returnSize();
-  template <> _NetworkExport void     SynchronisableVariable<const bool>::setAndIncrease(uint8_t*& mem);
-  template <> _NetworkExport void     SynchronisableVariable<const bool>::getAndIncrease(uint8_t*& mem);
-  template <> _NetworkExport bool     SynchronisableVariable<const bool>::checkEquality(uint8_t* mem);
-  template <> _NetworkExport uint32_t SynchronisableVariable<const unsigned char>::returnSize();
-  template <> _NetworkExport void     SynchronisableVariable<const unsigned char>::setAndIncrease(uint8_t*& mem);
-  template <> _NetworkExport void     SynchronisableVariable<const unsigned char>::getAndIncrease(uint8_t*& mem);
-  template <> _NetworkExport bool     SynchronisableVariable<const unsigned char>::checkEquality(uint8_t* mem);
-  template <> _NetworkExport uint32_t SynchronisableVariable<const short>::returnSize();
-  template <> _NetworkExport void     SynchronisableVariable<const short>::setAndIncrease(uint8_t*& mem);
-  template <> _NetworkExport void     SynchronisableVariable<const short>::getAndIncrease(uint8_t*& mem);
-  template <> _NetworkExport bool     SynchronisableVariable<const short>::checkEquality(uint8_t* mem);
-  template <> _NetworkExport uint32_t SynchronisableVariable<const unsigned short>::returnSize();
-  template <> _NetworkExport void     SynchronisableVariable<const unsigned short>::setAndIncrease(uint8_t*& mem);
-  template <> _NetworkExport void     SynchronisableVariable<const unsigned short>::getAndIncrease(uint8_t*& mem);
-  template <> _NetworkExport bool     SynchronisableVariable<const unsigned short>::checkEquality(uint8_t* mem);
-  template <> _NetworkExport uint32_t SynchronisableVariable<const int>::returnSize();
-  template <> _NetworkExport void     SynchronisableVariable<const int>::setAndIncrease(uint8_t*& mem);
-  template <> _NetworkExport void     SynchronisableVariable<const int>::getAndIncrease(uint8_t*& mem);
-  template <> _NetworkExport bool     SynchronisableVariable<const int>::checkEquality(uint8_t* mem);
-  template <> _NetworkExport uint32_t SynchronisableVariable<const unsigned int>::returnSize();
-  template <> _NetworkExport void     SynchronisableVariable<const unsigned int>::setAndIncrease(uint8_t*& mem);
-  template <> _NetworkExport void     SynchronisableVariable<const unsigned int>::getAndIncrease(uint8_t*& mem);
-  template <> _NetworkExport bool     SynchronisableVariable<const unsigned int>::checkEquality(uint8_t* mem);
-  template <> _NetworkExport uint32_t SynchronisableVariable<const long>::returnSize();
-  template <> _NetworkExport void     SynchronisableVariable<const long>::setAndIncrease(uint8_t*& mem);
-  template <> _NetworkExport void     SynchronisableVariable<const long>::getAndIncrease(uint8_t*& mem);
-  template <> _NetworkExport bool     SynchronisableVariable<const long>::checkEquality(uint8_t* mem);
-  template <> _NetworkExport uint32_t SynchronisableVariable<const unsigned long>::returnSize();
-  template <> _NetworkExport void     SynchronisableVariable<const unsigned long>::setAndIncrease(uint8_t*& mem);
-  template <> _NetworkExport void     SynchronisableVariable<const unsigned long>::getAndIncrease(uint8_t*& mem);
-  template <> _NetworkExport bool     SynchronisableVariable<const unsigned long>::checkEquality(uint8_t* mem);
-  template <> _NetworkExport uint32_t SynchronisableVariable<const long long>::returnSize();
-  template <> _NetworkExport void     SynchronisableVariable<const long long>::setAndIncrease(uint8_t*& mem);
-  template <> _NetworkExport void     SynchronisableVariable<const long long>::getAndIncrease(uint8_t*& mem);
-  template <> _NetworkExport bool     SynchronisableVariable<const long long>::checkEquality(uint8_t* mem);
-  template <> _NetworkExport uint32_t SynchronisableVariable<const unsigned long long>::returnSize();
-  template <> _NetworkExport void     SynchronisableVariable<const unsigned long long>::setAndIncrease(uint8_t*& mem);
-  template <> _NetworkExport void     SynchronisableVariable<const unsigned long long>::getAndIncrease(uint8_t*& mem);
-  template <> _NetworkExport bool     SynchronisableVariable<const unsigned long long>::checkEquality(uint8_t* mem);
-  template <> _NetworkExport uint32_t SynchronisableVariable<const float>::returnSize();
-  template <> _NetworkExport void     SynchronisableVariable<const float>::setAndIncrease(uint8_t*& mem);
-  template <> _NetworkExport void     SynchronisableVariable<const float>::getAndIncrease(uint8_t*& mem);
-  template <> _NetworkExport bool     SynchronisableVariable<const float>::checkEquality(uint8_t* mem);
-  template <> _NetworkExport uint32_t SynchronisableVariable<const double>::returnSize();
-  template <> _NetworkExport void     SynchronisableVariable<const double>::setAndIncrease(uint8_t*& mem);
-  template <> _NetworkExport void     SynchronisableVariable<const double>::getAndIncrease(uint8_t*& mem);
-  template <> _NetworkExport bool     SynchronisableVariable<const double>::checkEquality(uint8_t* mem);
-  template <> _NetworkExport uint32_t SynchronisableVariable<const long double>::returnSize();
-  template <> _NetworkExport void     SynchronisableVariable<const long double>::setAndIncrease(uint8_t*& mem);
-  template <> _NetworkExport void     SynchronisableVariable<const long double>::getAndIncrease(uint8_t*& mem);
-  template <> _NetworkExport bool     SynchronisableVariable<const long double>::checkEquality(uint8_t* mem);
-  template <> _NetworkExport uint32_t SynchronisableVariable<const std::string>::returnSize();
-  template <> _NetworkExport void     SynchronisableVariable<const std::string>::setAndIncrease(uint8_t*& mem);
-  template <> _NetworkExport void     SynchronisableVariable<const std::string>::getAndIncrease(uint8_t*& mem);
-  template <> _NetworkExport bool     SynchronisableVariable<const std::string>::checkEquality(uint8_t* mem);
-  template <> _NetworkExport uint32_t SynchronisableVariable<const Degree>::returnSize();
-  template <> _NetworkExport void     SynchronisableVariable<const Degree>::setAndIncrease(uint8_t*& mem);
-  template <> _NetworkExport void     SynchronisableVariable<const Degree>::getAndIncrease(uint8_t*& mem);
-  template <> _NetworkExport bool     SynchronisableVariable<const Degree>::checkEquality(uint8_t* mem);
 
 
@@ -229 +172 @@
     }
 
-    template <class T> void SynchronisableVariableBidirectional<T>::getData(uint8_t*& mem, uint8_t mode)
+    template <class T> uint32_t SynchronisableVariableBidirectional<T>::getData(uint8_t*& mem, uint8_t mode)
     {
       if ( this->mode_ == mode )
@@ -243 +186 @@
       mem += sizeof(this->varReference_);
   // now write the content
-      SynchronisableVariable<T>::getAndIncrease( mem );
-//   mem += SynchronisableVariable<T>::getSize();
+      saveAndIncrease( this->variable_, mem );
+      return SynchronisableVariableBidirectional::getSize(mode);
     }
 
@@ -255 +198 @@
         if ( *static_cast<uint8_t*>(mem) != this->varReference_ )
         { // wrong reference number, so discard the data
+//           COUT(0) << "discharding data" << endl;
           mem += getSize( mode ); // SynchronisableVariableBidirectional::getSize returns size of variable + reference
           return;
@@ -260 +204 @@
         else{
           // apply data
-          mem += sizeof(varReference_);
-          if ( SynchronisableVariableBidirectional<T>::checkEquality( mem )==true )
+          if ( checkEquality( this->variable_, mem+sizeof(varReference_) )==true )
           {
-            mem += SynchronisableVariable<T>::getSize( mode );
+            mem += getSize( mode );
             return;
           }
           else
           {
+            mem += sizeof(varReference_);
             memcpy((void*)&this->varBuffer_, &this->variable_, sizeof(T));
             if ( this->callback_ != 0 )
@@ -285 +229 @@
           this->varReference_ = *static_cast<uint8_t*>(mem);
           mem += sizeof(varReference_);
-          if ( SynchronisableVariable<T>::checkEquality( mem ) == false )
+          if ( checkEquality( this->variable_, mem ) == false )
           {
             // value changed so remark for callback
@@ -294 +238 @@
       }
   // now write the data
-      SynchronisableVariable<T>::setAndIncrease(mem);
+      loadAndIncrease(this->variable_, mem);
   // now do a callback if neccessary
       if ( callback )
         NetworkCallbackManager::triggerCallback( this->callback_ );
-        //this->callback_->call();
-    }
-
-    template <class T> uint32_t SynchronisableVariableBidirectional<T>::getSize(uint8_t mode)
-    {
-      return SynchronisableVariable<T>::returnSize() + sizeof(varReference_);
+    }
+
+    template <class T> inline uint32_t SynchronisableVariableBidirectional<T>::getSize(uint8_t mode)
+    {
+      return returnSize( this->variable_ ) + sizeof(varReference_);
     }
   

code/trunk/src/orxonox/OrxonoxPrereqs.h

@@ -140 +140 @@
     class SpawnPoint;
     class TeamSpawnPoint;
+    class Test;
 
     class Spectator;

code/trunk/src/orxonox/gamestates/GSGraphics.cc

@@ -57 +57 @@
 namespace orxonox
 {
-    AddGameState(GSGraphics, "graphics");
-
-    GSGraphics::GSGraphics(const std::string& name)
-        : GameState(name)
+    AddGameState(GSGraphics, "graphics", false);
+
+    GSGraphics::GSGraphics(const std::string& name, bool countTickTime)
+        : GameState(name, countTickTime)
         , inputManager_(0)
         , console_(0)
@@ -213 +213 @@
         uint64_t timeBeforeTick = time.getRealMicroseconds();
 
-        this->inputManager_->update(time);        // tick console
+        this->inputManager_->update(time);
         this->console_->update(time);
-        this->guiManager_->update(time);
 
         uint64_t timeAfterTick = time.getRealMicroseconds();
@@ -222 +221 @@
         Game::getInstance().addTickTime(timeAfterTick - timeBeforeTick);
 
+        // Process gui events
+        this->guiManager_->update(time);
         // Render
         this->graphicsManager_->update(time);

code/trunk/src/orxonox/gamestates/GSGraphics.h

@@ -51 +51 @@
     {
     public:
-        GSGraphics(const std::string& name);
+        GSGraphics(const std::string& name, bool countTickTime);
         ~GSGraphics();
         void setConfigValues();

code/trunk/src/orxonox/gamestates/GSRoot.cc

@@ -43 +43 @@
 namespace orxonox
 {
-    AddGameState(GSRoot, "root");
+    AddGameState(GSRoot, "root", false);
     SetCommandLineSwitch(console);
     // Shortcuts for easy direct loading
@@ -51 +51 @@
     SetCommandLineSwitch(standalone);
 
-    GSRoot::GSRoot(const std::string& name)
-        : GameState(name)
+    GSRoot::GSRoot(const std::string& name, bool countTickTime)
+        : GameState(name, countTickTime)
         , timeFactor_(1.0f)
         , bPaused_(false)

code/trunk/src/orxonox/gamestates/GSRoot.h

@@ -39 +39 @@
     {
     public:
-        GSRoot(const std::string& name);
+        GSRoot(const std::string& name, bool countTickTime);
         ~GSRoot();
 

code/trunk/src/orxonox/objects/CMakeLists.txt

@@ -10 +10 @@
   Teamcolourable.cc
   Tickable.cc
-  Test.cc
   Scene.cc
   Script.cc

code/trunk/src/orxonox/objects/Test.cc

@@ -31 +31 @@
 #include "core/ConfigValueIncludes.h"
 #include "core/ConsoleCommand.h"
+#include "network/NetworkFunction.h"
 #include "Test.h"
+#include "util/MultiType.h"
 
 namespace orxonox
@@ -41 +43 @@
   SetConsoleCommand(Test, printV3, true).accessLevel(AccessLevel::User);
   SetConsoleCommand(Test, printV4, true).accessLevel(AccessLevel::User);
+  SetConsoleCommand(Test, call, true).accessLevel(AccessLevel::User);
+  SetConsoleCommand(Test, call2, true).accessLevel(AccessLevel::User);
+  
+  
+  //void=* aaaaa = copyPtr<sizeof(&Test::printV1)>( &NETWORK_FUNCTION_POINTER, &Test::printV1 );
+  //void* NETWORK_FUNCTION_TEST_B = memcpy(&NETWORK_FUNCTION_POINTER, &a, sizeof(a));
+//   NetworkFunctionBase* NETWORK_FUNCTION_TEST_C = new NetworkFunctionStatic( createFunctor(&Test::printV1), "bla", NETWORK_FUNCTION_POINTER );
+  
+  registerStaticNetworkFunction( &Test::printV1 );
+  registerMemberNetworkFunction( Test, checkU1 );
+  registerMemberNetworkFunction( Test, printBlaBla );
   
   Test* Test::instance_ = 0;
@@ -73 +86 @@
 
 
-        void Test::registerVariables()
-        {
-                registerVariable ( u1, variableDirection::toclient, new NetworkCallback<Test> ( this, &Test::checkU1 ));
+  void Test::registerVariables()
+  {
+    registerVariable ( u1, variableDirection::toclient, new NetworkCallback<Test> ( this, &Test::checkU1 ));
     registerVariable ( u2, variableDirection::toserver, new NetworkCallback<Test> ( this, &Test::checkU2 ));
-                registerVariable ( u3, variableDirection::serverMaster, new NetworkCallback<Test> ( this, &Test::checkU3 ), true );
+    registerVariable ( u3, variableDirection::serverMaster, new NetworkCallback<Test> ( this, &Test::checkU3 ), true );
     registerVariable ( u4, variableDirection::clientMaster, new NetworkCallback<Test> ( this, &Test::checkU4 ), true );
     
@@ -84 +97 @@
     registerVariable ( s3, variableDirection::serverMaster, new NetworkCallback<Test> ( this, &Test::checkS3 ), true );
     registerVariable ( s4, variableDirection::clientMaster, new NetworkCallback<Test> ( this, &Test::checkS4 ), true );
-        }
-
+  }
+  
+  void Test::call(unsigned int clientID)
+  {
+    callStaticNetworkFunction( &Test::printV1, clientID );
+    callStaticNetworkFunction( &Test::printV1, clientID );
+  }
+  
+  void Test::call2(unsigned int clientID, std::string s1, std::string s2, std::string s3, std::string s4)
+  {
+    callMemberNetworkFunction( Test, printBlaBla, this->getObjectID(), clientID, s1, s2, s3, s4, s4 );
+  }
+  
+  void Test::tick(float dt)
+  {
+//     std::string str1 = "blub";
+//     //MultiType mt1(std::string("blub"));
+//     MultiType mt1(str1);
+//     uint8_t* mem = new uint8_t[mt1.getNetworkSize()];
+//     uint8_t* temp = mem;
+//     mt1.exportData( temp );
+//     assert( temp-mem == mt1.getNetworkSize() );
+//     MultiType mt2;
+//     temp = mem;
+//     mt2.importData( temp );
+//     assert( temp-mem == mt1.getNetworkSize() );
+//     COUT(0) << mt2 << endl;
+    if(!Core::isMaster())
+      call2(0, "bal", "a", "n", "ce");
+//       callMemberNetworkFunction( Test, checkU1, this->getObjectID(), 0 );
+  }
+  
+  void Test::printBlaBla(std::string s1, std::string s2, std::string s3, std::string s4, std::string s5)
+  {
+    COUT(0) << s1 << s2 << s3 << s4 << s5 << endl;
+  }
+  
   void Test::checkU1(){ COUT(1) << "U1 changed: " << u1 << std::endl; }
   void Test::checkU2(){ COUT(1) << "U2 changed: " << u2 << std::endl; }

code/trunk/src/orxonox/objects/Test.h

@@ -33 +33 @@
 #include "core/BaseObject.h"
 #include "network/synchronisable/Synchronisable.h"
+#include "Tickable.h"
 
 
@@ -41 +42 @@
 namespace orxonox
 {
-  class _OrxonoxExport Test: public BaseObject, public Synchronisable
+  class _OrxonoxExport Test: public BaseObject, public Synchronisable, public Tickable
   {
     public:
@@ -49 +50 @@
       void setConfigValues();
       void registerVariables();
+      
+      static void call(unsigned int clientID);
+      void call2(unsigned int clientID, std::string s1, std::string s2, std::string s3, std::string s4);
+      virtual void tick(float dt);
 
 
@@ -75 +80 @@
       static void printV3(){ instance_->checkU3(); }
       static void printV4(){ instance_->checkU4(); }
+      
+      void printBlaBla(std::string s1, std::string s2, std::string s3, std::string s4, std::string s5);
 
     private:

code/trunk/src/orxonox/objects/controllers/AIController.cc

@@ -30 +30 @@
 #include "AIController.h"
 
-#include "core/GameMode.h"
 #include "core/CoreIncludes.h"
 #include "core/Executor.h"
@@ -45 +44 @@
         RegisterObject(AIController);
 
-        if (GameMode::isMaster())
-            this->actionTimer_.setTimer(ACTION_INTERVAL, true, this, createExecutor(createFunctor(&AIController::action)));
+        this->actionTimer_.setTimer(ACTION_INTERVAL, true, this, createExecutor(createFunctor(&AIController::action)));
     }
 

code/trunk/src/orxonox/objects/worldentities/ControllableEntity.cc

@@ -379 +379 @@
         registerVariable(this->client_orientation_,      variableDirection::toserver, new NetworkCallback<ControllableEntity>(this, &ControllableEntity::processClientOrientation));
         registerVariable(this->client_angular_velocity_, variableDirection::toserver, new NetworkCallback<ControllableEntity>(this, &ControllableEntity::processClientAngularVelocity));
+        
 
         registerVariable(this->playerID_,                variableDirection::toclient, new NetworkCallback<ControllableEntity>(this, &ControllableEntity::networkcallback_changedplayerID));

code/trunk/src/orxonox/objects/worldentities/MobileEntity.h

@@ -61 +61 @@
                 { this->setAngularVelocity(Vector3(x, y, z)); }
             inline const Vector3& getAngularVelocity() const
-                { return this->linearAcceleration_; }
+                { return this->angularVelocity_; }
 
             void setAcceleration(const Vector3& acceleration);

code/trunk/src/orxonox/objects/worldentities/PongBall.cc

@@ -32 +32 @@
 #include "core/CoreIncludes.h"
 #include "core/GameMode.h"
-#include "objects/worldentities/PongBat.h"
 #include "objects/gametypes/Gametype.h"
 
@@ -47 +46 @@
         this->speed_ = 0;
         this->bat_ = 0;
+        this->batID_ = new unsigned int[2];
+        this->batID_[0] = OBJECTID_UNKNOWN;
+        this->batID_[1] = OBJECTID_UNKNOWN;
         this->relMercyOffset_ = 0.05;
+        
+        this->registerVariables();
+    }
+    
+    void PongBall::registerVariables()
+    {
+        registerVariable( this->fieldWidth_ );
+        registerVariable( this->fieldHeight_ );
+        registerVariable( this->batlength_ );
+        registerVariable( this->speed_ );
+        registerVariable( this->relMercyOffset_ );
+        registerVariable( this->batID_[0] );
+        registerVariable( this->batID_[1], variableDirection::toclient, new NetworkCallback<PongBall>( this, &PongBall::applyBats) );
     }
 
@@ -119 +134 @@
                 this->setPosition(position);
         }
+        else
+        {
+          Vector3 position = this->getPosition();
+          Vector3 velocity = this->getVelocity();
+
+          if (position.z > this->fieldHeight_ / 2 || position.z < -this->fieldHeight_ / 2)
+          {
+            velocity.z = -velocity.z;
+
+            if (position.z > this->fieldHeight_ / 2)
+              position.z = this->fieldHeight_ / 2;
+            if (position.z < -this->fieldHeight_ / 2)
+              position.z = -this->fieldHeight_ / 2;
+          }
+
+          if (position.x > this->fieldWidth_ / 2 || position.x < -this->fieldWidth_ / 2)
+          {
+            float distance = 0;
+
+            if (this->bat_)
+            {
+              if (position.x > this->fieldWidth_ / 2 && this->bat_[1])
+              {
+                distance = (position.z - this->bat_[1]->getPosition().z) / (this->fieldHeight_ * (this->batlength_ * 1.10) / 2);
+                if (fabs(distance) <= 1)
+                {
+                  position.x = this->fieldWidth_ / 2;
+                  velocity.x = -velocity.x;
+                  velocity.z = distance * distance * sgn(distance) * PongBall::MAX_REL_Z_VELOCITY * this->speed_;
+                }
+              }
+              if (position.x < -this->fieldWidth_ / 2 && this->bat_[0])
+              {
+                distance = (position.z - this->bat_[0]->getPosition().z) / (this->fieldHeight_ * (this->batlength_ * 1.10) / 2);
+                if (fabs(distance) <= 1)
+                {
+                  position.x = -this->fieldWidth_ / 2;
+                  velocity.x = -velocity.x;
+                  velocity.z = distance * distance * sgn(distance) * PongBall::MAX_REL_Z_VELOCITY * this->speed_;
+                }
+              }
+            }
+          }
+
+          if (velocity != this->getVelocity())
+            this->setVelocity(velocity);
+          if (position != this->getPosition())
+            this->setPosition(position);
+        }
     }
 

code/trunk/src/orxonox/objects/worldentities/PongBall.h

@@ -33 +33 @@
 
 #include "objects/worldentities/MovableEntity.h"
+#include "objects/worldentities/PongBat.h"
 
 namespace orxonox
@@ -43 +44 @@
 
             virtual void tick(float dt);
+            
+            void registerVariables();
 
             void setFieldDimension(float width, float height)
@@ -61 +64 @@
 
             void setBats(PongBat** bats)
-                { this->bat_ = bats; }
+            { this->bat_ = bats; this->batID_[0] = this->bat_[0]->getObjectID(); this->batID_[1] = this->bat_[1]->getObjectID(); }
+            
+            void applyBats()
+            { if(!this->bat_) this->bat_ = new PongBat*[2]; if(this->batID_[0] != OBJECTID_UNKNOWN) this->bat_[0] = dynamic_cast<PongBat*>(Synchronisable::getSynchronisable(this->batID_[0])); if(this->batID_[1] != OBJECTID_UNKNOWN) this->bat_[1] = dynamic_cast<PongBat*>(Synchronisable::getSynchronisable(this->batID_[1])); }
 
             static const float MAX_REL_Z_VELOCITY;
@@ -71 +77 @@
             float batlength_;
             PongBat** bat_;
+            unsigned int* batID_;
             float relMercyOffset_;
     };

code/trunk/src/orxonox/objects/worldentities/PongBat.cc

@@ -54 +54 @@
     {
         registerVariable(this->speed_);
-        registerVariable(this->speed_);
-        registerVariable(this->speed_);
+        registerVariable(this->fieldHeight_);
+        registerVariable(this->length_);
     }
 
@@ -91 +91 @@
             position.z = -this->fieldHeight_ / 2 + this->fieldHeight_ * this->length_ / 2;
         if (position != this->getPosition())
+        {
             this->setPosition(position);
+            this->setVelocity( Vector3::ZERO );
+        }
     }
 
@@ -97 +100 @@
     {
         this->bMoveLocal_ = false;
-        this->movement_ -= value.x;
+        this->movement_ = -value.x;
     }
 

code/trunk/src/orxonox/objects/worldentities/pawns/Pawn.cc

@@ -39 +39 @@
 #include "objects/worldentities/ParticleSpawner.h"
 #include "objects/worldentities/ExplosionChunk.h"
+
 #include "objects/weaponsystem/WeaponSystem.h"
 #include "objects/weaponsystem/WeaponSlot.h"
@@ -44 +45 @@
 #include "objects/weaponsystem/WeaponSet.h"
 
+#include "network/NetworkFunction.h"
+
 namespace orxonox
 {
     CreateFactory(Pawn);
+
+    registerMemberNetworkFunction( Pawn, doFire );
 
     Pawn::Pawn(BaseObject* creator) : ControllableEntity(creator)
@@ -123 +128 @@
         SUPER(Pawn, tick, dt);
 
-        if (this->weaponSystem_ && GameMode::isMaster())
-        {
-            for (unsigned int firemode = 0; firemode < WeaponSystem::MAX_FIRE_MODES; firemode++)
-                if (this->fire_ & WeaponSystem::getFiremodeMask(firemode))
-                    this->weaponSystem_->fire(firemode);
-
-            if (this->bReload_)
-                this->weaponSystem_->reload();
-        }
-
-        this->fire_ = this->firehack_;
-        this->firehack_ = 0x0;
+//        if (this->weaponSystem_ && GameMode::isMaster())
+//        {
+//            for (unsigned int firemode = 0; firemode < WeaponSystem::MAX_FIRE_MODES; firemode++)
+//                if (this->fire_ & WeaponSystem::getFiremodeMask(firemode))
+//                    this->weaponSystem_->fire(firemode);
+//
+//            if (this->bReload_)
+//                this->weaponSystem_->reload();
+//        }
+//
+//        this->fire_ = this->firehack_;
+//        this->firehack_ = 0x0;
         this->bReload_ = false;
 
-        if (this->health_ <= 0)
+        if (GameMode::isMaster())
+          if (this->health_ <= 0)
             this->death();
     }
@@ -263 +269 @@
     void Pawn::fire(unsigned int firemode)
     {
-        this->firehack_ |= WeaponSystem::getFiremodeMask(firemode);
+        this->doFire(firemode);
+    }
+
+    void Pawn::doFire(uint8_t firemode)
+    {
+        if(GameMode::isMaster())
+        {
+            if (this->weaponSystem_)
+                this->weaponSystem_->fire(firemode);
+        }
+        else
+        {
+            callMemberNetworkFunction(Pawn, doFire, this->getObjectID(), 0, ((uint8_t)firemode));
+            if (this->weaponSystem_)
+                this->weaponSystem_->fire(firemode);
+        }
     }
 

code/trunk/src/orxonox/objects/worldentities/pawns/Pawn.h

@@ -79 +79 @@
             virtual void fire(unsigned int firemode);
             virtual void reload();
+            virtual void doFire(uint8_t firemode);
             virtual void postSpawn();
 

code/trunk/src/util/MultiType.h

@@ -80 +80 @@
     enum MT_Type
     {
-        MT_null,
-        MT_char,
-        MT_uchar,
-        MT_short,
-        MT_ushort,
-        MT_int,
-        MT_uint,
-        MT_long,
-        MT_ulong,
-        MT_longlong,
-        MT_ulonglong,
-        MT_float,
-        MT_double,
-        MT_longdouble,
-        MT_bool,
-        MT_void,
-        MT_string,
-        MT_vector2,
-        MT_vector3,
-        MT_vector4,
-        MT_colourvalue,
-        MT_quaternion,
-        MT_radian,
-        MT_degree
+        MT_null=0,
+        MT_char=1,
+        MT_uchar=2,
+        MT_short=3,
+        MT_ushort=4,
+        MT_int=5,
+        MT_uint=6,
+        MT_long=7,
+        MT_ulong=8,
+        MT_longlong=9,
+        MT_ulonglong=10,
+        MT_float=11,
+        MT_double=12,
+        MT_longdouble=13,
+        MT_bool=14,
+        MT_void=15,
+        MT_string=16,
+        MT_vector2=17,
+        MT_vector3=18,
+        MT_vector4=19,
+        MT_colourvalue=20,
+        MT_quaternion=21,
+        MT_radian=22,
+        MT_degree=23
     };
 
@@ -223 +223 @@
 
             virtual void toString(std::ostream& outstream) const = 0;
+            
+            virtual void importData( uint8_t*& mem )=0;
+            virtual void exportData( uint8_t*& mem ) const=0;
+            virtual uint8_t getSize() const=0;
 
             MT_Type type_;          //!< The type of the current value
@@ -320 +324 @@
             template <typename T> inline bool isType()                  const { return false; } // Only works for specialized values - see below
             std::string                       getTypename()             const;
+            
+            /** @brief Saves the value of the MT to a bytestream (pointed at by mem) and increases mem pointer by size of MT */
+            inline void                       exportData(uint8_t*& mem) const { assert(sizeof(MT_Type)<=8); *(uint8_t*)(mem) = this->getType(); mem+=sizeof(uint8_t); this->value_->exportData(mem); }
+            /** @brief Loads the value of the MT from a bytestream (pointed at by mem) and increases mem pointer by size of MT */
+            inline void                       importData(uint8_t*& mem) { assert(sizeof(MT_Type)<=8); this->setType(static_cast<MT_Type>(*(uint8_t*)mem)); mem+=sizeof(uint8_t); this->value_->importData(mem); }
+            /** @brief Saves the value of the MT to a bytestream and increases pointer to bytestream by size of MT */
+            inline uint8_t*&                  operator << (uint8_t*& mem) { importData(mem); return mem; }
+            /** @brief Loads the value of the MT to a bytestream and increases pointer to bytestream by size of MT */
+            inline void                       operator >> (uint8_t*& mem) const { exportData(mem); }
+            inline uint32_t                   getNetworkSize() const { assert(this->value_); return this->value_->getSize() + sizeof(uint8_t); }
 
             /** @brief Checks whether the value is a default one. */

code/trunk/src/util/MultiTypeValue.h

@@ -40 +40 @@
 #include "MathConvert.h"
 #include "MultiType.h"
+#include "Serialise.h"
+#include <cassert>
 
 namespace orxonox
@@ -147 +149 @@
         /** @brief Puts the current value on the stream */
         inline void toString(std::ostream& outstream) const { outstream << this->value_; }
+        
+        /** @brief loads data from the bytestream (mem) into the MT and increases the bytestream pointer by the size of the data */
+        inline void importData( uint8_t*& mem )         { loadAndIncrease( /*(const T&)*/this->value_, mem ); }
+        /** @brief saves data from the MT into the bytestream (mem) and increases the bytestream pointer by the size of the data */
+        inline void exportData( uint8_t*& mem ) const   { saveAndIncrease( /*(const T&)*/this->value_, mem ); }
+        /** @brief returns the size of the data that would be saved by exportData */
+        inline uint8_t getSize() const { return returnSize( this->value_ ); }
 
         T value_; //!< The stored value
     };
+    
+    // Import / Export specialisation
+    // ColourValue
+    template <> inline void MT_Value<ColourValue>::importData( uint8_t*& mem )
+    {
+        loadAndIncrease( this->value_.r, mem );
+        loadAndIncrease( this->value_.g, mem );
+        loadAndIncrease( this->value_.b, mem );
+        loadAndIncrease( this->value_.a, mem );
+    }
+    template <> inline void MT_Value<ColourValue>::exportData( uint8_t*& mem ) const
+    {
+        saveAndIncrease( this->value_.r, mem );
+        saveAndIncrease( this->value_.g, mem );
+        saveAndIncrease( this->value_.b, mem );
+        saveAndIncrease( this->value_.a, mem );
+    }
+    template <> inline uint8_t MT_Value<ColourValue>::getSize() const
+    {
+        return 4*returnSize(this->value_.r);
+    }
+    // Ogre::Quaternion
+    template <> inline void MT_Value<Ogre::Quaternion>::importData( uint8_t*& mem )
+    {
+        loadAndIncrease( this->value_.x, mem );
+        loadAndIncrease( this->value_.y, mem );
+        loadAndIncrease( this->value_.z, mem );
+        loadAndIncrease( this->value_.w, mem );
+    }
+    template <> inline void MT_Value<Ogre::Quaternion>::exportData( uint8_t*& mem ) const
+    {
+        saveAndIncrease( this->value_.x, mem );
+        saveAndIncrease( this->value_.y, mem );
+        saveAndIncrease( this->value_.z, mem );
+        saveAndIncrease( this->value_.w, mem );
+    }template <> inline uint8_t MT_Value<Ogre::Quaternion>::getSize() const
+    {
+        return 4*returnSize(this->value_.x);
+    }
+    // Ogre::Vector2
+    template <> inline void MT_Value<Ogre::Vector2>::importData( uint8_t*& mem )
+    {
+        loadAndIncrease( this->value_.x, mem );
+        loadAndIncrease( this->value_.y, mem );
+    }
+    template <> inline void MT_Value<Ogre::Vector2>::exportData( uint8_t*& mem ) const
+    {
+        saveAndIncrease( this->value_.x, mem );
+        saveAndIncrease( this->value_.y, mem );
+    }
+    template <> inline uint8_t MT_Value<Ogre::Vector2>::getSize() const
+    {
+        return 2*returnSize(this->value_.x);
+    }
+    // Ogre::Vector3
+    template <> inline void MT_Value<Ogre::Vector3>::importData( uint8_t*& mem )
+    {
+        loadAndIncrease( this->value_.x, mem );
+        loadAndIncrease( this->value_.y, mem );
+        loadAndIncrease( this->value_.z, mem );
+    }
+    template <> inline void MT_Value<Ogre::Vector3>::exportData( uint8_t*& mem ) const
+    {
+        saveAndIncrease( this->value_.x, mem );
+        saveAndIncrease( this->value_.y, mem );
+        saveAndIncrease( this->value_.z, mem );
+    }
+    template <> inline uint8_t MT_Value<Ogre::Vector3>::getSize() const
+    {
+        return 3*returnSize(this->value_.x);
+    }
+    // Ogre::Vector4
+    template <> inline void MT_Value<Ogre::Vector4>::importData( uint8_t*& mem )
+    {
+        loadAndIncrease( this->value_.x, mem );
+        loadAndIncrease( this->value_.y, mem );
+        loadAndIncrease( this->value_.z, mem );
+        loadAndIncrease( this->value_.w, mem );
+    }
+    template <> inline void MT_Value<Ogre::Vector4>::exportData( uint8_t*& mem ) const
+    {
+        saveAndIncrease( this->value_.x, mem );
+        saveAndIncrease( this->value_.y, mem );
+        saveAndIncrease( this->value_.z, mem );
+        saveAndIncrease( this->value_.w, mem );
+    }
+    template <> inline uint8_t MT_Value<Ogre::Vector4>::getSize() const
+    {
+        return 4*returnSize(this->value_.x);
+    }
+    template <> inline void MT_Value<void*>::importData( uint8_t*& mem )
+    {
+        assert(0);
+    }
+    template <> inline void MT_Value<void*>::exportData( uint8_t*& mem ) const
+    {
+        assert(0);
+    }
+    template <> inline uint8_t MT_Value<void*>::getSize() const
+    {
+        assert(0); return 0;
+    }
 }