Changeset 9008 in orxonox.OLD for trunk/src/world_entities

Timestamp:

Jul 2, 2006, 2:22:19 PM (19 years ago)

Author:

bensch

Message:

orxonox/trunk: merged the network bak to the trunk
merged with command:
svn merge -r8804:HEAD ​https://svn.orxonox.net/orxonox/branches/multi_player_map .

conflicts all resolved in favour of the branche

Location:

trunk/src/world_entities

Files:

• playable.cc (modified) (2 diffs)
• space_ships/space_ship.cc (modified) (3 diffs)
• space_ships/space_ship.h (modified) (1 diff)
• spawning_point.cc (modified) (9 diffs)
• spawning_point.h (modified) (5 diffs)
• world_entity.cc (modified) (4 diffs)
• world_entity.h (modified) (2 diffs)

trunk/src/world_entities/playable.cc

@@ -65 +65 @@
 
   this->bDead = false;
-  
+
   this->subscribeReaction(CREngine::CR_PHYSICS_GROUND_WALK, CL_BSP_ENTITY);
 
@@ -392 +392 @@
     State::getGameRules()->onPlayerSpawn();
 
-
-  if( this->getOwner() % 2 == 0)
-  {
-    //     this->toList(OM_GROUP_00);
-    this->setAbsCoor(213.37, 57.71, -47.98);
-    this->setAbsDir(0, 0, 1, 0);
-  }
-  else
-  { // red team
-    //     this->toList(OM_GROUP_01);
-    this->setAbsCoor(-314.450, 40.701, 83.554);
-    this->setAbsDir(1.0, -0.015, -0.012, 0.011);
-  }
   this->reset();
   this->bDead = false;

trunk/src/world_entities/space_ships/space_ship.cc

@@ -220 +220 @@
   this->burstSystem->setColor(0.5, .5,.5,.8,.8);
   this->burstSystem->setColor(1.0, .8,.8,.8,.0);
-  
+
   registerVar( new SynchronizeableVector( &velocity, &velocity, "velocity" ) );
   registerVar( new SynchronizeableQuaternion( &mouseDir, &mouseDir, "mousedir", PERMISSION_OWNER ) );
@@ -384 +384 @@
   this->shiftCoor(move);
 
+//   PRINTF(0)("id of %s is: %i\n", this->getName(), this->getOMListNumber());
 
 }
@@ -504 +505 @@
 }
 
-
-
-
+void SpaceShip::destroy( )
+{
+  PRINTF(0)("spaceship destroy\n");
+}
+
+void SpaceShip::respawn( )
+{
+  toList( OM_PLAYERS );
+}
+
+
+
+

trunk/src/world_entities/space_ships/space_ship.h

@@ -36 +36 @@
     virtual void postSpawn();
     virtual void leftWorld();
+    
+    virtual void destroy();
+    virtual void respawn();
 
     virtual void collidesWith(WorldEntity* entity, const Vector& location);

trunk/src/world_entities/spawning_point.cc

@@ -22 +22 @@
 #include "world_entity.h"
 
+#include "class_list.h"
+
 #include "compiler.h"
 
@@ -27 +29 @@
 #include "game_rules.h"
 
+#include "shared_network_data.h"
+
+CREATE_FACTORY( SpawningPoint, CL_SPAWNING_POINT );
 
 /**
  *  constructor
  */
-SpawningPoint::SpawningPoint (ClassID classid, const Vector& position)
-{
-  this->setAbsCoor(position);
-  this->classid = classid;
-  this->mode = SPT_ALL_AT_ONCE;
-  this->delay = 0;
+SpawningPoint::SpawningPoint( const TiXmlElement * root )
+{
+  this->setAbsCoor( 0, 0, 0 );
 
   this->init();
-}
-
-
-/**
- *  standard constructor
- */
-SpawningPoint::SpawningPoint (const Vector& position, ClassID classid, SpawningPointMode mode, float delay)
-{
-  this->setAbsCoor(position);
-  this->classid = classid;
-  this->mode = mode;
-  this->delay = delay;
-
-  this->init();
-}
-
-
+  
+  if (root != NULL)
+    this->loadParams(root);
+}
 
 void SpawningPoint::init()
 {
   this->setClassID(CL_SPAWNING_POINT, "SpawningPoint");
+  PRINTF(0)("Created SpawningPoint\n");
   
   this->teamId = -1;
+  this->localTimer = 0.0f;
+  
+  this->toList( OM_DEAD_TICK );
+  
+  MessageManager::getInstance()->registerMessageHandler( MSGID_RESPAWN, respawnMessageHandler, NULL );
 }
 
@@ -81 +76 @@
   WorldEntity::loadParams(root);
 
