Changeset 8228 in orxonox.OLD

Timestamp:

Jun 8, 2006, 11:19:08 AM (18 years ago)

Author:

patrick

Message:

trunk: merged the network branche back to trunk with command: svn merge branches/network trunk -r8150:HEAD

Location:

trunk/src

Files:

• lib/event/event_handler.cc (modified) (1 diff)
• lib/network/message_manager.cc (modified) (2 diffs)
• lib/network/message_manager.h (modified) (2 diffs)
• lib/network/network_game_manager.cc (modified) (5 diffs)
• lib/network/network_manager.cc (modified) (8 diffs)
• lib/network/network_manager.h (modified) (1 diff)
• lib/network/network_stream.cc (modified) (7 diffs)
• lib/network/player_stats.cc (modified) (6 diffs)
• lib/network/synchronizeable.cc (modified) (1 diff)
• lib/network/udp_server_socket.cc (modified) (10 diffs)
• lib/network/udp_socket.cc (modified) (5 diffs)
• story_entities/multi_player_world.cc (modified) (2 diffs)
• story_entities/multi_player_world.h (modified) (1 diff)
• util/signal_handler.cc (modified) (3 diffs)
• util/signal_handler.h (modified) (5 diffs)
• world_entities/space_ships/space_ship.cc (modified) (1 diff)
• world_entities/spectator.cc (modified) (6 diffs)
• world_entities/spectator.h (modified) (2 diffs)

trunk/src/lib/event/event_handler.cc

@@ -353 +353 @@
   else
   {
-//    SDL_WM_GrabInput(SDL_GRAB_ON);
+    SDL_WM_GrabInput(SDL_GRAB_ON);
     SDL_ShowCursor(SDL_DISABLE);
   }

trunk/src/lib/network/message_manager.cc

@@ -17 +17 @@
 
 #include "message_manager.h"
+
+#include "network_stream.h"
 
 using namespace std;
@@ -312 +314 @@
          recieverType == RT_ALL_NOT_ME ||
          recieverType == RT_USER && it->first == reciever ||
-         recieverType == RT_NOT_USER && it->first != reciever
+         recieverType == RT_NOT_USER && it->first != reciever ||
+         recieverType == RT_SERVER && getNetworkStream()->isUserServer( it->first )
        )
     {

trunk/src/lib/network/message_manager.h

@@ -30 +30 @@
   TESTMESSAGEID = 1,
   MSGID_DELETESYNCHRONIZEABLE,
-  MSGID_PREFEREDTEAM
+  MSGID_PREFEREDTEAM,
+  MSGID_CHANGEPLAYERNAME
 };
 
@@ -40 +41 @@
   RT_ALL_ME,           //!< message is sent to all users
   RT_USER,             //!< message is only sent to reciever
-  RT_NOT_USER          //!< message is sent to all but reciever
+  RT_NOT_USER,         //!< message is sent to all but reciever
+  RT_SERVER            //!< message is sent to server only
 };
 

trunk/src/lib/network/network_game_manager.cc

@@ -112 +112 @@
   stats->setPlayableUniqueId( playable.getUniqueID() );
   stats->setModelFileName( playableModel );
+  
+  return true;
 }
 
@@ -122 +124 @@
 bool NetworkGameManager::signalLeftPlayer(int userID)
 {
-  delete PlayerStats::getStats( userID )->getPlayable();
-  delete PlayerStats::getStats( userID );
+  if ( PlayerStats::getStats( userID ) )
+  {
+    if ( PlayerStats::getStats( userID )->getPlayable() )
+      delete PlayerStats::getStats( userID )->getPlayable();
+    delete PlayerStats::getStats( userID );
+  }
+  
+  return true;
 }
 
@@ -165 +173 @@
         return true;
       }
-        
+      
       delete dynamic_cast<Synchronizeable*>(*it);
       return true;
     }
   }
+  
+  return true;
 }
 
