Changeset 8147 in orxonox.OLD for trunk/src

Timestamp:

Jun 5, 2006, 12:09:15 PM (19 years ago)

Author:

bensch

Message:

orxonox/trunk: merged the network branche back here
merged with command:
svn merge -r8070:HEAD ​https://svn.orxonox.net/orxonox/branches/network .
no conflicts

Location:

trunk/src

Files:

• lib/network/message_manager.h (modified) (1 diff)
• lib/network/network_game_manager.cc (modified) (4 diffs)
• lib/network/network_game_manager.h (modified) (3 diffs)
• lib/network/network_manager.cc (modified) (2 diffs)
• lib/network/player_stats.cc (modified) (4 diffs)
• lib/network/synchronizeable.cc (modified) (3 diffs)
• lib/network/synchronizeable_var/synchronizeable_string.cc (modified) (1 diff)
• util/multiplayer_team_deathmatch.cc (modified) (7 diffs)
• util/multiplayer_team_deathmatch.h (modified) (3 diffs)
• util/network_game_rules.cc (modified) (1 diff)
• util/network_game_rules.h (modified) (1 diff)
• world_entities/playable.cc (modified) (2 diffs)
• world_entities/player.cc (modified) (1 diff)
• world_entities/spectator.cc (modified) (2 diffs)
• world_entities/spectator.h (modified) (1 diff)
• world_entities/weapons/weapon_manager.cc (modified) (1 diff)

trunk/src/lib/network/message_manager.h

@@ -29 +29 @@
 {
   TESTMESSAGEID = 1,
-  MSGID_DELETESYNCHRONIZEABLE
+  MSGID_DELETESYNCHRONIZEABLE,
+  MSGID_PREFEREDTEAM
 };
 

trunk/src/lib/network/network_game_manager.cc

@@ -59 +59 @@
   
   MessageManager::getInstance()->registerMessageHandler( MSGID_DELETESYNCHRONIZEABLE, delSynchronizeableHandler, NULL );
+  MessageManager::getInstance()->registerMessageHandler( MSGID_PREFEREDTEAM, preferedTeamHandler, NULL );
   
   this->gameState = 0;
@@ -86 +87 @@
   
   int team = rules.getTeamForNewUser();
-  ClassID playableClassId = rules.getPlayableClassId( team );
-  std::string playableModel = rules.getPlayableModelFileName( team, playableClassId );
+  ClassID playableClassId = rules.getPlayableClassId( userId, team );
+  std::string playableModel = rules.getPlayableModelFileName( userId, team, playableClassId );
   
   BaseObject * bo = Factory::fabricate( playableClassId );