-  /* now load the frequency */
-  LoadParam(root, "delay", this, SpawningPoint, setSpawningDelay)
-      .describe("sets the delay of the spawning point");
-      
   /* load teamId */
   LoadParam(root, "teamId", this, SpawningPoint, setTeamId)
       .describe("sets teamId");
-
-
-  /* now load the seed */
-//   LoadParam(root, "entity", this, SpawningPoint, setSpawningEntity)
-//       .describe("sets the spawning entity");
-
-  /* now load the seed */
-/*  LoadParam(root, "classid", this, SpawningPoint, setSpawningEntity)
-      .describe("sets the class id of the entity to spawn")
-      .defaultValues(CL_WORLD_ENTITY);*/
 }
 
@@ -106 +87 @@
  *  @param entity WorldEntity to be added
  */
-void SpawningPoint::pushEntity(WorldEntity* entity, float delay)
+void SpawningPoint::pushEntity(Playable* entity, float delay)
 {
   QueueEntry qe;
   qe.entity = entity;
-  qe.list = entity->getOMListNumber();
   qe.respawnTime = this->localTimer + delay;
   
@@ -120 +100 @@
  *  spawn the entity
  */
-void SpawningPoint::spawn(WorldEntity* entity)
-{
-  PRINTF(1)("Spawningpoint spawns new Entity (%s)\n", entity->getClassName());
+void SpawningPoint::spawn(Playable* entity)
+{
+  PRINTF(0)("Spawningpoint spawns Entity (%s)\n", entity->getClassName());
 
 
@@ -129 +109 @@
   
   //TODO set camera (not smooth)
+  
+  if ( State::getGameRules() )
+  {
+    (State::getGameRules())->registerSpawn( entity );
+  }
+  
+  entity->respawn();
 }
 
@@ -141 +128 @@
 {
   this->localTimer += dt;
-
   std::list<QueueEntry>::iterator it = this->queue.begin();
   for( ; it != this->queue.end(); )
   {
-    
+    //PRINTF(0)("%f <= %f\n", it->respawnTime, this->localTimer);
     if( it->respawnTime <= this->localTimer)
     {
@@ -151 +137 @@
       this->spawn(it->entity);
       
-      it->entity->toList( it->list );
-      
-      if ( State::getGameRules() )
-      {
-        (State::getGameRules())->registerSpawn( it->entity );
-      }
-      
+      if ( SharedNetworkData::getInstance()->isGameServer() )
+        this->sendRespawnMessage( it->entity->getUniqueID() );
+
       std::list<QueueEntry>::iterator delit = it;
       it++;
@@ -179 +161 @@
  */
 void SpawningPoint::draw()
-{}
+{
+}
+
+void SpawningPoint::sendRespawnMessage( int uniqueId )
+{
+  byte * buf = new byte[2*INTSIZE];
+  
+  assert( Converter::intToByteArray( this->getUniqueID(), buf, INTSIZE ) == INTSIZE );
+  assert( Converter::intToByteArray( uniqueId, buf + INTSIZE, INTSIZE ) == INTSIZE );
+  
+  MessageManager::getInstance()->sendMessage( MSGID_RESPAWN, buf, 2*INTSIZE, RT_ALL_NOT_ME, 0, MP_HIGHBANDWIDTH );
+}
+
+bool SpawningPoint::respawnMessageHandler( MessageId messageId, byte * data, int dataLength, void * someData, int userId )
+{
+  if ( SharedNetworkData::getInstance()->isGameServer() )
+  {
+    PRINTF(2)("server received spawn message!\n");
+    return true;
+  }
+    
+  int spUniqueId;
+  int uniqueId;
+  
+  if ( dataLength != 2*INTSIZE )
+  {
+    PRINTF(2)("spawn message has wrong size: %d\n", dataLength );
+    return true;
+  }
+  
+  assert( Converter::byteArrayToInt( data, &spUniqueId ) == INTSIZE );
+  assert( Converter::byteArrayToInt( data+INTSIZE, &uniqueId ) == INTSIZE );
+  
+  SpawningPoint * sp = NULL;
+  Playable      * playable = NULL;
+  
+  const std::list<BaseObject*> * list = ClassList::getList( CL_SPAWNING_POINT );
+  
+  if ( list )
+  {
+    for ( std::list<BaseObject*>::const_iterator it = list->begin(); it != list->end(); it++ )
+    {
+      if ( dynamic_cast<SpawningPoint*>(*it)->getUniqueID() == uniqueId )
+      {
+        sp = dynamic_cast<SpawningPoint*>(*it);
+        break;
+      }
+    }
+  }
+  
+  if ( !sp )
+  {
+    PRINTF(2)("could not find spawning point\n");
+    return false;
+  }
+  
+  list = ClassList::getList( CL_PLAYABLE );
+  
+  if ( list )
+  {
+    for ( std::list<BaseObject*>::const_iterator it = list->begin(); it != list->end(); it++ )
+    {
+      if ( dynamic_cast<Playable*>(*it)->getUniqueID() == uniqueId )
+      {
+        playable = dynamic_cast<Playable*>(*it);
+        break;
+      }
+    }
+  }
+  
+  if ( !playable )
+  {
+    PRINTF(2)("could not find playable\n");
+    return false;
+  }
+  
+  sp->spawn( playable );
+  
+  return true;
+}
+

trunk/src/world_entities/spawning_point.h

@@ -10 +10 @@
 #include "playable.h"
 
+#include "message_manager.h"
+
 #include <list>
 
@@ -18 +20 @@
 {
   float respawnTime;
-  WorldEntity * entity;
-  OM_LIST list;
+  Playable * entity;
 };
 
@@ -43 +44 @@
 
   public:
-    SpawningPoint (ClassID classID, const Vector& position = Vector(0.0, 0.0, 0.0));
-    SpawningPoint (const Vector& position, ClassID classID, SpawningPointMode type, float delay);
+    SpawningPoint(const TiXmlElement* root = NULL);
     virtual ~SpawningPoint ();
     void init();
@@ -50 +50 @@
     virtual void loadParams(const TiXmlElement* root);
 
-    /**  sets the entity that is going to be spawned by this point @param classID: the id from the class_id.h file */
-    void SpawningPoint::setSpawningEntity(ClassID classid) { this->classid = classid; }
-    /** sets the frequency with which the point is going to spawn entities (1/sec) @param frequency: the frequency */
-    void SpawningPoint::setSpawningDelay(float delay) { this->delay = delay; }
-    /** sets the spawning point mode @param mode: the mode */
-    void SpawningPoint::setSpawningMode(int mode) { this->mode = (SpawningPointMode)mode; }
-    
     inline int getTeamId(){ return this->teamId; }
     inline void setTeamId( int teamId ){ this->teamId = teamId; }
 
-    void pushEntity(WorldEntity* entity, float delay = 0);
+    void pushEntity(Playable* entity, float delay = 0);
 
     /** activates the spawning point */
@@ -74 +67 @@
 
   private:
-    void spawn(WorldEntity* entity);
+    void spawn(Playable* entity);
+    
+    void sendRespawnMessage( int uniqueId );
+    static bool respawnMessageHandler( MessageId messageId, byte * data, int dataLength, void * someData, int userId );
 
 
   private:
-    float                           delay;                          //!< the timer that counts down until the next spawn
     float                           localTimer;                     //!< the local timer
-    float                           seed;                           //!< the random seed of the position
     int                             teamId;                         //!< only spawn players of this team
-    ClassID                         classid;                        //!< the classid of the entity to spawn
-    SpawningPointMode               mode;                           //!< the mode of the spawning point
     std::list<QueueEntry>           queue;                          //!< queue of waiting WorldEntities to be spawned
     bool                            bSpawning;                      //!< flag to indicate if this spawning point is active or not

trunk/src/world_entities/world_entity.cc

@@ -88 +88 @@
   modelFileName_handle = registerVarId( new SynchronizeableString( &modelFileName, &modelFileName, "modelFileName" ) );
   scaling_handle = registerVarId( new SynchronizeableFloat( &scaling, &scaling, "scaling" ) );
+  list_handle = registerVarId( new SynchronizeableInt( (int*)&objectListNumber, &list_write, "list" ) );
 }
 
@@ -733 +734 @@
  *  @param damage damage to be dealt
  */
-void WorldEntity::hit(float damage)
+void WorldEntity::hit(float damage, WorldEntity* killer)
 {
   this->decreaseHealth(damage);
@@ -748 +749 @@
 
     if( State::getGameRules() != NULL)
-      State::getGameRules()->registerKill(Kill(NULL, this));
+      State::getGameRules()->registerKill(Kill(killer, this));
   }
 }
@@ -832 +833 @@
   }
 
+  if ( std::find( id.begin(), id.end(), list_handle ) != id.end() )
+  {
+    this->toList( (OM_LIST)list_write );
+  }
+
   PNode::varChangeHandler( id );
 }

trunk/src/world_entities/world_entity.h

@@ -99 +99 @@
   void setOnGround(bool flag) { this->bOnGround = flag; }
 
-  virtual void hit(float damage);
+  virtual void hit(float damage, WorldEntity* killer);
+
   virtual void destroy();
 
@@ -195 +196 @@
   int                     modelFileName_handle;            //!< handle for syncing var
 
+  int                     list_write;                      //!< entity's list
+  int                     list_handle;                     //!< handle for list changes
+
   CollisionHandle*        collisionHandles[CREngine::CR_NUMBER];  //!< the list of the collision reactions
   bool                    bReactive;                              //!< true if there is at least one collision reaction subscibed