@@ -210 +220 @@
   
   NetworkGameManager::getInstance()->setPreferedTeam( userId, teamId );
+  
+  return true;
 }
 
@@ -220 +232 @@
   
   stats.setPreferedTeamId( teamId );
-  
 }
 

trunk/src/lib/network/network_manager.cc

@@ -51 +51 @@
 
   /* initialize the references */
-  this->netStreamList = NULL;
-  this->syncList = NULL;
-  this->defaultSyncStream = NULL;
+  this->networkStream = NULL;
   this->sharedNetworkData = SharedNetworkData::getInstance();
   this->elapsedTime = 0.0f;
@@ -71 +69 @@
  */
 NetworkManager::~NetworkManager()
-{}
+{
+  if ( this->networkStream )
+  {
+    delete this->networkStream;
+    this->networkStream = NULL;
+  }
+}
 
 
@@ -79 +83 @@
 void NetworkManager::initialize()
 {
-  /* get the synchronizeable list from the class list */
-  this->netStreamList = ClassList::getList(CL_SYNCHRONIZEABLE);
   PRINTF(0)("NetworkManager initzalized\n");
-
 }
 
@@ -101 +102 @@
 int NetworkManager::establishConnection(const std::string & name, unsigned int port)
 {
-  this->defaultSyncStream = new NetworkStream( name, port );
-  this->sharedNetworkData->setDefaultSyncStream(this->defaultSyncStream);
-  this->defaultSyncStream->startHandshake();
+  this->networkStream = new NetworkStream( name, port );
+  this->sharedNetworkData->setDefaultSyncStream(this->networkStream);
+  this->networkStream->startHandshake();
   return 1;
 }
@@ -116 +117 @@
   this->sharedNetworkData->setHostID(0);
   this->sharedNetworkData->setGameServer(true);
-  this->defaultSyncStream = new NetworkStream(port);
-  this->sharedNetworkData->setDefaultSyncStream(this->defaultSyncStream);
-  this->defaultSyncStream->createNetworkGameManager();
+  this->networkStream = new NetworkStream(port);
+  this->sharedNetworkData->setDefaultSyncStream(this->networkStream);
+  this->networkStream->createNetworkGameManager();
   PRINTF(0)("CREATE SERVER\n");
   SDL_Delay(20);
@@ -127 +128 @@
 void NetworkManager::connectSynchronizeable(Synchronizeable& sync)
 {
-  if( this->defaultSyncStream)
-    this->defaultSyncStream->connectSynchronizeable(sync);
+  if( this->networkStream)
+    this->networkStream->connectSynchronizeable(sync);
 }
 
@@ -143 +144 @@
   this->elapsedTime = 0.0f;
 
-  if (this->netStreamList != NULL || (this->netStreamList = ClassList::getList(CL_NETWORK_STREAM)) != NULL)
-  {
-    std::list<BaseObject*>::const_iterator stream;
-    for (stream = this->netStreamList->begin(); stream != this->netStreamList->end(); ++stream)
-      if( static_cast<NetworkStream*>(*stream)->isActive())
-        static_cast<NetworkStream*>(*stream)->processData();
-  }
+  if ( networkStream->isActive() )
+    networkStream->processData();
   
   NetworkGameManager::getInstance()->tick( this->elapsedTime );
@@ -162 +158 @@
 {
   PRINT(0)("=================Network::debug()=========\n");
-  this->defaultSyncStream->debug();
+  this->networkStream->debug();
   PRINT(0)("===========================================\n");
 }

trunk/src/lib/network/network_manager.h

@@ -55 +55 @@
 
   private:
-    const std::list<BaseObject*>*    netStreamList;           // list with refs to all network streams
-    const std::list<BaseObject*>*    syncList;                // list of synchronizeables
     static NetworkManager*           singletonRef;            //!< Pointer to the only instance of this Class