@@ -159 +160 @@
     if ( dynamic_cast<Synchronizeable*>(*it)->getUniqueID() == uniqueId )
     {
+      if ( (*it)->isA(CL_PLAYABLE) )
+      {
+        getInstance()->playablesToDelete.push_back( dynamic_cast<Playable*>(*it) );
+        return true;
+      }
+        
       delete dynamic_cast<Synchronizeable*>(*it);
       return true;
@@ -180 +187 @@
 
 
-
-
-
+/**
+ * handler for MSGID_PREFEREDTEAM message
+ * @param messageId 
+ * @param data 
+ * @param dataLength 
+ * @param someData 
+ * @param userId 
+ * @return 
+ */
+bool NetworkGameManager::preferedTeamHandler( MessageId messageId, byte * data, int dataLength, void * someData, int userId )
+{
+  assert( NetworkGameManager::getInstance()->isServer() );
+  
+  int teamId = 0;
+  int len = Converter::byteArrayToInt( data, &teamId );
+  
+  if ( len != dataLength )
+  {
+    PRINTF(2)("Recieved DeleteSynchronizeable message with incorrect size (%d) from client %d!\n", dataLength, userId);
+    return true;
+  }
+  
+  NetworkGameManager::getInstance()->setPreferedTeam( userId, teamId );
+}
+
+void NetworkGameManager::setPreferedTeam( int userId, int teamId )
+{
+  if ( !PlayerStats::getStats( userId ) )
+    return;
+  
+  PlayerStats & stats = *(PlayerStats::getStats( userId ));
+  
+  stats.setPreferedTeamId( teamId );
+  
+}
+
+/**
+ * set prefered team for this host
+ * @param teamId 
+ */
+void NetworkGameManager::prefereTeam( int teamId )
+{
+  if ( isServer() )
+    setPreferedTeam( getHostID(), teamId );
+  else
+  {
+    byte buf[INTSIZE];
+    
+    assert( Converter::intToByteArray( teamId, buf, INTSIZE) == INTSIZE );
+    
+    MessageManager::getInstance()->sendMessage( MSGID_PREFEREDTEAM, buf, INTSIZE, RT_USER, 0, MP_HIGHBANDWIDTH );
+  }
+}
+
+/**
+ * this function will be called periodically by networkManager
+ * @param ds time elapsed since last call of tick
+ */
+void NetworkGameManager::tick( float ds )
+{
+  //delete playables if they are not assigned to local player anymore
+  for ( std::list<Playable*>::iterator it = playablesToDelete.begin(); it != playablesToDelete.end();  )
+  {
+    if ( State::getPlayer()->getPlayable() != *it )
+    {
+      PRINTF(0)("Delete unused playable: %s owner: %d\n", (*it)->getClassName(), (*it)->getOwner() );
+      std::list<Playable*>::iterator delit = it;
+      it++;
+      delete *delit;
+      playablesToDelete.erase( delit );
+      continue;
+    }
+    it++;
+  }
+}
+
+
+
+

trunk/src/lib/network/network_game_manager.h

@@ -12 +12 @@
 /* include base_object.h since all classes are derived from this one */
 #include "synchronizeable.h"
+#include "playable.h"
 #include "message_manager.h"
 
@@ -56 +57 @@
     
     void removeSynchronizeable( int uniqueId );
+    
+    void prefereTeam( int teamId );
 
     inline void setGameState( int gameState ){ this->gameState = gameState; }
     inline int getGameState(){ return this->gameState; }
+    
+    void tick( float ds );
 
   private:
@@ -64 +69 @@
     
     static bool delSynchronizeableHandler( MessageId messageId, byte * data, int dataLength, void * someData, int userId );
+    static bool preferedTeamHandler( MessageId messageId, byte * data, int dataLength, void * someData, int userId );
+    
+    void setPreferedTeam( int userId, int teamId );
 
     static NetworkGameManager*    singletonRef;
     
     int                           gameState;
+    
+    std::list<Playable*>          playablesToDelete;
 };
 

trunk/src/lib/network/network_manager.cc

@@ -30 +30 @@
 #include "preferences.h"
 #include "network_log.h"
+#include "network_game_manager.h"
 
 
@@ -149 +150 @@
         static_cast<NetworkStream*>(*stream)->processData();
   }
+  
+  NetworkGameManager::getInstance()->tick( this->elapsedTime );
 }
 

trunk/src/lib/network/player_stats.cc

@@ -86 +86 @@
     
     PRINTF(0)("uniqueID changed %d %d\n", userId, getHostID());
-    
-    if ( userId == getHostID() )
-      State::getPlayer()->setPlayable( getPlayable() );
   }
 }
@@ -100 +97 @@
 {
   const std::list<BaseObject*> * list = ClassList::getList( CL_PLAYER_STATS );
+  
+  if ( !list )
+    return NULL;
   
   for ( std::list<BaseObject*>::const_iterator it = list->begin(); it != list->end(); it++ )
@@ -121 +121 @@
   const std::list<BaseObject*> * list = ClassList::getList( CL_PLAYABLE );
   
+  if ( !list )
+  {
+    this->playableUniqueId = uniqueId;
+    return;
+  }
+  
   this->playable = NULL;
   for ( std::list<BaseObject*>::const_iterator it = list->begin(); it != list->end(); it++ )
@@ -130 +136 @@
     }
   }
