Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

Changeset 8228 in orxonox.OLD for trunk


Ignore:
Timestamp:
Jun 8, 2006, 11:19:08 AM (19 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:
18 edited

Legend:

Unmodified
Added
Removed
  • trunk/src/lib/event/event_handler.cc

    r8148 r8228  
    353353  else
    354354  {
    355 //    SDL_WM_GrabInput(SDL_GRAB_ON);
     355    SDL_WM_GrabInput(SDL_GRAB_ON);
    356356    SDL_ShowCursor(SDL_DISABLE);
    357357  }
  • trunk/src/lib/network/message_manager.cc

    r8068 r8228  
    1717
    1818#include "message_manager.h"
     19
     20#include "network_stream.h"
    1921
    2022using namespace std;
     
    312314         recieverType == RT_ALL_NOT_ME ||
    313315         recieverType == RT_USER && it->first == reciever ||
    314          recieverType == RT_NOT_USER && it->first != reciever
     316         recieverType == RT_NOT_USER && it->first != reciever ||
     317         recieverType == RT_SERVER && getNetworkStream()->isUserServer( it->first )
    315318       )
    316319    {
  • trunk/src/lib/network/message_manager.h

    r8147 r8228  
    3030  TESTMESSAGEID = 1,
    3131  MSGID_DELETESYNCHRONIZEABLE,
    32   MSGID_PREFEREDTEAM
     32  MSGID_PREFEREDTEAM,
     33  MSGID_CHANGEPLAYERNAME
    3334};
    3435
     
    4041  RT_ALL_ME,           //!< message is sent to all users
    4142  RT_USER,             //!< message is only sent to reciever
    42   RT_NOT_USER          //!< message is sent to all but reciever
     43  RT_NOT_USER,         //!< message is sent to all but reciever
     44  RT_SERVER            //!< message is sent to server only
    4345};
    4446
  • trunk/src/lib/network/network_game_manager.cc

    r8147 r8228  
    112112  stats->setPlayableUniqueId( playable.getUniqueID() );
    113113  stats->setModelFileName( playableModel );
     114 
     115  return true;
    114116}
    115117
     
    122124bool NetworkGameManager::signalLeftPlayer(int userID)
    123125{
    124   delete PlayerStats::getStats( userID )->getPlayable();
    125   delete PlayerStats::getStats( userID );
     126  if ( PlayerStats::getStats( userID ) )
     127  {
     128    if ( PlayerStats::getStats( userID )->getPlayable() )
     129      delete PlayerStats::getStats( userID )->getPlayable();
     130    delete PlayerStats::getStats( userID );
     131  }
     132 
     133  return true;
    126134}
    127135
     
    165173        return true;
    166174      }
    167        
     175     
    168176      delete dynamic_cast<Synchronizeable*>(*it);
    169177      return true;
    170178    }
    171179  }
     180 
     181  return true;
    172182}
    173183
     
    210220 
    211221  NetworkGameManager::getInstance()->setPreferedTeam( userId, teamId );
     222 
     223  return true;
    212224}
    213225
     
    220232 
    221233  stats.setPreferedTeamId( teamId );
    222  
    223234}
    224235
  • trunk/src/lib/network/network_manager.cc

    r8147 r8228  
    5151
    5252  /* initialize the references */
    53   this->netStreamList = NULL;
    54   this->syncList = NULL;
    55   this->defaultSyncStream = NULL;
     53  this->networkStream = NULL;
    5654  this->sharedNetworkData = SharedNetworkData::getInstance();
    5755  this->elapsedTime = 0.0f;
     
    7169 */
    7270NetworkManager::~NetworkManager()
    73 {}
     71{
     72  if ( this->networkStream )
     73  {
     74    delete this->networkStream;
     75    this->networkStream = NULL;
     76  }
     77}
    7478
    7579
     
    7983void NetworkManager::initialize()
    8084{
    81   /* get the synchronizeable list from the class list */
    82   this->netStreamList = ClassList::getList(CL_SYNCHRONIZEABLE);
    8385  PRINTF(0)("NetworkManager initzalized\n");
    84 
    8586}
    8687
     
    101102int NetworkManager::establishConnection(const std::string & name, unsigned int port)
    102103{
    103   this->defaultSyncStream = new NetworkStream( name, port );
    104   this->sharedNetworkData->setDefaultSyncStream(this->defaultSyncStream);
    105   this->defaultSyncStream->startHandshake();
     104  this->networkStream = new NetworkStream( name, port );
     105  this->sharedNetworkData->setDefaultSyncStream(this->networkStream);
     106  this->networkStream->startHandshake();
    106107  return 1;
    107108}
     
    116117  this->sharedNetworkData->setHostID(0);
    117118  this->sharedNetworkData->setGameServer(true);
    118   this->defaultSyncStream = new NetworkStream(port);
    119   this->sharedNetworkData->setDefaultSyncStream(this->defaultSyncStream);
    120   this->defaultSyncStream->createNetworkGameManager();
     119  this->networkStream = new NetworkStream(port);
     120  this->sharedNetworkData->setDefaultSyncStream(this->networkStream);
     121  this->networkStream->createNetworkGameManager();
    121122  PRINTF(0)("CREATE SERVER\n");
    122123  SDL_Delay(20);
     
    127128void NetworkManager::connectSynchronizeable(Synchronizeable& sync)
    128129{
    129   if( this->defaultSyncStream)
    130     this->defaultSyncStream->connectSynchronizeable(sync);
     130  if( this->networkStream)
     131    this->networkStream->connectSynchronizeable(sync);
    131132}
    132133
     
    143144  this->elapsedTime = 0.0f;
    144145
    145   if (this->netStreamList != NULL || (this->netStreamList = ClassList::getList(CL_NETWORK_STREAM)) != NULL)
    146   {
    147     std::list<BaseObject*>::const_iterator stream;
    148     for (stream = this->netStreamList->begin(); stream != this->netStreamList->end(); ++stream)
    149       if( static_cast<NetworkStream*>(*stream)->isActive())
    150         static_cast<NetworkStream*>(*stream)->processData();
    151   }
     146  if ( networkStream->isActive() )
     147    networkStream->processData();
    152148 
    153149  NetworkGameManager::getInstance()->tick( this->elapsedTime );
     
    162158{
    163159  PRINT(0)("=================Network::debug()=========\n");
    164   this->defaultSyncStream->debug();
     160  this->networkStream->debug();
    165161  PRINT(0)("===========================================\n");
    166162}
  • trunk/src/lib/network/network_manager.h

    r7954 r8228  
    5555
    5656  private:
    57     const std::list<BaseObject*>*    netStreamList;           // list with refs to all network streams
    58     const std::list<BaseObject*>*    syncList;                // list of synchronizeables
    5957    static NetworkManager*           singletonRef;            //!< Pointer to the only instance of this Class
    60     NetworkStream*                   defaultSyncStream;       //!< FIXME: this is only for testing purposes
     58    NetworkStream*                   networkStream;       //!< pointer to network stream
    6159
    6260    SharedNetworkData*               sharedNetworkData;       //!< reference to the shared data
  • trunk/src/lib/network/network_stream.cc

    r8068 r8228  
    105105    serverSocket->close();
    106106    delete serverSocket;
     107    serverSocket = NULL;
    107108  }
    108109
     
    123124  }
    124125 
    125   if ( serverSocket )
    126   {
    127     delete serverSocket;
    128     serverSocket = NULL;
    129   }
    130 
     126  for ( SynchronizeableList::const_iterator it = getSyncBegin(); it != getSyncEnd(); it ++ )
     127    (*it)->setNetworkStream( NULL );
    131128}
    132129
     
    264261
    265262  //check if connections are ok else remove them
    266   for ( PeerList::iterator it = peers.begin(); it != peers.end(); it++ )
     263  for ( PeerList::iterator it = peers.begin(); it != peers.end(); )
    267264  {
    268265    if ( 
     
    297294
    298295      freeSocketSlots.push_back( it->second.userId );
    299 
    300     }
     296     
     297      PeerList::iterator delit = it;
     298      it++;
     299     
     300      peers.erase( delit );
     301     
     302      continue;
     303    }
     304   
     305    it++;
    301306  }
    302307
     
    651656          }
    652657        }
     658       
    653659
    654660        int n = sync->setStateDiff( peer->second.userId, buf+offset, syncDataLength, state, fromState );
     
    664670      }
    665671     
    666       //TODO REMOVE THIS
    667       int saveOffset = offset;
    668672     
    669673      for ( SynchronizeableList::iterator it = synchronizeables.begin(); it != synchronizeables.end(); it++ )
     
    682686      assert( peer->second.lastRecvedState < state );
    683687      peer->second.lastRecvedState = state;
    684      
    685       assert( saveOffset == offset );
    686      
     688
    687689    }
    688690 
  • trunk/src/lib/network/player_stats.cc

    r8147 r8228  
    2121#include "player.h"
    2222#include "state.h"
     23#include "shared_network_data.h"
    2324
    2425
     
    8586    this->setPlayableUniqueId( this->playableUniqueId );
    8687   
    87     PRINTF(0)("uniqueID changed %d %d\n", userId, getHostID());
     88    PRINTF(0)("uniqueID changed %d %d %d\n", userId, getHostID(), getUniqueID());
    8889  }
    8990}
     
    99100 
    100101  if ( !list )
     102  {
    101103    return NULL;
     104  }
    102105 
    103106  for ( std::list<BaseObject*>::const_iterator it = list->begin(); it != list->end(); it++ )
     
    108111    }
    109112  }
    110  
    111   //TODO maybe we should create an object here
    112113 
    113114  return NULL;
     
    133134    {
    134135      this->playable = dynamic_cast<Playable*>(*it);
     136      //TODO when OM_PLAYERS is ticked add line:
     137      //this->playable->toList( OM_PLAYERS );
    135138      break;
    136139    }
     
    138141 
    139142  if ( this->playable && userId == getHostID() )
     143  {
    140144    State::getPlayer()->setPlayable( this->playable );
     145  }
    141146 
    142147  this->playableUniqueId = uniqueId;
  • trunk/src/lib/network/synchronizeable.cc

    r8147 r8228  
    369369void Synchronizeable::cleanUpUser( int userId )
    370370{
    371   for ( UserStateHistory::iterator it = sentStates.begin(); it != sentStates.end(); it++ )
    372   {
    373     for ( StateHistory::iterator it2 = it->begin(); it2 != it->end(); it2++ )
    374     {
    375       if ( (*it2)->data )
    376         delete [] (*it2)->data;
    377       (*it2)->data = NULL;
    378      
    379       delete *it2;
    380     }
    381   }
    382  
    383   sentStates.clear();
    384  
    385   for ( UserStateHistory::iterator it = recvStates.begin(); it != recvStates.end(); it++ )
    386   {
    387     for ( StateHistory::iterator it2 = it->begin(); it2 != it->end(); it2++ )
    388     {
    389       if ( (*it2)->data )
    390         delete [] (*it2)->data;
    391       (*it2)->data = NULL;
    392      
    393       delete *it2;
    394     }
    395   }
    396  
    397   recvStates.clear();
     371  if ( recvStates.size() > userId )
     372  {
     373    for ( std::list<StateHistoryEntry*>::iterator it = recvStates[userId].begin(); it != recvStates[userId].end(); it++ )
     374    {
     375      if ( (*it)->data )
     376        delete [] (*it)->data;
     377      (*it)->data = NULL;
     378   
     379      delete *it;
     380    }
     381    recvStates[userId].clear();
     382  }
     383 
     384  if ( sentStates.size() > userId )
     385  {
     386   
     387    for ( std::list<StateHistoryEntry*>::iterator it = sentStates[userId].begin(); it != sentStates[userId].end(); it++ )
     388    {
     389      if ( (*it)->data )
     390        delete [] (*it)->data;
     391      (*it)->data = NULL;
     392   
     393      delete *it;
     394    }
     395    sentStates[userId].clear();
     396  }
    398397}
    399398
  • trunk/src/lib/network/udp_server_socket.cc

    r7954 r8228  
    4444UdpServerSocket::~UdpServerSocket( )
    4545{
    46   for ( int i = 0; i < packetBuffer.size(); i++ )
     46  for ( int i = 0; i < (int)packetBuffer.size(); i++ )
    4747    removeUserPackets( i );
    4848 
     
    9999{
    100100 
    101   for ( int i = 0; i < packetBuffer.size(); i++ )
     101  for ( int i = 0; i < (int)packetBuffer.size(); i++ )
    102102    removeUserPackets( i );
    103103 
     
    115115void UdpServerSocket::removeUserPackets( int userId )
    116116{
    117   if ( userId >= packetBuffer.size() )
     117  if ( userId >= (int)packetBuffer.size() )
    118118    return;
    119119 
     
    141141  res.length = 0;
    142142 
    143   if ( packetBuffer.size() > userId && packetBuffer[userId].size() > 0 )
     143  if ( (int)packetBuffer.size() > userId && (int)packetBuffer[userId].size() > 0 )
    144144  {
    145145    res.data = packetBuffer[userId].front().data;
    146146    res.length = packetBuffer[userId].front().length;
    147147    packetBuffer[userId].pop_front();
     148   
     149    if ( res.length == 0 )
     150      res.length = -1;
    148151  }
    149152 
     
    158161int UdpServerSocket::getPacketCount( int userId )
    159162{
    160   if ( userId >= packetBuffer.size() )
     163  if ( userId >= (int)packetBuffer.size() )
    161164    return -1;
    162165 
     
    179182  }
    180183 
    181   if ( userId < packetBuffer.size() )
     184  if ( userId < (int)packetBuffer.size() )
    182185    removeUserPackets( userId );
    183186 
    184   if ( packetBuffer.size() <= userId )
     187  if ( (int)packetBuffer.size() <= userId )
    185188    packetBuffer.resize( userId + 1 );
    186189 
    187   if ( userList.size() <= userId )
     190  if ( (int)userList.size() <= userId )
    188191    userList.resize( userId + 1 );
    189192 
     
    199202  removeUserPackets( userId );
    200203 
    201   if ( userId >= userList.size() )
     204  if ( userId >= (int)userList.size() )
    202205    return;
    203206 
     
    244247    bool isNewConnection = false;
    245248   
    246     for ( userId =0; userId < userList.size(); userId++ )
     249    for ( userId =0; userId < (int)userList.size(); userId++ )
    247250      if ( userList[userId].host == packet->address.host && userList[userId].port == packet->address.port )
    248251        break;
    249252   
    250     if ( userId >= userList.size() )
     253    if ( userId >= (int)userList.size() )
    251254    {
    252255     
     
    260263      }
    261264     
    262       for ( userId =0; userId < userList.size(); userId++ )
     265      for ( userId =0; userId < (int)userList.size(); userId++ )
    263266        if ( userList[userId].host == 0 && userList[userId].port == 0 )
    264267          break;
     
    281284    else
    282285    {
    283       if ( isNewConnection )
    284         continue;
    285      
    286286      networkPacket.data = NULL;
    287287    }
  • trunk/src/lib/network/udp_socket.cc

    r7954 r8228  
    8181UdpSocket::~UdpSocket( )
    8282{
     83  this->disconnectServer();
     84 
    8385  if ( serverSocket )
    8486    serverSocket->removeUser( userId );
    85  
    86   disconnectServer();
    87  
     87
    8888  if ( this->packet )
    8989    SDLNet_FreePacket( this->packet );
     
    128128    return;
    129129  }
    130  
     130}
     131
     132/**
     133 * disconnect from server
     134 */
     135void UdpSocket::disconnectServer( )
     136{
     137  PRINTF(0)("disconnect\n");
    131138  writePacket( NULL, 0 );
    132 }
    133 
    134 /**
    135  * disconnect from server
    136  */
    137 void UdpSocket::disconnectServer( )
    138 {
    139139  SDLNet_UDP_Unbind( socket, -1 );
    140140  SDLNet_UDP_Close( socket );
     
    171171    packet->len = length;
    172172   
    173     if ( SDLNet_UDP_Send( socket, 1, packet) == 0 )
     173    if ( socket && SDLNet_UDP_Send( socket, 1, packet) == 0 )
    174174    {
    175175      PRINTF(1)("SDLNet_UDP_Send: %s\n", SDLNet_GetError());
     
    196196    NetworkPacket networkPacket = serverSocket->getPacket( this->userId );
    197197   
     198    if ( networkPacket.length == -1 )
     199    {
     200      this->disconnectServer();
     201      return 0;
     202    }
     203   
    198204    if ( networkPacket.length > 0 )
    199205    {
     
    218224      assert( packet->len <= maxLength );
    219225     
     226      if ( packet->len == 0 )
     227      {
     228        this->disconnectServer();
     229        return 0;
     230      }
     231     
    220232      memcpy( data, packet->data, packet->len );
    221233      return packet->len;
  • trunk/src/story_entities/multi_player_world.cc

    r8068 r8228  
    2626
    2727#include "network_manager.h"
     28#include "network_game_manager.h"
    2829
    2930
     
    119120  ((MultiPlayerWorldData*)this->dataTank)->debug();
    120121}
     122
     123/**
     124 * cleanup
     125 * @return
     126 */
     127ErrorMessage MultiPlayerWorld::unloadData( )
     128{
     129   
     130  GameWorld::unloadData();
     131 
     132  delete NetworkManager::getInstance();
     133  delete NetworkGameManager::getInstance();
     134
     135}
  • trunk/src/story_entities/multi_player_world.h

    r8068 r8228  
    2626
    2727  virtual void loadParams(const TiXmlElement* root);
     28 
     29  virtual ErrorMessage unloadData();
    2830
    2931  void debug();
  • trunk/src/util/signal_handler.cc

    r8068 r8228  
    1717#include <assert.h>
    1818
     19SignalHandler * SignalHandler::singletonRef = NULL;
     20
    1921#ifndef __WIN32__
    20 
    21 SignalHandler * SignalHandler::singletonRef = NULL;
    2222
    2323SignalHandler::SignalHandler()
     
    5959void SignalHandler::sigHandler( int sig )
    6060{
     61  for ( SignalCallbackList::iterator it = SignalHandler::getInstance()->callbackList.begin(); it != SignalHandler::getInstance()->callbackList.end(); it++  )
     62  {
     63    (*(it->cb))( it->someData );
     64  }
     65 
    6166  std::string sigName = "UNKNOWN";
    6267
     
    113118}
    114119
     120void SignalHandler::registerCallback( SignalCallback cb, void * someData )
     121{
     122  SignalCallbackRec rec;
     123  rec.cb = cb;
     124  rec.someData = someData;
     125 
     126  callbackList.push_back(rec);
     127}
     128
    115129#endif /* __WIN32__ */
  • trunk/src/util/signal_handler.h

    r7440 r8228  
    1717};
    1818
     19typedef bool (*SignalCallback)( void * someData );
    1920
    2021#ifndef __WIN32__
     
    2728};
    2829
     30struct SignalCallbackRec
     31{
     32  SignalCallback cb;
     33  void * someData;
     34};
     35
    2936
    3037typedef std::list<SignalRec> SignalRecList;
     38typedef std::list<SignalCallbackRec> SignalCallbackList;
    3139
    3240class SignalHandler
     
    3543    SignalHandler();
    3644  public:
    37     inline static SignalHandler* getInstance() { if (!SignalHandler::singletonRef) SignalHandler::singletonRef = new SignalHandler();
    38       return SignalHandler::singletonRef; }
     45    inline static SignalHandler* getInstance() { if (!SignalHandler::singletonRef) SignalHandler::singletonRef = new SignalHandler(); return SignalHandler::singletonRef; }
     46     
     47    void registerCallback( SignalCallback cb, void * someData );
    3948
    4049    void doCatch( std::string appName, GdbRunType type = GDB_RUN_WRITE_TO_FILE );
     
    4655    void catchSignal( int sig );
    4756    SignalRecList sigRecList;
     57   
     58    SignalCallbackList callbackList;
    4859
    4960    static SignalHandler * singletonRef;
     
    5869{
    5970 public:
    60   inline static SignalHandler* getInstance() {};
     71   inline static SignalHandler* getInstance() { if (!SignalHandler::singletonRef) SignalHandler::singletonRef = new SignalHandler(); return SignalHandler::singletonRef; };
    6172  void doCatch( std::string appName, GdbRunType type = GDB_RUN_WRITE_TO_FILE ) {};
    6273  void dontCatch() {};
     74  void registerCallback( SignalCallback cb, void * someData ) {};
    6375};
    6476#endif
  • trunk/src/world_entities/space_ships/space_ship.cc

    r7954 r8228  
    305305    }
    306306  }
    307 //  PRINTF(3)("collision %s vs %s @ (%f,%f,%f)\n", this->getClassName(), entity->getClassName(), location.x, location.y, location.z);
     307  PRINTF(3)("collision %s vs %s @ (%f,%f,%f)\n", this->getClassName(), entity->getClassName(), location.x, location.y, location.z);
    308308}
    309309
  • trunk/src/world_entities/spectator.cc

    r8147 r8228  
    2424
    2525
    26 /**
    27  * constructor
    28  */
    29 Spectator::Spectator( const TiXmlElement * root )
    30 {
     26using namespace std;
     27
     28
     29/**
     30 *  destructs the Spectator, deletes alocated memory
     31 */
     32Spectator::~Spectator ()
     33{
     34  this->setPlayer(NULL);
     35}
     36
     37
     38/**
     39 *  creates a new Spectator from Xml Data
     40 * @param root the xml element containing Spectator data
     41
     42   @todo add more parameters to load
     43 */
     44Spectator::Spectator(const TiXmlElement* root)
     45{
     46  this->init();
     47  if (root != NULL)
     48    this->loadParams(root);
     49
     50}
     51
     52
     53/**
     54 * initializes a Spectator
     55 */
     56void Spectator::init()
     57{
     58//  this->setRelDir(Quaternion(M_PI, Vector(1,0,0)));
    3159  this->setClassID(CL_SPECTATOR, "Spectator");
    32  
    33   bool                  bLeft;
    34   bool                  bRight;
    35   bool                  bForward;
    36   bool                  bBackward;
    37    
    38   float                 xMouse;             //!< mouse moved in x-Direction
    39   float                 yMouse;             //!< mouse moved in y-Direction
     60
     61  this->getWeaponManager().changeWeaponConfig(1);
    4062
    4163  this->bLeft = false;
     
    4567  this->xMouse = 0.0f;
    4668  this->yMouse = 0.0f;
    47    
     69
     70  this->setHealthMax(100);
     71  this->setHealth(80);
     72
     73  this->mouseDir = this->getAbsDir();
     74
     75  //add events to the eventlist
    4876  registerEvent(KeyMapper::PEV_FORWARD);
    4977  registerEvent(KeyMapper::PEV_BACKWARD);
     
    5280  registerEvent(KeyMapper::PEV_FIRE1);
    5381  registerEvent(EV_MOUSE_MOTION);
    54  
     82
     83  this->getWeaponManager().setSlotCount(0);
     84
     85  this->getWeaponManager().getFixedTarget()->setParent(this);
     86  this->getWeaponManager().getFixedTarget()->setRelCoor(100000,0,0);
     87
     88  dynamic_cast<Element2D*>(this->getWeaponManager().getFixedTarget())->setVisibility( false);
     89
     90 
    5591  registerVar( new SynchronizeableBool( &bLeft, &bLeft, "bLeft", PERMISSION_OWNER ) );
    5692  registerVar( new SynchronizeableBool( &bRight, &bRight, "bRight", PERMISSION_OWNER ) );
     
    6096}
    6197
    62 /**
    63  * destructor
    64  */
    65 Spectator::~Spectator( )
    66 {
    67   this->setPlayer(NULL);
    68 }
    69 
    70 void Spectator::setPlayDirection( const Quaternion & rot, float speed )
    71 {
    72   this->mouseDir =  rot;
    73   this->angleY = rot.getHeading();
    74   this->angleX = rot.getAttitude();
    75 }
    76 
    77 void Spectator::enter( )
    78 {
     98
     99/**
     100 * loads the Settings of a Spectator from an XML-element.
     101 * @param root the XML-element to load the Spaceship's properties from
     102 */
     103void Spectator::loadParams(const TiXmlElement* root)
     104{
     105  Playable::loadParams(root);
     106}
     107
     108void Spectator::setPlayDirection(const Quaternion& quat, float speed)
     109{
     110  this->mouseDir = quat;
     111  this->angleY = quat.getHeading();
     112  this->angleX = quat.getAttitude();
     113}
     114
     115
     116void Spectator::reset()
     117{
     118  this->bLeft = false;
     119  this->bRight = false;
     120  this->bForward = false;
     121  this->bBackward = false;
     122  this->xMouse = 0.0f;
     123  this->yMouse = 0.0f;
     124
     125  this->setHealth(80);
     126}
     127
     128
     129void Spectator::enter()
     130{
     131  dynamic_cast<Element2D*>(this->getWeaponManager().getFixedTarget())->setVisibility( false );
    79132  this->attachCamera();
    80133}
    81134
    82 void Spectator::leave( )
    83 {
     135void Spectator::leave()
     136{
     137  dynamic_cast<Element2D*>(this->getWeaponManager().getFixedTarget())->setVisibility( false);
    84138  this->detachCamera();
    85139}
    86140
    87 /**
    88  * collision handling
    89  * @param entity other entity
    90  * @param location
    91  * @todo dont allow spectator to go through walls
    92  */
    93 void Spectator::collidesWith( WorldEntity * entity, const Vector & location )
    94 {
    95 }
    96 
    97 void Spectator::tick( float time )
     141
     142/**
     143 *  this function is called, when two entities collide
     144 * @param entity: the world entity with whom it collides
     145 *
     146 * Implement behaviour like damage application or other miscellaneous collision stuff in this function
     147 * @todo dont let Spectator fly through walls
     148 */
     149void Spectator::collidesWith(WorldEntity* entity, const Vector& location)
     150{
     151}
     152
     153
     154
     155/**
     156 *  the function called for each passing timeSnap
     157 * @param time The timespan passed since last update
     158 */
     159void Spectator::tick (float time)
    98160{
    99161  Playable::tick( time );
     
    147209}
    148210
    149 void Spectator::process( const Event & event )
     211/**
     212 * @todo switch statement ??
     213 */
     214void Spectator::process(const Event &event)
    150215{
    151216  Playable::process(event);
     
    165230  }
    166231}
     232
     233
     234
     235
  • trunk/src/world_entities/spectator.h

    r8147 r8228  
    1111class Spectator : public Playable
    1212{
     13
    1314  public:
    14     Spectator( const TiXmlElement* root = NULL );
     15    Spectator(const TiXmlElement* root = NULL);
    1516    virtual ~Spectator();
    16    
     17
     18    virtual void loadParams(const TiXmlElement* root);
     19
    1720    virtual void setPlayDirection(const Quaternion& rot, float speed = 0.0f);
    1821
    1922    virtual void enter();
    2023    virtual void leave();
    21    
     24
     25    virtual void reset();
     26
    2227    virtual void collidesWith(WorldEntity* entity, const Vector& location);
    2328    virtual void tick(float time);
    2429
    2530    virtual void process(const Event &event);
    26    
     31
    2732  private:
     33    void init();
     34
    2835    bool                  bLeft;
    2936    bool                  bRight;
     
    3542    Quaternion            mouseDir;           //!< the direction where the player wants to fly
    3643
    37     //Quaternion            rotY;
    38     //Quaternion            rotAxis;
    3944    float                 angleX;
    4045    float                 angleY;
     46
    4147};
    4248
Note: See TracChangeset for help on using the changeset viewer.