-    NetworkStream*                   defaultSyncStream;       //!< FIXME: this is only for testing purposes
+    NetworkStream*                   networkStream;       //!< pointer to network stream
 
     SharedNetworkData*               sharedNetworkData;       //!< reference to the shared data

trunk/src/lib/network/network_stream.cc

@@ -105 +105 @@
     serverSocket->close();
     delete serverSocket;
+    serverSocket = NULL;
   }
 
@@ -123 +124 @@
   }
   
-  if ( serverSocket )
-  {
-    delete serverSocket;
-    serverSocket = NULL;
-  }
-
+  for ( SynchronizeableList::const_iterator it = getSyncBegin(); it != getSyncEnd(); it ++ )
+    (*it)->setNetworkStream( NULL );
 }
 
@@ -264 +261 @@
 
   //check if connections are ok else remove them
-  for ( PeerList::iterator it = peers.begin(); it != peers.end(); it++ )
+  for ( PeerList::iterator it = peers.begin(); it != peers.end(); )
   {
     if (  
@@ -297 +294 @@
 
       freeSocketSlots.push_back( it->second.userId );
-
-    }
+      
+      PeerList::iterator delit = it;
+      it++;
+      
+      peers.erase( delit );
+      
+      continue;
+    }
+    
+    it++;
   }
 
@@ -651 +656 @@
           }
         }
+        
 
         int n = sync->setStateDiff( peer->second.userId, buf+offset, syncDataLength, state, fromState ); 
@@ -664 +670 @@
       }
       
-      //TODO REMOVE THIS
-      int saveOffset = offset;
       
       for ( SynchronizeableList::iterator it = synchronizeables.begin(); it != synchronizeables.end(); it++ )
@@ -682 +686 @@
       assert( peer->second.lastRecvedState < state );
       peer->second.lastRecvedState = state;
-      
-      assert( saveOffset == offset );
-      
+
     }
   

trunk/src/lib/network/player_stats.cc

@@ -21 +21 @@
 #include "player.h"
 #include "state.h"
+#include "shared_network_data.h"
 
 
@@ -85 +86 @@
     this->setPlayableUniqueId( this->playableUniqueId );
     
-    PRINTF(0)("uniqueID changed %d %d\n", userId, getHostID());
+    PRINTF(0)("uniqueID changed %d %d %d\n", userId, getHostID(), getUniqueID());
   }
 }
@@ -99 +100 @@
   
   if ( !list )
+  {
     return NULL;
+  }
   
   for ( std::list<BaseObject*>::const_iterator it = list->begin(); it != list->end(); it++ )
@@ -108 +111 @@
     }
   }
-  
-  //TODO maybe we should create an object here
   
   return NULL;
@@ -133 +134 @@
     {
       this->playable = dynamic_cast<Playable*>(*it);
+      //TODO when OM_PLAYERS is ticked add line:
+      //this->playable->toList( OM_PLAYERS );
       break;
     }
@@ -138 +141 @@
   
   if ( this->playable && userId == getHostID() )
+  {
     State::getPlayer()->setPlayable( this->playable );
+  }
   
   this->playableUniqueId = uniqueId;

trunk/src/lib/network/synchronizeable.cc