+  
+  if ( this->playable && userId == getHostID() )
+    State::getPlayer()->setPlayable( this->playable );
   
   this->playableUniqueId = uniqueId;

trunk/src/lib/network/synchronizeable.cc

@@ -108 +108 @@
 
   for ( SyncVarList::iterator it = syncVarList.begin(); it != syncVarList.end(); it++ )
+  {
+    //PRINTF(0)("SIZE = %d %s\n", (*it)->getSize(), (*it)->getName().c_str());
     neededSize += (*it)->getSize();
+  }
 
   if ( !( neededSize <= maxLength ) )
@@ -183 +186 @@
                     );
     
-    if ( ( hasPermission && (*it)->getPriority() >= priorityTH ) || sizeIter == stateFrom->sizeList.end() )
+    if ( ( sizeIter != stateFrom->sizeList.end() && *sizeIter != (*it)->getSize() ) || ( hasPermission && (*it)->getPriority() >= priorityTH ) || sizeIter == stateFrom->sizeList.end() )
     {
       n = (*it)->writeToBuf( stateTo->data+i, stateTo->dataLength - i );
@@ -209 +212 @@
   sentStates[userId].push_back( stateTo );
   
-  assert( i == neededSize );
+  if ( i != neededSize )
+  {
+    PRINTF(0)("strange error: (%s) %d != %d\n", this->getClassName(), i, neededSize);
+    assert(false);
+  }
 
   //write diff to data

trunk/src/lib/network/synchronizeable_var/synchronizeable_string.cc

@@ -48 +48 @@
   
   assert( res > 0 );
+  assert( res == vPtrIn->length()+INTSIZE );
   
   return res;

trunk/src/util/multiplayer_team_deathmatch.cc

@@ -37 +37 @@
 
 #include "network_game_manager.h"
+
+#include "event_handler.h"
+
+#include "glgui.h"
+
+#include "story_entity.h"
 
 
@@ -59 +65 @@
   this->currentGameState = GAMESTATE_PRE_GAME;
   this->gameStateTimer = 10.0f;
+  
+  this->box = NULL;
 
   this->deathScreen = new ImagePlane();
@@ -138 +146 @@
 void MultiplayerTeamDeathmatch::tick(float dt)
 {
+  //on client side hostId is -1 until hanshake finished
+  if ( SharedNetworkData::getInstance()->getHostID() < 0 )
+    return;
+  
+  if ( currentGameState == GAMESTATE_PRE_GAME )
+  {
+    if ( PlayerStats::getStats( SharedNetworkData::getInstance()->getHostID() )
+         && PlayerStats::getStats( SharedNetworkData::getInstance()->getHostID() )->getPreferedTeamId() == TEAM_NOTEAM 
+         && box == NULL
+       )
+    {
+      EventHandler::getInstance()->pushState( ES_MENU );
+      
+      OrxGui::GLGuiHandler::getInstance()->activateCursor();
+      
+      box = new OrxGui::GLGuiBox();
+      box->setAbsCoor2D( 300, 100 );
+      
+      OrxGui::GLGuiPushButton * buttonSpectator = new OrxGui::GLGuiPushButton("Spectator");
+      box->pack( buttonSpectator );
+      buttonSpectator->connect(SIGNAL(buttonSpectator, released), this, SLOT(MultiplayerTeamDeathmatch, onButtonSpectator));
+      
+      OrxGui::GLGuiPushButton * buttonRandom = new OrxGui::GLGuiPushButton("Random");
+      box->pack( buttonRandom );
+      buttonRandom->connect(SIGNAL(buttonRandom, released), this, SLOT(MultiplayerTeamDeathmatch, onButtonRandom));
+      
+      OrxGui::GLGuiPushButton * buttonTeam0 = new OrxGui::GLGuiPushButton("Blue Team");
+      box->pack( buttonTeam0 );
+      buttonTeam0->connect(SIGNAL(buttonTeam0, released), this, SLOT(MultiplayerTeamDeathmatch, onButtonTeam0));
+      
+      OrxGui::GLGuiPushButton * buttonTeam1 = new OrxGui::GLGuiPushButton("Red Team");
+      box->pack( buttonTeam1 );
+      buttonTeam1->connect(SIGNAL(buttonTeam1, released), this, SLOT(MultiplayerTeamDeathmatch, onButtonTeam1));
+      
+      OrxGui::GLGuiPushButton * buttonExit = new OrxGui::GLGuiPushButton("Exit");
+      box->pack( buttonExit );
+      buttonExit->connect(SIGNAL(buttonExit, released), this, SLOT(MultiplayerTeamDeathmatch, onButtonExit));
+      
+      box->showAll();
+    }
+  }
+
+  if ( box != NULL
+       && PlayerStats::getStats( SharedNetworkData::getInstance()->getHostID() )
+       && PlayerStats::getStats( SharedNetworkData::getInstance()->getHostID() )->getPreferedTeamId() != TEAM_NOTEAM 
+     )
+  {
+    delete box;
+    box = NULL;
+      
+    OrxGui::GLGuiHandler::getInstance()->deactivateCursor( true );
+      
+    EventHandler::getInstance()->popState();
+  }
+  
+  if ( box != NULL )
+  {
+    OrxGui::GLGuiHandler::getInstance()->tick( dt );
+  }
+  
+  assignPlayable();
+  
   if ( !SharedNetworkData::getInstance()->isGameServer() )
     return;
   
   gameStateTimer -= dt;
-  PRINTF(0)("TICK %f\n", gameStateTimer);
+  //PRINTF(0)("TICK %f\n", gameStateTimer);
   
   if ( currentGameState != GAMESTATE_GAME && gameStateTimer < 0 )
@@ -210 +280 @@
  * @return group id
  */
-int MultiplayerTeamDeathmatch::getTeamForNewUser( )
+int MultiplayerTeamDeathmatch::getTeamForNewUser()
 {
   return TEAM_NOTEAM;
 }
 
-ClassID MultiplayerTeamDeathmatch::getPlayableClassId( int team )
-{
-  return CL_SPECTATOR;
-}
-
-std::string MultiplayerTeamDeathmatch::getPlayableModelFileName( int team, ClassID classId )
-{
-  return "";
+ClassID MultiplayerTeamDeathmatch::getPlayableClassId( int userId, int team )
+{
+  if ( team == TEAM_NOTEAM || team == TEAM_SPECTATOR )
+    return CL_SPECTATOR;
+  
+  if ( team == 0 || team == 1 )
+    return CL_SPACE_SHIP;
+  
+  assert( false );
+}
+
+std::string MultiplayerTeamDeathmatch::getPlayableModelFileName( int userId, int team, ClassID classId )
+{
+  if ( team == 0 )
+    return "models/ships/reap_#.obj";
+  else if ( team == 1 )
+    return "models/ships/fighter.obj";
+  else
+    return "";
 }
 
@@ -334 +415 @@
     if ( stats.getTeamId() != stats.getPreferedTeamId() )
     {
-      if ( stats.getPreferedTeamId() == TEAM_SPECTATOR || ( stats.getPreferedTeamId() <= 0 && stats.getPreferedTeamId() < numTeams ) )
+      if ( stats.getPreferedTeamId() == TEAM_SPECTATOR || ( stats.getPreferedTeamId() >= 0 && stats.getPreferedTeamId() < numTeams ) )
       {
         teamChange( stats.getUserId() );
@@ -350 +431 @@
       if ( stats.getPreferedTeamId() == TEAM_RANDOM )
       {
-        stats.setPreferedTeamId( getTeamForNewUser() );
+        stats.setPreferedTeamId( getRandomTeam() );
         teamChange( stats.getUserId() );
       }
@@ -362 +443 @@
   PlayerStats & stats = *(PlayerStats::getStats( userId ));
   
-  assert(false);
-}
-
-
-
-
-
-
+  stats.setTeamId( stats.getPreferedTeamId() );
+  
+  Playable * oldPlayable = stats.getPlayable();
+  
+  
+  ClassID playableClassId = getPlayableClassId( userId, stats.getPreferedTeamId() );
+  std::string playableModel = getPlayableModelFileName( userId, stats.getPreferedTeamId(), playableClassId );
+  
+  BaseObject * bo = Factory::fabricate( playableClassId );
+  
+  assert( bo != NULL );
+  assert( bo->isA( CL_PLAYABLE ) );
+  
+  Playable & playable = *(dynamic_cast<Playable*>(bo));
+  
+  playable.loadModel( playableModel );
+  playable.setOwner( userId );
+  playable.setUniqueID( SharedNetworkData::getInstance()->getNewUniqueID() );
+  playable.setSynchronized( true );
+  
+  stats.setTeamId( stats.getPreferedTeamId() );
+  stats.setPlayableClassId( playableClassId );
+  stats.setPlayableUniqueId( playable.getUniqueID() );
+  stats.setModelFileName( playableModel );
+  
+  if ( oldPlayable )
+  {
+    //if ( userId == SharedNetworkData::getInstance()->getHostID() )
+    //  State::getPlayer()->setPlayable( NULL );
+    delete oldPlayable;
+  }
+}
+
+void MultiplayerTeamDeathmatch::onButtonExit( )
+{
+  State::getCurrentStoryEntity()->stop();
+}
+
+void MultiplayerTeamDeathmatch::onButtonRandom( )
+{
+  NetworkGameManager::getInstance()->prefereTeam( TEAM_RANDOM );
+}
+
+void MultiplayerTeamDeathmatch::onButtonTeam0( )
+{
+  NetworkGameManager::getInstance()->prefereTeam( 0 );
+}
+
+void MultiplayerTeamDeathmatch::onButtonTeam1( )
+{
+  NetworkGameManager::getInstance()->prefereTeam( 1 );
+}
+
+void MultiplayerTeamDeathmatch::onButtonSpectator( )
+{
+  NetworkGameManager::getInstance()->prefereTeam( TEAM_SPECTATOR );
+}
+
+void MultiplayerTeamDeathmatch::assignPlayable( )
+{
+  if ( PlayerStats::getStats( SharedNetworkData::getInstance()->getHostID() ) )
+    PlayerStats::getStats( SharedNetworkData::getInstance()->getHostID() )->getPlayable();
+}
+
+
+
+
+
+

trunk/src/util/multiplayer_team_deathmatch.h

@@ -12 +12 @@
 #include "network_game_rules.h"
 
+#include "glgui_box.h"
 
 class TiXmlElement;
@@ -36 +37 @@
 
     virtual int getTeamForNewUser();
-    virtual ClassID getPlayableClassId( int team );
-    virtual std::string getPlayableModelFileName( int team, ClassID classId );
+    virtual ClassID getPlayableClassId( int userId, int team );
+    virtual std::string getPlayableModelFileName( int userId, int team, ClassID classId );
 
     virtual void onPlayerSpawn();
@@ -73 +74 @@
     float              gameStateTimer;             //!< if less than 0 -> change game state
 
+    OrxGui::GLGuiBox* box;
+
+
     void calculateTeamScore();
     void nextGameState();
     void handleTeamChanges();
     void teamChange( int userId );
+    void assignPlayable();
+    
+    void onButtonSpectator();
+    void onButtonRandom();
+    void onButtonTeam0();
+    void onButtonTeam1();
+    void onButtonExit();
 };
 

trunk/src/util/network_game_rules.cc

@@ -38 +38 @@
 }
 
-std::string NetworkGameRules::getPlayableModelFileName( int team, ClassID classId )
+std::string NetworkGameRules::getPlayableModelFileName( int uesrId, int team, ClassID classId )
 {
   return "models/ships/reap_#.obj";
 }
 
-ClassID NetworkGameRules::getPlayableClassId( int team )
+ClassID NetworkGameRules::getPlayableClassId( int userId, int team )
 {
   return CL_SPACE_SHIP;

trunk/src/util/network_game_rules.h

@@ -21 +21 @@
     
     virtual int getTeamForNewUser();
-    virtual ClassID getPlayableClassId( int team );
-    virtual std::string getPlayableModelFileName( int team, ClassID classId );
+    virtual ClassID getPlayableClassId( int userId, int team );
+    virtual std::string getPlayableModelFileName( int userId, int team, ClassID classId );
     
     virtual PlayerStats * getNewPlayerStats( int userId ){ return new PlayerStats( userId ); }

trunk/src/world_entities/playable.cc

@@ -79 +79 @@
   // this->setPlayer(NULL);
   // IN ITS DESTRUCTOR.
+  
   assert(this->currentPlayer == NULL);
 }
@@ -281 +282 @@
  */
 void  Playable::detachCamera()
-{}
+{
+}
 
 

trunk/src/world_entities/player.cc

@@ -81 +81 @@
       return true;
   }