@@ -369 +369 @@
 void Synchronizeable::cleanUpUser( int userId )
 {
-  for ( UserStateHistory::iterator it = sentStates.begin(); it != sentStates.end(); it++ )
-  {
-    for ( StateHistory::iterator it2 = it->begin(); it2 != it->end(); it2++ )
-    {
-      if ( (*it2)->data )
-        delete [] (*it2)->data;
-      (*it2)->data = NULL;
-      
-      delete *it2;
-    }
-  }
-  
-  sentStates.clear();
-  
-  for ( UserStateHistory::iterator it = recvStates.begin(); it != recvStates.end(); it++ )
-  {
-    for ( StateHistory::iterator it2 = it->begin(); it2 != it->end(); it2++ )
-    {
-      if ( (*it2)->data )
-        delete [] (*it2)->data;
-      (*it2)->data = NULL;
-      
-      delete *it2;
-    }
-  }
-  
-  recvStates.clear();
+  if ( recvStates.size() > userId )
+  {
+    for ( std::list<StateHistoryEntry*>::iterator it = recvStates[userId].begin(); it != recvStates[userId].end(); it++ )
+    {
+      if ( (*it)->data )
+        delete [] (*it)->data;
+      (*it)->data = NULL;
+    
+      delete *it;
+    }
+    recvStates[userId].clear();
+  }
+ 
+  if ( sentStates.size() > userId )
+  {
+    
+    for ( std::list<StateHistoryEntry*>::iterator it = sentStates[userId].begin(); it != sentStates[userId].end(); it++ )
+    {
+      if ( (*it)->data )
+        delete [] (*it)->data;
+      (*it)->data = NULL;
+    
+      delete *it;
+    }
+    sentStates[userId].clear();
+  }
 }
 

trunk/src/lib/network/udp_server_socket.cc

@@ -44 +44 @@
 UdpServerSocket::~UdpServerSocket( )
 {
-  for ( int i = 0; i < packetBuffer.size(); i++ )
+  for ( int i = 0; i < (int)packetBuffer.size(); i++ )
     removeUserPackets( i );
   
@@ -99 +99 @@
 {
   
-  for ( int i = 0; i < packetBuffer.size(); i++ )
+  for ( int i = 0; i < (int)packetBuffer.size(); i++ )
     removeUserPackets( i );
   
@@ -115 +115 @@
 void UdpServerSocket::removeUserPackets( int userId )
 {
-  if ( userId >= packetBuffer.size() )
+  if ( userId >= (int)packetBuffer.size() )
     return;
   
@@ -141 +141 @@
   res.length = 0;
   
-  if ( packetBuffer.size() > userId && packetBuffer[userId].size() > 0 )
+  if ( (int)packetBuffer.size() > userId && (int)packetBuffer[userId].size() > 0 )
   {
     res.data = packetBuffer[userId].front().data;
     res.length = packetBuffer[userId].front().length;
     packetBuffer[userId].pop_front();
+    
+    if ( res.length == 0 )
+      res.length = -1;
   }
   
@@ -158 +161 @@
 int UdpServerSocket::getPacketCount( int userId )
 {
-  if ( userId >= packetBuffer.size() )
+  if ( userId >= (int)packetBuffer.size() )
     return -1;
   
@@ -179 +182 @@
   }
   
-  if ( userId < packetBuffer.size() )
+  if ( userId < (int)packetBuffer.size() )
     removeUserPackets( userId );
   
-  if ( packetBuffer.size() <= userId )
+  if ( (int)packetBuffer.size() <= userId )
     packetBuffer.resize( userId + 1 );
   
-  if ( userList.size() <= userId )
+  if ( (int)userList.size() <= userId )
     userList.resize( userId + 1 );
   
@@ -199 +202 @@
   removeUserPackets( userId );
   
-  if ( userId >= userList.size() )
+  if ( userId >= (int)userList.size() )
     return;
   
@@ -244 +247 @@
     bool isNewConnection = false;
     
-    for ( userId =0; userId < userList.size(); userId++ )
+    for ( userId =0; userId < (int)userList.size(); userId++ )
       if ( userList[userId].host == packet->address.host && userList[userId].port == packet->address.port )
         break;
     
-    if ( userId >= userList.size() )
+    if ( userId >= (int)userList.size() )
     {
       
@@ -260 +263 @@
       }
       
-      for ( userId =0; userId < userList.size(); userId++ )
+      for ( userId =0; userId < (int)userList.size(); userId++ )
         if ( userList[userId].host == 0 && userList[userId].port == 0 )
           break;
@@ -281 +284 @@
     else
     {
-      if ( isNewConnection )
-        continue;
-      
       networkPacket.data = NULL;
     }

trunk/src/lib/network/udp_socket.cc

@@ -81 +81 @@
 UdpSocket::~UdpSocket( )
 {
+  this->disconnectServer();
+  
   if ( serverSocket )
     serverSocket->removeUser( userId );
-  
-  disconnectServer();
-  
+
   if ( this->packet )
     SDLNet_FreePacket( this->packet );
@@ -128 +128 @@
     return;
   }
-  
+}
+
+/**
+ * disconnect from server
+ */
+void UdpSocket::disconnectServer( )
+{
+  PRINTF(0)("disconnect\n");
   writePacket( NULL, 0 );
-}
-
-/**
- * disconnect from server
- */
-void UdpSocket::disconnectServer( )
-{
   SDLNet_UDP_Unbind( socket, -1 );
   SDLNet_UDP_Close( socket );
@@ -171 +171 @@
     packet->len = length;
     
-    if ( SDLNet_UDP_Send( socket, 1, packet) == 0 )
+    if ( socket && SDLNet_UDP_Send( socket, 1, packet) == 0 )
     {
       PRINTF(1)("SDLNet_UDP_Send: %s\n", SDLNet_GetError());
@@ -196 +196 @@
     NetworkPacket networkPacket = serverSocket->getPacket( this->userId );
     
+    if ( networkPacket.length == -1 )
+    {
+      this->disconnectServer();
+      return 0;
+    }
+    
     if ( networkPacket.length > 0 )
     {
@@ -218 +224 @@
       assert( packet->len <= maxLength );
       
+      if ( packet->len == 0 )
+      {
+        this->disconnectServer();
+        return 0;
+      }
+      
       memcpy( data, packet->data, packet->len );
       return packet->len;

trunk/src/story_entities/multi_player_world.cc

@@ -26 +26 @@
 
 #include "network_manager.h"
+#include "network_game_manager.h"
 
 
@@ -119 +120 @@
   ((MultiPlayerWorldData*)this->dataTank)->debug();
 }
+
+/**
+ * cleanup
+ * @return 
+ */
+ErrorMessage MultiPlayerWorld::unloadData( )
+{
+    
+  GameWorld::unloadData();
+  
+  delete NetworkManager::getInstance();
+  delete NetworkGameManager::getInstance();
+
+}

trunk/src/story_entities/multi_player_world.h

@@ -26 +26 @@
 
   virtual void loadParams(const TiXmlElement* root);
+  
+  virtual ErrorMessage unloadData();
 
   void debug();

trunk/src/util/signal_handler.cc

@@ -17 +17 @@
 #include <assert.h>
 
+SignalHandler * SignalHandler::singletonRef = NULL;
+
 #ifndef __WIN32__
-
-SignalHandler * SignalHandler::singletonRef = NULL;
 
 SignalHandler::SignalHandler()
@@ -59 +59 @@
 void SignalHandler::sigHandler( int sig )
 {
+  for ( SignalCallbackList::iterator it = SignalHandler::getInstance()->callbackList.begin(); it != SignalHandler::getInstance()->callbackList.end(); it++  )
+  {
+    (*(it->cb))( it->someData );
+  }
+  
   std::string sigName = "UNKNOWN";
 
@@ -113 +118 @@
 }
 
+void SignalHandler::registerCallback( SignalCallback cb, void * someData )
+{
+  SignalCallbackRec rec;
+  rec.cb = cb;
+  rec.someData = someData;
+  
+  callbackList.push_back(rec);
+}
+
 #endif /* __WIN32__ */

trunk/src/util/signal_handler.h

@@ -17 +17 @@
 };
 
+typedef bool (*SignalCallback)( void * someData );
 
 #ifndef __WIN32__
@@ -27 +28 @@
 };
 
+struct SignalCallbackRec
+{
+  SignalCallback cb;
+  void * someData;
+};
+
 
 typedef std::list<SignalRec> SignalRecList;
+typedef std::list<SignalCallbackRec> SignalCallbackList;
 
 class SignalHandler
@@ -35 +43 @@
     SignalHandler();
   public:
-    inline static SignalHandler* getInstance() { if (!SignalHandler::singletonRef) SignalHandler::singletonRef = new SignalHandler();
-      return SignalHandler::singletonRef; }
+    inline static SignalHandler* getInstance() { if (!SignalHandler::singletonRef) SignalHandler::singletonRef = new SignalHandler(); return SignalHandler::singletonRef; }
+      
+    void registerCallback( SignalCallback cb, void * someData );
 
     void doCatch( std::string appName, GdbRunType type = GDB_RUN_WRITE_TO_FILE );
@@ -46 +55 @@
     void catchSignal( int sig );
     SignalRecList sigRecList;
+    
+    SignalCallbackList callbackList;
 
     static SignalHandler * singletonRef;
@@ -58 +69 @@
 {
  public:
-  inline static SignalHandler* getInstance() {};
+   inline static SignalHandler* getInstance() { if (!SignalHandler::singletonRef) SignalHandler::singletonRef = new SignalHandler(); return SignalHandler::singletonRef; };
   void doCatch( std::string appName, GdbRunType type = GDB_RUN_WRITE_TO_FILE ) {};
   void dontCatch() {};
+  void registerCallback( SignalCallback cb, void * someData ) {};
 };
 #endif

trunk/src/world_entities/space_ships/space_ship.cc

@@ -305 +305 @@
     }
   }