+  
+  if ( playable == NULL )
+    this->playable = NULL;
 
   return true;

trunk/src/world_entities/spectator.cc

@@ -71 +71 @@
 {
   this->mouseDir =  rot;
-  this->rotY = Quaternion( rot.getHeading(), Vector( 0, 1, 0) );
-  this->rotAxis = Quaternion( rot.getAttitude(), Vector( 0, 0, 1 ) );
+  this->angleY = rot.getHeading();
+  this->angleX = rot.getAttitude();
 }
 
@@ -104 +104 @@
     yMouse *= time / 10;
     
-    this->rotY *= Quaternion(-M_PI/4.0*this->xMouse, Vector(0,1,0));
-    this->rotAxis *= Quaternion(-M_PI/4.0*this->yMouse, Vector(0,0,1) );
-
-    this->mouseDir = rotY * rotAxis;
-    //this->mouseDir *= Quaternion(-M_PI/4.0*this->yMouse, Vector(0,0,1));
+    angleX -= xMouse;
+    angleY -= yMouse;
+    
+    if ( angleY > 2.05 )
+      angleY = 2.05;
+    
+    if ( angleY < -1.15 )
+      angleY = -1.15;
+    
+    this->mouseDir = Quaternion( angleX, Vector( 0, 1, 0 ) ) * Quaternion( angleY, Vector( 0, 0, 1 ) );
+    
     xMouse = yMouse = 0;
   }
   
   this->setAbsDir( this->mouseDir );
+  
+  Vector velocity;
+  
+  if ( this->bForward )
+  {
+    velocity += this->getAbsDirX();
+  }
+  
+  if ( this->bBackward )
+  {
+    velocity -= this->getAbsDirX();
+  }
+  
+  if ( this->bRight )
+  {
+    velocity += this->getAbsDirZ();
+  }
+  
+  if ( this->bLeft )
+  {
+    velocity -= this->getAbsDirZ();
+  }
+  
+  velocity *= 100;
+  
+  this->shiftCoor( velocity*time );
 }
 

trunk/src/world_entities/spectator.h

@@ -35 +35 @@
     Quaternion            mouseDir;           //!< the direction where the player wants to fly
 
-    Quaternion            rotY;
-    Quaternion            rotAxis;
+    //Quaternion            rotY;
+    //Quaternion            rotAxis;
+    float                 angleX;
+    float                 angleY;
 };
 

trunk/src/world_entities/weapons/weapon_manager.cc

@@ -55 +55 @@
 {
   // crosshair being a PNode it must not be deleted (this is because PNodes delete themselves.)
-  //delete this->crosshair;
+  // rennerc: crosshair seems not to delete itselve
+  delete this->crosshair;
 }