-//  PRINTF(3)("collision %s vs %s @ (%f,%f,%f)\n", this->getClassName(), entity->getClassName(), location.x, location.y, location.z);
+  PRINTF(3)("collision %s vs %s @ (%f,%f,%f)\n", this->getClassName(), entity->getClassName(), location.x, location.y, location.z);
 }
 

trunk/src/world_entities/spectator.cc

@@ -24 +24 @@
 
 
-/**
- * constructor
- */
-Spectator::Spectator( const TiXmlElement * root )
-{
+using namespace std;
+
+
+/**
+ *  destructs the Spectator, deletes alocated memory
+ */
+Spectator::~Spectator ()
+{
+  this->setPlayer(NULL);
+}
+
+
+/**
+ *  creates a new Spectator from Xml Data
+ * @param root the xml element containing Spectator data
+
+   @todo add more parameters to load
+ */
+Spectator::Spectator(const TiXmlElement* root)
+{
+  this->init();
+  if (root != NULL)
+    this->loadParams(root);
+
+}
+
+
+/**
+ * initializes a Spectator
+ */
+void Spectator::init()
+{
+//  this->setRelDir(Quaternion(M_PI, Vector(1,0,0)));
   this->setClassID(CL_SPECTATOR, "Spectator");
-  
-  bool                  bLeft;
-  bool                  bRight;
-  bool                  bForward;
-  bool                  bBackward;
-    
-  float                 xMouse;             //!< mouse moved in x-Direction
-  float                 yMouse;             //!< mouse moved in y-Direction
+
+  this->getWeaponManager().changeWeaponConfig(1);
 
   this->bLeft = false;
@@ -45 +67 @@
   this->xMouse = 0.0f;
   this->yMouse = 0.0f;
-    
+
+  this->setHealthMax(100);
+  this->setHealth(80);
+
+  this->mouseDir = this->getAbsDir();
+
+  //add events to the eventlist
   registerEvent(KeyMapper::PEV_FORWARD);
   registerEvent(KeyMapper::PEV_BACKWARD);
@@ -52 +80 @@
   registerEvent(KeyMapper::PEV_FIRE1);
   registerEvent(EV_MOUSE_MOTION);
-  
+
+  this->getWeaponManager().setSlotCount(0);
+
+  this->getWeaponManager().getFixedTarget()->setParent(this);
+  this->getWeaponManager().getFixedTarget()->setRelCoor(100000,0,0);
+
+  dynamic_cast<Element2D*>(this->getWeaponManager().getFixedTarget())->setVisibility( false);
+
+ 
   registerVar( new SynchronizeableBool( &bLeft, &bLeft, "bLeft", PERMISSION_OWNER ) );
   registerVar( new SynchronizeableBool( &bRight, &bRight, "bRight", PERMISSION_OWNER ) );
@@ -60 +96 @@
 }
 
-/**
- * destructor
- */
-Spectator::~Spectator( )
-{
-  this->setPlayer(NULL);
-}
-
-void Spectator::setPlayDirection( const Quaternion & rot, float speed )
-{
-  this->mouseDir =  rot;
-  this->angleY = rot.getHeading();
-  this->angleX = rot.getAttitude();
-}
-
-void Spectator::enter( )
-{
+
+/**
+ * loads the Settings of a Spectator from an XML-element.
+ * @param root the XML-element to load the Spaceship's properties from
+ */
+void Spectator::loadParams(const TiXmlElement* root)
+{
+  Playable::loadParams(root);
+}
+
+void Spectator::setPlayDirection(const Quaternion& quat, float speed)
+{
+  this->mouseDir = quat;
+  this->angleY = quat.getHeading();
+  this->angleX = quat.getAttitude();
+}
+
+
+void Spectator::reset()
+{
+  this->bLeft = false;
+  this->bRight = false;
+  this->bForward = false;
+  this->bBackward = false;
+  this->xMouse = 0.0f;
+  this->yMouse = 0.0f;
+
+  this->setHealth(80);
+}
+
+
+void Spectator::enter()
+{
+  dynamic_cast<Element2D*>(this->getWeaponManager().getFixedTarget())->setVisibility( false );
   this->attachCamera();
 }
 
-void Spectator::leave( )
-{
+void Spectator::leave()
+{
+  dynamic_cast<Element2D*>(this->getWeaponManager().getFixedTarget())->setVisibility( false);
   this->detachCamera();
 }
 
-/**
- * collision handling
- * @param entity other entity
- * @param location 
- * @todo dont allow spectator to go through walls
- */
-void Spectator::collidesWith( WorldEntity * entity, const Vector & location )
-{
-}
-
-void Spectator::tick( float time )
+
+/**
+ *  this function is called, when two entities collide
+ * @param entity: the world entity with whom it collides
+ *
+ * Implement behaviour like damage application or other miscellaneous collision stuff in this function
+ * @todo dont let Spectator fly through walls
+ */
+void Spectator::collidesWith(WorldEntity* entity, const Vector& location)
+{
+}
+
+
+
+/**
+ *  the function called for each passing timeSnap
+ * @param time The timespan passed since last update
+ */
+void Spectator::tick (float time)
 {
   Playable::tick( time );
@@ -147 +209 @@
 }
 
-void Spectator::process( const Event & event )
+/**
+ * @todo switch statement ??
+ */
+void Spectator::process(const Event &event)
 {
   Playable::process(event);
@@ -165 +230 @@
   }
 }
+
+
+
+

trunk/src/world_entities/spectator.h

@@ -11 +11 @@
 class Spectator : public Playable
 {
+
   public:
-    Spectator( const TiXmlElement* root = NULL );
+    Spectator(const TiXmlElement* root = NULL);
     virtual ~Spectator();
-    
+
+    virtual void loadParams(const TiXmlElement* root);
+
     virtual void setPlayDirection(const Quaternion& rot, float speed = 0.0f);
 
     virtual void enter();
     virtual void leave();
-    
+
+    virtual void reset();
+
     virtual void collidesWith(WorldEntity* entity, const Vector& location);
     virtual void tick(float time);
 
     virtual void process(const Event &event);
-    
+
   private:
+    void init();
+
     bool                  bLeft;
     bool                  bRight;
@@ -35 +42 @@
     Quaternion            mouseDir;           //!< the direction where the player wants to fly
 
-    //Quaternion            rotY;
-    //Quaternion            rotAxis;
     float                 angleX;
     float                 angleY;
+
 };